Context Navigation

libvtcross_wrap.cpp @ 466

Revision 466, 222.5 KB (checked in by bhilburn, 15 years ago)
Adding SWIG files to the SCM.

Line
1	/* ----------------------------------------------------------------------------
2	* This file was automatically generated by SWIG (http://www.swig.org).
3	* Version 1.3.39
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
7	* changes to this file unless you know what you are doing--modify the SWIG
8	* interface file instead.
9	* ----------------------------------------------------------------------------- */
10
11	#define SWIGPYTHON
12	#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14
15	#ifdef __cplusplus
16	/* SwigValueWrapper is described in swig.swg */
17	template<typename T> class SwigValueWrapper {
18	struct SwigMovePointer {
19	T *ptr;
20	SwigMovePointer(T *p) : ptr(p) { }
21	~SwigMovePointer() { delete ptr; }
22	SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
23	} pointer;
24	SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
25	SwigValueWrapper(const SwigValueWrapper<T>& rhs);
26	public:
27	SwigValueWrapper() : pointer(0) { }
28	SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
29	operator T&() const { return *pointer.ptr; }
30	T *operator&() { return pointer.ptr; }
31	};
32
33	template <typename T> T SwigValueInit() {
34	return T();
35	}
36	#endif
37
38	/* -----------------------------------------------------------------------------
39	* This section contains generic SWIG labels for method/variable
40	* declarations/attributes, and other compiler dependent labels.
41	* ----------------------------------------------------------------------------- */
42
43	/* template workaround for compilers that cannot correctly implement the C++ standard */
44	#ifndef SWIGTEMPLATEDISAMBIGUATOR
45	# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
46	# define SWIGTEMPLATEDISAMBIGUATOR template
47	# elif defined(__HP_aCC)
48	/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
49	/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
50	# define SWIGTEMPLATEDISAMBIGUATOR template
51	# else
52	# define SWIGTEMPLATEDISAMBIGUATOR
53	# endif
54	#endif
55
56	/* inline attribute */
57	#ifndef SWIGINLINE
58	# if defined(__cplusplus) \|\| (defined(__GNUC__) && !defined(__STRICT_ANSI__))
59	# define SWIGINLINE inline
60	# else
61	# define SWIGINLINE
62	# endif
63	#endif
64
65	/* attribute recognised by some compilers to avoid 'unused' warnings */
66	#ifndef SWIGUNUSED
67	# if defined(__GNUC__)
68	# if !(defined(__cplusplus)) \|\| (__GNUC__ > 3 \|\| (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
69	# define SWIGUNUSED __attribute__ ((__unused__))
70	# else
71	# define SWIGUNUSED
72	# endif
73	# elif defined(__ICC)
74	# define SWIGUNUSED __attribute__ ((__unused__))
75	# else
76	# define SWIGUNUSED
77	# endif
78	#endif
79
80	#ifndef SWIG_MSC_UNSUPPRESS_4505
81	# if defined(_MSC_VER)
82	# pragma warning(disable : 4505) /* unreferenced local function has been removed */
83	# endif
84	#endif
85
86	#ifndef SWIGUNUSEDPARM
87	# ifdef __cplusplus
88	# define SWIGUNUSEDPARM(p)
89	# else
90	# define SWIGUNUSEDPARM(p) p SWIGUNUSED
91	# endif
92	#endif
93
94	/* internal SWIG method */
95	#ifndef SWIGINTERN
96	# define SWIGINTERN static SWIGUNUSED
97	#endif
98
99	/* internal inline SWIG method */
100	#ifndef SWIGINTERNINLINE
101	# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
102	#endif
103
104	/* exporting methods */
105	#if (__GNUC__ >= 4) \|\| (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
106	# ifndef GCC_HASCLASSVISIBILITY
107	# define GCC_HASCLASSVISIBILITY
108	# endif
109	#endif
110
111	#ifndef SWIGEXPORT
112	# if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
113	# if defined(STATIC_LINKED)
114	# define SWIGEXPORT
115	# else
116	# define SWIGEXPORT __declspec(dllexport)
117	# endif
118	# else
119	# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
120	# define SWIGEXPORT __attribute__ ((visibility("default")))
121	# else
122	# define SWIGEXPORT
123	# endif
124	# endif
125	#endif
126
127	/* calling conventions for Windows */
128	#ifndef SWIGSTDCALL
129	# if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
130	# define SWIGSTDCALL __stdcall
131	# else
132	# define SWIGSTDCALL
133	# endif
134	#endif
135
136	/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
137	#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
138	# define _CRT_SECURE_NO_DEPRECATE
139	#endif
140
141	/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
142	#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
143	# define _SCL_SECURE_NO_DEPRECATE
144	#endif
145
146
147
148	/* Python.h has to appear first */
149	#include <Python.h>
150
151	/* -----------------------------------------------------------------------------
152	* swigrun.swg
153	*
154	* This file contains generic C API SWIG runtime support for pointer
155	* type checking.
156	* ----------------------------------------------------------------------------- */
157
158	/* This should only be incremented when either the layout of swig_type_info changes,
159	or for whatever reason, the runtime changes incompatibly */
160	#define SWIG_RUNTIME_VERSION "4"
161
162	/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
163	#ifdef SWIG_TYPE_TABLE
164	# define SWIG_QUOTE_STRING(x) #x
165	# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
166	# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
167	#else
168	# define SWIG_TYPE_TABLE_NAME
169	#endif
170
171	/*
172	You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
173	creating a static or dynamic library from the SWIG runtime code.
174	In 99.9% of the cases, SWIG just needs to declare them as 'static'.
175
176	But only do this if strictly necessary, ie, if you have problems
177	with your compiler or suchlike.
178	*/
179
180	#ifndef SWIGRUNTIME
181	# define SWIGRUNTIME SWIGINTERN
182	#endif
183
184	#ifndef SWIGRUNTIMEINLINE
185	# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
186	#endif
187
188	/* Generic buffer size */
189	#ifndef SWIG_BUFFER_SIZE
190	# define SWIG_BUFFER_SIZE 1024
191	#endif
192
193	/* Flags for pointer conversions */
194	#define SWIG_POINTER_DISOWN 0x1
195	#define SWIG_CAST_NEW_MEMORY 0x2
196
197	/* Flags for new pointer objects */
198	#define SWIG_POINTER_OWN 0x1
199
200
201	/*
202	Flags/methods for returning states.
203
204	The SWIG conversion methods, as ConvertPtr, return and integer
205	that tells if the conversion was successful or not. And if not,
206	an error code can be returned (see swigerrors.swg for the codes).
207
208	Use the following macros/flags to set or process the returning
209	states.
210
211	In old versions of SWIG, code such as the following was usually written:
212
213	if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
214	// success code
215	} else {
216	//fail code
217	}
218
219	Now you can be more explicit:
220
221	int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
222	if (SWIG_IsOK(res)) {
223	// success code
224	} else {
225	// fail code
226	}
227
228	which is the same really, but now you can also do
229
230	Type *ptr;
231	int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
232	if (SWIG_IsOK(res)) {
233	// success code
234	if (SWIG_IsNewObj(res) {
235	...
236	delete *ptr;
237	} else {
238	...
239	}
240	} else {
241	// fail code
242	}
243
244	I.e., now SWIG_ConvertPtr can return new objects and you can
245	identify the case and take care of the deallocation. Of course that
246	also requires SWIG_ConvertPtr to return new result values, such as
247
248	int SWIG_ConvertPtr(obj, ptr,...) {
249	if (<obj is ok>) {
250	if (<need new object>) {
251	*ptr = <ptr to new allocated object>;
252	return SWIG_NEWOBJ;
253	} else {
254	*ptr = <ptr to old object>;
255	return SWIG_OLDOBJ;
256	}
257	} else {
258	return SWIG_BADOBJ;
259	}
260	}
261
262	Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
263	more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
264	SWIG errors code.
265
266	Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
267	allows to return the 'cast rank', for example, if you have this
268
269	int food(double)
270	int fooi(int);
271
272	and you call
273
274	food(1) // cast rank '1' (1 -> 1.0)
275	fooi(1) // cast rank '0'
276
277	just use the SWIG_AddCast()/SWIG_CheckState()
278	*/
279
280	#define SWIG_OK (0)
281	#define SWIG_ERROR (-1)
282	#define SWIG_IsOK(r) (r >= 0)
283	#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
284
285	/* The CastRankLimit says how many bits are used for the cast rank */
286	#define SWIG_CASTRANKLIMIT (1 << 8)
287	/* The NewMask denotes the object was created (using new/malloc) */
288	#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
289	/* The TmpMask is for in/out typemaps that use temporal objects */
290	#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
291	/* Simple returning values */
292	#define SWIG_BADOBJ (SWIG_ERROR)
293	#define SWIG_OLDOBJ (SWIG_OK)
294	#define SWIG_NEWOBJ (SWIG_OK \| SWIG_NEWOBJMASK)
295	#define SWIG_TMPOBJ (SWIG_OK \| SWIG_TMPOBJMASK)
296	/* Check, add and del mask methods */
297	#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r \| SWIG_NEWOBJMASK) : r)
298	#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
299	#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
300	#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r \| SWIG_TMPOBJMASK) : r)
301	#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
302	#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
303
304	/* Cast-Rank Mode */
305	#if defined(SWIG_CASTRANK_MODE)
306	# ifndef SWIG_TypeRank
307	# define SWIG_TypeRank unsigned long
308	# endif
309	# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
310	# define SWIG_MAXCASTRANK (2)
311	# endif
312	# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
313	# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
314	SWIGINTERNINLINE int SWIG_AddCast(int r) {
315	return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
316	}
317	SWIGINTERNINLINE int SWIG_CheckState(int r) {
318	return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
319	}
320	#else /* no cast-rank mode */
321	# define SWIG_AddCast
322	# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
323	#endif
324
325
326	#include <string.h>
327
328	#ifdef __cplusplus
329	extern "C" {
330	#endif
331
332	typedef void (swig_converter_func)(void , int );
333	typedef struct swig_type_info (swig_dycast_func)(void **);
334
335	/* Structure to store information on one type */
336	typedef struct swig_type_info {
337	const char name; / mangled name of this type */
338	const char str; / human readable name of this type */
339	swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
340	struct swig_cast_info cast; / linked list of types that can cast into this type */
341	void clientdata; / language specific type data */
342	int owndata; /* flag if the structure owns the clientdata */
343	} swig_type_info;
344
345	/* Structure to store a type and conversion function used for casting */
346	typedef struct swig_cast_info {
347	swig_type_info type; / pointer to type that is equivalent to this type */
348	swig_converter_func converter; /* function to cast the void pointers */
349	struct swig_cast_info next; / pointer to next cast in linked list */
350	struct swig_cast_info prev; / pointer to the previous cast */
351	} swig_cast_info;
352
353	/* Structure used to store module information
354	* Each module generates one structure like this, and the runtime collects
355	* all of these structures and stores them in a circularly linked list.*/
356	typedef struct swig_module_info {
357	swig_type_info *types; / Array of pointers to swig_type_info structures that are in this module */
358	size_t size; /* Number of types in this module */
359	struct swig_module_info next; / Pointer to next element in circularly linked list */
360	swig_type_info *type_initial; / Array of initially generated type structures */
361	swig_cast_info *cast_initial; / Array of initially generated casting structures */
362	void clientdata; / Language specific module data */
363	} swig_module_info;
364
365	/*
366	Compare two type names skipping the space characters, therefore
367	"char" == "char " and "Class<int>" == "Class<int >", etc.
368
369	Return 0 when the two name types are equivalent, as in
370	strncmp, but skipping ' '.
371	*/
372	SWIGRUNTIME int
373	SWIG_TypeNameComp(const char f1, const char l1,
374	const char f2, const char l2) {
375	for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
376	while ((*f1 == ' ') && (f1 != l1)) ++f1;
377	while ((*f2 == ' ') && (f2 != l2)) ++f2;
378	if (f1 != f2) return (f1 > f2) ? 1 : -1;
379	}
380	return (int)((l1 - f1) - (l2 - f2));
381	}
382
383	/*
384	Check type equivalence in a name list like <name1>\|<name2>\|...
385	Return 0 if not equal, 1 if equal
386	*/
387	SWIGRUNTIME int
388	SWIG_TypeEquiv(const char nb, const char tb) {
389	int equiv = 0;
390	const char* te = tb + strlen(tb);
391	const char* ne = nb;
392	while (!equiv && *ne) {
393	for (nb = ne; *ne; ++ne) {
394	if (*ne == '\|') break;
395	}
396	equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
397	if (*ne) ++ne;
398	}
399	return equiv;
400	}
401
402	/*
403	Check type equivalence in a name list like <name1>\|<name2>\|...
404	Return 0 if equal, -1 if nb < tb, 1 if nb > tb
405	*/
406	SWIGRUNTIME int
407	SWIG_TypeCompare(const char nb, const char tb) {
408	int equiv = 0;
409	const char* te = tb + strlen(tb);
410	const char* ne = nb;
411	while (!equiv && *ne) {
412	for (nb = ne; *ne; ++ne) {
413	if (*ne == '\|') break;
414	}
415	equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
416	if (*ne) ++ne;
417	}
418	return equiv;
419	}
420
421
422	/*
423	Check the typename
424	*/
425	SWIGRUNTIME swig_cast_info *
426	SWIG_TypeCheck(const char c, swig_type_info ty) {
427	if (ty) {
428	swig_cast_info *iter = ty->cast;
429	while (iter) {
430	if (strcmp(iter->type->name, c) == 0) {
431	if (iter == ty->cast)
432	return iter;
433	/* Move iter to the top of the linked list */
434	iter->prev->next = iter->next;
435	if (iter->next)
436	iter->next->prev = iter->prev;
437	iter->next = ty->cast;
438	iter->prev = 0;
439	if (ty->cast) ty->cast->prev = iter;
440	ty->cast = iter;
441	return iter;
442	}
443	iter = iter->next;
444	}
445	}
446	return 0;
447	}
448
449	/*
450	Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
451	*/
452	SWIGRUNTIME swig_cast_info *
453	SWIG_TypeCheckStruct(swig_type_info from, swig_type_info ty) {
454	if (ty) {
455	swig_cast_info *iter = ty->cast;
456	while (iter) {
457	if (iter->type == from) {
458	if (iter == ty->cast)
459	return iter;
460	/* Move iter to the top of the linked list */
461	iter->prev->next = iter->next;
462	if (iter->next)
463	iter->next->prev = iter->prev;
464	iter->next = ty->cast;
465	iter->prev = 0;
466	if (ty->cast) ty->cast->prev = iter;
467	ty->cast = iter;
468	return iter;
469	}
470	iter = iter->next;
471	}
472	}
473	return 0;
474	}
475
476	/*
477	Cast a pointer up an inheritance hierarchy
478	*/
479	SWIGRUNTIMEINLINE void *
480	SWIG_TypeCast(swig_cast_info ty, void ptr, int *newmemory) {
481	return ((!ty) \|\| (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
482	}
483
484	/*
485	Dynamic pointer casting. Down an inheritance hierarchy
486	*/
487	SWIGRUNTIME swig_type_info *
488	SWIG_TypeDynamicCast(swig_type_info ty, void *ptr) {
489	swig_type_info *lastty = ty;
490	if (!ty \|\| !ty->dcast) return ty;
491	while (ty && (ty->dcast)) {
492	ty = (*ty->dcast)(ptr);
493	if (ty) lastty = ty;
494	}
495	return lastty;
496	}
497
498	/*
499	Return the name associated with this type
500	*/
501	SWIGRUNTIMEINLINE const char *
502	SWIG_TypeName(const swig_type_info *ty) {
503	return ty->name;
504	}
505
506	/*
507	Return the pretty name associated with this type,
508	that is an unmangled type name in a form presentable to the user.
509	*/
510	SWIGRUNTIME const char *
511	SWIG_TypePrettyName(const swig_type_info *type) {
512	/* The "str" field contains the equivalent pretty names of the
513	type, separated by vertical-bar characters. We choose
514	to print the last name, as it is often (?) the most
515	specific. */
516	if (!type) return NULL;
517	if (type->str != NULL) {
518	const char *last_name = type->str;
519	const char *s;
520	for (s = type->str; *s; s++)
521	if (*s == '\|') last_name = s+1;
522	return last_name;
523	}
524	else
525	return type->name;
526	}
527
528	/*
529	Set the clientdata field for a type
530	*/
531	SWIGRUNTIME void
532	SWIG_TypeClientData(swig_type_info ti, void clientdata) {
533	swig_cast_info *cast = ti->cast;
534	/* if (ti->clientdata == clientdata) return; */
535	ti->clientdata = clientdata;
536
537	while (cast) {
538	if (!cast->converter) {
539	swig_type_info *tc = cast->type;
540	if (!tc->clientdata) {
541	SWIG_TypeClientData(tc, clientdata);
542	}
543	}
544	cast = cast->next;
545	}
546	}
547	SWIGRUNTIME void
548	SWIG_TypeNewClientData(swig_type_info ti, void clientdata) {
549	SWIG_TypeClientData(ti, clientdata);
550	ti->owndata = 1;
551	}
552
553	/*
554	Search for a swig_type_info structure only by mangled name
555	Search is a O(log #types)
556
557	We start searching at module start, and finish searching when start == end.
558	Note: if start == end at the beginning of the function, we go all the way around
559	the circular list.
560	*/
561	SWIGRUNTIME swig_type_info *
562	SWIG_MangledTypeQueryModule(swig_module_info *start,
563	swig_module_info *end,
564	const char *name) {
565	swig_module_info *iter = start;
566	do {
567	if (iter->size) {
568	register size_t l = 0;
569	register size_t r = iter->size - 1;
570	do {
571	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
572	register size_t i = (l + r) >> 1;
573	const char *iname = iter->types[i]->name;
574	if (iname) {
575	register int compare = strcmp(name, iname);
576	if (compare == 0) {
577	return iter->types[i];
578	} else if (compare < 0) {
579	if (i) {
580	r = i - 1;
581	} else {
582	break;
583	}
584	} else if (compare > 0) {
585	l = i + 1;
586	}
587	} else {
588	break; /* should never happen */
589	}
590	} while (l <= r);
591	}
592	iter = iter->next;
593	} while (iter != end);
594	return 0;
595	}
596
597	/*
598	Search for a swig_type_info structure for either a mangled name or a human readable name.
599	It first searches the mangled names of the types, which is a O(log #types)
600	If a type is not found it then searches the human readable names, which is O(#types).
601
602	We start searching at module start, and finish searching when start == end.
603	Note: if start == end at the beginning of the function, we go all the way around
604	the circular list.
605	*/
606	SWIGRUNTIME swig_type_info *
607	SWIG_TypeQueryModule(swig_module_info *start,
608	swig_module_info *end,
609	const char *name) {
610	/* STEP 1: Search the name field using binary search */
611	swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
612	if (ret) {
613	return ret;
614	} else {
615	/* STEP 2: If the type hasn't been found, do a complete search
616	of the str field (the human readable name) */
617	swig_module_info *iter = start;
618	do {
619	register size_t i = 0;
620	for (; i < iter->size; ++i) {
621	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
622	return iter->types[i];
623	}
624	iter = iter->next;
625	} while (iter != end);
626	}
627
628	/* neither found a match */
629	return 0;
630	}
631
632	/*
633	Pack binary data into a string
634	*/
635	SWIGRUNTIME char *
636	SWIG_PackData(char c, void ptr, size_t sz) {
637	static const char hex[17] = "0123456789abcdef";
638	register const unsigned char u = (unsigned char ) ptr;
639	register const unsigned char *eu = u + sz;
640	for (; u != eu; ++u) {
641	register unsigned char uu = *u;
642	*(c++) = hex[(uu & 0xf0) >> 4];
643	*(c++) = hex[uu & 0xf];
644	}
645	return c;
646	}
647
648	/*
649	Unpack binary data from a string
650	*/
651	SWIGRUNTIME const char *
652	SWIG_UnpackData(const char c, void ptr, size_t sz) {
653	register unsigned char u = (unsigned char ) ptr;
654	register const unsigned char *eu = u + sz;
655	for (; u != eu; ++u) {
656	register char d = *(c++);
657	register unsigned char uu;
658	if ((d >= '0') && (d <= '9'))
659	uu = ((d - '0') << 4);
660	else if ((d >= 'a') && (d <= 'f'))
661	uu = ((d - ('a'-10)) << 4);
662	else
663	return (char *) 0;
664	d = *(c++);
665	if ((d >= '0') && (d <= '9'))
666	uu \|= (d - '0');
667	else if ((d >= 'a') && (d <= 'f'))
668	uu \|= (d - ('a'-10));
669	else
670	return (char *) 0;
671	*u = uu;
672	}
673	return c;
674	}
675
676	/*
677	Pack 'void *' into a string buffer.
678	*/
679	SWIGRUNTIME char *
680	SWIG_PackVoidPtr(char buff, void ptr, const char *name, size_t bsz) {
681	char *r = buff;
682	if ((2sizeof(void ) + 2) > bsz) return 0;
683	*(r++) = '_';
684	r = SWIG_PackData(r,&ptr,sizeof(void *));
685	if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
686	strcpy(r,name);
687	return buff;
688	}
689
690	SWIGRUNTIME const char *
691	SWIG_UnpackVoidPtr(const char c, void ptr, const char name) {
692	if (*c != '_') {
693	if (strcmp(c,"NULL") == 0) {
694	ptr = (void ) 0;
695	return name;
696	} else {
697	return 0;
698	}
699	}
700	return SWIG_UnpackData(++c,ptr,sizeof(void *));
701	}
702
703	SWIGRUNTIME char *
704	SWIG_PackDataName(char buff, void ptr, size_t sz, const char *name, size_t bsz) {
705	char *r = buff;
706	size_t lname = (name ? strlen(name) : 0);
707	if ((2*sz + 2 + lname) > bsz) return 0;
708	*(r++) = '_';
709	r = SWIG_PackData(r,ptr,sz);
710	if (lname) {
711	strncpy(r,name,lname+1);
712	} else {
713	*r = 0;
714	}
715	return buff;
716	}
717
718	SWIGRUNTIME const char *
719	SWIG_UnpackDataName(const char c, void ptr, size_t sz, const char *name) {
720	if (*c != '_') {
721	if (strcmp(c,"NULL") == 0) {
722	memset(ptr,0,sz);
723	return name;
724	} else {
725	return 0;
726	}
727	}
728	return SWIG_UnpackData(++c,ptr,sz);
729	}
730
731	#ifdef __cplusplus
732	}
733	#endif
734
735	/* Errors in SWIG */
736	#define SWIG_UnknownError -1
737	#define SWIG_IOError -2
738	#define SWIG_RuntimeError -3
739	#define SWIG_IndexError -4
740	#define SWIG_TypeError -5
741	#define SWIG_DivisionByZero -6
742	#define SWIG_OverflowError -7
743	#define SWIG_SyntaxError -8
744	#define SWIG_ValueError -9
745	#define SWIG_SystemError -10
746	#define SWIG_AttributeError -11
747	#define SWIG_MemoryError -12
748	#define SWIG_NullReferenceError -13
749
750
751
752	/* Compatibility marcos for Python 3 */
753	#if PY_VERSION_HEX >= 0x03000000
754
755	#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
756	#define PyInt_Check(x) PyLong_Check(x)
757	#define PyInt_AsLong(x) PyLong_AsLong(x)
758	#define PyInt_FromLong(x) PyLong_FromLong(x)
759	#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
760
761	#endif
762
763	#ifndef Py_TYPE
764	# define Py_TYPE(op) ((op)->ob_type)
765	#endif
766
767	/* SWIG APIs for compatibility of both Python 2 & 3 */
768
769	#if PY_VERSION_HEX >= 0x03000000
770	# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
771	#else
772	# define SWIG_Python_str_FromFormat PyString_FromFormat
773	#endif
774
775
776	/* Warning: This function will allocate a new string in Python 3,
777	* so please call SWIG_Python_str_DelForPy3(x) to free the space.
778	*/
779	SWIGINTERN char*
780	SWIG_Python_str_AsChar(PyObject *str)
781	{
782	#if PY_VERSION_HEX >= 0x03000000
783	char *cstr;
784	char *newstr;
785	int len;
786	str = PyUnicode_AsUTF8String(str);
787	PyBytes_AsStringAndSize(str, &cstr, &len);
788	newstr = (char *) malloc(len+1);
789	memcpy(newstr, cstr, len+1);
790	Py_XDECREF(str);
791	return newstr;
792	#else
793	return PyString_AsString(str);
794	#endif
795	}
796
797	#if PY_VERSION_HEX >= 0x03000000
798	# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
799	#else
800	# define SWIG_Python_str_DelForPy3(x)
801	#endif
802
803
804	SWIGINTERN PyObject*
805	SWIG_Python_str_FromChar(const char *c)
806	{
807	#if PY_VERSION_HEX >= 0x03000000
808	return PyUnicode_FromString(c);
809	#else
810	return PyString_FromString(c);
811	#endif
812	}
813
814	/* Add PyOS_snprintf for old Pythons */
815	#if PY_VERSION_HEX < 0x02020000
816	# if defined(_MSC_VER) \|\| defined(__BORLANDC__) \|\| defined(_WATCOM)
817	# define PyOS_snprintf _snprintf
818	# else
819	# define PyOS_snprintf snprintf
820	# endif
821	#endif
822
823	/* A crude PyString_FromFormat implementation for old Pythons */
824	#if PY_VERSION_HEX < 0x02020000
825
826	#ifndef SWIG_PYBUFFER_SIZE
827	# define SWIG_PYBUFFER_SIZE 1024
828	#endif
829
830	static PyObject *
831	PyString_FromFormat(const char *fmt, ...) {
832	va_list ap;
833	char buf[SWIG_PYBUFFER_SIZE * 2];
834	int res;
835	va_start(ap, fmt);
836	res = vsnprintf(buf, sizeof(buf), fmt, ap);
837	va_end(ap);
838	return (res < 0 \|\| res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
839	}
840	#endif
841
842	/* Add PyObject_Del for old Pythons */
843	#if PY_VERSION_HEX < 0x01060000
844	# define PyObject_Del(op) PyMem_DEL((op))
845	#endif
846	#ifndef PyObject_DEL
847	# define PyObject_DEL PyObject_Del
848	#endif
849
850	/* A crude PyExc_StopIteration exception for old Pythons */
851	#if PY_VERSION_HEX < 0x02020000
852	# ifndef PyExc_StopIteration
853	# define PyExc_StopIteration PyExc_RuntimeError
854	# endif
855	# ifndef PyObject_GenericGetAttr
856	# define PyObject_GenericGetAttr 0
857	# endif
858	#endif
859
860	/* Py_NotImplemented is defined in 2.1 and up. */
861	#if PY_VERSION_HEX < 0x02010000
862	# ifndef Py_NotImplemented
863	# define Py_NotImplemented PyExc_RuntimeError
864	# endif
865	#endif
866
867	/* A crude PyString_AsStringAndSize implementation for old Pythons */
868	#if PY_VERSION_HEX < 0x02010000
869	# ifndef PyString_AsStringAndSize
870	# define PyString_AsStringAndSize(obj, s, len) {s = PyString_AsString(obj); len = s ? strlen(s) : 0;}
871	# endif
872	#endif
873
874	/* PySequence_Size for old Pythons */
875	#if PY_VERSION_HEX < 0x02000000
876	# ifndef PySequence_Size
877	# define PySequence_Size PySequence_Length
878	# endif
879	#endif
880
881	/* PyBool_FromLong for old Pythons */
882	#if PY_VERSION_HEX < 0x02030000
883	static
884	PyObject *PyBool_FromLong(long ok)
885	{
886	PyObject *result = ok ? Py_True : Py_False;
887	Py_INCREF(result);
888	return result;
889	}
890	#endif
891
892	/* Py_ssize_t for old Pythons */
893	/* This code is as recommended by: */
894	/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
895	#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
896	typedef int Py_ssize_t;
897	# define PY_SSIZE_T_MAX INT_MAX
898	# define PY_SSIZE_T_MIN INT_MIN
899	#endif
900
901	/* -----------------------------------------------------------------------------
902	* error manipulation
903	* ----------------------------------------------------------------------------- */
904
905	SWIGRUNTIME PyObject*
906	SWIG_Python_ErrorType(int code) {
907	PyObject* type = 0;
908	switch(code) {
909	case SWIG_MemoryError:
910	type = PyExc_MemoryError;
911	break;
912	case SWIG_IOError:
913	type = PyExc_IOError;
914	break;
915	case SWIG_RuntimeError:
916	type = PyExc_RuntimeError;
917	break;
918	case SWIG_IndexError:
919	type = PyExc_IndexError;
920	break;
921	case SWIG_TypeError:
922	type = PyExc_TypeError;
923	break;
924	case SWIG_DivisionByZero:
925	type = PyExc_ZeroDivisionError;
926	break;
927	case SWIG_OverflowError:
928	type = PyExc_OverflowError;
929	break;
930	case SWIG_SyntaxError:
931	type = PyExc_SyntaxError;
932	break;
933	case SWIG_ValueError:
934	type = PyExc_ValueError;
935	break;
936	case SWIG_SystemError:
937	type = PyExc_SystemError;
938	break;
939	case SWIG_AttributeError:
940	type = PyExc_AttributeError;
941	break;
942	default:
943	type = PyExc_RuntimeError;
944	}
945	return type;
946	}
947
948
949	SWIGRUNTIME void
950	SWIG_Python_AddErrorMsg(const char* mesg)
951	{
952	PyObject *type = 0;
953	PyObject *value = 0;
954	PyObject *traceback = 0;
955
956	if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
957	if (value) {
958	char *tmp;
959	PyObject *old_str = PyObject_Str(value);
960	PyErr_Clear();
961	Py_XINCREF(type);
962
963	PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
964	SWIG_Python_str_DelForPy3(tmp);
965	Py_DECREF(old_str);
966	Py_DECREF(value);
967	} else {
968	PyErr_SetString(PyExc_RuntimeError, mesg);
969	}
970	}
971
972	#if defined(SWIG_PYTHON_NO_THREADS)
973	# if defined(SWIG_PYTHON_THREADS)
974	# undef SWIG_PYTHON_THREADS
975	# endif
976	#endif
977	#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
978	# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
979	# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
980	# define SWIG_PYTHON_USE_GIL
981	# endif
982	# endif
983	# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
984	# ifndef SWIG_PYTHON_INITIALIZE_THREADS
985	# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
986	# endif
987	# ifdef __cplusplus /* C++ code */
988	class SWIG_Python_Thread_Block {
989	bool status;
990	PyGILState_STATE state;
991	public:
992	void end() { if (status) { PyGILState_Release(state); status = false;} }
993	SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
994	~SWIG_Python_Thread_Block() { end(); }
995	};
996	class SWIG_Python_Thread_Allow {
997	bool status;
998	PyThreadState *save;
999	public:
1000	void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1001	SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1002	~SWIG_Python_Thread_Allow() { end(); }
1003	};
1004	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1005	# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1006	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1007	# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1008	# else /* C code */
1009	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1010	# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1011	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1012	# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1013	# endif
1014	# else /* Old thread way, not implemented, user must provide it */
1015	# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1016	# define SWIG_PYTHON_INITIALIZE_THREADS
1017	# endif
1018	# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1019	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1020	# endif
1021	# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1022	# define SWIG_PYTHON_THREAD_END_BLOCK
1023	# endif
1024	# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1025	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1026	# endif
1027	# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1028	# define SWIG_PYTHON_THREAD_END_ALLOW
1029	# endif
1030	# endif
1031	#else /* No thread support */
1032	# define SWIG_PYTHON_INITIALIZE_THREADS
1033	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1034	# define SWIG_PYTHON_THREAD_END_BLOCK
1035	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1036	# define SWIG_PYTHON_THREAD_END_ALLOW
1037	#endif
1038
1039	/* -----------------------------------------------------------------------------
1040	* Python API portion that goes into the runtime
1041	* ----------------------------------------------------------------------------- */
1042
1043	#ifdef __cplusplus
1044	extern "C" {
1045	#if 0
1046	} /* cc-mode */
1047	#endif
1048	#endif
1049
1050	/* -----------------------------------------------------------------------------
1051	* Constant declarations
1052	* ----------------------------------------------------------------------------- */
1053
1054	/* Constant Types */
1055	#define SWIG_PY_POINTER 4
1056	#define SWIG_PY_BINARY 5
1057
1058	/* Constant information structure */
1059	typedef struct swig_const_info {
1060	int type;
1061	char *name;
1062	long lvalue;
1063	double dvalue;
1064	void *pvalue;
1065	swig_type_info **ptype;
1066	} swig_const_info;
1067
1068
1069	/* -----------------------------------------------------------------------------
1070	* Wrapper of PyInstanceMethod_New() used in Python 3
1071	* It is exported to the generated module, used for -fastproxy
1072	* ----------------------------------------------------------------------------- */
1073	SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject self, PyObject func)
1074	{
1075	#if PY_VERSION_HEX >= 0x03000000
1076	return PyInstanceMethod_New(func);
1077	#else
1078	return NULL;
1079	#endif
1080	}
1081
1082	#ifdef __cplusplus
1083	#if 0
1084	{ /* cc-mode */
1085	#endif
1086	}
1087	#endif
1088
1089
1090	/* -----------------------------------------------------------------------------
1091	* See the LICENSE file for information on copyright, usage and redistribution
1092	* of SWIG, and the README file for authors - http://www.swig.org/release.html.
1093	*
1094	* pyrun.swg
1095	*
1096	* This file contains the runtime support for Python modules
1097	* and includes code for managing global variables and pointer
1098	* type checking.
1099	*
1100	* ----------------------------------------------------------------------------- */
1101
1102	/* Common SWIG API */
1103
1104	/* for raw pointers */
1105	#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1106	#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1107	#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1108	#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
1109	#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1110	#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1111	#define swig_owntype int
1112
1113	/* for raw packed data */
1114	#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1115	#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1116
1117	/* for class or struct pointers */
1118	#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1119	#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1120
1121	/* for C or C++ function pointers */
1122	#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1123	#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1124
1125	/* for C++ member pointers, ie, member methods */
1126	#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1127	#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1128
1129
1130	/* Runtime API */
1131
1132	#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1133	#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1134	#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1135
1136	#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1137	#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1138	#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1139	#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1140	#define SWIG_fail goto fail
1141
1142
1143	/* Runtime API implementation */
1144
1145	/* Error manipulation */
1146
1147	SWIGINTERN void
1148	SWIG_Python_SetErrorObj(PyObject errtype, PyObject obj) {
1149	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1150	PyErr_SetObject(errtype, obj);
1151	Py_DECREF(obj);
1152	SWIG_PYTHON_THREAD_END_BLOCK;
1153	}
1154
1155	SWIGINTERN void
1156	SWIG_Python_SetErrorMsg(PyObject errtype, const char msg) {
1157	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1158	PyErr_SetString(errtype, (char *) msg);
1159	SWIG_PYTHON_THREAD_END_BLOCK;
1160	}
1161
1162	#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1163
1164	/* Set a constant value */
1165
1166	SWIGINTERN void
1167	SWIG_Python_SetConstant(PyObject d, const char name, PyObject *obj) {
1168	PyDict_SetItemString(d, (char*) name, obj);
1169	Py_DECREF(obj);
1170	}
1171
1172	/* Append a value to the result obj */
1173
1174	SWIGINTERN PyObject*
1175	SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1176	#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1177	if (!result) {
1178	result = obj;
1179	} else if (result == Py_None) {
1180	Py_DECREF(result);
1181	result = obj;
1182	} else {
1183	if (!PyList_Check(result)) {
1184	PyObject *o2 = result;
1185	result = PyList_New(1);
1186	PyList_SetItem(result, 0, o2);
1187	}
1188	PyList_Append(result,obj);
1189	Py_DECREF(obj);
1190	}
1191	return result;
1192	#else
1193	PyObject* o2;
1194	PyObject* o3;
1195	if (!result) {
1196	result = obj;
1197	} else if (result == Py_None) {
1198	Py_DECREF(result);
1199	result = obj;
1200	} else {
1201	if (!PyTuple_Check(result)) {
1202	o2 = result;
1203	result = PyTuple_New(1);
1204	PyTuple_SET_ITEM(result, 0, o2);
1205	}
1206	o3 = PyTuple_New(1);
1207	PyTuple_SET_ITEM(o3, 0, obj);
1208	o2 = result;
1209	result = PySequence_Concat(o2, o3);
1210	Py_DECREF(o2);
1211	Py_DECREF(o3);
1212	}
1213	return result;
1214	#endif
1215	}
1216
1217	/* Unpack the argument tuple */
1218
1219	SWIGINTERN int
1220	SWIG_Python_UnpackTuple(PyObject args, const char name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1221	{
1222	if (!args) {
1223	if (!min && !max) {
1224	return 1;
1225	} else {
1226	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1227	name, (min == max ? "" : "at least "), (int)min);
1228	return 0;
1229	}
1230	}
1231	if (!PyTuple_Check(args)) {
1232	PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1233	return 0;
1234	} else {
1235	register Py_ssize_t l = PyTuple_GET_SIZE(args);
1236	if (l < min) {
1237	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1238	name, (min == max ? "" : "at least "), (int)min, (int)l);
1239	return 0;
1240	} else if (l > max) {
1241	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1242	name, (min == max ? "" : "at most "), (int)max, (int)l);
1243	return 0;
1244	} else {
1245	register int i;
1246	for (i = 0; i < l; ++i) {
1247	objs[i] = PyTuple_GET_ITEM(args, i);
1248	}
1249	for (; l < max; ++l) {
1250	objs[l] = 0;
1251	}
1252	return i + 1;
1253	}
1254	}
1255	}
1256
1257	/* A functor is a function object with one single object argument */
1258	#if PY_VERSION_HEX >= 0x02020000
1259	#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1260	#else
1261	#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1262	#endif
1263
1264	/*
1265	Helper for static pointer initialization for both C and C++ code, for example
1266	static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1267	*/
1268	#ifdef __cplusplus
1269	#define SWIG_STATIC_POINTER(var) var
1270	#else
1271	#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1272	#endif
1273
1274	/* -----------------------------------------------------------------------------
1275	* Pointer declarations
1276	* ----------------------------------------------------------------------------- */
1277
1278	/* Flags for new pointer objects */
1279	#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1280	#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW \| SWIG_POINTER_OWN)
1281
1282	#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1283
1284	#ifdef __cplusplus
1285	extern "C" {
1286	#if 0
1287	} /* cc-mode */
1288	#endif
1289	#endif
1290
1291	/* How to access Py_None */
1292	#if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
1293	# ifndef SWIG_PYTHON_NO_BUILD_NONE
1294	# ifndef SWIG_PYTHON_BUILD_NONE
1295	# define SWIG_PYTHON_BUILD_NONE
1296	# endif
1297	# endif
1298	#endif
1299
1300	#ifdef SWIG_PYTHON_BUILD_NONE
1301	# ifdef Py_None
1302	# undef Py_None
1303	# define Py_None SWIG_Py_None()
1304	# endif
1305	SWIGRUNTIMEINLINE PyObject *
1306	_SWIG_Py_None(void)
1307	{
1308	PyObject none = Py_BuildValue((char)"");
1309	Py_DECREF(none);
1310	return none;
1311	}
1312	SWIGRUNTIME PyObject *
1313	SWIG_Py_None(void)
1314	{
1315	static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1316	return none;
1317	}
1318	#endif
1319
1320	/* The python void return value */
1321
1322	SWIGRUNTIMEINLINE PyObject *
1323	SWIG_Py_Void(void)
1324	{
1325	PyObject *none = Py_None;
1326	Py_INCREF(none);
1327	return none;
1328	}
1329
1330	/* SwigPyClientData */
1331
1332	typedef struct {
1333	PyObject *klass;
1334	PyObject *newraw;
1335	PyObject *newargs;
1336	PyObject *destroy;
1337	int delargs;
1338	int implicitconv;
1339	} SwigPyClientData;
1340
1341	SWIGRUNTIMEINLINE int
1342	SWIG_Python_CheckImplicit(swig_type_info *ty)
1343	{
1344	SwigPyClientData data = (SwigPyClientData )ty->clientdata;
1345	return data ? data->implicitconv : 0;
1346	}
1347
1348	SWIGRUNTIMEINLINE PyObject *
1349	SWIG_Python_ExceptionType(swig_type_info *desc) {
1350	SwigPyClientData data = desc ? (SwigPyClientData ) desc->clientdata : 0;
1351	PyObject *klass = data ? data->klass : 0;
1352	return (klass ? klass : PyExc_RuntimeError);
1353	}
1354
1355
1356	SWIGRUNTIME SwigPyClientData *
1357	SwigPyClientData_New(PyObject* obj)
1358	{
1359	if (!obj) {
1360	return 0;
1361	} else {
1362	SwigPyClientData data = (SwigPyClientData )malloc(sizeof(SwigPyClientData));
1363	/* the klass element */
1364	data->klass = obj;
1365	Py_INCREF(data->klass);
1366	/* the newraw method and newargs arguments used to create a new raw instance */
1367	if (PyClass_Check(obj)) {
1368	data->newraw = 0;
1369	data->newargs = obj;
1370	Py_INCREF(obj);
1371	} else {
1372	#if (PY_VERSION_HEX < 0x02020000)
1373	data->newraw = 0;
1374	#else
1375	data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1376	#endif
1377	if (data->newraw) {
1378	Py_INCREF(data->newraw);
1379	data->newargs = PyTuple_New(1);
1380	PyTuple_SetItem(data->newargs, 0, obj);
1381	} else {
1382	data->newargs = obj;
1383	}
1384	Py_INCREF(data->newargs);
1385	}
1386	/* the destroy method, aka as the C++ delete method */
1387	data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1388	if (PyErr_Occurred()) {
1389	PyErr_Clear();
1390	data->destroy = 0;
1391	}
1392	if (data->destroy) {
1393	int flags;
1394	Py_INCREF(data->destroy);
1395	flags = PyCFunction_GET_FLAGS(data->destroy);
1396	#ifdef METH_O
1397	data->delargs = !(flags & (METH_O));
1398	#else
1399	data->delargs = 0;
1400	#endif
1401	} else {
1402	data->delargs = 0;
1403	}
1404	data->implicitconv = 0;
1405	return data;
1406	}
1407	}
1408
1409	SWIGRUNTIME void
1410	SwigPyClientData_Del(SwigPyClientData* data)
1411	{
1412	Py_XDECREF(data->newraw);
1413	Py_XDECREF(data->newargs);
1414	Py_XDECREF(data->destroy);
1415	}
1416
1417	/* =============== SwigPyObject =====================*/
1418
1419	typedef struct {
1420	PyObject_HEAD
1421	void *ptr;
1422	swig_type_info *ty;
1423	int own;
1424	PyObject *next;
1425	} SwigPyObject;
1426
1427	SWIGRUNTIME PyObject *
1428	SwigPyObject_long(SwigPyObject *v)
1429	{
1430	return PyLong_FromVoidPtr(v->ptr);
1431	}
1432
1433	SWIGRUNTIME PyObject *
1434	SwigPyObject_format(const char* fmt, SwigPyObject *v)
1435	{
1436	PyObject *res = NULL;
1437	PyObject *args = PyTuple_New(1);
1438	if (args) {
1439	if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1440	PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1441	if (ofmt) {
1442	#if PY_VERSION_HEX >= 0x03000000
1443	res = PyUnicode_Format(ofmt,args);
1444	#else
1445	res = PyString_Format(ofmt,args);
1446	#endif
1447	Py_DECREF(ofmt);
1448	}
1449	Py_DECREF(args);
1450	}
1451	}
1452	return res;
1453	}
1454
1455	SWIGRUNTIME PyObject *
1456	SwigPyObject_oct(SwigPyObject *v)
1457	{
1458	return SwigPyObject_format("%o",v);
1459	}
1460
1461	SWIGRUNTIME PyObject *
1462	SwigPyObject_hex(SwigPyObject *v)
1463	{
1464	return SwigPyObject_format("%x",v);
1465	}
1466
1467	SWIGRUNTIME PyObject *
1468	#ifdef METH_NOARGS
1469	SwigPyObject_repr(SwigPyObject *v)
1470	#else
1471	SwigPyObject_repr(SwigPyObject v, PyObject args)
1472	#endif
1473	{
1474	const char *name = SWIG_TypePrettyName(v->ty);
1475	PyObject *hex = SwigPyObject_hex(v);
1476	PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", name, hex);
1477	Py_DECREF(hex);
1478	if (v->next) {
1479	#ifdef METH_NOARGS
1480	PyObject nrep = SwigPyObject_repr((SwigPyObject )v->next);
1481	#else
1482	PyObject nrep = SwigPyObject_repr((SwigPyObject )v->next, args);
1483	#endif
1484	#if PY_VERSION_HEX >= 0x03000000
1485	PyObject *joined = PyUnicode_Concat(repr, nrep);
1486	Py_DecRef(repr);
1487	Py_DecRef(nrep);
1488	repr = joined;
1489	#else
1490	PyString_ConcatAndDel(&repr,nrep);
1491	#endif
1492	}
1493	return repr;
1494	}
1495
1496	SWIGRUNTIME int
1497	SwigPyObject_print(SwigPyObject v, FILE fp, int SWIGUNUSEDPARM(flags))
1498	{
1499	char *str;
1500	#ifdef METH_NOARGS
1501	PyObject *repr = SwigPyObject_repr(v);
1502	#else
1503	PyObject *repr = SwigPyObject_repr(v, NULL);
1504	#endif
1505	if (repr) {
1506	str = SWIG_Python_str_AsChar(repr);
1507	fputs(str, fp);
1508	SWIG_Python_str_DelForPy3(str);
1509	Py_DECREF(repr);
1510	return 0;
1511	} else {
1512	return 1;
1513	}
1514	}
1515
1516	SWIGRUNTIME PyObject *
1517	SwigPyObject_str(SwigPyObject *v)
1518	{
1519	char result[SWIG_BUFFER_SIZE];
1520	return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1521	SWIG_Python_str_FromChar(result) : 0;
1522	}
1523
1524	SWIGRUNTIME int
1525	SwigPyObject_compare(SwigPyObject v, SwigPyObject w)
1526	{
1527	void *i = v->ptr;
1528	void *j = w->ptr;
1529	return (i < j) ? -1 : ((i > j) ? 1 : 0);
1530	}
1531
1532	/* Added for Python 3.x, whould it also useful for Python 2.x? */
1533	SWIGRUNTIME PyObject*
1534	SwigPyObject_richcompare(SwigPyObject v, SwigPyObject w, int op)
1535	{
1536	PyObject* res;
1537	if( op != Py_EQ && op != Py_NE ) {
1538	Py_INCREF(Py_NotImplemented);
1539	return Py_NotImplemented;
1540	}
1541	if( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) )
1542	res = Py_True;
1543	else
1544	res = Py_False;
1545	Py_INCREF(res);
1546	return res;
1547	}
1548
1549
1550	SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1551
1552	SWIGRUNTIME PyTypeObject*
1553	SwigPyObject_type(void) {
1554	static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1555	return type;
1556	}
1557
1558	SWIGRUNTIMEINLINE int
1559	SwigPyObject_Check(PyObject *op) {
1560	return (Py_TYPE(op) == SwigPyObject_type())
1561	\|\| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1562	}
1563
1564	SWIGRUNTIME PyObject *
1565	SwigPyObject_New(void ptr, swig_type_info ty, int own);
1566
1567	SWIGRUNTIME void
1568	SwigPyObject_dealloc(PyObject *v)
1569	{
1570	SwigPyObject sobj = (SwigPyObject ) v;
1571	PyObject *next = sobj->next;
1572	if (sobj->own == SWIG_POINTER_OWN) {
1573	swig_type_info *ty = sobj->ty;
1574	SwigPyClientData data = ty ? (SwigPyClientData ) ty->clientdata : 0;
1575	PyObject *destroy = data ? data->destroy : 0;
1576	if (destroy) {
1577	/* destroy is always a VARARGS method */
1578	PyObject *res;
1579	if (data->delargs) {
1580	/* we need to create a temporal object to carry the destroy operation */
1581	PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1582	res = SWIG_Python_CallFunctor(destroy, tmp);
1583	Py_DECREF(tmp);
1584	} else {
1585	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1586	PyObject *mself = PyCFunction_GET_SELF(destroy);
1587	res = ((*meth)(mself, v));
1588	}
1589	Py_XDECREF(res);
1590	}
1591	#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1592	else {
1593	const char *name = SWIG_TypePrettyName(ty);
1594	printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1595	}
1596	#endif
1597	}
1598	Py_XDECREF(next);
1599	PyObject_DEL(v);
1600	}
1601
1602	SWIGRUNTIME PyObject*
1603	SwigPyObject_append(PyObject* v, PyObject* next)
1604	{
1605	SwigPyObject sobj = (SwigPyObject ) v;
1606	#ifndef METH_O
1607	PyObject *tmp = 0;
1608	if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1609	next = tmp;
1610	#endif
1611	if (!SwigPyObject_Check(next)) {
1612	return NULL;
1613	}
1614	sobj->next = next;
1615	Py_INCREF(next);
1616	return SWIG_Py_Void();
1617	}
1618
1619	SWIGRUNTIME PyObject*
1620	#ifdef METH_NOARGS
1621	SwigPyObject_next(PyObject* v)
1622	#else
1623	SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1624	#endif
1625	{
1626	SwigPyObject sobj = (SwigPyObject ) v;
1627	if (sobj->next) {
1628	Py_INCREF(sobj->next);
1629	return sobj->next;
1630	} else {
1631	return SWIG_Py_Void();
1632	}
1633	}
1634
1635	SWIGINTERN PyObject*
1636	#ifdef METH_NOARGS
1637	SwigPyObject_disown(PyObject *v)
1638	#else
1639	SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1640	#endif
1641	{
1642	SwigPyObject sobj = (SwigPyObject )v;
1643	sobj->own = 0;
1644	return SWIG_Py_Void();
1645	}
1646
1647	SWIGINTERN PyObject*
1648	#ifdef METH_NOARGS
1649	SwigPyObject_acquire(PyObject *v)
1650	#else
1651	SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1652	#endif
1653	{
1654	SwigPyObject sobj = (SwigPyObject )v;
1655	sobj->own = SWIG_POINTER_OWN;
1656	return SWIG_Py_Void();
1657	}
1658
1659	SWIGINTERN PyObject*
1660	SwigPyObject_own(PyObject v, PyObject args)
1661	{
1662	PyObject *val = 0;
1663	#if (PY_VERSION_HEX < 0x02020000)
1664	if (!PyArg_ParseTuple(args,(char *)"\|O:own",&val))
1665	#else
1666	if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1667	#endif
1668	{
1669	return NULL;
1670	}
1671	else
1672	{
1673	SwigPyObject sobj = (SwigPyObject )v;
1674	PyObject *obj = PyBool_FromLong(sobj->own);
1675	if (val) {
1676	#ifdef METH_NOARGS
1677	if (PyObject_IsTrue(val)) {
1678	SwigPyObject_acquire(v);
1679	} else {
1680	SwigPyObject_disown(v);
1681	}
1682	#else
1683	if (PyObject_IsTrue(val)) {
1684	SwigPyObject_acquire(v,args);
1685	} else {
1686	SwigPyObject_disown(v,args);
1687	}
1688	#endif
1689	}
1690	return obj;
1691	}
1692	}
1693
1694	#ifdef METH_O
1695	static PyMethodDef
1696	swigobject_methods[] = {
1697	{(char )"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char )"releases ownership of the pointer"},
1698	{(char )"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char )"aquires ownership of the pointer"},
1699	{(char )"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char )"returns/sets ownership of the pointer"},
1700	{(char )"append", (PyCFunction)SwigPyObject_append, METH_O, (char )"appends another 'this' object"},
1701	{(char )"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char )"returns the next 'this' object"},
1702	{(char )"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char )"returns object representation"},
1703	{0, 0, 0, 0}
1704	};
1705	#else
1706	static PyMethodDef
1707	swigobject_methods[] = {
1708	{(char )"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char )"releases ownership of the pointer"},
1709	{(char )"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char )"aquires ownership of the pointer"},
1710	{(char )"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char )"returns/sets ownership of the pointer"},
1711	{(char )"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char )"appends another 'this' object"},
1712	{(char )"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char )"returns the next 'this' object"},
1713	{(char )"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char )"returns object representation"},
1714	{0, 0, 0, 0}
1715	};
1716	#endif
1717
1718	#if PY_VERSION_HEX < 0x02020000
1719	SWIGINTERN PyObject *
1720	SwigPyObject_getattr(SwigPyObject sobj,char name)
1721	{
1722	return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1723	}
1724	#endif
1725
1726	SWIGRUNTIME PyTypeObject*
1727	_PySwigObject_type(void) {
1728	static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1729
1730	static PyNumberMethods SwigPyObject_as_number = {
1731	(binaryfunc)0, /nb_add/
1732	(binaryfunc)0, /nb_subtract/
1733	(binaryfunc)0, /nb_multiply/
1734	/* nb_divide removed in Python 3 */
1735	#if PY_VERSION_HEX < 0x03000000
1736	(binaryfunc)0, /nb_divide/
1737	#endif
1738	(binaryfunc)0, /nb_remainder/
1739	(binaryfunc)0, /nb_divmod/
1740	(ternaryfunc)0,/nb_power/
1741	(unaryfunc)0, /nb_negative/
1742	(unaryfunc)0, /nb_positive/
1743	(unaryfunc)0, /nb_absolute/
1744	(inquiry)0, /nb_nonzero/
1745	0, /nb_invert/
1746	0, /nb_lshift/
1747	0, /nb_rshift/
1748	0, /nb_and/
1749	0, /nb_xor/
1750	0, /nb_or/
1751	#if PY_VERSION_HEX < 0x03000000
1752	0, /nb_coerce/
1753	#endif
1754	(unaryfunc)SwigPyObject_long, /nb_int/
1755	#if PY_VERSION_HEX < 0x03000000
1756	(unaryfunc)SwigPyObject_long, /nb_long/
1757	#else
1758	0, /nb_reserved/
1759	#endif
1760	(unaryfunc)0, /nb_float/
1761	#if PY_VERSION_HEX < 0x03000000
1762	(unaryfunc)SwigPyObject_oct, /nb_oct/
1763	(unaryfunc)SwigPyObject_hex, /nb_hex/
1764	#endif
1765	#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1766	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1767	#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1768	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1769	#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1770	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1771	#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1772	0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1773	#endif
1774	};
1775
1776	static PyTypeObject swigpyobject_type;
1777	static int type_init = 0;
1778	if (!type_init) {
1779	const PyTypeObject tmp
1780	= {
1781	/* PyOjbect header changed in Python 3 */
1782	#if PY_VERSION_HEX >= 0x03000000
1783	PyVarObject_HEAD_INIT(&PyType_Type, 0)
1784	#else
1785	PyObject_HEAD_INIT(NULL)
1786	0, /* ob_size */
1787	#endif
1788	(char )"SwigPyObject", / tp_name */
1789	sizeof(SwigPyObject), /* tp_basicsize */
1790	0, /* tp_itemsize */
1791	(destructor)SwigPyObject_dealloc, /* tp_dealloc */
1792	(printfunc)SwigPyObject_print, /* tp_print */
1793	#if PY_VERSION_HEX < 0x02020000
1794	(getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1795	#else
1796	(getattrfunc)0, /* tp_getattr */
1797	#endif
1798	(setattrfunc)0, /* tp_setattr */
1799	#if PY_VERSION_HEX >= 0x03000000
1800	0, /* tp_reserved in 3.0.1 */
1801	#else
1802	(cmpfunc)SwigPyObject_compare, /* tp_compare */
1803	#endif
1804	(reprfunc)SwigPyObject_repr, /* tp_repr */
1805	&SwigPyObject_as_number, /* tp_as_number */
1806	0, /* tp_as_sequence */
1807	0, /* tp_as_mapping */
1808	(hashfunc)0, /* tp_hash */
1809	(ternaryfunc)0, /* tp_call */
1810	(reprfunc)SwigPyObject_str, /* tp_str */
1811	PyObject_GenericGetAttr, /* tp_getattro */
1812	0, /* tp_setattro */
1813	0, /* tp_as_buffer */
1814	Py_TPFLAGS_DEFAULT, /* tp_flags */
1815	swigobject_doc, /* tp_doc */
1816	0, /* tp_traverse */
1817	0, /* tp_clear */
1818	(richcmpfunc)SwigPyObject_richcompare, /* tp_richcompare */
1819	0, /* tp_weaklistoffset */
1820	#if PY_VERSION_HEX >= 0x02020000
1821	0, /* tp_iter */
1822	0, /* tp_iternext */
1823	swigobject_methods, /* tp_methods */
1824	0, /* tp_members */
1825	0, /* tp_getset */
1826	0, /* tp_base */
1827	0, /* tp_dict */
1828	0, /* tp_descr_get */
1829	0, /* tp_descr_set */
1830	0, /* tp_dictoffset */
1831	0, /* tp_init */
1832	0, /* tp_alloc */
1833	0, /* tp_new */
1834	0, /* tp_free */
1835	0, /* tp_is_gc */
1836	0, /* tp_bases */
1837	0, /* tp_mro */
1838	0, /* tp_cache */
1839	0, /* tp_subclasses */
1840	0, /* tp_weaklist */
1841	#endif
1842	#if PY_VERSION_HEX >= 0x02030000
1843	0, /* tp_del */
1844	#endif
1845	#ifdef COUNT_ALLOCS
1846	0,0,0,0 /* tp_alloc -> tp_next */
1847	#endif
1848	};
1849	swigpyobject_type = tmp;
1850	/* for Python 3 we already assigned the ob_type in PyVarObject_HEAD_INIT() */
1851	#if PY_VERSION_HEX < 0x03000000
1852	swigpyobject_type.ob_type = &PyType_Type;
1853	#endif
1854	type_init = 1;
1855	}
1856	return &swigpyobject_type;
1857	}
1858
1859	SWIGRUNTIME PyObject *
1860	SwigPyObject_New(void ptr, swig_type_info ty, int own)
1861	{
1862	SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1863	if (sobj) {
1864	sobj->ptr = ptr;
1865	sobj->ty = ty;
1866	sobj->own = own;
1867	sobj->next = 0;
1868	}
1869	return (PyObject *)sobj;
1870	}
1871
1872	/* -----------------------------------------------------------------------------
1873	* Implements a simple Swig Packed type, and use it instead of string
1874	* ----------------------------------------------------------------------------- */
1875
1876	typedef struct {
1877	PyObject_HEAD
1878	void *pack;
1879	swig_type_info *ty;
1880	size_t size;
1881	} SwigPyPacked;
1882
1883	SWIGRUNTIME int
1884	SwigPyPacked_print(SwigPyPacked v, FILE fp, int SWIGUNUSEDPARM(flags))
1885	{
1886	char result[SWIG_BUFFER_SIZE];
1887	fputs("<Swig Packed ", fp);
1888	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1889	fputs("at ", fp);
1890	fputs(result, fp);
1891	}
1892	fputs(v->ty->name,fp);
1893	fputs(">", fp);
1894	return 0;
1895	}
1896
1897	SWIGRUNTIME PyObject *
1898	SwigPyPacked_repr(SwigPyPacked *v)
1899	{
1900	char result[SWIG_BUFFER_SIZE];
1901	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1902	return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1903	} else {
1904	return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1905	}
1906	}
1907
1908	SWIGRUNTIME PyObject *
1909	SwigPyPacked_str(SwigPyPacked *v)
1910	{
1911	char result[SWIG_BUFFER_SIZE];
1912	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1913	return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1914	} else {
1915	return SWIG_Python_str_FromChar(v->ty->name);
1916	}
1917	}
1918
1919	SWIGRUNTIME int
1920	SwigPyPacked_compare(SwigPyPacked v, SwigPyPacked w)
1921	{
1922	size_t i = v->size;
1923	size_t j = w->size;
1924	int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1925	return s ? s : strncmp((char )v->pack, (char )w->pack, 2*v->size);
1926	}
1927
1928	SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1929
1930	SWIGRUNTIME PyTypeObject*
1931	SwigPyPacked_type(void) {
1932	static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1933	return type;
1934	}
1935
1936	SWIGRUNTIMEINLINE int
1937	SwigPyPacked_Check(PyObject *op) {
1938	return ((op)->ob_type == _PySwigPacked_type())
1939	\|\| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
1940	}
1941
1942	SWIGRUNTIME void
1943	SwigPyPacked_dealloc(PyObject *v)
1944	{
1945	if (SwigPyPacked_Check(v)) {
1946	SwigPyPacked sobj = (SwigPyPacked ) v;
1947	free(sobj->pack);
1948	}
1949	PyObject_DEL(v);
1950	}
1951
1952	SWIGRUNTIME PyTypeObject*
1953	_PySwigPacked_type(void) {
1954	static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1955	static PyTypeObject swigpypacked_type;
1956	static int type_init = 0;
1957	if (!type_init) {
1958	const PyTypeObject tmp
1959	= {
1960	/* PyObject header changed in Python 3 */
1961	#if PY_VERSION_HEX>=0x03000000
1962	PyVarObject_HEAD_INIT(&PyType_Type, 0)
1963	#else
1964	PyObject_HEAD_INIT(NULL)
1965	0, /* ob_size */
1966	#endif
1967	(char )"SwigPyPacked", / tp_name */
1968	sizeof(SwigPyPacked), /* tp_basicsize */
1969	0, /* tp_itemsize */
1970	(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
1971	(printfunc)SwigPyPacked_print, /* tp_print */
1972	(getattrfunc)0, /* tp_getattr */
1973	(setattrfunc)0, /* tp_setattr */
1974	#if PY_VERSION_HEX>=0x03000000
1975	0, /* tp_reserved in 3.0.1 */
1976	#else
1977	(cmpfunc)SwigPyPacked_compare, /* tp_compare */
1978	#endif
1979	(reprfunc)SwigPyPacked_repr, /* tp_repr */
1980	0, /* tp_as_number */
1981	0, /* tp_as_sequence */
1982	0, /* tp_as_mapping */
1983	(hashfunc)0, /* tp_hash */
1984	(ternaryfunc)0, /* tp_call */
1985	(reprfunc)SwigPyPacked_str, /* tp_str */
1986	PyObject_GenericGetAttr, /* tp_getattro */
1987	0, /* tp_setattro */
1988	0, /* tp_as_buffer */
1989	Py_TPFLAGS_DEFAULT, /* tp_flags */
1990	swigpacked_doc, /* tp_doc */
1991	0, /* tp_traverse */
1992	0, /* tp_clear */
1993	0, /* tp_richcompare */
1994	0, /* tp_weaklistoffset */
1995	#if PY_VERSION_HEX >= 0x02020000
1996	0, /* tp_iter */
1997	0, /* tp_iternext */
1998	0, /* tp_methods */
1999	0, /* tp_members */
2000	0, /* tp_getset */
2001	0, /* tp_base */
2002	0, /* tp_dict */
2003	0, /* tp_descr_get */
2004	0, /* tp_descr_set */
2005	0, /* tp_dictoffset */
2006	0, /* tp_init */
2007	0, /* tp_alloc */
2008	0, /* tp_new */
2009	0, /* tp_free */
2010	0, /* tp_is_gc */
2011	0, /* tp_bases */
2012	0, /* tp_mro */
2013	0, /* tp_cache */
2014	0, /* tp_subclasses */
2015	0, /* tp_weaklist */
2016	#endif
2017	#if PY_VERSION_HEX >= 0x02030000
2018	0, /* tp_del */
2019	#endif
2020	#ifdef COUNT_ALLOCS
2021	0,0,0,0 /* tp_alloc -> tp_next */
2022	#endif
2023	};
2024	swigpypacked_type = tmp;
2025	/* for Python 3 the ob_type already assigned in PyVarObject_HEAD_INIT() */
2026	#if PY_VERSION_HEX < 0x03000000
2027	swigpypacked_type.ob_type = &PyType_Type;
2028	#endif
2029	type_init = 1;
2030	}
2031	return &swigpypacked_type;
2032	}
2033
2034	SWIGRUNTIME PyObject *
2035	SwigPyPacked_New(void ptr, size_t size, swig_type_info ty)
2036	{
2037	SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2038	if (sobj) {
2039	void *pack = malloc(size);
2040	if (pack) {
2041	memcpy(pack, ptr, size);
2042	sobj->pack = pack;
2043	sobj->ty = ty;
2044	sobj->size = size;
2045	} else {
2046	PyObject_DEL((PyObject *) sobj);
2047	sobj = 0;
2048	}
2049	}
2050	return (PyObject *) sobj;
2051	}
2052
2053	SWIGRUNTIME swig_type_info *
2054	SwigPyPacked_UnpackData(PyObject obj, void ptr, size_t size)
2055	{
2056	if (SwigPyPacked_Check(obj)) {
2057	SwigPyPacked sobj = (SwigPyPacked )obj;
2058	if (sobj->size != size) return 0;
2059	memcpy(ptr, sobj->pack, size);
2060	return sobj->ty;
2061	} else {
2062	return 0;
2063	}
2064	}
2065
2066	/* -----------------------------------------------------------------------------
2067	* pointers/data manipulation
2068	* ----------------------------------------------------------------------------- */
2069
2070	SWIGRUNTIMEINLINE PyObject *
2071	_SWIG_This(void)
2072	{
2073	return SWIG_Python_str_FromChar("this");
2074	}
2075
2076	SWIGRUNTIME PyObject *
2077	SWIG_This(void)
2078	{
2079	static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
2080	return swig_this;
2081	}
2082
2083	/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2084
2085	/* TODO: I don't know how to implement the fast getset in Python 3 right now */
2086	#if PY_VERSION_HEX>=0x03000000
2087	#define SWIG_PYTHON_SLOW_GETSET_THIS
2088	#endif
2089
2090	SWIGRUNTIME SwigPyObject *
2091	SWIG_Python_GetSwigThis(PyObject *pyobj)
2092	{
2093	if (SwigPyObject_Check(pyobj)) {
2094	return (SwigPyObject *) pyobj;
2095	} else {
2096	PyObject *obj = 0;
2097	#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2098	if (PyInstance_Check(pyobj)) {
2099	obj = _PyInstance_Lookup(pyobj, SWIG_This());
2100	} else {
2101	PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2102	if (dictptr != NULL) {
2103	PyObject dict = dictptr;
2104	obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2105	} else {
2106	#ifdef PyWeakref_CheckProxy
2107	if (PyWeakref_CheckProxy(pyobj)) {
2108	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2109	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2110	}
2111	#endif
2112	obj = PyObject_GetAttr(pyobj,SWIG_This());
2113	if (obj) {
2114	Py_DECREF(obj);
2115	} else {
2116	if (PyErr_Occurred()) PyErr_Clear();
2117	return 0;
2118	}
2119	}
2120	}
2121	#else
2122	obj = PyObject_GetAttr(pyobj,SWIG_This());
2123	if (obj) {
2124	Py_DECREF(obj);
2125	} else {
2126	if (PyErr_Occurred()) PyErr_Clear();
2127	return 0;
2128	}
2129	#endif
2130	if (obj && !SwigPyObject_Check(obj)) {
2131	/* a PyObject is called 'this', try to get the 'real this'
2132	SwigPyObject from it */
2133	return SWIG_Python_GetSwigThis(obj);
2134	}
2135	return (SwigPyObject *)obj;
2136	}
2137	}
2138
2139	/* Acquire a pointer value */
2140
2141	SWIGRUNTIME int
2142	SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2143	if (own == SWIG_POINTER_OWN) {
2144	SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2145	if (sobj) {
2146	int oldown = sobj->own;
2147	sobj->own = own;
2148	return oldown;
2149	}
2150	}
2151	return 0;
2152	}
2153
2154	/* Convert a pointer value */
2155
2156	SWIGRUNTIME int
2157	SWIG_Python_ConvertPtrAndOwn(PyObject obj, void ptr, swig_type_info ty, int flags, int *own) {
2158	if (!obj) return SWIG_ERROR;
2159	if (obj == Py_None) {
2160	if (ptr) *ptr = 0;
2161	return SWIG_OK;
2162	} else {
2163	SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2164	if (own)
2165	*own = 0;
2166	while (sobj) {
2167	void *vptr = sobj->ptr;
2168	if (ty) {
2169	swig_type_info *to = sobj->ty;
2170	if (to == ty) {
2171	/* no type cast needed */
2172	if (ptr) *ptr = vptr;
2173	break;
2174	} else {
2175	swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2176	if (!tc) {
2177	sobj = (SwigPyObject *)sobj->next;
2178	} else {
2179	if (ptr) {
2180	int newmemory = 0;
2181	*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2182	if (newmemory == SWIG_CAST_NEW_MEMORY) {
2183	assert(own);
2184	if (own)
2185	own = own \| SWIG_CAST_NEW_MEMORY;
2186	}
2187	}
2188	break;
2189	}
2190	}
2191	} else {
2192	if (ptr) *ptr = vptr;
2193	break;
2194	}
2195	}
2196	if (sobj) {
2197	if (own)
2198	own = own \| sobj->own;
2199	if (flags & SWIG_POINTER_DISOWN) {
2200	sobj->own = 0;
2201	}
2202	return SWIG_OK;
2203	} else {
2204	int res = SWIG_ERROR;
2205	if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2206	SwigPyClientData data = ty ? (SwigPyClientData ) ty->clientdata : 0;
2207	if (data && !data->implicitconv) {
2208	PyObject *klass = data->klass;
2209	if (klass) {
2210	PyObject *impconv;
2211	data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2212	impconv = SWIG_Python_CallFunctor(klass, obj);
2213	data->implicitconv = 0;
2214	if (PyErr_Occurred()) {
2215	PyErr_Clear();
2216	impconv = 0;
2217	}
2218	if (impconv) {
2219	SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2220	if (iobj) {
2221	void *vptr;
2222	res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2223	if (SWIG_IsOK(res)) {
2224	if (ptr) {
2225	*ptr = vptr;
2226	/* transfer the ownership to 'ptr' */
2227	iobj->own = 0;
2228	res = SWIG_AddCast(res);
2229	res = SWIG_AddNewMask(res);
2230	} else {
2231	res = SWIG_AddCast(res);
2232	}
2233	}
2234	}
2235	Py_DECREF(impconv);
2236	}
2237	}
2238	}
2239	}
2240	return res;
2241	}
2242	}
2243	}
2244
2245	/* Convert a function ptr value */
2246
2247	SWIGRUNTIME int
2248	SWIG_Python_ConvertFunctionPtr(PyObject obj, void ptr, swig_type_info ty) {
2249	if (!PyCFunction_Check(obj)) {
2250	return SWIG_ConvertPtr(obj, ptr, ty, 0);
2251	} else {
2252	void *vptr = 0;
2253
2254	/* here we get the method pointer for callbacks */
2255	const char doc = (((PyCFunctionObject )obj) -> m_ml -> ml_doc);
2256	const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2257	if (desc) {
2258	desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2259	if (!desc) return SWIG_ERROR;
2260	}
2261	if (ty) {
2262	swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2263	if (tc) {
2264	int newmemory = 0;
2265	*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2266	assert(!newmemory); /* newmemory handling not yet implemented */
2267	} else {
2268	return SWIG_ERROR;
2269	}
2270	} else {
2271	*ptr = vptr;
2272	}
2273	return SWIG_OK;
2274	}
2275	}
2276
2277	/* Convert a packed value value */
2278
2279	SWIGRUNTIME int
2280	SWIG_Python_ConvertPacked(PyObject obj, void ptr, size_t sz, swig_type_info *ty) {
2281	swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2282	if (!to) return SWIG_ERROR;
2283	if (ty) {
2284	if (to != ty) {
2285	/* check type cast? */
2286	swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2287	if (!tc) return SWIG_ERROR;
2288	}
2289	}
2290	return SWIG_OK;
2291	}
2292
2293	/* -----------------------------------------------------------------------------
2294	* Create a new pointer object
2295	* ----------------------------------------------------------------------------- */
2296
2297	/*
2298	Create a new instance object, whitout calling __init__, and set the
2299	'this' attribute.
2300	*/
2301
2302	SWIGRUNTIME PyObject*
2303	SWIG_Python_NewShadowInstance(SwigPyClientData data, PyObject swig_this)
2304	{
2305	#if (PY_VERSION_HEX >= 0x02020000)
2306	PyObject *inst = 0;
2307	PyObject *newraw = data->newraw;
2308	if (newraw) {
2309	inst = PyObject_Call(newraw, data->newargs, NULL);
2310	if (inst) {
2311	#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2312	PyObject **dictptr = _PyObject_GetDictPtr(inst);
2313	if (dictptr != NULL) {
2314	PyObject dict = dictptr;
2315	if (dict == NULL) {
2316	dict = PyDict_New();
2317	*dictptr = dict;
2318	PyDict_SetItem(dict, SWIG_This(), swig_this);
2319	}
2320	}
2321	#else
2322	PyObject *key = SWIG_This();
2323	PyObject_SetAttr(inst, key, swig_this);
2324	#endif
2325	}
2326	} else {
2327	#if PY_VERSION_HEX >= 0x03000000
2328	inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2329	PyObject_SetAttr(inst, SWIG_This(), swig_this);
2330	Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2331	#else
2332	PyObject *dict = PyDict_New();
2333	PyDict_SetItem(dict, SWIG_This(), swig_this);
2334	inst = PyInstance_NewRaw(data->newargs, dict);
2335	Py_DECREF(dict);
2336	#endif
2337	}
2338	return inst;
2339	#else
2340	#if (PY_VERSION_HEX >= 0x02010000)
2341	PyObject *inst;
2342	PyObject *dict = PyDict_New();
2343	PyDict_SetItem(dict, SWIG_This(), swig_this);
2344	inst = PyInstance_NewRaw(data->newargs, dict);
2345	Py_DECREF(dict);
2346	return (PyObject *) inst;
2347	#else
2348	PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2349	if (inst == NULL) {
2350	return NULL;
2351	}
2352	inst->in_class = (PyClassObject *)data->newargs;
2353	Py_INCREF(inst->in_class);
2354	inst->in_dict = PyDict_New();
2355	if (inst->in_dict == NULL) {
2356	Py_DECREF(inst);
2357	return NULL;
2358	}
2359	#ifdef Py_TPFLAGS_HAVE_WEAKREFS
2360	inst->in_weakreflist = NULL;
2361	#endif
2362	#ifdef Py_TPFLAGS_GC
2363	PyObject_GC_Init(inst);
2364	#endif
2365	PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2366	return (PyObject *) inst;
2367	#endif
2368	#endif
2369	}
2370
2371	SWIGRUNTIME void
2372	SWIG_Python_SetSwigThis(PyObject inst, PyObject swig_this)
2373	{
2374	PyObject *dict;
2375	#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2376	PyObject **dictptr = _PyObject_GetDictPtr(inst);
2377	if (dictptr != NULL) {
2378	dict = *dictptr;
2379	if (dict == NULL) {
2380	dict = PyDict_New();
2381	*dictptr = dict;
2382	}
2383	PyDict_SetItem(dict, SWIG_This(), swig_this);
2384	return;
2385	}
2386	#endif
2387	dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2388	PyDict_SetItem(dict, SWIG_This(), swig_this);
2389	Py_DECREF(dict);
2390	}
2391
2392
2393	SWIGINTERN PyObject *
2394	SWIG_Python_InitShadowInstance(PyObject *args) {
2395	PyObject *obj[2];
2396	if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2397	return NULL;
2398	} else {
2399	SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2400	if (sthis) {
2401	SwigPyObject_append((PyObject*) sthis, obj[1]);
2402	} else {
2403	SWIG_Python_SetSwigThis(obj[0], obj[1]);
2404	}
2405	return SWIG_Py_Void();
2406	}
2407	}
2408
2409	/* Create a new pointer object */
2410
2411	SWIGRUNTIME PyObject *
2412	SWIG_Python_NewPointerObj(void ptr, swig_type_info type, int flags) {
2413	if (!ptr) {
2414	return SWIG_Py_Void();
2415	} else {
2416	int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2417	PyObject *robj = SwigPyObject_New(ptr, type, own);
2418	SwigPyClientData clientdata = type ? (SwigPyClientData )(type->clientdata) : 0;
2419	if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2420	PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2421	if (inst) {
2422	Py_DECREF(robj);
2423	robj = inst;
2424	}
2425	}
2426	return robj;
2427	}
2428	}
2429
2430	/* Create a new packed object */
2431
2432	SWIGRUNTIMEINLINE PyObject *
2433	SWIG_Python_NewPackedObj(void ptr, size_t sz, swig_type_info type) {
2434	return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2435	}
2436
2437	/* -----------------------------------------------------------------------------*
2438	* Get type list
2439	* -----------------------------------------------------------------------------*/
2440
2441	#ifdef SWIG_LINK_RUNTIME
2442	void SWIG_ReturnGlobalTypeList(void );
2443	#endif
2444
2445	SWIGRUNTIME swig_module_info *
2446	SWIG_Python_GetModule(void) {
2447	static void type_pointer = (void )0;
2448	/* first check if module already created */
2449	if (!type_pointer) {
2450	#ifdef SWIG_LINK_RUNTIME
2451	type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2452	#else
2453	type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2454	(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2455	if (PyErr_Occurred()) {
2456	PyErr_Clear();
2457	type_pointer = (void *)0;
2458	}
2459	#endif
2460	}
2461	return (swig_module_info *) type_pointer;
2462	}
2463
2464	#if PY_MAJOR_VERSION < 2
2465	/* PyModule_AddObject function was introduced in Python 2.0. The following function
2466	is copied out of Python/modsupport.c in python version 2.3.4 */
2467	SWIGINTERN int
2468	PyModule_AddObject(PyObject m, char name, PyObject *o)
2469	{
2470	PyObject *dict;
2471	if (!PyModule_Check(m)) {
2472	PyErr_SetString(PyExc_TypeError,
2473	"PyModule_AddObject() needs module as first arg");
2474	return SWIG_ERROR;
2475	}
2476	if (!o) {
2477	PyErr_SetString(PyExc_TypeError,
2478	"PyModule_AddObject() needs non-NULL value");
2479	return SWIG_ERROR;
2480	}
2481
2482	dict = PyModule_GetDict(m);
2483	if (dict == NULL) {
2484	/* Internal error -- modules must have a dict! */
2485	PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2486	PyModule_GetName(m));
2487	return SWIG_ERROR;
2488	}
2489	if (PyDict_SetItemString(dict, name, o))
2490	return SWIG_ERROR;
2491	Py_DECREF(o);
2492	return SWIG_OK;
2493	}
2494	#endif
2495
2496	SWIGRUNTIME void
2497	SWIG_Python_DestroyModule(void *vptr)
2498	{
2499	swig_module_info swig_module = (swig_module_info ) vptr;
2500	swig_type_info **types = swig_module->types;
2501	size_t i;
2502	for (i =0; i < swig_module->size; ++i) {
2503	swig_type_info *ty = types[i];
2504	if (ty->owndata) {
2505	SwigPyClientData data = (SwigPyClientData ) ty->clientdata;
2506	if (data) SwigPyClientData_Del(data);
2507	}
2508	}
2509	Py_DECREF(SWIG_This());
2510	}
2511
2512	SWIGRUNTIME void
2513	SWIG_Python_SetModule(swig_module_info *swig_module) {
2514	static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2515
2516	#if PY_VERSION_HEX >= 0x03000000
2517	/* Add a dummy module object into sys.modules */
2518	PyObject module = PyImport_AddModule((char)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2519	#else
2520	PyObject module = Py_InitModule((char)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2521	swig_empty_runtime_method_table);
2522	#endif
2523	PyObject pointer = PyCObject_FromVoidPtr((void ) swig_module, SWIG_Python_DestroyModule);
2524	if (pointer && module) {
2525	PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2526	} else {
2527	Py_XDECREF(pointer);
2528	}
2529	}
2530
2531	/* The python cached type query */
2532	SWIGRUNTIME PyObject *
2533	SWIG_Python_TypeCache(void) {
2534	static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2535	return cache;
2536	}
2537
2538	SWIGRUNTIME swig_type_info *
2539	SWIG_Python_TypeQuery(const char *type)
2540	{
2541	PyObject *cache = SWIG_Python_TypeCache();
2542	PyObject *key = SWIG_Python_str_FromChar(type);
2543	PyObject *obj = PyDict_GetItem(cache, key);
2544	swig_type_info *descriptor;
2545	if (obj) {
2546	descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2547	} else {
2548	swig_module_info *swig_module = SWIG_Python_GetModule();
2549	descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2550	if (descriptor) {
2551	obj = PyCObject_FromVoidPtr(descriptor, NULL);
2552	PyDict_SetItem(cache, key, obj);
2553	Py_DECREF(obj);
2554	}
2555	}
2556	Py_DECREF(key);
2557	return descriptor;
2558	}
2559
2560	/*
2561	For backward compatibility only
2562	*/
2563	#define SWIG_POINTER_EXCEPTION 0
2564	#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2565	#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2566
2567	SWIGRUNTIME int
2568	SWIG_Python_AddErrMesg(const char* mesg, int infront)
2569	{
2570	if (PyErr_Occurred()) {
2571	PyObject *type = 0;
2572	PyObject *value = 0;
2573	PyObject *traceback = 0;
2574	PyErr_Fetch(&type, &value, &traceback);
2575	if (value) {
2576	char *tmp;
2577	PyObject *old_str = PyObject_Str(value);
2578	Py_XINCREF(type);
2579	PyErr_Clear();
2580	if (infront) {
2581	PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2582	} else {
2583	PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2584	}
2585	SWIG_Python_str_DelForPy3(tmp);
2586	Py_DECREF(old_str);
2587	}
2588	return 1;
2589	} else {
2590	return 0;
2591	}
2592	}
2593
2594	SWIGRUNTIME int
2595	SWIG_Python_ArgFail(int argnum)
2596	{
2597	if (PyErr_Occurred()) {
2598	/* add information about failing argument */
2599	char mesg[256];
2600	PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2601	return SWIG_Python_AddErrMesg(mesg, 1);
2602	} else {
2603	return 0;
2604	}
2605	}
2606
2607	SWIGRUNTIMEINLINE const char *
2608	SwigPyObject_GetDesc(PyObject *self)
2609	{
2610	SwigPyObject v = (SwigPyObject )self;
2611	swig_type_info *ty = v ? v->ty : 0;
2612	return ty ? ty->str : (char*)"";
2613	}
2614
2615	SWIGRUNTIME void
2616	SWIG_Python_TypeError(const char type, PyObject obj)
2617	{
2618	if (type) {
2619	#if defined(SWIG_COBJECT_TYPES)
2620	if (obj && SwigPyObject_Check(obj)) {
2621	const char otype = (const char ) SwigPyObject_GetDesc(obj);
2622	if (otype) {
2623	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2624	type, otype);
2625	return;
2626	}
2627	} else
2628	#endif
2629	{
2630	const char *otype = (obj ? obj->ob_type->tp_name : 0);
2631	if (otype) {
2632	PyObject *str = PyObject_Str(obj);
2633	const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2634	if (cstr) {
2635	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2636	type, otype, cstr);
2637	SWIG_Python_str_DelForPy3(cstr);
2638	} else {
2639	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2640	type, otype);
2641	}
2642	Py_XDECREF(str);
2643	return;
2644	}
2645	}
2646	PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2647	} else {
2648	PyErr_Format(PyExc_TypeError, "unexpected type is received");
2649	}
2650	}
2651
2652
2653	/* Convert a pointer value, signal an exception on a type mismatch */
2654	SWIGRUNTIME void *
2655	SWIG_Python_MustGetPtr(PyObject obj, swig_type_info ty, int argnum, int flags) {
2656	void *result;
2657	if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2658	PyErr_Clear();
2659	#if SWIG_POINTER_EXCEPTION
2660	if (flags) {
2661	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2662	SWIG_Python_ArgFail(argnum);
2663	}
2664	#endif
2665	}
2666	return result;
2667	}
2668
2669
2670	#ifdef __cplusplus
2671	#if 0
2672	{ /* cc-mode */
2673	#endif
2674	}
2675	#endif
2676
2677
2678
2679	#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2680
2681	#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2682
2683
2684
2685	/* -------- TYPES TABLE (BEGIN) -------- */
2686
2687	#define SWIGTYPE_p_Affect swig_types[0]
2688	#define SWIGTYPE_p_CE_Reg swig_types[1]
2689	#define SWIGTYPE_p_Component swig_types[2]
2690	#define SWIGTYPE_p_Mission swig_types[3]
2691	#define SWIGTYPE_p_Observable swig_types[4]
2692	#define SWIGTYPE_p_Parameter swig_types[5]
2693	#define SWIGTYPE_p_Radio_Info swig_types[6]
2694	#define SWIGTYPE_p_Service swig_types[7]
2695	#define SWIGTYPE_p_Utility swig_types[8]
2696	#define SWIGTYPE_p_char swig_types[9]
2697	#define SWIGTYPE_p_int32_t swig_types[10]
2698	#define SWIGTYPE_p_std__string swig_types[11]
2699	#define SWIGTYPE_p_uint16_t swig_types[12]
2700	#define SWIGTYPE_p_uint32_t swig_types[13]
2701	static swig_type_info *swig_types[15];
2702	static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
2703	#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2704	#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2705
2706	/* -------- TYPES TABLE (END) -------- */
2707
2708	#if (PY_VERSION_HEX <= 0x02000000)
2709	# if !defined(SWIG_PYTHON_CLASSIC)
2710	# error "This python version requires swig to be run with the '-classic' option"
2711	# endif
2712	#endif
2713
2714	/*-----------------------------------------------
2715	@(target):= _cross.so
2716	------------------------------------------------*/
2717	#if PY_VERSION_HEX >= 0x03000000
2718	# define SWIG_init PyInit__cross
2719
2720	#else
2721	# define SWIG_init init_cross
2722
2723	#endif
2724	#define SWIG_name "_cross"
2725
2726	#define SWIGVERSION 0x010339
2727	#define SWIG_VERSION SWIGVERSION
2728
2729
2730	#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2731	#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(a),reinterpret_cast< void* >(a))
2732
2733
2734	#include <stdexcept>
2735
2736
2737	namespace swig {
2738	class SwigPtr_PyObject {
2739	protected:
2740	PyObject *_obj;
2741
2742	public:
2743	SwigPtr_PyObject() :_obj(0)
2744	{
2745	}
2746
2747	SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
2748	{
2749	Py_XINCREF(_obj);
2750	}
2751
2752	SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
2753	{
2754	if (initial_ref) {
2755	Py_XINCREF(_obj);
2756	}
2757	}
2758
2759	SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
2760	{
2761	Py_XINCREF(item._obj);
2762	Py_XDECREF(_obj);
2763	_obj = item._obj;
2764	return *this;
2765	}
2766
2767	~SwigPtr_PyObject()
2768	{
2769	Py_XDECREF(_obj);
2770	}
2771
2772	operator PyObject *() const
2773	{
2774	return _obj;
2775	}
2776
2777	PyObject *operator->() const
2778	{
2779	return _obj;
2780	}
2781	};
2782	}
2783
2784
2785	namespace swig {
2786	struct SwigVar_PyObject : SwigPtr_PyObject {
2787	SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
2788
2789	SwigVar_PyObject & operator = (PyObject* obj)
2790	{
2791	Py_XDECREF(_obj);
2792	_obj = obj;
2793	return *this;
2794	}
2795	};
2796	}
2797
2798
2799	#include "vtcross/libvtcross.h"
2800	#include "vtcross/containers.h"
2801
2802
2803	#include <string>
2804
2805
2806	#include <limits.h>
2807	#if !defined(SWIG_NO_LLONG_MAX)
2808	# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2809	# define LLONG_MAX __LONG_LONG_MAX__
2810	# define LLONG_MIN (-LLONG_MAX - 1LL)
2811	# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2812	# endif
2813	#endif
2814
2815
2816	SWIGINTERN int
2817	SWIG_AsVal_double (PyObject obj, double val)
2818	{
2819	int res = SWIG_TypeError;
2820	if (PyFloat_Check(obj)) {
2821	if (val) *val = PyFloat_AsDouble(obj);
2822	return SWIG_OK;
2823	} else if (PyInt_Check(obj)) {
2824	if (val) *val = PyInt_AsLong(obj);
2825	return SWIG_OK;
2826	} else if (PyLong_Check(obj)) {
2827	double v = PyLong_AsDouble(obj);
2828	if (!PyErr_Occurred()) {
2829	if (val) *val = v;
2830	return SWIG_OK;
2831	} else {
2832	PyErr_Clear();
2833	}
2834	}
2835	#ifdef SWIG_PYTHON_CAST_MODE
2836	{
2837	int dispatch = 0;
2838	double d = PyFloat_AsDouble(obj);
2839	if (!PyErr_Occurred()) {
2840	if (val) *val = d;
2841	return SWIG_AddCast(SWIG_OK);
2842	} else {
2843	PyErr_Clear();
2844	}
2845	if (!dispatch) {
2846	long v = PyLong_AsLong(obj);
2847	if (!PyErr_Occurred()) {
2848	if (val) *val = v;
2849	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2850	} else {
2851	PyErr_Clear();
2852	}
2853	}
2854	}
2855	#endif
2856	return res;
2857	}
2858
2859
2860	#include <float.h>
2861
2862
2863	#include <math.h>
2864
2865
2866	SWIGINTERNINLINE int
2867	SWIG_CanCastAsInteger(double *d, double min, double max) {
2868	double x = *d;
2869	if ((min <= x && x <= max)) {
2870	double fx = floor(x);
2871	double cx = ceil(x);
2872	double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2873	if ((errno == EDOM) \|\| (errno == ERANGE)) {
2874	errno = 0;
2875	} else {
2876	double summ, reps, diff;
2877	if (rd < x) {
2878	diff = x - rd;
2879	} else if (rd > x) {
2880	diff = rd - x;
2881	} else {
2882	return 1;
2883	}
2884	summ = rd + x;
2885	reps = diff/summ;
2886	if (reps < 8*DBL_EPSILON) {
2887	*d = rd;
2888	return 1;
2889	}
2890	}
2891	}
2892	return 0;
2893	}
2894
2895
2896	SWIGINTERN int
2897	SWIG_AsVal_long (PyObject obj, long val)
2898	{
2899	if (PyInt_Check(obj)) {
2900	if (val) *val = PyInt_AsLong(obj);
2901	return SWIG_OK;
2902	} else if (PyLong_Check(obj)) {
2903	long v = PyLong_AsLong(obj);
2904	if (!PyErr_Occurred()) {
2905	if (val) *val = v;
2906	return SWIG_OK;
2907	} else {
2908	PyErr_Clear();
2909	}
2910	}
2911	#ifdef SWIG_PYTHON_CAST_MODE
2912	{
2913	int dispatch = 0;
2914	long v = PyInt_AsLong(obj);
2915	if (!PyErr_Occurred()) {
2916	if (val) *val = v;
2917	return SWIG_AddCast(SWIG_OK);
2918	} else {
2919	PyErr_Clear();
2920	}
2921	if (!dispatch) {
2922	double d;
2923	int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2924	if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2925	if (val) *val = (long)(d);
2926	return res;
2927	}
2928	}
2929	}
2930	#endif
2931	return SWIG_TypeError;
2932	}
2933
2934
2935	SWIGINTERN int
2936	SWIG_AsVal_int (PyObject * obj, int *val)
2937	{
2938	long v;
2939	int res = SWIG_AsVal_long (obj, &v);
2940	if (SWIG_IsOK(res)) {
2941	if ((v < INT_MIN \|\| v > INT_MAX)) {
2942	return SWIG_OverflowError;
2943	} else {
2944	if (val) *val = static_cast< int >(v);
2945	}
2946	}
2947	return res;
2948	}
2949
2950
2951	SWIGINTERN swig_type_info*
2952	SWIG_pchar_descriptor(void)
2953	{
2954	static int init = 0;
2955	static swig_type_info* info = 0;
2956	if (!init) {
2957	info = SWIG_TypeQuery("_p_char");
2958	init = 1;
2959	}
2960	return info;
2961	}
2962
2963
2964	SWIGINTERN int
2965	SWIG_AsCharPtrAndSize(PyObject obj, char* cptr, size_t* psize, int *alloc)
2966	{
2967	#if PY_VERSION_HEX>=0x03000000
2968	if (PyUnicode_Check(obj))
2969	#else
2970	if (PyString_Check(obj))
2971	#endif
2972	{
2973	char *cstr; Py_ssize_t len;
2974	#if PY_VERSION_HEX>=0x03000000
2975	if (!alloc && cptr) {
2976	/* We can't allow converting without allocation, since the internal
2977	representation of string in Python 3 is UCS-2/UCS-4 but we require
2978	a UTF-8 representation.
2979	TODO(bhy) More detailed explanation */
2980	return SWIG_RuntimeError;
2981	}
2982	obj = PyUnicode_AsUTF8String(obj);
2983	PyBytes_AsStringAndSize(obj, &cstr, &len);
2984	if(alloc) *alloc = SWIG_NEWOBJ;
2985	#else
2986	PyString_AsStringAndSize(obj, &cstr, &len);
2987	#endif
2988	if (cptr) {
2989	if (alloc) {
2990	/*
2991	In python the user should not be able to modify the inner
2992	string representation. To warranty that, if you define
2993	SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
2994	buffer is always returned.
2995
2996	The default behavior is just to return the pointer value,
2997	so, be careful.
2998	*/
2999	#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3000	if (*alloc != SWIG_OLDOBJ)
3001	#else
3002	if (*alloc == SWIG_NEWOBJ)
3003	#endif
3004	{
3005	cptr = reinterpret_cast< char >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3006	*alloc = SWIG_NEWOBJ;
3007	}
3008	else {
3009	*cptr = cstr;
3010	*alloc = SWIG_OLDOBJ;
3011	}
3012	} else {
3013	#if PY_VERSION_HEX>=0x03000000
3014	assert(0); /* Should never reach here in Python 3 */
3015	#endif
3016	*cptr = SWIG_Python_str_AsChar(obj);
3017	}
3018	}
3019	if (psize) *psize = len + 1;
3020	#if PY_VERSION_HEX>=0x03000000
3021	Py_XDECREF(obj);
3022	#endif
3023	return SWIG_OK;
3024	} else {
3025	swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3026	if (pchar_descriptor) {
3027	void* vptr = 0;
3028	if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3029	if (cptr) cptr = (char ) vptr;
3030	if (psize) psize = vptr ? (strlen((char )vptr) + 1) : 0;
3031	if (alloc) *alloc = SWIG_OLDOBJ;
3032	return SWIG_OK;
3033	}
3034	}
3035	}
3036	return SWIG_TypeError;
3037	}
3038
3039
3040	SWIGINTERN int
3041	SWIG_AsPtr_std_string (PyObject * obj, std::string **val)
3042	{
3043	char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
3044	if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
3045	if (buf) {
3046	if (val) *val = new std::string(buf, size - 1);
3047	if (alloc == SWIG_NEWOBJ) delete[] buf;
3048	return SWIG_NEWOBJ;
3049	} else {
3050	if (val) *val = 0;
3051	return SWIG_OLDOBJ;
3052	}
3053	} else {
3054	static int init = 0;
3055	static swig_type_info* descriptor = 0;
3056	if (!init) {
3057	descriptor = SWIG_TypeQuery("std::string" " *");
3058	init = 1;
3059	}
3060	if (descriptor) {
3061	std::string *vptr;
3062	int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
3063	if (SWIG_IsOK(res) && val) *val = vptr;
3064	return res;
3065	}
3066	}
3067	return SWIG_ERROR;
3068	}
3069
3070
3071	SWIGINTERNINLINE PyObject *
3072	SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3073	{
3074	if (carray) {
3075	if (size > INT_MAX) {
3076	swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3077	return pchar_descriptor ?
3078	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3079	} else {
3080	#if PY_VERSION_HEX >= 0x03000000
3081	return PyUnicode_FromStringAndSize(carray, static_cast< int >(size));
3082	#else
3083	return PyString_FromStringAndSize(carray, static_cast< int >(size));
3084	#endif
3085	}
3086	} else {
3087	return SWIG_Py_Void();
3088	}
3089	}
3090
3091
3092	SWIGINTERNINLINE PyObject *
3093	SWIG_From_std_string (const std::string& s)
3094	{
3095	if (s.size()) {
3096	return SWIG_FromCharPtrAndSize(s.data(), s.size());
3097	} else {
3098	return SWIG_FromCharPtrAndSize(s.c_str(), 0);
3099	}
3100	}
3101
3102
3103	SWIGINTERN int
3104	SWIG_AsVal_float (PyObject * obj, float *val)
3105	{
3106	double v;
3107	int res = SWIG_AsVal_double (obj, &v);
3108	if (SWIG_IsOK(res)) {
3109	if ((v < -FLT_MAX \|\| v > FLT_MAX)) {
3110	return SWIG_OverflowError;
3111	} else {
3112	if (val) *val = static_cast< float >(v);
3113	}
3114	}
3115	return res;
3116	}
3117
3118
3119	#define SWIG_From_double PyFloat_FromDouble
3120
3121
3122	SWIGINTERNINLINE PyObject *
3123	SWIG_From_float (float value)
3124	{
3125	return SWIG_From_double (value);
3126	}
3127
3128	SWIGINTERN Utility *new_Utility(int nutilities){
3129	Utility * u = new Utility[nutilities];
3130	return u;
3131	}
3132	SWIGINTERN void delete_Utility(Utility *self){
3133	delete [] self;
3134	}
3135	SWIGINTERN Utility Utility___getitem__(Utility self,int i){
3136	return self+i;
3137	}
3138	SWIGINTERN Parameter *new_Parameter(int nparameters){
3139	Parameter * p = new Parameter[nparameters];
3140	return p;
3141	}
3142	SWIGINTERN void delete_Parameter(Parameter *self){
3143	delete [] self;
3144	}
3145	SWIGINTERN Parameter Parameter___getitem__(Parameter self,int i){
3146	return self+i;
3147	}
3148	SWIGINTERN Observable *new_Observable(int nobservables){
3149	Observable * o = new Observable[nobservables];
3150	return o;
3151	}
3152	SWIGINTERN void delete_Observable(Observable *self){
3153	delete [] self;
3154	}
3155	SWIGINTERN Observable Observable___getitem__(Observable self,int i){
3156	return self+i;
3157	}
3158
3159	SWIGINTERNINLINE PyObject*
3160	SWIG_From_bool (bool value)
3161	{
3162	return PyBool_FromLong(value ? 1 : 0);
3163	}
3164
3165
3166
3167
3168	#ifdef __cplusplus
3169	extern "C" {
3170	#endif
3171	SWIGINTERN PyObject _wrap_Radio_Info_numUtilities_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3172	PyObject *resultobj = 0;
3173	Radio_Info arg1 = (Radio_Info ) 0 ;
3174	uint32_t arg2 ;
3175	void *argp1 = 0 ;
3176	int res1 = 0 ;
3177	int val2 ;
3178	int ecode2 = 0 ;
3179	PyObject * obj0 = 0 ;
3180	PyObject * obj1 = 0 ;
3181
3182	if (!PyArg_ParseTuple(args,(char *)"OO:Radio_Info_numUtilities_set",&obj0,&obj1)) SWIG_fail;
3183	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Radio_Info, 0 \| 0 );
3184	if (!SWIG_IsOK(res1)) {
3185	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Radio_Info_numUtilities_set" "', argument " "1"" of type '" "Radio_Info *""'");
3186	}
3187	arg1 = reinterpret_cast< Radio_Info * >(argp1);
3188	ecode2 = SWIG_AsVal_int(obj1, &val2);
3189	if (!SWIG_IsOK(ecode2)) {
3190	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Radio_Info_numUtilities_set" "', argument " "2"" of type '" "uint32_t""'");
3191	}
3192	arg2 = static_cast< uint32_t >(val2);
3193	if (arg1) (arg1)->numUtilities = arg2;
3194	resultobj = SWIG_Py_Void();
3195	return resultobj;
3196	fail:
3197	return NULL;
3198	}
3199
3200
3201	SWIGINTERN PyObject _wrap_Radio_Info_numUtilities_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3202	PyObject *resultobj = 0;
3203	Radio_Info arg1 = (Radio_Info ) 0 ;
3204	void *argp1 = 0 ;
3205	int res1 = 0 ;
3206	PyObject * obj0 = 0 ;
3207	uint32_t result;
3208
3209	if (!PyArg_ParseTuple(args,(char *)"O:Radio_Info_numUtilities_get",&obj0)) SWIG_fail;
3210	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Radio_Info, 0 \| 0 );
3211	if (!SWIG_IsOK(res1)) {
3212	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Radio_Info_numUtilities_get" "', argument " "1"" of type '" "Radio_Info *""'");
3213	}
3214	arg1 = reinterpret_cast< Radio_Info * >(argp1);
3215	result = ((arg1)->numUtilities);
3216	resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN \| 0 );
3217	return resultobj;
3218	fail:
3219	return NULL;
3220	}
3221
3222
3223	SWIGINTERN PyObject _wrap_Radio_Info_numParameters_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3224	PyObject *resultobj = 0;
3225	Radio_Info arg1 = (Radio_Info ) 0 ;
3226	uint32_t arg2 ;
3227	void *argp1 = 0 ;
3228	int res1 = 0 ;
3229	int val2 ;
3230	int ecode2 = 0 ;
3231	PyObject * obj0 = 0 ;
3232	PyObject * obj1 = 0 ;
3233
3234	if (!PyArg_ParseTuple(args,(char *)"OO:Radio_Info_numParameters_set",&obj0,&obj1)) SWIG_fail;
3235	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Radio_Info, 0 \| 0 );
3236	if (!SWIG_IsOK(res1)) {
3237	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Radio_Info_numParameters_set" "', argument " "1"" of type '" "Radio_Info *""'");
3238	}
3239	arg1 = reinterpret_cast< Radio_Info * >(argp1);
3240	ecode2 = SWIG_AsVal_int(obj1, &val2);
3241	if (!SWIG_IsOK(ecode2)) {
3242	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Radio_Info_numParameters_set" "', argument " "2"" of type '" "uint32_t""'");
3243	}
3244	arg2 = static_cast< uint32_t >(val2);
3245	if (arg1) (arg1)->numParameters = arg2;
3246	resultobj = SWIG_Py_Void();
3247	return resultobj;
3248	fail:
3249	return NULL;
3250	}
3251
3252
3253	SWIGINTERN PyObject _wrap_Radio_Info_numParameters_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3254	PyObject *resultobj = 0;
3255	Radio_Info arg1 = (Radio_Info ) 0 ;
3256	void *argp1 = 0 ;
3257	int res1 = 0 ;
3258	PyObject * obj0 = 0 ;
3259	uint32_t result;
3260
3261	if (!PyArg_ParseTuple(args,(char *)"O:Radio_Info_numParameters_get",&obj0)) SWIG_fail;
3262	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Radio_Info, 0 \| 0 );
3263	if (!SWIG_IsOK(res1)) {
3264	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Radio_Info_numParameters_get" "', argument " "1"" of type '" "Radio_Info *""'");
3265	}
3266	arg1 = reinterpret_cast< Radio_Info * >(argp1);
3267	result = ((arg1)->numParameters);
3268	resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN \| 0 );
3269	return resultobj;
3270	fail:
3271	return NULL;
3272	}
3273
3274
3275	SWIGINTERN PyObject _wrap_Radio_Info_numObservables_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3276	PyObject *resultobj = 0;
3277	Radio_Info arg1 = (Radio_Info ) 0 ;
3278	uint32_t arg2 ;
3279	void *argp1 = 0 ;
3280	int res1 = 0 ;
3281	int val2 ;
3282	int ecode2 = 0 ;
3283	PyObject * obj0 = 0 ;
3284	PyObject * obj1 = 0 ;
3285
3286	if (!PyArg_ParseTuple(args,(char *)"OO:Radio_Info_numObservables_set",&obj0,&obj1)) SWIG_fail;
3287	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Radio_Info, 0 \| 0 );
3288	if (!SWIG_IsOK(res1)) {
3289	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Radio_Info_numObservables_set" "', argument " "1"" of type '" "Radio_Info *""'");
3290	}
3291	arg1 = reinterpret_cast< Radio_Info * >(argp1);
3292	ecode2 = SWIG_AsVal_int(obj1, &val2);
3293	if (!SWIG_IsOK(ecode2)) {
3294	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Radio_Info_numObservables_set" "', argument " "2"" of type '" "uint32_t""'");
3295	}
3296	arg2 = static_cast< uint32_t >(val2);
3297	if (arg1) (arg1)->numObservables = arg2;
3298	resultobj = SWIG_Py_Void();
3299	return resultobj;
3300	fail:
3301	return NULL;
3302	}
3303
3304
3305	SWIGINTERN PyObject _wrap_Radio_Info_numObservables_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3306	PyObject *resultobj = 0;
3307	Radio_Info arg1 = (Radio_Info ) 0 ;
3308	void *argp1 = 0 ;
3309	int res1 = 0 ;
3310	PyObject * obj0 = 0 ;
3311	uint32_t result;
3312
3313	if (!PyArg_ParseTuple(args,(char *)"O:Radio_Info_numObservables_get",&obj0)) SWIG_fail;
3314	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Radio_Info, 0 \| 0 );
3315	if (!SWIG_IsOK(res1)) {
3316	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Radio_Info_numObservables_get" "', argument " "1"" of type '" "Radio_Info *""'");
3317	}
3318	arg1 = reinterpret_cast< Radio_Info * >(argp1);
3319	result = ((arg1)->numObservables);
3320	resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN \| 0 );
3321	return resultobj;
3322	fail:
3323	return NULL;
3324	}
3325
3326
3327	SWIGINTERN PyObject _wrap_Radio_Info_policy_engine_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3328	PyObject *resultobj = 0;
3329	Radio_Info arg1 = (Radio_Info ) 0 ;
3330	uint32_t arg2 ;
3331	void *argp1 = 0 ;
3332	int res1 = 0 ;
3333	int val2 ;
3334	int ecode2 = 0 ;
3335	PyObject * obj0 = 0 ;
3336	PyObject * obj1 = 0 ;
3337
3338	if (!PyArg_ParseTuple(args,(char *)"OO:Radio_Info_policy_engine_set",&obj0,&obj1)) SWIG_fail;
3339	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Radio_Info, 0 \| 0 );
3340	if (!SWIG_IsOK(res1)) {
3341	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Radio_Info_policy_engine_set" "', argument " "1"" of type '" "Radio_Info *""'");
3342	}
3343	arg1 = reinterpret_cast< Radio_Info * >(argp1);
3344	ecode2 = SWIG_AsVal_int(obj1, &val2);
3345	if (!SWIG_IsOK(ecode2)) {
3346	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Radio_Info_policy_engine_set" "', argument " "2"" of type '" "uint32_t""'");
3347	}
3348	arg2 = static_cast< uint32_t >(val2);
3349	if (arg1) (arg1)->policy_engine = arg2;
3350	resultobj = SWIG_Py_Void();
3351	return resultobj;
3352	fail:
3353	return NULL;
3354	}
3355
3356
3357	SWIGINTERN PyObject _wrap_Radio_Info_policy_engine_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3358	PyObject *resultobj = 0;
3359	Radio_Info arg1 = (Radio_Info ) 0 ;
3360	void *argp1 = 0 ;
3361	int res1 = 0 ;
3362	PyObject * obj0 = 0 ;
3363	uint32_t result;
3364
3365	if (!PyArg_ParseTuple(args,(char *)"O:Radio_Info_policy_engine_get",&obj0)) SWIG_fail;
3366	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Radio_Info, 0 \| 0 );
3367	if (!SWIG_IsOK(res1)) {
3368	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Radio_Info_policy_engine_get" "', argument " "1"" of type '" "Radio_Info *""'");
3369	}
3370	arg1 = reinterpret_cast< Radio_Info * >(argp1);
3371	result = ((arg1)->policy_engine);
3372	resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN \| 0 );
3373	return resultobj;
3374	fail:
3375	return NULL;
3376	}
3377
3378
3379	SWIGINTERN PyObject _wrap_Radio_Info_policy_socket_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3380	PyObject *resultobj = 0;
3381	Radio_Info arg1 = (Radio_Info ) 0 ;
3382	uint32_t arg2 ;
3383	void *argp1 = 0 ;
3384	int res1 = 0 ;
3385	int val2 ;
3386	int ecode2 = 0 ;
3387	PyObject * obj0 = 0 ;
3388	PyObject * obj1 = 0 ;
3389
3390	if (!PyArg_ParseTuple(args,(char *)"OO:Radio_Info_policy_socket_set",&obj0,&obj1)) SWIG_fail;
3391	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Radio_Info, 0 \| 0 );
3392	if (!SWIG_IsOK(res1)) {
3393	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Radio_Info_policy_socket_set" "', argument " "1"" of type '" "Radio_Info *""'");
3394	}
3395	arg1 = reinterpret_cast< Radio_Info * >(argp1);
3396	ecode2 = SWIG_AsVal_int(obj1, &val2);
3397	if (!SWIG_IsOK(ecode2)) {
3398	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Radio_Info_policy_socket_set" "', argument " "2"" of type '" "uint32_t""'");
3399	}
3400	arg2 = static_cast< uint32_t >(val2);
3401	if (arg1) (arg1)->policy_socket = arg2;
3402	resultobj = SWIG_Py_Void();
3403	return resultobj;
3404	fail:
3405	return NULL;
3406	}
3407
3408
3409	SWIGINTERN PyObject _wrap_Radio_Info_policy_socket_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3410	PyObject *resultobj = 0;
3411	Radio_Info arg1 = (Radio_Info ) 0 ;
3412	void *argp1 = 0 ;
3413	int res1 = 0 ;
3414	PyObject * obj0 = 0 ;
3415	uint32_t result;
3416
3417	if (!PyArg_ParseTuple(args,(char *)"O:Radio_Info_policy_socket_get",&obj0)) SWIG_fail;
3418	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Radio_Info, 0 \| 0 );
3419	if (!SWIG_IsOK(res1)) {
3420	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Radio_Info_policy_socket_get" "', argument " "1"" of type '" "Radio_Info *""'");
3421	}
3422	arg1 = reinterpret_cast< Radio_Info * >(argp1);
3423	result = ((arg1)->policy_socket);
3424	resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN \| 0 );
3425	return resultobj;
3426	fail:
3427	return NULL;
3428	}
3429
3430
3431	SWIGINTERN PyObject _wrap_Radio_Info_ce_socket_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3432	PyObject *resultobj = 0;
3433	Radio_Info arg1 = (Radio_Info ) 0 ;
3434	uint32_t arg2 ;
3435	void *argp1 = 0 ;
3436	int res1 = 0 ;
3437	int val2 ;
3438	int ecode2 = 0 ;
3439	PyObject * obj0 = 0 ;
3440	PyObject * obj1 = 0 ;
3441
3442	if (!PyArg_ParseTuple(args,(char *)"OO:Radio_Info_ce_socket_set",&obj0,&obj1)) SWIG_fail;
3443	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Radio_Info, 0 \| 0 );
3444	if (!SWIG_IsOK(res1)) {
3445	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Radio_Info_ce_socket_set" "', argument " "1"" of type '" "Radio_Info *""'");
3446	}
3447	arg1 = reinterpret_cast< Radio_Info * >(argp1);
3448	ecode2 = SWIG_AsVal_int(obj1, &val2);
3449	if (!SWIG_IsOK(ecode2)) {
3450	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Radio_Info_ce_socket_set" "', argument " "2"" of type '" "uint32_t""'");
3451	}
3452	arg2 = static_cast< uint32_t >(val2);
3453	if (arg1) (arg1)->ce_socket = arg2;
3454	resultobj = SWIG_Py_Void();
3455	return resultobj;
3456	fail:
3457	return NULL;
3458	}
3459
3460
3461	SWIGINTERN PyObject _wrap_Radio_Info_ce_socket_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3462	PyObject *resultobj = 0;
3463	Radio_Info arg1 = (Radio_Info ) 0 ;
3464	void *argp1 = 0 ;
3465	int res1 = 0 ;
3466	PyObject * obj0 = 0 ;
3467	uint32_t result;
3468
3469	if (!PyArg_ParseTuple(args,(char *)"O:Radio_Info_ce_socket_get",&obj0)) SWIG_fail;
3470	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Radio_Info, 0 \| 0 );
3471	if (!SWIG_IsOK(res1)) {
3472	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Radio_Info_ce_socket_get" "', argument " "1"" of type '" "Radio_Info *""'");
3473	}
3474	arg1 = reinterpret_cast< Radio_Info * >(argp1);
3475	result = ((arg1)->ce_socket);
3476	resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN \| 0 );
3477	return resultobj;
3478	fail:
3479	return NULL;
3480	}
3481
3482
3483	SWIGINTERN PyObject _wrap_new_Radio_Info(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3484	PyObject *resultobj = 0;
3485	Radio_Info *result = 0 ;
3486
3487	if (!PyArg_ParseTuple(args,(char *)":new_Radio_Info")) SWIG_fail;
3488	result = (Radio_Info *)new Radio_Info();
3489	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Radio_Info, SWIG_POINTER_NEW \| 0 );
3490	return resultobj;
3491	fail:
3492	return NULL;
3493	}
3494
3495
3496	SWIGINTERN PyObject _wrap_delete_Radio_Info(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3497	PyObject *resultobj = 0;
3498	Radio_Info arg1 = (Radio_Info ) 0 ;
3499	void *argp1 = 0 ;
3500	int res1 = 0 ;
3501	PyObject * obj0 = 0 ;
3502
3503	if (!PyArg_ParseTuple(args,(char *)"O:delete_Radio_Info",&obj0)) SWIG_fail;
3504	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Radio_Info, SWIG_POINTER_DISOWN \| 0 );
3505	if (!SWIG_IsOK(res1)) {
3506	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Radio_Info" "', argument " "1"" of type '" "Radio_Info *""'");
3507	}
3508	arg1 = reinterpret_cast< Radio_Info * >(argp1);
3509	delete arg1;
3510	resultobj = SWIG_Py_Void();
3511	return resultobj;
3512	fail:
3513	return NULL;
3514	}
3515
3516
3517	SWIGINTERN PyObject Radio_Info_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3518	PyObject *obj;
3519	if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
3520	SWIG_TypeNewClientData(SWIGTYPE_p_Radio_Info, SWIG_NewClientData(obj));
3521	return SWIG_Py_Void();
3522	}
3523
3524	SWIGINTERN PyObject _wrap_Utility_name_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3525	PyObject *resultobj = 0;
3526	Utility arg1 = (Utility ) 0 ;
3527	std::string *arg2 = 0 ;
3528	void *argp1 = 0 ;
3529	int res1 = 0 ;
3530	int res2 = SWIG_OLDOBJ ;
3531	PyObject * obj0 = 0 ;
3532	PyObject * obj1 = 0 ;
3533
3534	if (!PyArg_ParseTuple(args,(char *)"OO:Utility_name_set",&obj0,&obj1)) SWIG_fail;
3535	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Utility, 0 \| 0 );
3536	if (!SWIG_IsOK(res1)) {
3537	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Utility_name_set" "', argument " "1"" of type '" "Utility *""'");
3538	}
3539	arg1 = reinterpret_cast< Utility * >(argp1);
3540	{
3541	std::string ptr = (std::string )0;
3542	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
3543	if (!SWIG_IsOK(res2)) {
3544	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Utility_name_set" "', argument " "2"" of type '" "std::string const &""'");
3545	}
3546	if (!ptr) {
3547	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Utility_name_set" "', argument " "2"" of type '" "std::string const &""'");
3548	}
3549	arg2 = ptr;
3550	}
3551	if (arg1) (arg1)->name = *arg2;
3552	resultobj = SWIG_Py_Void();
3553	if (SWIG_IsNewObj(res2)) delete arg2;
3554	return resultobj;
3555	fail:
3556	if (SWIG_IsNewObj(res2)) delete arg2;
3557	return NULL;
3558	}
3559
3560
3561	SWIGINTERN PyObject _wrap_Utility_name_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3562	PyObject *resultobj = 0;
3563	Utility arg1 = (Utility ) 0 ;
3564	void *argp1 = 0 ;
3565	int res1 = 0 ;
3566	PyObject * obj0 = 0 ;
3567	std::string *result = 0 ;
3568
3569	if (!PyArg_ParseTuple(args,(char *)"O:Utility_name_get",&obj0)) SWIG_fail;
3570	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Utility, 0 \| 0 );
3571	if (!SWIG_IsOK(res1)) {
3572	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Utility_name_get" "', argument " "1"" of type '" "Utility *""'");
3573	}
3574	arg1 = reinterpret_cast< Utility * >(argp1);
3575	result = (std::string *) & ((arg1)->name);
3576	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
3577	return resultobj;
3578	fail:
3579	return NULL;
3580	}
3581
3582
3583	SWIGINTERN PyObject _wrap_Utility_units_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3584	PyObject *resultobj = 0;
3585	Utility arg1 = (Utility ) 0 ;
3586	std::string *arg2 = 0 ;
3587	void *argp1 = 0 ;
3588	int res1 = 0 ;
3589	int res2 = SWIG_OLDOBJ ;
3590	PyObject * obj0 = 0 ;
3591	PyObject * obj1 = 0 ;
3592
3593	if (!PyArg_ParseTuple(args,(char *)"OO:Utility_units_set",&obj0,&obj1)) SWIG_fail;
3594	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Utility, 0 \| 0 );
3595	if (!SWIG_IsOK(res1)) {
3596	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Utility_units_set" "', argument " "1"" of type '" "Utility *""'");
3597	}
3598	arg1 = reinterpret_cast< Utility * >(argp1);
3599	{
3600	std::string ptr = (std::string )0;
3601	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
3602	if (!SWIG_IsOK(res2)) {
3603	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Utility_units_set" "', argument " "2"" of type '" "std::string const &""'");
3604	}
3605	if (!ptr) {
3606	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Utility_units_set" "', argument " "2"" of type '" "std::string const &""'");
3607	}
3608	arg2 = ptr;
3609	}
3610	if (arg1) (arg1)->units = *arg2;
3611	resultobj = SWIG_Py_Void();
3612	if (SWIG_IsNewObj(res2)) delete arg2;
3613	return resultobj;
3614	fail:
3615	if (SWIG_IsNewObj(res2)) delete arg2;
3616	return NULL;
3617	}
3618
3619
3620	SWIGINTERN PyObject _wrap_Utility_units_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3621	PyObject *resultobj = 0;
3622	Utility arg1 = (Utility ) 0 ;
3623	void *argp1 = 0 ;
3624	int res1 = 0 ;
3625	PyObject * obj0 = 0 ;
3626	std::string *result = 0 ;
3627
3628	if (!PyArg_ParseTuple(args,(char *)"O:Utility_units_get",&obj0)) SWIG_fail;
3629	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Utility, 0 \| 0 );
3630	if (!SWIG_IsOK(res1)) {
3631	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Utility_units_get" "', argument " "1"" of type '" "Utility *""'");
3632	}
3633	arg1 = reinterpret_cast< Utility * >(argp1);
3634	result = (std::string *) & ((arg1)->units);
3635	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
3636	return resultobj;
3637	fail:
3638	return NULL;
3639	}
3640
3641
3642	SWIGINTERN PyObject _wrap_Utility_goal_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3643	PyObject *resultobj = 0;
3644	Utility arg1 = (Utility ) 0 ;
3645	std::string *arg2 = 0 ;
3646	void *argp1 = 0 ;
3647	int res1 = 0 ;
3648	int res2 = SWIG_OLDOBJ ;
3649	PyObject * obj0 = 0 ;
3650	PyObject * obj1 = 0 ;
3651
3652	if (!PyArg_ParseTuple(args,(char *)"OO:Utility_goal_set",&obj0,&obj1)) SWIG_fail;
3653	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Utility, 0 \| 0 );
3654	if (!SWIG_IsOK(res1)) {
3655	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Utility_goal_set" "', argument " "1"" of type '" "Utility *""'");
3656	}
3657	arg1 = reinterpret_cast< Utility * >(argp1);
3658	{
3659	std::string ptr = (std::string )0;
3660	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
3661	if (!SWIG_IsOK(res2)) {
3662	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Utility_goal_set" "', argument " "2"" of type '" "std::string const &""'");
3663	}
3664	if (!ptr) {
3665	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Utility_goal_set" "', argument " "2"" of type '" "std::string const &""'");
3666	}
3667	arg2 = ptr;
3668	}
3669	if (arg1) (arg1)->goal = *arg2;
3670	resultobj = SWIG_Py_Void();
3671	if (SWIG_IsNewObj(res2)) delete arg2;
3672	return resultobj;
3673	fail:
3674	if (SWIG_IsNewObj(res2)) delete arg2;
3675	return NULL;
3676	}
3677
3678
3679	SWIGINTERN PyObject _wrap_Utility_goal_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3680	PyObject *resultobj = 0;
3681	Utility arg1 = (Utility ) 0 ;
3682	void *argp1 = 0 ;
3683	int res1 = 0 ;
3684	PyObject * obj0 = 0 ;
3685	std::string *result = 0 ;
3686
3687	if (!PyArg_ParseTuple(args,(char *)"O:Utility_goal_get",&obj0)) SWIG_fail;
3688	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Utility, 0 \| 0 );
3689	if (!SWIG_IsOK(res1)) {
3690	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Utility_goal_get" "', argument " "1"" of type '" "Utility *""'");
3691	}
3692	arg1 = reinterpret_cast< Utility * >(argp1);
3693	result = (std::string *) & ((arg1)->goal);
3694	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
3695	return resultobj;
3696	fail:
3697	return NULL;
3698	}
3699
3700
3701	SWIGINTERN PyObject _wrap_Utility_target_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3702	PyObject *resultobj = 0;
3703	Utility arg1 = (Utility ) 0 ;
3704	float arg2 ;
3705	void *argp1 = 0 ;
3706	int res1 = 0 ;
3707	float val2 ;
3708	int ecode2 = 0 ;
3709	PyObject * obj0 = 0 ;
3710	PyObject * obj1 = 0 ;
3711
3712	if (!PyArg_ParseTuple(args,(char *)"OO:Utility_target_set",&obj0,&obj1)) SWIG_fail;
3713	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Utility, 0 \| 0 );
3714	if (!SWIG_IsOK(res1)) {
3715	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Utility_target_set" "', argument " "1"" of type '" "Utility *""'");
3716	}
3717	arg1 = reinterpret_cast< Utility * >(argp1);
3718	ecode2 = SWIG_AsVal_float(obj1, &val2);
3719	if (!SWIG_IsOK(ecode2)) {
3720	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Utility_target_set" "', argument " "2"" of type '" "float""'");
3721	}
3722	arg2 = static_cast< float >(val2);
3723	if (arg1) (arg1)->target = arg2;
3724	resultobj = SWIG_Py_Void();
3725	return resultobj;
3726	fail:
3727	return NULL;
3728	}
3729
3730
3731	SWIGINTERN PyObject _wrap_Utility_target_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3732	PyObject *resultobj = 0;
3733	Utility arg1 = (Utility ) 0 ;
3734	void *argp1 = 0 ;
3735	int res1 = 0 ;
3736	PyObject * obj0 = 0 ;
3737	float result;
3738
3739	if (!PyArg_ParseTuple(args,(char *)"O:Utility_target_get",&obj0)) SWIG_fail;
3740	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Utility, 0 \| 0 );
3741	if (!SWIG_IsOK(res1)) {
3742	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Utility_target_get" "', argument " "1"" of type '" "Utility *""'");
3743	}
3744	arg1 = reinterpret_cast< Utility * >(argp1);
3745	result = (float) ((arg1)->target);
3746	resultobj = SWIG_From_float(static_cast< float >(result));
3747	return resultobj;
3748	fail:
3749	return NULL;
3750	}
3751
3752
3753	SWIGINTERN PyObject _wrap_Utility_value_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3754	PyObject *resultobj = 0;
3755	Utility arg1 = (Utility ) 0 ;
3756	float arg2 ;
3757	void *argp1 = 0 ;
3758	int res1 = 0 ;
3759	float val2 ;
3760	int ecode2 = 0 ;
3761	PyObject * obj0 = 0 ;
3762	PyObject * obj1 = 0 ;
3763
3764	if (!PyArg_ParseTuple(args,(char *)"OO:Utility_value_set",&obj0,&obj1)) SWIG_fail;
3765	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Utility, 0 \| 0 );
3766	if (!SWIG_IsOK(res1)) {
3767	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Utility_value_set" "', argument " "1"" of type '" "Utility *""'");
3768	}
3769	arg1 = reinterpret_cast< Utility * >(argp1);
3770	ecode2 = SWIG_AsVal_float(obj1, &val2);
3771	if (!SWIG_IsOK(ecode2)) {
3772	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Utility_value_set" "', argument " "2"" of type '" "float""'");
3773	}
3774	arg2 = static_cast< float >(val2);
3775	if (arg1) (arg1)->value = arg2;
3776	resultobj = SWIG_Py_Void();
3777	return resultobj;
3778	fail:
3779	return NULL;
3780	}
3781
3782
3783	SWIGINTERN PyObject _wrap_Utility_value_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3784	PyObject *resultobj = 0;
3785	Utility arg1 = (Utility ) 0 ;
3786	void *argp1 = 0 ;
3787	int res1 = 0 ;
3788	PyObject * obj0 = 0 ;
3789	float result;
3790
3791	if (!PyArg_ParseTuple(args,(char *)"O:Utility_value_get",&obj0)) SWIG_fail;
3792	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Utility, 0 \| 0 );
3793	if (!SWIG_IsOK(res1)) {
3794	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Utility_value_get" "', argument " "1"" of type '" "Utility *""'");
3795	}
3796	arg1 = reinterpret_cast< Utility * >(argp1);
3797	result = (float) ((arg1)->value);
3798	resultobj = SWIG_From_float(static_cast< float >(result));
3799	return resultobj;
3800	fail:
3801	return NULL;
3802	}
3803
3804
3805	SWIGINTERN PyObject _wrap_new_Utility(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3806	PyObject *resultobj = 0;
3807	int arg1 ;
3808	int val1 ;
3809	int ecode1 = 0 ;
3810	PyObject * obj0 = 0 ;
3811	Utility *result = 0 ;
3812
3813	if (!PyArg_ParseTuple(args,(char *)"O:new_Utility",&obj0)) SWIG_fail;
3814	ecode1 = SWIG_AsVal_int(obj0, &val1);
3815	if (!SWIG_IsOK(ecode1)) {
3816	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Utility" "', argument " "1"" of type '" "int""'");
3817	}
3818	arg1 = static_cast< int >(val1);
3819	result = (Utility *)new_Utility(arg1);
3820	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Utility, SWIG_POINTER_NEW \| 0 );
3821	return resultobj;
3822	fail:
3823	return NULL;
3824	}
3825
3826
3827	SWIGINTERN PyObject _wrap_delete_Utility(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3828	PyObject *resultobj = 0;
3829	Utility arg1 = (Utility ) 0 ;
3830	void *argp1 = 0 ;
3831	int res1 = 0 ;
3832	PyObject * obj0 = 0 ;
3833
3834	if (!PyArg_ParseTuple(args,(char *)"O:delete_Utility",&obj0)) SWIG_fail;
3835	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Utility, SWIG_POINTER_DISOWN \| 0 );
3836	if (!SWIG_IsOK(res1)) {
3837	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Utility" "', argument " "1"" of type '" "Utility *""'");
3838	}
3839	arg1 = reinterpret_cast< Utility * >(argp1);
3840	delete_Utility(arg1);
3841	resultobj = SWIG_Py_Void();
3842	return resultobj;
3843	fail:
3844	return NULL;
3845	}
3846
3847
3848	SWIGINTERN PyObject _wrap_Utility___getitem__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3849	PyObject *resultobj = 0;
3850	Utility arg1 = (Utility ) 0 ;
3851	int arg2 ;
3852	void *argp1 = 0 ;
3853	int res1 = 0 ;
3854	int val2 ;
3855	int ecode2 = 0 ;
3856	PyObject * obj0 = 0 ;
3857	PyObject * obj1 = 0 ;
3858	Utility *result = 0 ;
3859
3860	if (!PyArg_ParseTuple(args,(char *)"OO:Utility___getitem__",&obj0,&obj1)) SWIG_fail;
3861	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Utility, 0 \| 0 );
3862	if (!SWIG_IsOK(res1)) {
3863	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Utility___getitem__" "', argument " "1"" of type '" "Utility *""'");
3864	}
3865	arg1 = reinterpret_cast< Utility * >(argp1);
3866	ecode2 = SWIG_AsVal_int(obj1, &val2);
3867	if (!SWIG_IsOK(ecode2)) {
3868	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Utility___getitem__" "', argument " "2"" of type '" "int""'");
3869	}
3870	arg2 = static_cast< int >(val2);
3871	result = (Utility *)Utility___getitem__(arg1,arg2);
3872	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Utility, 0 \| 0 );
3873	return resultobj;
3874	fail:
3875	return NULL;
3876	}
3877
3878
3879	SWIGINTERN PyObject Utility_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3880	PyObject *obj;
3881	if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
3882	SWIG_TypeNewClientData(SWIGTYPE_p_Utility, SWIG_NewClientData(obj));
3883	return SWIG_Py_Void();
3884	}
3885
3886	SWIGINTERN PyObject _wrap_Affect_u_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3887	PyObject *resultobj = 0;
3888	Affect arg1 = (Affect ) 0 ;
3889	Utility arg2 = (Utility ) 0 ;
3890	void *argp1 = 0 ;
3891	int res1 = 0 ;
3892	void *argp2 = 0 ;
3893	int res2 = 0 ;
3894	PyObject * obj0 = 0 ;
3895	PyObject * obj1 = 0 ;
3896
3897	if (!PyArg_ParseTuple(args,(char *)"OO:Affect_u_set",&obj0,&obj1)) SWIG_fail;
3898	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Affect, 0 \| 0 );
3899	if (!SWIG_IsOK(res1)) {
3900	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Affect_u_set" "', argument " "1"" of type '" "Affect *""'");
3901	}
3902	arg1 = reinterpret_cast< Affect * >(argp1);
3903	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Utility, SWIG_POINTER_DISOWN \| 0 );
3904	if (!SWIG_IsOK(res2)) {
3905	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Affect_u_set" "', argument " "2"" of type '" "Utility *""'");
3906	}
3907	arg2 = reinterpret_cast< Utility * >(argp2);
3908	if (arg1) (arg1)->u = arg2;
3909	resultobj = SWIG_Py_Void();
3910	return resultobj;
3911	fail:
3912	return NULL;
3913	}
3914
3915
3916	SWIGINTERN PyObject _wrap_Affect_u_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3917	PyObject *resultobj = 0;
3918	Affect arg1 = (Affect ) 0 ;
3919	void *argp1 = 0 ;
3920	int res1 = 0 ;
3921	PyObject * obj0 = 0 ;
3922	Utility *result = 0 ;
3923
3924	if (!PyArg_ParseTuple(args,(char *)"O:Affect_u_get",&obj0)) SWIG_fail;
3925	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Affect, 0 \| 0 );
3926	if (!SWIG_IsOK(res1)) {
3927	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Affect_u_get" "', argument " "1"" of type '" "Affect *""'");
3928	}
3929	arg1 = reinterpret_cast< Affect * >(argp1);
3930	result = (Utility *) ((arg1)->u);
3931	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Utility, 0 \| 0 );
3932	return resultobj;
3933	fail:
3934	return NULL;
3935	}
3936
3937
3938	SWIGINTERN PyObject _wrap_Affect_relation_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3939	PyObject *resultobj = 0;
3940	Affect arg1 = (Affect ) 0 ;
3941	std::string *arg2 = 0 ;
3942	void *argp1 = 0 ;
3943	int res1 = 0 ;
3944	int res2 = SWIG_OLDOBJ ;
3945	PyObject * obj0 = 0 ;
3946	PyObject * obj1 = 0 ;
3947
3948	if (!PyArg_ParseTuple(args,(char *)"OO:Affect_relation_set",&obj0,&obj1)) SWIG_fail;
3949	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Affect, 0 \| 0 );
3950	if (!SWIG_IsOK(res1)) {
3951	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Affect_relation_set" "', argument " "1"" of type '" "Affect *""'");
3952	}
3953	arg1 = reinterpret_cast< Affect * >(argp1);
3954	{
3955	std::string ptr = (std::string )0;
3956	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
3957	if (!SWIG_IsOK(res2)) {
3958	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Affect_relation_set" "', argument " "2"" of type '" "std::string const &""'");
3959	}
3960	if (!ptr) {
3961	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Affect_relation_set" "', argument " "2"" of type '" "std::string const &""'");
3962	}
3963	arg2 = ptr;
3964	}
3965	if (arg1) (arg1)->relation = *arg2;
3966	resultobj = SWIG_Py_Void();
3967	if (SWIG_IsNewObj(res2)) delete arg2;
3968	return resultobj;
3969	fail:
3970	if (SWIG_IsNewObj(res2)) delete arg2;
3971	return NULL;
3972	}
3973
3974
3975	SWIGINTERN PyObject _wrap_Affect_relation_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3976	PyObject *resultobj = 0;
3977	Affect arg1 = (Affect ) 0 ;
3978	void *argp1 = 0 ;
3979	int res1 = 0 ;
3980	PyObject * obj0 = 0 ;
3981	std::string *result = 0 ;
3982
3983	if (!PyArg_ParseTuple(args,(char *)"O:Affect_relation_get",&obj0)) SWIG_fail;
3984	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Affect, 0 \| 0 );
3985	if (!SWIG_IsOK(res1)) {
3986	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Affect_relation_get" "', argument " "1"" of type '" "Affect *""'");
3987	}
3988	arg1 = reinterpret_cast< Affect * >(argp1);
3989	result = (std::string *) & ((arg1)->relation);
3990	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
3991	return resultobj;
3992	fail:
3993	return NULL;
3994	}
3995
3996
3997	SWIGINTERN PyObject _wrap_new_Affect(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3998	PyObject *resultobj = 0;
3999	Affect *result = 0 ;
4000
4001	if (!PyArg_ParseTuple(args,(char *)":new_Affect")) SWIG_fail;
4002	result = (Affect *)new Affect();
4003	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Affect, SWIG_POINTER_NEW \| 0 );
4004	return resultobj;
4005	fail:
4006	return NULL;
4007	}
4008
4009
4010	SWIGINTERN PyObject _wrap_delete_Affect(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4011	PyObject *resultobj = 0;
4012	Affect arg1 = (Affect ) 0 ;
4013	void *argp1 = 0 ;
4014	int res1 = 0 ;
4015	PyObject * obj0 = 0 ;
4016
4017	if (!PyArg_ParseTuple(args,(char *)"O:delete_Affect",&obj0)) SWIG_fail;
4018	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Affect, SWIG_POINTER_DISOWN \| 0 );
4019	if (!SWIG_IsOK(res1)) {
4020	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Affect" "', argument " "1"" of type '" "Affect *""'");
4021	}
4022	arg1 = reinterpret_cast< Affect * >(argp1);
4023	delete arg1;
4024	resultobj = SWIG_Py_Void();
4025	return resultobj;
4026	fail:
4027	return NULL;
4028	}
4029
4030
4031	SWIGINTERN PyObject Affect_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4032	PyObject *obj;
4033	if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4034	SWIG_TypeNewClientData(SWIGTYPE_p_Affect, SWIG_NewClientData(obj));
4035	return SWIG_Py_Void();
4036	}
4037
4038	SWIGINTERN PyObject _wrap_Parameter_name_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4039	PyObject *resultobj = 0;
4040	Parameter arg1 = (Parameter ) 0 ;
4041	std::string *arg2 = 0 ;
4042	void *argp1 = 0 ;
4043	int res1 = 0 ;
4044	int res2 = SWIG_OLDOBJ ;
4045	PyObject * obj0 = 0 ;
4046	PyObject * obj1 = 0 ;
4047
4048	if (!PyArg_ParseTuple(args,(char *)"OO:Parameter_name_set",&obj0,&obj1)) SWIG_fail;
4049	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4050	if (!SWIG_IsOK(res1)) {
4051	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_name_set" "', argument " "1"" of type '" "Parameter *""'");
4052	}
4053	arg1 = reinterpret_cast< Parameter * >(argp1);
4054	{
4055	std::string ptr = (std::string )0;
4056	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
4057	if (!SWIG_IsOK(res2)) {
4058	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Parameter_name_set" "', argument " "2"" of type '" "std::string const &""'");
4059	}
4060	if (!ptr) {
4061	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Parameter_name_set" "', argument " "2"" of type '" "std::string const &""'");
4062	}
4063	arg2 = ptr;
4064	}
4065	if (arg1) (arg1)->name = *arg2;
4066	resultobj = SWIG_Py_Void();
4067	if (SWIG_IsNewObj(res2)) delete arg2;
4068	return resultobj;
4069	fail:
4070	if (SWIG_IsNewObj(res2)) delete arg2;
4071	return NULL;
4072	}
4073
4074
4075	SWIGINTERN PyObject _wrap_Parameter_name_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4076	PyObject *resultobj = 0;
4077	Parameter arg1 = (Parameter ) 0 ;
4078	void *argp1 = 0 ;
4079	int res1 = 0 ;
4080	PyObject * obj0 = 0 ;
4081	std::string *result = 0 ;
4082
4083	if (!PyArg_ParseTuple(args,(char *)"O:Parameter_name_get",&obj0)) SWIG_fail;
4084	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4085	if (!SWIG_IsOK(res1)) {
4086	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_name_get" "', argument " "1"" of type '" "Parameter *""'");
4087	}
4088	arg1 = reinterpret_cast< Parameter * >(argp1);
4089	result = (std::string *) & ((arg1)->name);
4090	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
4091	return resultobj;
4092	fail:
4093	return NULL;
4094	}
4095
4096
4097	SWIGINTERN PyObject _wrap_Parameter_units_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4098	PyObject *resultobj = 0;
4099	Parameter arg1 = (Parameter ) 0 ;
4100	std::string *arg2 = 0 ;
4101	void *argp1 = 0 ;
4102	int res1 = 0 ;
4103	int res2 = SWIG_OLDOBJ ;
4104	PyObject * obj0 = 0 ;
4105	PyObject * obj1 = 0 ;
4106
4107	if (!PyArg_ParseTuple(args,(char *)"OO:Parameter_units_set",&obj0,&obj1)) SWIG_fail;
4108	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4109	if (!SWIG_IsOK(res1)) {
4110	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_units_set" "', argument " "1"" of type '" "Parameter *""'");
4111	}
4112	arg1 = reinterpret_cast< Parameter * >(argp1);
4113	{
4114	std::string ptr = (std::string )0;
4115	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
4116	if (!SWIG_IsOK(res2)) {
4117	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Parameter_units_set" "', argument " "2"" of type '" "std::string const &""'");
4118	}
4119	if (!ptr) {
4120	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Parameter_units_set" "', argument " "2"" of type '" "std::string const &""'");
4121	}
4122	arg2 = ptr;
4123	}
4124	if (arg1) (arg1)->units = *arg2;
4125	resultobj = SWIG_Py_Void();
4126	if (SWIG_IsNewObj(res2)) delete arg2;
4127	return resultobj;
4128	fail:
4129	if (SWIG_IsNewObj(res2)) delete arg2;
4130	return NULL;
4131	}
4132
4133
4134	SWIGINTERN PyObject _wrap_Parameter_units_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4135	PyObject *resultobj = 0;
4136	Parameter arg1 = (Parameter ) 0 ;
4137	void *argp1 = 0 ;
4138	int res1 = 0 ;
4139	PyObject * obj0 = 0 ;
4140	std::string *result = 0 ;
4141
4142	if (!PyArg_ParseTuple(args,(char *)"O:Parameter_units_get",&obj0)) SWIG_fail;
4143	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4144	if (!SWIG_IsOK(res1)) {
4145	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_units_get" "', argument " "1"" of type '" "Parameter *""'");
4146	}
4147	arg1 = reinterpret_cast< Parameter * >(argp1);
4148	result = (std::string *) & ((arg1)->units);
4149	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
4150	return resultobj;
4151	fail:
4152	return NULL;
4153	}
4154
4155
4156	SWIGINTERN PyObject _wrap_Parameter_min_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4157	PyObject *resultobj = 0;
4158	Parameter arg1 = (Parameter ) 0 ;
4159	float arg2 ;
4160	void *argp1 = 0 ;
4161	int res1 = 0 ;
4162	float val2 ;
4163	int ecode2 = 0 ;
4164	PyObject * obj0 = 0 ;
4165	PyObject * obj1 = 0 ;
4166
4167	if (!PyArg_ParseTuple(args,(char *)"OO:Parameter_min_set",&obj0,&obj1)) SWIG_fail;
4168	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4169	if (!SWIG_IsOK(res1)) {
4170	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_min_set" "', argument " "1"" of type '" "Parameter *""'");
4171	}
4172	arg1 = reinterpret_cast< Parameter * >(argp1);
4173	ecode2 = SWIG_AsVal_float(obj1, &val2);
4174	if (!SWIG_IsOK(ecode2)) {
4175	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parameter_min_set" "', argument " "2"" of type '" "float""'");
4176	}
4177	arg2 = static_cast< float >(val2);
4178	if (arg1) (arg1)->min = arg2;
4179	resultobj = SWIG_Py_Void();
4180	return resultobj;
4181	fail:
4182	return NULL;
4183	}
4184
4185
4186	SWIGINTERN PyObject _wrap_Parameter_min_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4187	PyObject *resultobj = 0;
4188	Parameter arg1 = (Parameter ) 0 ;
4189	void *argp1 = 0 ;
4190	int res1 = 0 ;
4191	PyObject * obj0 = 0 ;
4192	float result;
4193
4194	if (!PyArg_ParseTuple(args,(char *)"O:Parameter_min_get",&obj0)) SWIG_fail;
4195	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4196	if (!SWIG_IsOK(res1)) {
4197	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_min_get" "', argument " "1"" of type '" "Parameter *""'");
4198	}
4199	arg1 = reinterpret_cast< Parameter * >(argp1);
4200	result = (float) ((arg1)->min);
4201	resultobj = SWIG_From_float(static_cast< float >(result));
4202	return resultobj;
4203	fail:
4204	return NULL;
4205	}
4206
4207
4208	SWIGINTERN PyObject _wrap_Parameter_numAffects_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4209	PyObject *resultobj = 0;
4210	Parameter arg1 = (Parameter ) 0 ;
4211	uint32_t arg2 ;
4212	void *argp1 = 0 ;
4213	int res1 = 0 ;
4214	int val2 ;
4215	int ecode2 = 0 ;
4216	PyObject * obj0 = 0 ;
4217	PyObject * obj1 = 0 ;
4218
4219	if (!PyArg_ParseTuple(args,(char *)"OO:Parameter_numAffects_set",&obj0,&obj1)) SWIG_fail;
4220	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4221	if (!SWIG_IsOK(res1)) {
4222	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_numAffects_set" "', argument " "1"" of type '" "Parameter *""'");
4223	}
4224	arg1 = reinterpret_cast< Parameter * >(argp1);
4225	ecode2 = SWIG_AsVal_int(obj1, &val2);
4226	if (!SWIG_IsOK(ecode2)) {
4227	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parameter_numAffects_set" "', argument " "2"" of type '" "uint32_t""'");
4228	}
4229	arg2 = static_cast< uint32_t >(val2);
4230	if (arg1) (arg1)->numAffects = arg2;
4231	resultobj = SWIG_Py_Void();
4232	return resultobj;
4233	fail:
4234	return NULL;
4235	}
4236
4237
4238	SWIGINTERN PyObject _wrap_Parameter_numAffects_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4239	PyObject *resultobj = 0;
4240	Parameter arg1 = (Parameter ) 0 ;
4241	void *argp1 = 0 ;
4242	int res1 = 0 ;
4243	PyObject * obj0 = 0 ;
4244	uint32_t result;
4245
4246	if (!PyArg_ParseTuple(args,(char *)"O:Parameter_numAffects_get",&obj0)) SWIG_fail;
4247	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4248	if (!SWIG_IsOK(res1)) {
4249	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_numAffects_get" "', argument " "1"" of type '" "Parameter *""'");
4250	}
4251	arg1 = reinterpret_cast< Parameter * >(argp1);
4252	result = ((arg1)->numAffects);
4253	resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN \| 0 );
4254	return resultobj;
4255	fail:
4256	return NULL;
4257	}
4258
4259
4260	SWIGINTERN PyObject _wrap_Parameter_affection_list_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4261	PyObject *resultobj = 0;
4262	Parameter arg1 = (Parameter ) 0 ;
4263	Affect *arg2 ;
4264	void *argp1 = 0 ;
4265	int res1 = 0 ;
4266	void *argp2 = 0 ;
4267	int res2 = 0 ;
4268	PyObject * obj0 = 0 ;
4269	PyObject * obj1 = 0 ;
4270
4271	if (!PyArg_ParseTuple(args,(char *)"OO:Parameter_affection_list_set",&obj0,&obj1)) SWIG_fail;
4272	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4273	if (!SWIG_IsOK(res1)) {
4274	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_affection_list_set" "', argument " "1"" of type '" "Parameter *""'");
4275	}
4276	arg1 = reinterpret_cast< Parameter * >(argp1);
4277	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Affect, 0 \| 0 );
4278	if (!SWIG_IsOK(res2)) {
4279	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Parameter_affection_list_set" "', argument " "2"" of type '" "Affect [10]""'");
4280	}
4281	arg2 = reinterpret_cast< Affect * >(argp2);
4282	{
4283	if (arg2) {
4284	size_t ii = 0;
4285	for (; ii < (size_t)10; ++ii) arg1->affection_list[ii] = arg2[ii];
4286	} else {
4287	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""affection_list""' of type '""Affect [10]""'");
4288	}
4289	}
4290	resultobj = SWIG_Py_Void();
4291	return resultobj;
4292	fail:
4293	return NULL;
4294	}
4295
4296
4297	SWIGINTERN PyObject _wrap_Parameter_affection_list_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4298	PyObject *resultobj = 0;
4299	Parameter arg1 = (Parameter ) 0 ;
4300	void *argp1 = 0 ;
4301	int res1 = 0 ;
4302	PyObject * obj0 = 0 ;
4303	Affect *result = 0 ;
4304
4305	if (!PyArg_ParseTuple(args,(char *)"O:Parameter_affection_list_get",&obj0)) SWIG_fail;
4306	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4307	if (!SWIG_IsOK(res1)) {
4308	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_affection_list_get" "', argument " "1"" of type '" "Parameter *""'");
4309	}
4310	arg1 = reinterpret_cast< Parameter * >(argp1);
4311	result = (Affect )(Affect ) ((arg1)->affection_list);
4312	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Affect, 0 \| 0 );
4313	return resultobj;
4314	fail:
4315	return NULL;
4316	}
4317
4318
4319	SWIGINTERN PyObject _wrap_Parameter_max_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4320	PyObject *resultobj = 0;
4321	Parameter arg1 = (Parameter ) 0 ;
4322	float arg2 ;
4323	void *argp1 = 0 ;
4324	int res1 = 0 ;
4325	float val2 ;
4326	int ecode2 = 0 ;
4327	PyObject * obj0 = 0 ;
4328	PyObject * obj1 = 0 ;
4329
4330	if (!PyArg_ParseTuple(args,(char *)"OO:Parameter_max_set",&obj0,&obj1)) SWIG_fail;
4331	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4332	if (!SWIG_IsOK(res1)) {
4333	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_max_set" "', argument " "1"" of type '" "Parameter *""'");
4334	}
4335	arg1 = reinterpret_cast< Parameter * >(argp1);
4336	ecode2 = SWIG_AsVal_float(obj1, &val2);
4337	if (!SWIG_IsOK(ecode2)) {
4338	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parameter_max_set" "', argument " "2"" of type '" "float""'");
4339	}
4340	arg2 = static_cast< float >(val2);
4341	if (arg1) (arg1)->max = arg2;
4342	resultobj = SWIG_Py_Void();
4343	return resultobj;
4344	fail:
4345	return NULL;
4346	}
4347
4348
4349	SWIGINTERN PyObject _wrap_Parameter_max_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4350	PyObject *resultobj = 0;
4351	Parameter arg1 = (Parameter ) 0 ;
4352	void *argp1 = 0 ;
4353	int res1 = 0 ;
4354	PyObject * obj0 = 0 ;
4355	float result;
4356
4357	if (!PyArg_ParseTuple(args,(char *)"O:Parameter_max_get",&obj0)) SWIG_fail;
4358	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4359	if (!SWIG_IsOK(res1)) {
4360	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_max_get" "', argument " "1"" of type '" "Parameter *""'");
4361	}
4362	arg1 = reinterpret_cast< Parameter * >(argp1);
4363	result = (float) ((arg1)->max);
4364	resultobj = SWIG_From_float(static_cast< float >(result));
4365	return resultobj;
4366	fail:
4367	return NULL;
4368	}
4369
4370
4371	SWIGINTERN PyObject _wrap_Parameter_step_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4372	PyObject *resultobj = 0;
4373	Parameter arg1 = (Parameter ) 0 ;
4374	float arg2 ;
4375	void *argp1 = 0 ;
4376	int res1 = 0 ;
4377	float val2 ;
4378	int ecode2 = 0 ;
4379	PyObject * obj0 = 0 ;
4380	PyObject * obj1 = 0 ;
4381
4382	if (!PyArg_ParseTuple(args,(char *)"OO:Parameter_step_set",&obj0,&obj1)) SWIG_fail;
4383	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4384	if (!SWIG_IsOK(res1)) {
4385	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_step_set" "', argument " "1"" of type '" "Parameter *""'");
4386	}
4387	arg1 = reinterpret_cast< Parameter * >(argp1);
4388	ecode2 = SWIG_AsVal_float(obj1, &val2);
4389	if (!SWIG_IsOK(ecode2)) {
4390	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parameter_step_set" "', argument " "2"" of type '" "float""'");
4391	}
4392	arg2 = static_cast< float >(val2);
4393	if (arg1) (arg1)->step = arg2;
4394	resultobj = SWIG_Py_Void();
4395	return resultobj;
4396	fail:
4397	return NULL;
4398	}
4399
4400
4401	SWIGINTERN PyObject _wrap_Parameter_step_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4402	PyObject *resultobj = 0;
4403	Parameter arg1 = (Parameter ) 0 ;
4404	void *argp1 = 0 ;
4405	int res1 = 0 ;
4406	PyObject * obj0 = 0 ;
4407	float result;
4408
4409	if (!PyArg_ParseTuple(args,(char *)"O:Parameter_step_get",&obj0)) SWIG_fail;
4410	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4411	if (!SWIG_IsOK(res1)) {
4412	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_step_get" "', argument " "1"" of type '" "Parameter *""'");
4413	}
4414	arg1 = reinterpret_cast< Parameter * >(argp1);
4415	result = (float) ((arg1)->step);
4416	resultobj = SWIG_From_float(static_cast< float >(result));
4417	return resultobj;
4418	fail:
4419	return NULL;
4420	}
4421
4422
4423	SWIGINTERN PyObject _wrap_Parameter_value_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4424	PyObject *resultobj = 0;
4425	Parameter arg1 = (Parameter ) 0 ;
4426	float arg2 ;
4427	void *argp1 = 0 ;
4428	int res1 = 0 ;
4429	float val2 ;
4430	int ecode2 = 0 ;
4431	PyObject * obj0 = 0 ;
4432	PyObject * obj1 = 0 ;
4433
4434	if (!PyArg_ParseTuple(args,(char *)"OO:Parameter_value_set",&obj0,&obj1)) SWIG_fail;
4435	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4436	if (!SWIG_IsOK(res1)) {
4437	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_value_set" "', argument " "1"" of type '" "Parameter *""'");
4438	}
4439	arg1 = reinterpret_cast< Parameter * >(argp1);
4440	ecode2 = SWIG_AsVal_float(obj1, &val2);
4441	if (!SWIG_IsOK(ecode2)) {
4442	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parameter_value_set" "', argument " "2"" of type '" "float""'");
4443	}
4444	arg2 = static_cast< float >(val2);
4445	if (arg1) (arg1)->value = arg2;
4446	resultobj = SWIG_Py_Void();
4447	return resultobj;
4448	fail:
4449	return NULL;
4450	}
4451
4452
4453	SWIGINTERN PyObject _wrap_Parameter_value_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4454	PyObject *resultobj = 0;
4455	Parameter arg1 = (Parameter ) 0 ;
4456	void *argp1 = 0 ;
4457	int res1 = 0 ;
4458	PyObject * obj0 = 0 ;
4459	float result;
4460
4461	if (!PyArg_ParseTuple(args,(char *)"O:Parameter_value_get",&obj0)) SWIG_fail;
4462	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4463	if (!SWIG_IsOK(res1)) {
4464	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_value_get" "', argument " "1"" of type '" "Parameter *""'");
4465	}
4466	arg1 = reinterpret_cast< Parameter * >(argp1);
4467	result = (float) ((arg1)->value);
4468	resultobj = SWIG_From_float(static_cast< float >(result));
4469	return resultobj;
4470	fail:
4471	return NULL;
4472	}
4473
4474
4475	SWIGINTERN PyObject _wrap_new_Parameter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4476	PyObject *resultobj = 0;
4477	int arg1 ;
4478	int val1 ;
4479	int ecode1 = 0 ;
4480	PyObject * obj0 = 0 ;
4481	Parameter *result = 0 ;
4482
4483	if (!PyArg_ParseTuple(args,(char *)"O:new_Parameter",&obj0)) SWIG_fail;
4484	ecode1 = SWIG_AsVal_int(obj0, &val1);
4485	if (!SWIG_IsOK(ecode1)) {
4486	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Parameter" "', argument " "1"" of type '" "int""'");
4487	}
4488	arg1 = static_cast< int >(val1);
4489	result = (Parameter *)new_Parameter(arg1);
4490	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, SWIG_POINTER_NEW \| 0 );
4491	return resultobj;
4492	fail:
4493	return NULL;
4494	}
4495
4496
4497	SWIGINTERN PyObject _wrap_delete_Parameter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4498	PyObject *resultobj = 0;
4499	Parameter arg1 = (Parameter ) 0 ;
4500	void *argp1 = 0 ;
4501	int res1 = 0 ;
4502	PyObject * obj0 = 0 ;
4503
4504	if (!PyArg_ParseTuple(args,(char *)"O:delete_Parameter",&obj0)) SWIG_fail;
4505	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, SWIG_POINTER_DISOWN \| 0 );
4506	if (!SWIG_IsOK(res1)) {
4507	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Parameter" "', argument " "1"" of type '" "Parameter *""'");
4508	}
4509	arg1 = reinterpret_cast< Parameter * >(argp1);
4510	delete_Parameter(arg1);
4511	resultobj = SWIG_Py_Void();
4512	return resultobj;
4513	fail:
4514	return NULL;
4515	}
4516
4517
4518	SWIGINTERN PyObject _wrap_Parameter___getitem__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4519	PyObject *resultobj = 0;
4520	Parameter arg1 = (Parameter ) 0 ;
4521	int arg2 ;
4522	void *argp1 = 0 ;
4523	int res1 = 0 ;
4524	int val2 ;
4525	int ecode2 = 0 ;
4526	PyObject * obj0 = 0 ;
4527	PyObject * obj1 = 0 ;
4528	Parameter *result = 0 ;
4529
4530	if (!PyArg_ParseTuple(args,(char *)"OO:Parameter___getitem__",&obj0,&obj1)) SWIG_fail;
4531	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
4532	if (!SWIG_IsOK(res1)) {
4533	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter___getitem__" "', argument " "1"" of type '" "Parameter *""'");
4534	}
4535	arg1 = reinterpret_cast< Parameter * >(argp1);
4536	ecode2 = SWIG_AsVal_int(obj1, &val2);
4537	if (!SWIG_IsOK(ecode2)) {
4538	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parameter___getitem__" "', argument " "2"" of type '" "int""'");
4539	}
4540	arg2 = static_cast< int >(val2);
4541	result = (Parameter *)Parameter___getitem__(arg1,arg2);
4542	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 \| 0 );
4543	return resultobj;
4544	fail:
4545	return NULL;
4546	}
4547
4548
4549	SWIGINTERN PyObject Parameter_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4550	PyObject *obj;
4551	if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4552	SWIG_TypeNewClientData(SWIGTYPE_p_Parameter, SWIG_NewClientData(obj));
4553	return SWIG_Py_Void();
4554	}
4555
4556	SWIGINTERN PyObject _wrap_Observable_name_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4557	PyObject *resultobj = 0;
4558	Observable arg1 = (Observable ) 0 ;
4559	std::string *arg2 = 0 ;
4560	void *argp1 = 0 ;
4561	int res1 = 0 ;
4562	int res2 = SWIG_OLDOBJ ;
4563	PyObject * obj0 = 0 ;
4564	PyObject * obj1 = 0 ;
4565
4566	if (!PyArg_ParseTuple(args,(char *)"OO:Observable_name_set",&obj0,&obj1)) SWIG_fail;
4567	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Observable, 0 \| 0 );
4568	if (!SWIG_IsOK(res1)) {
4569	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Observable_name_set" "', argument " "1"" of type '" "Observable *""'");
4570	}
4571	arg1 = reinterpret_cast< Observable * >(argp1);
4572	{
4573	std::string ptr = (std::string )0;
4574	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
4575	if (!SWIG_IsOK(res2)) {
4576	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Observable_name_set" "', argument " "2"" of type '" "std::string const &""'");
4577	}
4578	if (!ptr) {
4579	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Observable_name_set" "', argument " "2"" of type '" "std::string const &""'");
4580	}
4581	arg2 = ptr;
4582	}
4583	if (arg1) (arg1)->name = *arg2;
4584	resultobj = SWIG_Py_Void();
4585	if (SWIG_IsNewObj(res2)) delete arg2;
4586	return resultobj;
4587	fail:
4588	if (SWIG_IsNewObj(res2)) delete arg2;
4589	return NULL;
4590	}
4591
4592
4593	SWIGINTERN PyObject _wrap_Observable_name_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4594	PyObject *resultobj = 0;
4595	Observable arg1 = (Observable ) 0 ;
4596	void *argp1 = 0 ;
4597	int res1 = 0 ;
4598	PyObject * obj0 = 0 ;
4599	std::string *result = 0 ;
4600
4601	if (!PyArg_ParseTuple(args,(char *)"O:Observable_name_get",&obj0)) SWIG_fail;
4602	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Observable, 0 \| 0 );
4603	if (!SWIG_IsOK(res1)) {
4604	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Observable_name_get" "', argument " "1"" of type '" "Observable *""'");
4605	}
4606	arg1 = reinterpret_cast< Observable * >(argp1);
4607	result = (std::string *) & ((arg1)->name);
4608	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
4609	return resultobj;
4610	fail:
4611	return NULL;
4612	}
4613
4614
4615	SWIGINTERN PyObject _wrap_Observable_affection_list_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4616	PyObject *resultobj = 0;
4617	Observable arg1 = (Observable ) 0 ;
4618	Affect *arg2 ;
4619	void *argp1 = 0 ;
4620	int res1 = 0 ;
4621	void *argp2 = 0 ;
4622	int res2 = 0 ;
4623	PyObject * obj0 = 0 ;
4624	PyObject * obj1 = 0 ;
4625
4626	if (!PyArg_ParseTuple(args,(char *)"OO:Observable_affection_list_set",&obj0,&obj1)) SWIG_fail;
4627	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Observable, 0 \| 0 );
4628	if (!SWIG_IsOK(res1)) {
4629	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Observable_affection_list_set" "', argument " "1"" of type '" "Observable *""'");
4630	}
4631	arg1 = reinterpret_cast< Observable * >(argp1);
4632	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Affect, 0 \| 0 );
4633	if (!SWIG_IsOK(res2)) {
4634	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Observable_affection_list_set" "', argument " "2"" of type '" "Affect [10]""'");
4635	}
4636	arg2 = reinterpret_cast< Affect * >(argp2);
4637	{
4638	if (arg2) {
4639	size_t ii = 0;
4640	for (; ii < (size_t)10; ++ii) arg1->affection_list[ii] = arg2[ii];
4641	} else {
4642	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""affection_list""' of type '""Affect [10]""'");
4643	}
4644	}
4645	resultobj = SWIG_Py_Void();
4646	return resultobj;
4647	fail:
4648	return NULL;
4649	}
4650
4651
4652	SWIGINTERN PyObject _wrap_Observable_affection_list_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4653	PyObject *resultobj = 0;
4654	Observable arg1 = (Observable ) 0 ;
4655	void *argp1 = 0 ;
4656	int res1 = 0 ;
4657	PyObject * obj0 = 0 ;
4658	Affect *result = 0 ;
4659
4660	if (!PyArg_ParseTuple(args,(char *)"O:Observable_affection_list_get",&obj0)) SWIG_fail;
4661	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Observable, 0 \| 0 );
4662	if (!SWIG_IsOK(res1)) {
4663	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Observable_affection_list_get" "', argument " "1"" of type '" "Observable *""'");
4664	}
4665	arg1 = reinterpret_cast< Observable * >(argp1);
4666	result = (Affect )(Affect ) ((arg1)->affection_list);
4667	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Affect, 0 \| 0 );
4668	return resultobj;
4669	fail:
4670	return NULL;
4671	}
4672
4673
4674	SWIGINTERN PyObject _wrap_Observable_numAffects_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4675	PyObject *resultobj = 0;
4676	Observable arg1 = (Observable ) 0 ;
4677	uint32_t arg2 ;
4678	void *argp1 = 0 ;
4679	int res1 = 0 ;
4680	int val2 ;
4681	int ecode2 = 0 ;
4682	PyObject * obj0 = 0 ;
4683	PyObject * obj1 = 0 ;
4684
4685	if (!PyArg_ParseTuple(args,(char *)"OO:Observable_numAffects_set",&obj0,&obj1)) SWIG_fail;
4686	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Observable, 0 \| 0 );
4687	if (!SWIG_IsOK(res1)) {
4688	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Observable_numAffects_set" "', argument " "1"" of type '" "Observable *""'");
4689	}
4690	arg1 = reinterpret_cast< Observable * >(argp1);
4691	ecode2 = SWIG_AsVal_int(obj1, &val2);
4692	if (!SWIG_IsOK(ecode2)) {
4693	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Observable_numAffects_set" "', argument " "2"" of type '" "uint32_t""'");
4694	}
4695	arg2 = static_cast< uint32_t >(val2);
4696	if (arg1) (arg1)->numAffects = arg2;
4697	resultobj = SWIG_Py_Void();
4698	return resultobj;
4699	fail:
4700	return NULL;
4701	}
4702
4703
4704	SWIGINTERN PyObject _wrap_Observable_numAffects_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4705	PyObject *resultobj = 0;
4706	Observable arg1 = (Observable ) 0 ;
4707	void *argp1 = 0 ;
4708	int res1 = 0 ;
4709	PyObject * obj0 = 0 ;
4710	uint32_t result;
4711
4712	if (!PyArg_ParseTuple(args,(char *)"O:Observable_numAffects_get",&obj0)) SWIG_fail;
4713	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Observable, 0 \| 0 );
4714	if (!SWIG_IsOK(res1)) {
4715	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Observable_numAffects_get" "', argument " "1"" of type '" "Observable *""'");
4716	}
4717	arg1 = reinterpret_cast< Observable * >(argp1);
4718	result = ((arg1)->numAffects);
4719	resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN \| 0 );
4720	return resultobj;
4721	fail:
4722	return NULL;
4723	}
4724
4725
4726	SWIGINTERN PyObject _wrap_Observable_value_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4727	PyObject *resultobj = 0;
4728	Observable arg1 = (Observable ) 0 ;
4729	float arg2 ;
4730	void *argp1 = 0 ;
4731	int res1 = 0 ;
4732	float val2 ;
4733	int ecode2 = 0 ;
4734	PyObject * obj0 = 0 ;
4735	PyObject * obj1 = 0 ;
4736
4737	if (!PyArg_ParseTuple(args,(char *)"OO:Observable_value_set",&obj0,&obj1)) SWIG_fail;
4738	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Observable, 0 \| 0 );
4739	if (!SWIG_IsOK(res1)) {
4740	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Observable_value_set" "', argument " "1"" of type '" "Observable *""'");
4741	}
4742	arg1 = reinterpret_cast< Observable * >(argp1);
4743	ecode2 = SWIG_AsVal_float(obj1, &val2);
4744	if (!SWIG_IsOK(ecode2)) {
4745	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Observable_value_set" "', argument " "2"" of type '" "float""'");
4746	}
4747	arg2 = static_cast< float >(val2);
4748	if (arg1) (arg1)->value = arg2;
4749	resultobj = SWIG_Py_Void();
4750	return resultobj;
4751	fail:
4752	return NULL;
4753	}
4754
4755
4756	SWIGINTERN PyObject _wrap_Observable_value_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4757	PyObject *resultobj = 0;
4758	Observable arg1 = (Observable ) 0 ;
4759	void *argp1 = 0 ;
4760	int res1 = 0 ;
4761	PyObject * obj0 = 0 ;
4762	float result;
4763
4764	if (!PyArg_ParseTuple(args,(char *)"O:Observable_value_get",&obj0)) SWIG_fail;
4765	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Observable, 0 \| 0 );
4766	if (!SWIG_IsOK(res1)) {
4767	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Observable_value_get" "', argument " "1"" of type '" "Observable *""'");
4768	}
4769	arg1 = reinterpret_cast< Observable * >(argp1);
4770	result = (float) ((arg1)->value);
4771	resultobj = SWIG_From_float(static_cast< float >(result));
4772	return resultobj;
4773	fail:
4774	return NULL;
4775	}
4776
4777
4778	SWIGINTERN PyObject _wrap_new_Observable(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4779	PyObject *resultobj = 0;
4780	int arg1 ;
4781	int val1 ;
4782	int ecode1 = 0 ;
4783	PyObject * obj0 = 0 ;
4784	Observable *result = 0 ;
4785
4786	if (!PyArg_ParseTuple(args,(char *)"O:new_Observable",&obj0)) SWIG_fail;
4787	ecode1 = SWIG_AsVal_int(obj0, &val1);
4788	if (!SWIG_IsOK(ecode1)) {
4789	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Observable" "', argument " "1"" of type '" "int""'");
4790	}
4791	arg1 = static_cast< int >(val1);
4792	result = (Observable *)new_Observable(arg1);
4793	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Observable, SWIG_POINTER_NEW \| 0 );
4794	return resultobj;
4795	fail:
4796	return NULL;
4797	}
4798
4799
4800	SWIGINTERN PyObject _wrap_delete_Observable(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4801	PyObject *resultobj = 0;
4802	Observable arg1 = (Observable ) 0 ;
4803	void *argp1 = 0 ;
4804	int res1 = 0 ;
4805	PyObject * obj0 = 0 ;
4806
4807	if (!PyArg_ParseTuple(args,(char *)"O:delete_Observable",&obj0)) SWIG_fail;
4808	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Observable, SWIG_POINTER_DISOWN \| 0 );
4809	if (!SWIG_IsOK(res1)) {
4810	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Observable" "', argument " "1"" of type '" "Observable *""'");
4811	}
4812	arg1 = reinterpret_cast< Observable * >(argp1);
4813	delete_Observable(arg1);
4814	resultobj = SWIG_Py_Void();
4815	return resultobj;
4816	fail:
4817	return NULL;
4818	}
4819
4820
4821	SWIGINTERN PyObject _wrap_Observable___getitem__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4822	PyObject *resultobj = 0;
4823	Observable arg1 = (Observable ) 0 ;
4824	int arg2 ;
4825	void *argp1 = 0 ;
4826	int res1 = 0 ;
4827	int val2 ;
4828	int ecode2 = 0 ;
4829	PyObject * obj0 = 0 ;
4830	PyObject * obj1 = 0 ;
4831	Observable *result = 0 ;
4832
4833	if (!PyArg_ParseTuple(args,(char *)"OO:Observable___getitem__",&obj0,&obj1)) SWIG_fail;
4834	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Observable, 0 \| 0 );
4835	if (!SWIG_IsOK(res1)) {
4836	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Observable___getitem__" "', argument " "1"" of type '" "Observable *""'");
4837	}
4838	arg1 = reinterpret_cast< Observable * >(argp1);
4839	ecode2 = SWIG_AsVal_int(obj1, &val2);
4840	if (!SWIG_IsOK(ecode2)) {
4841	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Observable___getitem__" "', argument " "2"" of type '" "int""'");
4842	}
4843	arg2 = static_cast< int >(val2);
4844	result = (Observable *)Observable___getitem__(arg1,arg2);
4845	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Observable, 0 \| 0 );
4846	return resultobj;
4847	fail:
4848	return NULL;
4849	}
4850
4851
4852	SWIGINTERN PyObject Observable_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4853	PyObject *obj;
4854	if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4855	SWIG_TypeNewClientData(SWIGTYPE_p_Observable, SWIG_NewClientData(obj));
4856	return SWIG_Py_Void();
4857	}
4858
4859	SWIGINTERN PyObject _wrap_Service_name_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4860	PyObject *resultobj = 0;
4861	Service arg1 = (Service ) 0 ;
4862	std::string *arg2 = 0 ;
4863	void *argp1 = 0 ;
4864	int res1 = 0 ;
4865	int res2 = SWIG_OLDOBJ ;
4866	PyObject * obj0 = 0 ;
4867	PyObject * obj1 = 0 ;
4868
4869	if (!PyArg_ParseTuple(args,(char *)"OO:Service_name_set",&obj0,&obj1)) SWIG_fail;
4870	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, 0 \| 0 );
4871	if (!SWIG_IsOK(res1)) {
4872	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Service_name_set" "', argument " "1"" of type '" "Service *""'");
4873	}
4874	arg1 = reinterpret_cast< Service * >(argp1);
4875	{
4876	std::string ptr = (std::string )0;
4877	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
4878	if (!SWIG_IsOK(res2)) {
4879	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Service_name_set" "', argument " "2"" of type '" "std::string const &""'");
4880	}
4881	if (!ptr) {
4882	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Service_name_set" "', argument " "2"" of type '" "std::string const &""'");
4883	}
4884	arg2 = ptr;
4885	}
4886	if (arg1) (arg1)->name = *arg2;
4887	resultobj = SWIG_Py_Void();
4888	if (SWIG_IsNewObj(res2)) delete arg2;
4889	return resultobj;
4890	fail:
4891	if (SWIG_IsNewObj(res2)) delete arg2;
4892	return NULL;
4893	}
4894
4895
4896	SWIGINTERN PyObject _wrap_Service_name_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4897	PyObject *resultobj = 0;
4898	Service arg1 = (Service ) 0 ;
4899	void *argp1 = 0 ;
4900	int res1 = 0 ;
4901	PyObject * obj0 = 0 ;
4902	std::string *result = 0 ;
4903
4904	if (!PyArg_ParseTuple(args,(char *)"O:Service_name_get",&obj0)) SWIG_fail;
4905	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, 0 \| 0 );
4906	if (!SWIG_IsOK(res1)) {
4907	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Service_name_get" "', argument " "1"" of type '" "Service *""'");
4908	}
4909	arg1 = reinterpret_cast< Service * >(argp1);
4910	result = (std::string *) & ((arg1)->name);
4911	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
4912	return resultobj;
4913	fail:
4914	return NULL;
4915	}
4916
4917
4918	SWIGINTERN PyObject _wrap_Service_socketFD_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4919	PyObject *resultobj = 0;
4920	Service arg1 = (Service ) 0 ;
4921	int32_t arg2 ;
4922	void *argp1 = 0 ;
4923	int res1 = 0 ;
4924	void *argp2 ;
4925	int res2 = 0 ;
4926	PyObject * obj0 = 0 ;
4927	PyObject * obj1 = 0 ;
4928
4929	if (!PyArg_ParseTuple(args,(char *)"OO:Service_socketFD_set",&obj0,&obj1)) SWIG_fail;
4930	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, 0 \| 0 );
4931	if (!SWIG_IsOK(res1)) {
4932	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Service_socketFD_set" "', argument " "1"" of type '" "Service *""'");
4933	}
4934	arg1 = reinterpret_cast< Service * >(argp1);
4935	{
4936	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int32_t, 0 \| 0);
4937	if (!SWIG_IsOK(res2)) {
4938	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Service_socketFD_set" "', argument " "2"" of type '" "int32_t""'");
4939	}
4940	if (!argp2) {
4941	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Service_socketFD_set" "', argument " "2"" of type '" "int32_t""'");
4942	} else {
4943	int32_t * temp = reinterpret_cast< int32_t * >(argp2);
4944	arg2 = *temp;
4945	if (SWIG_IsNewObj(res2)) delete temp;
4946	}
4947	}
4948	if (arg1) (arg1)->socketFD = arg2;
4949	resultobj = SWIG_Py_Void();
4950	return resultobj;
4951	fail:
4952	return NULL;
4953	}
4954
4955
4956	SWIGINTERN PyObject _wrap_Service_socketFD_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4957	PyObject *resultobj = 0;
4958	Service arg1 = (Service ) 0 ;
4959	void *argp1 = 0 ;
4960	int res1 = 0 ;
4961	PyObject * obj0 = 0 ;
4962	int32_t result;
4963
4964	if (!PyArg_ParseTuple(args,(char *)"O:Service_socketFD_get",&obj0)) SWIG_fail;
4965	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, 0 \| 0 );
4966	if (!SWIG_IsOK(res1)) {
4967	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Service_socketFD_get" "', argument " "1"" of type '" "Service *""'");
4968	}
4969	arg1 = reinterpret_cast< Service * >(argp1);
4970	result = ((arg1)->socketFD);
4971	resultobj = SWIG_NewPointerObj((new int32_t(static_cast< const int32_t& >(result))), SWIGTYPE_p_int32_t, SWIG_POINTER_OWN \| 0 );
4972	return resultobj;
4973	fail:
4974	return NULL;
4975	}
4976
4977
4978	SWIGINTERN PyObject _wrap_Service_componentID_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
4979	PyObject *resultobj = 0;
4980	Service arg1 = (Service ) 0 ;
4981	int32_t arg2 ;
4982	void *argp1 = 0 ;
4983	int res1 = 0 ;
4984	void *argp2 ;
4985	int res2 = 0 ;
4986	PyObject * obj0 = 0 ;
4987	PyObject * obj1 = 0 ;
4988
4989	if (!PyArg_ParseTuple(args,(char *)"OO:Service_componentID_set",&obj0,&obj1)) SWIG_fail;
4990	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, 0 \| 0 );
4991	if (!SWIG_IsOK(res1)) {
4992	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Service_componentID_set" "', argument " "1"" of type '" "Service *""'");
4993	}
4994	arg1 = reinterpret_cast< Service * >(argp1);
4995	{
4996	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int32_t, 0 \| 0);
4997	if (!SWIG_IsOK(res2)) {
4998	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Service_componentID_set" "', argument " "2"" of type '" "int32_t""'");
4999	}
5000	if (!argp2) {
5001	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Service_componentID_set" "', argument " "2"" of type '" "int32_t""'");
5002	} else {
5003	int32_t * temp = reinterpret_cast< int32_t * >(argp2);
5004	arg2 = *temp;
5005	if (SWIG_IsNewObj(res2)) delete temp;
5006	}
5007	}
5008	if (arg1) (arg1)->componentID = arg2;
5009	resultobj = SWIG_Py_Void();
5010	return resultobj;
5011	fail:
5012	return NULL;
5013	}
5014
5015
5016	SWIGINTERN PyObject _wrap_Service_componentID_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5017	PyObject *resultobj = 0;
5018	Service arg1 = (Service ) 0 ;
5019	void *argp1 = 0 ;
5020	int res1 = 0 ;
5021	PyObject * obj0 = 0 ;
5022	int32_t result;
5023
5024	if (!PyArg_ParseTuple(args,(char *)"O:Service_componentID_get",&obj0)) SWIG_fail;
5025	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, 0 \| 0 );
5026	if (!SWIG_IsOK(res1)) {
5027	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Service_componentID_get" "', argument " "1"" of type '" "Service *""'");
5028	}
5029	arg1 = reinterpret_cast< Service * >(argp1);
5030	result = ((arg1)->componentID);
5031	resultobj = SWIG_NewPointerObj((new int32_t(static_cast< const int32_t& >(result))), SWIGTYPE_p_int32_t, SWIG_POINTER_OWN \| 0 );
5032	return resultobj;
5033	fail:
5034	return NULL;
5035	}
5036
5037
5038	SWIGINTERN PyObject _wrap_Service_num_conds_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5039	PyObject *resultobj = 0;
5040	Service arg1 = (Service ) 0 ;
5041	uint16_t arg2 ;
5042	void *argp1 = 0 ;
5043	int res1 = 0 ;
5044	void *argp2 ;
5045	int res2 = 0 ;
5046	PyObject * obj0 = 0 ;
5047	PyObject * obj1 = 0 ;
5048
5049	if (!PyArg_ParseTuple(args,(char *)"OO:Service_num_conds_set",&obj0,&obj1)) SWIG_fail;
5050	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, 0 \| 0 );
5051	if (!SWIG_IsOK(res1)) {
5052	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Service_num_conds_set" "', argument " "1"" of type '" "Service *""'");
5053	}
5054	arg1 = reinterpret_cast< Service * >(argp1);
5055	{
5056	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint16_t, 0 \| 0);
5057	if (!SWIG_IsOK(res2)) {
5058	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Service_num_conds_set" "', argument " "2"" of type '" "uint16_t""'");
5059	}
5060	if (!argp2) {
5061	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Service_num_conds_set" "', argument " "2"" of type '" "uint16_t""'");
5062	} else {
5063	uint16_t * temp = reinterpret_cast< uint16_t * >(argp2);
5064	arg2 = *temp;
5065	if (SWIG_IsNewObj(res2)) delete temp;
5066	}
5067	}
5068	if (arg1) (arg1)->num_conds = arg2;
5069	resultobj = SWIG_Py_Void();
5070	return resultobj;
5071	fail:
5072	return NULL;
5073	}
5074
5075
5076	SWIGINTERN PyObject _wrap_Service_num_conds_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5077	PyObject *resultobj = 0;
5078	Service arg1 = (Service ) 0 ;
5079	void *argp1 = 0 ;
5080	int res1 = 0 ;
5081	PyObject * obj0 = 0 ;
5082	uint16_t result;
5083
5084	if (!PyArg_ParseTuple(args,(char *)"O:Service_num_conds_get",&obj0)) SWIG_fail;
5085	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, 0 \| 0 );
5086	if (!SWIG_IsOK(res1)) {
5087	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Service_num_conds_get" "', argument " "1"" of type '" "Service *""'");
5088	}
5089	arg1 = reinterpret_cast< Service * >(argp1);
5090	result = ((arg1)->num_conds);
5091	resultobj = SWIG_NewPointerObj((new uint16_t(static_cast< const uint16_t& >(result))), SWIGTYPE_p_uint16_t, SWIG_POINTER_OWN \| 0 );
5092	return resultobj;
5093	fail:
5094	return NULL;
5095	}
5096
5097
5098	SWIGINTERN PyObject _wrap_Service_parameter_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5099	PyObject *resultobj = 0;
5100	Service arg1 = (Service ) 0 ;
5101	std::string *arg2 = 0 ;
5102	void *argp1 = 0 ;
5103	int res1 = 0 ;
5104	int res2 = SWIG_OLDOBJ ;
5105	PyObject * obj0 = 0 ;
5106	PyObject * obj1 = 0 ;
5107
5108	if (!PyArg_ParseTuple(args,(char *)"OO:Service_parameter_set",&obj0,&obj1)) SWIG_fail;
5109	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, 0 \| 0 );
5110	if (!SWIG_IsOK(res1)) {
5111	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Service_parameter_set" "', argument " "1"" of type '" "Service *""'");
5112	}
5113	arg1 = reinterpret_cast< Service * >(argp1);
5114	{
5115	std::string ptr = (std::string )0;
5116	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5117	if (!SWIG_IsOK(res2)) {
5118	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Service_parameter_set" "', argument " "2"" of type '" "std::string const &""'");
5119	}
5120	if (!ptr) {
5121	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Service_parameter_set" "', argument " "2"" of type '" "std::string const &""'");
5122	}
5123	arg2 = ptr;
5124	}
5125	if (arg1) (arg1)->parameter = *arg2;
5126	resultobj = SWIG_Py_Void();
5127	if (SWIG_IsNewObj(res2)) delete arg2;
5128	return resultobj;
5129	fail:
5130	if (SWIG_IsNewObj(res2)) delete arg2;
5131	return NULL;
5132	}
5133
5134
5135	SWIGINTERN PyObject _wrap_Service_parameter_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5136	PyObject *resultobj = 0;
5137	Service arg1 = (Service ) 0 ;
5138	void *argp1 = 0 ;
5139	int res1 = 0 ;
5140	PyObject * obj0 = 0 ;
5141	std::string *result = 0 ;
5142
5143	if (!PyArg_ParseTuple(args,(char *)"O:Service_parameter_get",&obj0)) SWIG_fail;
5144	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, 0 \| 0 );
5145	if (!SWIG_IsOK(res1)) {
5146	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Service_parameter_get" "', argument " "1"" of type '" "Service *""'");
5147	}
5148	arg1 = reinterpret_cast< Service * >(argp1);
5149	result = (std::string *) & ((arg1)->parameter);
5150	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
5151	return resultobj;
5152	fail:
5153	return NULL;
5154	}
5155
5156
5157	SWIGINTERN PyObject _wrap_Service_input_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5158	PyObject *resultobj = 0;
5159	Service arg1 = (Service ) 0 ;
5160	std::string *arg2 ;
5161	void *argp1 = 0 ;
5162	int res1 = 0 ;
5163	void *argp2 = 0 ;
5164	int res2 = 0 ;
5165	PyObject * obj0 = 0 ;
5166	PyObject * obj1 = 0 ;
5167
5168	if (!PyArg_ParseTuple(args,(char *)"OO:Service_input_set",&obj0,&obj1)) SWIG_fail;
5169	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, 0 \| 0 );
5170	if (!SWIG_IsOK(res1)) {
5171	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Service_input_set" "', argument " "1"" of type '" "Service *""'");
5172	}
5173	arg1 = reinterpret_cast< Service * >(argp1);
5174	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__string, 0 \| 0 );
5175	if (!SWIG_IsOK(res2)) {
5176	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Service_input_set" "', argument " "2"" of type '" "std::string [10]""'");
5177	}
5178	arg2 = reinterpret_cast< std::string * >(argp2);
5179	{
5180	if (arg2) {
5181	size_t ii = 0;
5182	for (; ii < (size_t)10; ++ii) arg1->input[ii] = arg2[ii];
5183	} else {
5184	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""input""' of type '""std::string [10]""'");
5185	}
5186	}
5187	resultobj = SWIG_Py_Void();
5188	return resultobj;
5189	fail:
5190	return NULL;
5191	}
5192
5193
5194	SWIGINTERN PyObject _wrap_Service_input_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5195	PyObject *resultobj = 0;
5196	Service arg1 = (Service ) 0 ;
5197	void *argp1 = 0 ;
5198	int res1 = 0 ;
5199	PyObject * obj0 = 0 ;
5200	std::string *result = 0 ;
5201
5202	if (!PyArg_ParseTuple(args,(char *)"O:Service_input_get",&obj0)) SWIG_fail;
5203	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, 0 \| 0 );
5204	if (!SWIG_IsOK(res1)) {
5205	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Service_input_get" "', argument " "1"" of type '" "Service *""'");
5206	}
5207	arg1 = reinterpret_cast< Service * >(argp1);
5208	result = (std::string )(std::string ) ((arg1)->input);
5209	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 \| 0 );
5210	return resultobj;
5211	fail:
5212	return NULL;
5213	}
5214
5215
5216	SWIGINTERN PyObject _wrap_Service_output_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5217	PyObject *resultobj = 0;
5218	Service arg1 = (Service ) 0 ;
5219	std::string *arg2 ;
5220	void *argp1 = 0 ;
5221	int res1 = 0 ;
5222	void *argp2 = 0 ;
5223	int res2 = 0 ;
5224	PyObject * obj0 = 0 ;
5225	PyObject * obj1 = 0 ;
5226
5227	if (!PyArg_ParseTuple(args,(char *)"OO:Service_output_set",&obj0,&obj1)) SWIG_fail;
5228	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, 0 \| 0 );
5229	if (!SWIG_IsOK(res1)) {
5230	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Service_output_set" "', argument " "1"" of type '" "Service *""'");
5231	}
5232	arg1 = reinterpret_cast< Service * >(argp1);
5233	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__string, 0 \| 0 );
5234	if (!SWIG_IsOK(res2)) {
5235	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Service_output_set" "', argument " "2"" of type '" "std::string [10]""'");
5236	}
5237	arg2 = reinterpret_cast< std::string * >(argp2);
5238	{
5239	if (arg2) {
5240	size_t ii = 0;
5241	for (; ii < (size_t)10; ++ii) arg1->output[ii] = arg2[ii];
5242	} else {
5243	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""output""' of type '""std::string [10]""'");
5244	}
5245	}
5246	resultobj = SWIG_Py_Void();
5247	return resultobj;
5248	fail:
5249	return NULL;
5250	}
5251
5252
5253	SWIGINTERN PyObject _wrap_Service_output_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5254	PyObject *resultobj = 0;
5255	Service arg1 = (Service ) 0 ;
5256	void *argp1 = 0 ;
5257	int res1 = 0 ;
5258	PyObject * obj0 = 0 ;
5259	std::string *result = 0 ;
5260
5261	if (!PyArg_ParseTuple(args,(char *)"O:Service_output_get",&obj0)) SWIG_fail;
5262	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, 0 \| 0 );
5263	if (!SWIG_IsOK(res1)) {
5264	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Service_output_get" "', argument " "1"" of type '" "Service *""'");
5265	}
5266	arg1 = reinterpret_cast< Service * >(argp1);
5267	result = (std::string )(std::string ) ((arg1)->output);
5268	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 \| 0 );
5269	return resultobj;
5270	fail:
5271	return NULL;
5272	}
5273
5274
5275	SWIGINTERN PyObject _wrap_new_Service(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5276	PyObject *resultobj = 0;
5277	Service *result = 0 ;
5278
5279	if (!PyArg_ParseTuple(args,(char *)":new_Service")) SWIG_fail;
5280	result = (Service *)new Service();
5281	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Service, SWIG_POINTER_NEW \| 0 );
5282	return resultobj;
5283	fail:
5284	return NULL;
5285	}
5286
5287
5288	SWIGINTERN PyObject _wrap_delete_Service(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5289	PyObject *resultobj = 0;
5290	Service arg1 = (Service ) 0 ;
5291	void *argp1 = 0 ;
5292	int res1 = 0 ;
5293	PyObject * obj0 = 0 ;
5294
5295	if (!PyArg_ParseTuple(args,(char *)"O:delete_Service",&obj0)) SWIG_fail;
5296	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Service, SWIG_POINTER_DISOWN \| 0 );
5297	if (!SWIG_IsOK(res1)) {
5298	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Service" "', argument " "1"" of type '" "Service *""'");
5299	}
5300	arg1 = reinterpret_cast< Service * >(argp1);
5301	delete arg1;
5302	resultobj = SWIG_Py_Void();
5303	return resultobj;
5304	fail:
5305	return NULL;
5306	}
5307
5308
5309	SWIGINTERN PyObject Service_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5310	PyObject *obj;
5311	if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5312	SWIG_TypeNewClientData(SWIGTYPE_p_Service, SWIG_NewClientData(obj));
5313	return SWIG_Py_Void();
5314	}
5315
5316	SWIGINTERN PyObject _wrap_Mission_name_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5317	PyObject *resultobj = 0;
5318	Mission arg1 = (Mission ) 0 ;
5319	std::string *arg2 = 0 ;
5320	void *argp1 = 0 ;
5321	int res1 = 0 ;
5322	int res2 = SWIG_OLDOBJ ;
5323	PyObject * obj0 = 0 ;
5324	PyObject * obj1 = 0 ;
5325
5326	if (!PyArg_ParseTuple(args,(char *)"OO:Mission_name_set",&obj0,&obj1)) SWIG_fail;
5327	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Mission, 0 \| 0 );
5328	if (!SWIG_IsOK(res1)) {
5329	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mission_name_set" "', argument " "1"" of type '" "Mission *""'");
5330	}
5331	arg1 = reinterpret_cast< Mission * >(argp1);
5332	{
5333	std::string ptr = (std::string )0;
5334	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5335	if (!SWIG_IsOK(res2)) {
5336	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mission_name_set" "', argument " "2"" of type '" "std::string const &""'");
5337	}
5338	if (!ptr) {
5339	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mission_name_set" "', argument " "2"" of type '" "std::string const &""'");
5340	}
5341	arg2 = ptr;
5342	}
5343	if (arg1) (arg1)->name = *arg2;
5344	resultobj = SWIG_Py_Void();
5345	if (SWIG_IsNewObj(res2)) delete arg2;
5346	return resultobj;
5347	fail:
5348	if (SWIG_IsNewObj(res2)) delete arg2;
5349	return NULL;
5350	}
5351
5352
5353	SWIGINTERN PyObject _wrap_Mission_name_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5354	PyObject *resultobj = 0;
5355	Mission arg1 = (Mission ) 0 ;
5356	void *argp1 = 0 ;
5357	int res1 = 0 ;
5358	PyObject * obj0 = 0 ;
5359	std::string *result = 0 ;
5360
5361	if (!PyArg_ParseTuple(args,(char *)"O:Mission_name_get",&obj0)) SWIG_fail;
5362	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Mission, 0 \| 0 );
5363	if (!SWIG_IsOK(res1)) {
5364	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mission_name_get" "', argument " "1"" of type '" "Mission *""'");
5365	}
5366	arg1 = reinterpret_cast< Mission * >(argp1);
5367	result = (std::string *) & ((arg1)->name);
5368	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
5369	return resultobj;
5370	fail:
5371	return NULL;
5372	}
5373
5374
5375	SWIGINTERN PyObject _wrap_Mission_missionID_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5376	PyObject *resultobj = 0;
5377	Mission arg1 = (Mission ) 0 ;
5378	uint32_t arg2 ;
5379	void *argp1 = 0 ;
5380	int res1 = 0 ;
5381	int val2 ;
5382	int ecode2 = 0 ;
5383	PyObject * obj0 = 0 ;
5384	PyObject * obj1 = 0 ;
5385
5386	if (!PyArg_ParseTuple(args,(char *)"OO:Mission_missionID_set",&obj0,&obj1)) SWIG_fail;
5387	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Mission, 0 \| 0 );
5388	if (!SWIG_IsOK(res1)) {
5389	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mission_missionID_set" "', argument " "1"" of type '" "Mission *""'");
5390	}
5391	arg1 = reinterpret_cast< Mission * >(argp1);
5392	ecode2 = SWIG_AsVal_int(obj1, &val2);
5393	if (!SWIG_IsOK(ecode2)) {
5394	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mission_missionID_set" "', argument " "2"" of type '" "uint32_t""'");
5395	}
5396	arg2 = static_cast< uint32_t >(val2);
5397	if (arg1) (arg1)->missionID = arg2;
5398	resultobj = SWIG_Py_Void();
5399	return resultobj;
5400	fail:
5401	return NULL;
5402	}
5403
5404
5405	SWIGINTERN PyObject _wrap_Mission_missionID_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5406	PyObject *resultobj = 0;
5407	Mission arg1 = (Mission ) 0 ;
5408	void *argp1 = 0 ;
5409	int res1 = 0 ;
5410	PyObject * obj0 = 0 ;
5411	uint32_t result;
5412
5413	if (!PyArg_ParseTuple(args,(char *)"O:Mission_missionID_get",&obj0)) SWIG_fail;
5414	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Mission, 0 \| 0 );
5415	if (!SWIG_IsOK(res1)) {
5416	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mission_missionID_get" "', argument " "1"" of type '" "Mission *""'");
5417	}
5418	arg1 = reinterpret_cast< Mission * >(argp1);
5419	result = ((arg1)->missionID);
5420	resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN \| 0 );
5421	return resultobj;
5422	fail:
5423	return NULL;
5424	}
5425
5426
5427	SWIGINTERN PyObject _wrap_Mission_numServices_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5428	PyObject *resultobj = 0;
5429	Mission arg1 = (Mission ) 0 ;
5430	uint32_t arg2 ;
5431	void *argp1 = 0 ;
5432	int res1 = 0 ;
5433	int val2 ;
5434	int ecode2 = 0 ;
5435	PyObject * obj0 = 0 ;
5436	PyObject * obj1 = 0 ;
5437
5438	if (!PyArg_ParseTuple(args,(char *)"OO:Mission_numServices_set",&obj0,&obj1)) SWIG_fail;
5439	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Mission, 0 \| 0 );
5440	if (!SWIG_IsOK(res1)) {
5441	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mission_numServices_set" "', argument " "1"" of type '" "Mission *""'");
5442	}
5443	arg1 = reinterpret_cast< Mission * >(argp1);
5444	ecode2 = SWIG_AsVal_int(obj1, &val2);
5445	if (!SWIG_IsOK(ecode2)) {
5446	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mission_numServices_set" "', argument " "2"" of type '" "uint32_t""'");
5447	}
5448	arg2 = static_cast< uint32_t >(val2);
5449	if (arg1) (arg1)->numServices = arg2;
5450	resultobj = SWIG_Py_Void();
5451	return resultobj;
5452	fail:
5453	return NULL;
5454	}
5455
5456
5457	SWIGINTERN PyObject _wrap_Mission_numServices_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5458	PyObject *resultobj = 0;
5459	Mission arg1 = (Mission ) 0 ;
5460	void *argp1 = 0 ;
5461	int res1 = 0 ;
5462	PyObject * obj0 = 0 ;
5463	uint32_t result;
5464
5465	if (!PyArg_ParseTuple(args,(char *)"O:Mission_numServices_get",&obj0)) SWIG_fail;
5466	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Mission, 0 \| 0 );
5467	if (!SWIG_IsOK(res1)) {
5468	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mission_numServices_get" "', argument " "1"" of type '" "Mission *""'");
5469	}
5470	arg1 = reinterpret_cast< Mission * >(argp1);
5471	result = ((arg1)->numServices);
5472	resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN \| 0 );
5473	return resultobj;
5474	fail:
5475	return NULL;
5476	}
5477
5478
5479	SWIGINTERN PyObject _wrap_Mission_services_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5480	PyObject *resultobj = 0;
5481	Mission arg1 = (Mission ) 0 ;
5482	Service arg2 = (Service ) 0 ;
5483	void *argp1 = 0 ;
5484	int res1 = 0 ;
5485	void *argp2 = 0 ;
5486	int res2 = 0 ;
5487	PyObject * obj0 = 0 ;
5488	PyObject * obj1 = 0 ;
5489
5490	if (!PyArg_ParseTuple(args,(char *)"OO:Mission_services_set",&obj0,&obj1)) SWIG_fail;
5491	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Mission, 0 \| 0 );
5492	if (!SWIG_IsOK(res1)) {
5493	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mission_services_set" "', argument " "1"" of type '" "Mission *""'");
5494	}
5495	arg1 = reinterpret_cast< Mission * >(argp1);
5496	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Service, SWIG_POINTER_DISOWN \| 0 );
5497	if (!SWIG_IsOK(res2)) {
5498	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mission_services_set" "', argument " "2"" of type '" "Service *""'");
5499	}
5500	arg2 = reinterpret_cast< Service * >(argp2);
5501	if (arg1) (arg1)->services = arg2;
5502	resultobj = SWIG_Py_Void();
5503	return resultobj;
5504	fail:
5505	return NULL;
5506	}
5507
5508
5509	SWIGINTERN PyObject _wrap_Mission_services_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5510	PyObject *resultobj = 0;
5511	Mission arg1 = (Mission ) 0 ;
5512	void *argp1 = 0 ;
5513	int res1 = 0 ;
5514	PyObject * obj0 = 0 ;
5515	Service *result = 0 ;
5516
5517	if (!PyArg_ParseTuple(args,(char *)"O:Mission_services_get",&obj0)) SWIG_fail;
5518	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Mission, 0 \| 0 );
5519	if (!SWIG_IsOK(res1)) {
5520	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mission_services_get" "', argument " "1"" of type '" "Mission *""'");
5521	}
5522	arg1 = reinterpret_cast< Mission * >(argp1);
5523	result = (Service *) ((arg1)->services);
5524	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Service, 0 \| 0 );
5525	return resultobj;
5526	fail:
5527	return NULL;
5528	}
5529
5530
5531	SWIGINTERN PyObject _wrap_Mission_input_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5532	PyObject *resultobj = 0;
5533	Mission arg1 = (Mission ) 0 ;
5534	std::string *arg2 ;
5535	void *argp1 = 0 ;
5536	int res1 = 0 ;
5537	void *argp2 = 0 ;
5538	int res2 = 0 ;
5539	PyObject * obj0 = 0 ;
5540	PyObject * obj1 = 0 ;
5541
5542	if (!PyArg_ParseTuple(args,(char *)"OO:Mission_input_set",&obj0,&obj1)) SWIG_fail;
5543	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Mission, 0 \| 0 );
5544	if (!SWIG_IsOK(res1)) {
5545	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mission_input_set" "', argument " "1"" of type '" "Mission *""'");
5546	}
5547	arg1 = reinterpret_cast< Mission * >(argp1);
5548	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__string, 0 \| 0 );
5549	if (!SWIG_IsOK(res2)) {
5550	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mission_input_set" "', argument " "2"" of type '" "std::string [10]""'");
5551	}
5552	arg2 = reinterpret_cast< std::string * >(argp2);
5553	{
5554	if (arg2) {
5555	size_t ii = 0;
5556	for (; ii < (size_t)10; ++ii) arg1->input[ii] = arg2[ii];
5557	} else {
5558	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""input""' of type '""std::string [10]""'");
5559	}
5560	}
5561	resultobj = SWIG_Py_Void();
5562	return resultobj;
5563	fail:
5564	return NULL;
5565	}
5566
5567
5568	SWIGINTERN PyObject _wrap_Mission_input_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5569	PyObject *resultobj = 0;
5570	Mission arg1 = (Mission ) 0 ;
5571	void *argp1 = 0 ;
5572	int res1 = 0 ;
5573	PyObject * obj0 = 0 ;
5574	std::string *result = 0 ;
5575
5576	if (!PyArg_ParseTuple(args,(char *)"O:Mission_input_get",&obj0)) SWIG_fail;
5577	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Mission, 0 \| 0 );
5578	if (!SWIG_IsOK(res1)) {
5579	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mission_input_get" "', argument " "1"" of type '" "Mission *""'");
5580	}
5581	arg1 = reinterpret_cast< Mission * >(argp1);
5582	result = (std::string )(std::string ) ((arg1)->input);
5583	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 \| 0 );
5584	return resultobj;
5585	fail:
5586	return NULL;
5587	}
5588
5589
5590	SWIGINTERN PyObject _wrap_Mission_output_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5591	PyObject *resultobj = 0;
5592	Mission arg1 = (Mission ) 0 ;
5593	std::string *arg2 ;
5594	void *argp1 = 0 ;
5595	int res1 = 0 ;
5596	void *argp2 = 0 ;
5597	int res2 = 0 ;
5598	PyObject * obj0 = 0 ;
5599	PyObject * obj1 = 0 ;
5600
5601	if (!PyArg_ParseTuple(args,(char *)"OO:Mission_output_set",&obj0,&obj1)) SWIG_fail;
5602	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Mission, 0 \| 0 );
5603	if (!SWIG_IsOK(res1)) {
5604	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mission_output_set" "', argument " "1"" of type '" "Mission *""'");
5605	}
5606	arg1 = reinterpret_cast< Mission * >(argp1);
5607	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__string, 0 \| 0 );
5608	if (!SWIG_IsOK(res2)) {
5609	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mission_output_set" "', argument " "2"" of type '" "std::string [10]""'");
5610	}
5611	arg2 = reinterpret_cast< std::string * >(argp2);
5612	{
5613	if (arg2) {
5614	size_t ii = 0;
5615	for (; ii < (size_t)10; ++ii) arg1->output[ii] = arg2[ii];
5616	} else {
5617	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""output""' of type '""std::string [10]""'");
5618	}
5619	}
5620	resultobj = SWIG_Py_Void();
5621	return resultobj;
5622	fail:
5623	return NULL;
5624	}
5625
5626
5627	SWIGINTERN PyObject _wrap_Mission_output_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5628	PyObject *resultobj = 0;
5629	Mission arg1 = (Mission ) 0 ;
5630	void *argp1 = 0 ;
5631	int res1 = 0 ;
5632	PyObject * obj0 = 0 ;
5633	std::string *result = 0 ;
5634
5635	if (!PyArg_ParseTuple(args,(char *)"O:Mission_output_get",&obj0)) SWIG_fail;
5636	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Mission, 0 \| 0 );
5637	if (!SWIG_IsOK(res1)) {
5638	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mission_output_get" "', argument " "1"" of type '" "Mission *""'");
5639	}
5640	arg1 = reinterpret_cast< Mission * >(argp1);
5641	result = (std::string )(std::string ) ((arg1)->output);
5642	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 \| 0 );
5643	return resultobj;
5644	fail:
5645	return NULL;
5646	}
5647
5648
5649	SWIGINTERN PyObject _wrap_new_Mission(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5650	PyObject *resultobj = 0;
5651	Mission *result = 0 ;
5652
5653	if (!PyArg_ParseTuple(args,(char *)":new_Mission")) SWIG_fail;
5654	result = (Mission *)new Mission();
5655	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Mission, SWIG_POINTER_NEW \| 0 );
5656	return resultobj;
5657	fail:
5658	return NULL;
5659	}
5660
5661
5662	SWIGINTERN PyObject _wrap_delete_Mission(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5663	PyObject *resultobj = 0;
5664	Mission arg1 = (Mission ) 0 ;
5665	void *argp1 = 0 ;
5666	int res1 = 0 ;
5667	PyObject * obj0 = 0 ;
5668
5669	if (!PyArg_ParseTuple(args,(char *)"O:delete_Mission",&obj0)) SWIG_fail;
5670	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Mission, SWIG_POINTER_DISOWN \| 0 );
5671	if (!SWIG_IsOK(res1)) {
5672	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mission" "', argument " "1"" of type '" "Mission *""'");
5673	}
5674	arg1 = reinterpret_cast< Mission * >(argp1);
5675	delete arg1;
5676	resultobj = SWIG_Py_Void();
5677	return resultobj;
5678	fail:
5679	return NULL;
5680	}
5681
5682
5683	SWIGINTERN PyObject Mission_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5684	PyObject *obj;
5685	if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5686	SWIG_TypeNewClientData(SWIGTYPE_p_Mission, SWIG_NewClientData(obj));
5687	return SWIG_Py_Void();
5688	}
5689
5690	SWIGINTERN PyObject _wrap_CE_Reg_ID_num_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5691	PyObject *resultobj = 0;
5692	CE_Reg arg1 = (CE_Reg ) 0 ;
5693	int32_t arg2 ;
5694	void *argp1 = 0 ;
5695	int res1 = 0 ;
5696	void *argp2 ;
5697	int res2 = 0 ;
5698	PyObject * obj0 = 0 ;
5699	PyObject * obj1 = 0 ;
5700
5701	if (!PyArg_ParseTuple(args,(char *)"OO:CE_Reg_ID_num_set",&obj0,&obj1)) SWIG_fail;
5702	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CE_Reg, 0 \| 0 );
5703	if (!SWIG_IsOK(res1)) {
5704	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CE_Reg_ID_num_set" "', argument " "1"" of type '" "CE_Reg *""'");
5705	}
5706	arg1 = reinterpret_cast< CE_Reg * >(argp1);
5707	{
5708	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int32_t, 0 \| 0);
5709	if (!SWIG_IsOK(res2)) {
5710	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CE_Reg_ID_num_set" "', argument " "2"" of type '" "int32_t""'");
5711	}
5712	if (!argp2) {
5713	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CE_Reg_ID_num_set" "', argument " "2"" of type '" "int32_t""'");
5714	} else {
5715	int32_t * temp = reinterpret_cast< int32_t * >(argp2);
5716	arg2 = *temp;
5717	if (SWIG_IsNewObj(res2)) delete temp;
5718	}
5719	}
5720	if (arg1) (arg1)->ID_num = arg2;
5721	resultobj = SWIG_Py_Void();
5722	return resultobj;
5723	fail:
5724	return NULL;
5725	}
5726
5727
5728	SWIGINTERN PyObject _wrap_CE_Reg_ID_num_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5729	PyObject *resultobj = 0;
5730	CE_Reg arg1 = (CE_Reg ) 0 ;
5731	void *argp1 = 0 ;
5732	int res1 = 0 ;
5733	PyObject * obj0 = 0 ;
5734	int32_t result;
5735
5736	if (!PyArg_ParseTuple(args,(char *)"O:CE_Reg_ID_num_get",&obj0)) SWIG_fail;
5737	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CE_Reg, 0 \| 0 );
5738	if (!SWIG_IsOK(res1)) {
5739	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CE_Reg_ID_num_get" "', argument " "1"" of type '" "CE_Reg *""'");
5740	}
5741	arg1 = reinterpret_cast< CE_Reg * >(argp1);
5742	result = ((arg1)->ID_num);
5743	resultobj = SWIG_NewPointerObj((new int32_t(static_cast< const int32_t& >(result))), SWIGTYPE_p_int32_t, SWIG_POINTER_OWN \| 0 );
5744	return resultobj;
5745	fail:
5746	return NULL;
5747	}
5748
5749
5750	SWIGINTERN PyObject _wrap_CE_Reg_FD_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5751	PyObject *resultobj = 0;
5752	CE_Reg arg1 = (CE_Reg ) 0 ;
5753	int32_t arg2 ;
5754	void *argp1 = 0 ;
5755	int res1 = 0 ;
5756	void *argp2 ;
5757	int res2 = 0 ;
5758	PyObject * obj0 = 0 ;
5759	PyObject * obj1 = 0 ;
5760
5761	if (!PyArg_ParseTuple(args,(char *)"OO:CE_Reg_FD_set",&obj0,&obj1)) SWIG_fail;
5762	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CE_Reg, 0 \| 0 );
5763	if (!SWIG_IsOK(res1)) {
5764	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CE_Reg_FD_set" "', argument " "1"" of type '" "CE_Reg *""'");
5765	}
5766	arg1 = reinterpret_cast< CE_Reg * >(argp1);
5767	{
5768	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int32_t, 0 \| 0);
5769	if (!SWIG_IsOK(res2)) {
5770	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CE_Reg_FD_set" "', argument " "2"" of type '" "int32_t""'");
5771	}
5772	if (!argp2) {
5773	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CE_Reg_FD_set" "', argument " "2"" of type '" "int32_t""'");
5774	} else {
5775	int32_t * temp = reinterpret_cast< int32_t * >(argp2);
5776	arg2 = *temp;
5777	if (SWIG_IsNewObj(res2)) delete temp;
5778	}
5779	}
5780	if (arg1) (arg1)->FD = arg2;
5781	resultobj = SWIG_Py_Void();
5782	return resultobj;
5783	fail:
5784	return NULL;
5785	}
5786
5787
5788	SWIGINTERN PyObject _wrap_CE_Reg_FD_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5789	PyObject *resultobj = 0;
5790	CE_Reg arg1 = (CE_Reg ) 0 ;
5791	void *argp1 = 0 ;
5792	int res1 = 0 ;
5793	PyObject * obj0 = 0 ;
5794	int32_t result;
5795
5796	if (!PyArg_ParseTuple(args,(char *)"O:CE_Reg_FD_get",&obj0)) SWIG_fail;
5797	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CE_Reg, 0 \| 0 );
5798	if (!SWIG_IsOK(res1)) {
5799	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CE_Reg_FD_get" "', argument " "1"" of type '" "CE_Reg *""'");
5800	}
5801	arg1 = reinterpret_cast< CE_Reg * >(argp1);
5802	result = ((arg1)->FD);
5803	resultobj = SWIG_NewPointerObj((new int32_t(static_cast< const int32_t& >(result))), SWIGTYPE_p_int32_t, SWIG_POINTER_OWN \| 0 );
5804	return resultobj;
5805	fail:
5806	return NULL;
5807	}
5808
5809
5810	SWIGINTERN PyObject _wrap_new_CE_Reg(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5811	PyObject *resultobj = 0;
5812	CE_Reg *result = 0 ;
5813
5814	if (!PyArg_ParseTuple(args,(char *)":new_CE_Reg")) SWIG_fail;
5815	result = (CE_Reg *)new CE_Reg();
5816	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CE_Reg, SWIG_POINTER_NEW \| 0 );
5817	return resultobj;
5818	fail:
5819	return NULL;
5820	}
5821
5822
5823	SWIGINTERN PyObject _wrap_delete_CE_Reg(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5824	PyObject *resultobj = 0;
5825	CE_Reg arg1 = (CE_Reg ) 0 ;
5826	void *argp1 = 0 ;
5827	int res1 = 0 ;
5828	PyObject * obj0 = 0 ;
5829
5830	if (!PyArg_ParseTuple(args,(char *)"O:delete_CE_Reg",&obj0)) SWIG_fail;
5831	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CE_Reg, SWIG_POINTER_DISOWN \| 0 );
5832	if (!SWIG_IsOK(res1)) {
5833	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CE_Reg" "', argument " "1"" of type '" "CE_Reg *""'");
5834	}
5835	arg1 = reinterpret_cast< CE_Reg * >(argp1);
5836	delete arg1;
5837	resultobj = SWIG_Py_Void();
5838	return resultobj;
5839	fail:
5840	return NULL;
5841	}
5842
5843
5844	SWIGINTERN PyObject CE_Reg_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5845	PyObject *obj;
5846	if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5847	SWIG_TypeNewClientData(SWIGTYPE_p_CE_Reg, SWIG_NewClientData(obj));
5848	return SWIG_Py_Void();
5849	}
5850
5851	SWIGINTERN PyObject _wrap_ParseRadioConfiguration(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5852	PyObject *resultobj = 0;
5853	bool result;
5854
5855	if (!PyArg_ParseTuple(args,(char *)":ParseRadioConfiguration")) SWIG_fail;
5856	result = (bool)ParseRadioConfiguration();
5857	resultobj = SWIG_From_bool(static_cast< bool >(result));
5858	return resultobj;
5859	fail:
5860	return NULL;
5861	}
5862
5863
5864	SWIGINTERN PyObject _wrap_ListCurrentRadioConfiguration(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5865	PyObject *resultobj = 0;
5866
5867	if (!PyArg_ParseTuple(args,(char *)":ListCurrentRadioConfiguration")) SWIG_fail;
5868	ListCurrentRadioConfiguration();
5869	resultobj = SWIG_Py_Void();
5870	return resultobj;
5871	fail:
5872	return NULL;
5873	}
5874
5875
5876	SWIGINTERN PyObject _wrap_GetRadioObservables(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5877	PyObject *resultobj = 0;
5878	Observable *result = 0 ;
5879
5880	if (!PyArg_ParseTuple(args,(char *)":GetRadioObservables")) SWIG_fail;
5881	result = (Observable *)GetRadioObservables();
5882	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Observable, 0 \| 0 );
5883	return resultobj;
5884	fail:
5885	return NULL;
5886	}
5887
5888
5889	SWIGINTERN PyObject _wrap_GetRadioParameters(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5890	PyObject *resultobj = 0;
5891	Parameter *result = 0 ;
5892
5893	if (!PyArg_ParseTuple(args,(char *)":GetRadioParameters")) SWIG_fail;
5894	result = (Parameter *)GetRadioParameters();
5895	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 \| 0 );
5896	return resultobj;
5897	fail:
5898	return NULL;
5899	}
5900
5901
5902	SWIGINTERN PyObject _wrap_GetRadioUtilities(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5903	PyObject *resultobj = 0;
5904	Utility *result = 0 ;
5905
5906	if (!PyArg_ParseTuple(args,(char *)":GetRadioUtilities")) SWIG_fail;
5907	result = (Utility *)GetRadioUtilities();
5908	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Utility, 0 \| 0 );
5909	return resultobj;
5910	fail:
5911	return NULL;
5912	}
5913
5914
5915	SWIGINTERN PyObject _wrap_GetConnectedCognitiveEngines(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5916	PyObject *resultobj = 0;
5917	uint32_t *result = 0 ;
5918
5919	if (!PyArg_ParseTuple(args,(char *)":GetConnectedCognitiveEngines")) SWIG_fail;
5920	result = (uint32_t *)GetConnectedCognitiveEngines();
5921	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uint32_t, 0 \| 0 );
5922	return resultobj;
5923	fail:
5924	return NULL;
5925	}
5926
5927
5928	SWIGINTERN PyObject _wrap_GetConnectedPolicyEngines(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5929	PyObject *resultobj = 0;
5930	uint32_t *result = 0 ;
5931
5932	if (!PyArg_ParseTuple(args,(char *)":GetConnectedPolicyEngines")) SWIG_fail;
5933	result = (uint32_t *)GetConnectedPolicyEngines();
5934	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uint32_t, 0 \| 0 );
5935	return resultobj;
5936	fail:
5937	return NULL;
5938	}
5939
5940
5941	SWIGINTERN PyObject _wrap_GetConnectedManagementServiceLayers(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5942	PyObject *resultobj = 0;
5943	uint32_t *result = 0 ;
5944
5945	if (!PyArg_ParseTuple(args,(char *)":GetConnectedManagementServiceLayers")) SWIG_fail;
5946	result = (uint32_t *)GetConnectedManagementServiceLayers();
5947	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uint32_t, 0 \| 0 );
5948	return resultobj;
5949	fail:
5950	return NULL;
5951	}
5952
5953
5954	SWIGINTERN PyObject _wrap_GetConnectedComponents(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5955	PyObject *resultobj = 0;
5956	uint32_t *result = 0 ;
5957
5958	if (!PyArg_ParseTuple(args,(char *)":GetConnectedComponents")) SWIG_fail;
5959	result = (uint32_t *)GetConnectedComponents();
5960	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uint32_t, 0 \| 0 );
5961	return resultobj;
5962	fail:
5963	return NULL;
5964	}
5965
5966
5967	SWIGINTERN PyObject _wrap_GetComponentInformation(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5968	PyObject *resultobj = 0;
5969	uint32_t arg1 ;
5970	int val1 ;
5971	int ecode1 = 0 ;
5972	PyObject * obj0 = 0 ;
5973	Component *result = 0 ;
5974
5975	if (!PyArg_ParseTuple(args,(char *)"O:GetComponentInformation",&obj0)) SWIG_fail;
5976	ecode1 = SWIG_AsVal_int(obj0, &val1);
5977	if (!SWIG_IsOK(ecode1)) {
5978	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetComponentInformation" "', argument " "1"" of type '" "uint32_t""'");
5979	}
5980	arg1 = static_cast< uint32_t >(val1);
5981	result = (Component *)GetComponentInformation(arg1);
5982	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Component, 0 \| 0 );
5983	return resultobj;
5984	fail:
5985	return NULL;
5986	}
5987
5988
5989	SWIGINTERN PyObject _wrap_GetOptimalParameters(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
5990	PyObject *resultobj = 0;
5991	Observable arg1 = (Observable ) 0 ;
5992	uint32_t arg2 ;
5993	Parameter arg3 = (Parameter ) 0 ;
5994	uint32_t arg4 ;
5995	void *argp1 = 0 ;
5996	int res1 = 0 ;
5997	int val2 ;
5998	int ecode2 = 0 ;
5999	void *argp3 = 0 ;
6000	int res3 = 0 ;
6001	int val4 ;
6002	int ecode4 = 0 ;
6003	PyObject * obj0 = 0 ;
6004	PyObject * obj1 = 0 ;
6005	PyObject * obj2 = 0 ;
6006	PyObject * obj3 = 0 ;
6007	Parameter *result = 0 ;
6008
6009	if (!PyArg_ParseTuple(args,(char *)"OOOO:GetOptimalParameters",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6010	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Observable, 0 \| 0 );
6011	if (!SWIG_IsOK(res1)) {
6012	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetOptimalParameters" "', argument " "1"" of type '" "Observable *""'");
6013	}
6014	arg1 = reinterpret_cast< Observable * >(argp1);
6015	ecode2 = SWIG_AsVal_int(obj1, &val2);
6016	if (!SWIG_IsOK(ecode2)) {
6017	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetOptimalParameters" "', argument " "2"" of type '" "uint32_t""'");
6018	}
6019	arg2 = static_cast< uint32_t >(val2);
6020	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Parameter, 0 \| 0 );
6021	if (!SWIG_IsOK(res3)) {
6022	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetOptimalParameters" "', argument " "3"" of type '" "Parameter *""'");
6023	}
6024	arg3 = reinterpret_cast< Parameter * >(argp3);
6025	ecode4 = SWIG_AsVal_int(obj3, &val4);
6026	if (!SWIG_IsOK(ecode4)) {
6027	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetOptimalParameters" "', argument " "4"" of type '" "uint32_t""'");
6028	}
6029	arg4 = static_cast< uint32_t >(val4);
6030	result = (Parameter *)GetOptimalParameters(arg1,arg2,arg3,arg4);
6031	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 \| 0 );
6032	return resultobj;
6033	fail:
6034	return NULL;
6035	}
6036
6037
6038	SWIGINTERN PyObject _wrap_UpdateParameterPerformance(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
6039	PyObject *resultobj = 0;
6040	Parameter arg1 = (Parameter ) 0 ;
6041	uint32_t arg2 ;
6042	Observable arg3 = (Observable ) 0 ;
6043	uint32_t arg4 ;
6044	void *argp1 = 0 ;
6045	int res1 = 0 ;
6046	int val2 ;
6047	int ecode2 = 0 ;
6048	void *argp3 = 0 ;
6049	int res3 = 0 ;
6050	int val4 ;
6051	int ecode4 = 0 ;
6052	PyObject * obj0 = 0 ;
6053	PyObject * obj1 = 0 ;
6054	PyObject * obj2 = 0 ;
6055	PyObject * obj3 = 0 ;
6056	bool result;
6057
6058	if (!PyArg_ParseTuple(args,(char *)"OOOO:UpdateParameterPerformance",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6059	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Parameter, 0 \| 0 );
6060	if (!SWIG_IsOK(res1)) {
6061	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateParameterPerformance" "', argument " "1"" of type '" "Parameter *""'");
6062	}
6063	arg1 = reinterpret_cast< Parameter * >(argp1);
6064	ecode2 = SWIG_AsVal_int(obj1, &val2);
6065	if (!SWIG_IsOK(ecode2)) {
6066	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateParameterPerformance" "', argument " "2"" of type '" "uint32_t""'");
6067	}
6068	arg2 = static_cast< uint32_t >(val2);
6069	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Observable, 0 \| 0 );
6070	if (!SWIG_IsOK(res3)) {
6071	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UpdateParameterPerformance" "', argument " "3"" of type '" "Observable *""'");
6072	}
6073	arg3 = reinterpret_cast< Observable * >(argp3);
6074	ecode4 = SWIG_AsVal_int(obj3, &val4);
6075	if (!SWIG_IsOK(ecode4)) {
6076	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UpdateParameterPerformance" "', argument " "4"" of type '" "uint32_t""'");
6077	}
6078	arg4 = static_cast< uint32_t >(val4);
6079	result = (bool)UpdateParameterPerformance(arg1,arg2,arg3,arg4);
6080	resultobj = SWIG_From_bool(static_cast< bool >(result));
6081	return resultobj;
6082	fail:
6083	return NULL;
6084	}
6085
6086
6087	SWIGINTERN PyObject _wrap_ActivateComponent(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
6088	PyObject *resultobj = 0;
6089	uint32_t arg1 ;
6090	int val1 ;
6091	int ecode1 = 0 ;
6092	PyObject * obj0 = 0 ;
6093	bool result;
6094
6095	if (!PyArg_ParseTuple(args,(char *)"O:ActivateComponent",&obj0)) SWIG_fail;
6096	ecode1 = SWIG_AsVal_int(obj0, &val1);
6097	if (!SWIG_IsOK(ecode1)) {
6098	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ActivateComponent" "', argument " "1"" of type '" "uint32_t""'");
6099	}
6100	arg1 = static_cast< uint32_t >(val1);
6101	result = (bool)ActivateComponent(arg1);
6102	resultobj = SWIG_From_bool(static_cast< bool >(result));
6103	return resultobj;
6104	fail:
6105	return NULL;
6106	}
6107
6108
6109	SWIGINTERN PyObject _wrap_DeactivateComponent(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
6110	PyObject *resultobj = 0;
6111	uint32_t arg1 ;
6112	int val1 ;
6113	int ecode1 = 0 ;
6114	PyObject * obj0 = 0 ;
6115	bool result;
6116
6117	if (!PyArg_ParseTuple(args,(char *)"O:DeactivateComponent",&obj0)) SWIG_fail;
6118	ecode1 = SWIG_AsVal_int(obj0, &val1);
6119	if (!SWIG_IsOK(ecode1)) {
6120	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DeactivateComponent" "', argument " "1"" of type '" "uint32_t""'");
6121	}
6122	arg1 = static_cast< uint32_t >(val1);
6123	result = (bool)DeactivateComponent(arg1);
6124	resultobj = SWIG_From_bool(static_cast< bool >(result));
6125	return resultobj;
6126	fail:
6127	return NULL;
6128	}
6129
6130
6131	SWIGINTERN PyObject _wrap_DisconnectComponent(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
6132	PyObject *resultobj = 0;
6133	uint32_t arg1 ;
6134	int val1 ;
6135	int ecode1 = 0 ;
6136	PyObject * obj0 = 0 ;
6137	bool result;
6138
6139	if (!PyArg_ParseTuple(args,(char *)"O:DisconnectComponent",&obj0)) SWIG_fail;
6140	ecode1 = SWIG_AsVal_int(obj0, &val1);
6141	if (!SWIG_IsOK(ecode1)) {
6142	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DisconnectComponent" "', argument " "1"" of type '" "uint32_t""'");
6143	}
6144	arg1 = static_cast< uint32_t >(val1);
6145	result = (bool)DisconnectComponent(arg1);
6146	resultobj = SWIG_From_bool(static_cast< bool >(result));
6147	return resultobj;
6148	fail:
6149	return NULL;
6150	}
6151
6152
6153	SWIGINTERN PyObject _wrap_SetActiveMission(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
6154	PyObject *resultobj = 0;
6155	char arg1 = (char ) 0 ;
6156	int res1 ;
6157	char *buf1 = 0 ;
6158	int alloc1 = 0 ;
6159	PyObject * obj0 = 0 ;
6160	uint32_t result;
6161
6162	if (!PyArg_ParseTuple(args,(char *)"O:SetActiveMission",&obj0)) SWIG_fail;
6163	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
6164	if (!SWIG_IsOK(res1)) {
6165	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetActiveMission" "', argument " "1"" of type '" "char *""'");
6166	}
6167	arg1 = reinterpret_cast< char * >(buf1);
6168	result = SetActiveMission(arg1);
6169	resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN \| 0 );
6170	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
6171	return resultobj;
6172	fail:
6173	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
6174	return NULL;
6175	}
6176
6177
6178	SWIGINTERN PyObject _wrap_Shutdown(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
6179	PyObject *resultobj = 0;
6180	bool result;
6181
6182	if (!PyArg_ParseTuple(args,(char *)":Shutdown")) SWIG_fail;
6183	result = (bool)Shutdown();
6184	resultobj = SWIG_From_bool(static_cast< bool >(result));
6185	return resultobj;
6186	fail:
6187	return NULL;
6188	}
6189
6190
6191	SWIGINTERN PyObject _wrap_GetNumParameters(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
6192	PyObject *resultobj = 0;
6193	uint32_t result;
6194
6195	if (!PyArg_ParseTuple(args,(char *)":GetNumParameters")) SWIG_fail;
6196	result = GetNumParameters();
6197	resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN \| 0 );
6198	return resultobj;
6199	fail:
6200	return NULL;
6201	}
6202
6203
6204	SWIGINTERN PyObject _wrap_GetNumObservables(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
6205	PyObject *resultobj = 0;
6206	uint32_t result;
6207
6208	if (!PyArg_ParseTuple(args,(char *)":GetNumObservables")) SWIG_fail;
6209	result = GetNumObservables();
6210	resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN \| 0 );
6211	return resultobj;
6212	fail:
6213	return NULL;
6214	}
6215
6216
6217	SWIGINTERN PyObject _wrap_GetNumUtilities(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
6218	PyObject *resultobj = 0;
6219	uint32_t result;
6220
6221	if (!PyArg_ParseTuple(args,(char *)":GetNumUtilities")) SWIG_fail;
6222	result = GetNumUtilities();
6223	resultobj = SWIG_NewPointerObj((new uint32_t(static_cast< const uint32_t& >(result))), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN \| 0 );
6224	return resultobj;
6225	fail:
6226	return NULL;
6227	}
6228
6229
6230	static PyMethodDef SwigMethods[] = {
6231	{ (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
6232	{ (char *)"Radio_Info_numUtilities_set", _wrap_Radio_Info_numUtilities_set, METH_VARARGS, NULL},
6233	{ (char *)"Radio_Info_numUtilities_get", _wrap_Radio_Info_numUtilities_get, METH_VARARGS, NULL},
6234	{ (char *)"Radio_Info_numParameters_set", _wrap_Radio_Info_numParameters_set, METH_VARARGS, NULL},
6235	{ (char *)"Radio_Info_numParameters_get", _wrap_Radio_Info_numParameters_get, METH_VARARGS, NULL},
6236	{ (char *)"Radio_Info_numObservables_set", _wrap_Radio_Info_numObservables_set, METH_VARARGS, NULL},
6237	{ (char *)"Radio_Info_numObservables_get", _wrap_Radio_Info_numObservables_get, METH_VARARGS, NULL},
6238	{ (char *)"Radio_Info_policy_engine_set", _wrap_Radio_Info_policy_engine_set, METH_VARARGS, NULL},
6239	{ (char *)"Radio_Info_policy_engine_get", _wrap_Radio_Info_policy_engine_get, METH_VARARGS, NULL},
6240	{ (char *)"Radio_Info_policy_socket_set", _wrap_Radio_Info_policy_socket_set, METH_VARARGS, NULL},
6241	{ (char *)"Radio_Info_policy_socket_get", _wrap_Radio_Info_policy_socket_get, METH_VARARGS, NULL},
6242	{ (char *)"Radio_Info_ce_socket_set", _wrap_Radio_Info_ce_socket_set, METH_VARARGS, NULL},
6243	{ (char *)"Radio_Info_ce_socket_get", _wrap_Radio_Info_ce_socket_get, METH_VARARGS, NULL},
6244	{ (char *)"new_Radio_Info", _wrap_new_Radio_Info, METH_VARARGS, NULL},
6245	{ (char *)"delete_Radio_Info", _wrap_delete_Radio_Info, METH_VARARGS, NULL},
6246	{ (char *)"Radio_Info_swigregister", Radio_Info_swigregister, METH_VARARGS, NULL},
6247	{ (char *)"Utility_name_set", _wrap_Utility_name_set, METH_VARARGS, NULL},
6248	{ (char *)"Utility_name_get", _wrap_Utility_name_get, METH_VARARGS, NULL},
6249	{ (char *)"Utility_units_set", _wrap_Utility_units_set, METH_VARARGS, NULL},
6250	{ (char *)"Utility_units_get", _wrap_Utility_units_get, METH_VARARGS, NULL},
6251	{ (char *)"Utility_goal_set", _wrap_Utility_goal_set, METH_VARARGS, NULL},
6252	{ (char *)"Utility_goal_get", _wrap_Utility_goal_get, METH_VARARGS, NULL},
6253	{ (char *)"Utility_target_set", _wrap_Utility_target_set, METH_VARARGS, NULL},
6254	{ (char *)"Utility_target_get", _wrap_Utility_target_get, METH_VARARGS, NULL},
6255	{ (char *)"Utility_value_set", _wrap_Utility_value_set, METH_VARARGS, NULL},
6256	{ (char *)"Utility_value_get", _wrap_Utility_value_get, METH_VARARGS, NULL},
6257	{ (char *)"new_Utility", _wrap_new_Utility, METH_VARARGS, NULL},
6258	{ (char *)"delete_Utility", _wrap_delete_Utility, METH_VARARGS, NULL},
6259	{ (char *)"Utility___getitem__", _wrap_Utility___getitem__, METH_VARARGS, NULL},
6260	{ (char *)"Utility_swigregister", Utility_swigregister, METH_VARARGS, NULL},
6261	{ (char *)"Affect_u_set", _wrap_Affect_u_set, METH_VARARGS, NULL},
6262	{ (char *)"Affect_u_get", _wrap_Affect_u_get, METH_VARARGS, NULL},
6263	{ (char *)"Affect_relation_set", _wrap_Affect_relation_set, METH_VARARGS, NULL},
6264	{ (char *)"Affect_relation_get", _wrap_Affect_relation_get, METH_VARARGS, NULL},
6265	{ (char *)"new_Affect", _wrap_new_Affect, METH_VARARGS, NULL},
6266	{ (char *)"delete_Affect", _wrap_delete_Affect, METH_VARARGS, NULL},
6267	{ (char *)"Affect_swigregister", Affect_swigregister, METH_VARARGS, NULL},
6268	{ (char *)"Parameter_name_set", _wrap_Parameter_name_set, METH_VARARGS, NULL},
6269	{ (char *)"Parameter_name_get", _wrap_Parameter_name_get, METH_VARARGS, NULL},
6270	{ (char *)"Parameter_units_set", _wrap_Parameter_units_set, METH_VARARGS, NULL},
6271	{ (char *)"Parameter_units_get", _wrap_Parameter_units_get, METH_VARARGS, NULL},
6272	{ (char *)"Parameter_min_set", _wrap_Parameter_min_set, METH_VARARGS, NULL},
6273	{ (char *)"Parameter_min_get", _wrap_Parameter_min_get, METH_VARARGS, NULL},
6274	{ (char *)"Parameter_numAffects_set", _wrap_Parameter_numAffects_set, METH_VARARGS, NULL},
6275	{ (char *)"Parameter_numAffects_get", _wrap_Parameter_numAffects_get, METH_VARARGS, NULL},
6276	{ (char *)"Parameter_affection_list_set", _wrap_Parameter_affection_list_set, METH_VARARGS, NULL},
6277	{ (char *)"Parameter_affection_list_get", _wrap_Parameter_affection_list_get, METH_VARARGS, NULL},
6278	{ (char *)"Parameter_max_set", _wrap_Parameter_max_set, METH_VARARGS, NULL},
6279	{ (char *)"Parameter_max_get", _wrap_Parameter_max_get, METH_VARARGS, NULL},
6280	{ (char *)"Parameter_step_set", _wrap_Parameter_step_set, METH_VARARGS, NULL},
6281	{ (char *)"Parameter_step_get", _wrap_Parameter_step_get, METH_VARARGS, NULL},
6282	{ (char *)"Parameter_value_set", _wrap_Parameter_value_set, METH_VARARGS, NULL},
6283	{ (char *)"Parameter_value_get", _wrap_Parameter_value_get, METH_VARARGS, NULL},
6284	{ (char *)"new_Parameter", _wrap_new_Parameter, METH_VARARGS, NULL},
6285	{ (char *)"delete_Parameter", _wrap_delete_Parameter, METH_VARARGS, NULL},
6286	{ (char *)"Parameter___getitem__", _wrap_Parameter___getitem__, METH_VARARGS, NULL},
6287	{ (char *)"Parameter_swigregister", Parameter_swigregister, METH_VARARGS, NULL},
6288	{ (char *)"Observable_name_set", _wrap_Observable_name_set, METH_VARARGS, NULL},
6289	{ (char *)"Observable_name_get", _wrap_Observable_name_get, METH_VARARGS, NULL},
6290	{ (char *)"Observable_affection_list_set", _wrap_Observable_affection_list_set, METH_VARARGS, NULL},
6291	{ (char *)"Observable_affection_list_get", _wrap_Observable_affection_list_get, METH_VARARGS, NULL},
6292	{ (char *)"Observable_numAffects_set", _wrap_Observable_numAffects_set, METH_VARARGS, NULL},
6293	{ (char *)"Observable_numAffects_get", _wrap_Observable_numAffects_get, METH_VARARGS, NULL},
6294	{ (char *)"Observable_value_set", _wrap_Observable_value_set, METH_VARARGS, NULL},
6295	{ (char *)"Observable_value_get", _wrap_Observable_value_get, METH_VARARGS, NULL},
6296	{ (char *)"new_Observable", _wrap_new_Observable, METH_VARARGS, NULL},
6297	{ (char *)"delete_Observable", _wrap_delete_Observable, METH_VARARGS, NULL},
6298	{ (char *)"Observable___getitem__", _wrap_Observable___getitem__, METH_VARARGS, NULL},
6299	{ (char *)"Observable_swigregister", Observable_swigregister, METH_VARARGS, NULL},
6300	{ (char *)"Service_name_set", _wrap_Service_name_set, METH_VARARGS, NULL},
6301	{ (char *)"Service_name_get", _wrap_Service_name_get, METH_VARARGS, NULL},
6302	{ (char *)"Service_socketFD_set", _wrap_Service_socketFD_set, METH_VARARGS, NULL},
6303	{ (char *)"Service_socketFD_get", _wrap_Service_socketFD_get, METH_VARARGS, NULL},
6304	{ (char *)"Service_componentID_set", _wrap_Service_componentID_set, METH_VARARGS, NULL},
6305	{ (char *)"Service_componentID_get", _wrap_Service_componentID_get, METH_VARARGS, NULL},
6306	{ (char *)"Service_num_conds_set", _wrap_Service_num_conds_set, METH_VARARGS, NULL},
6307	{ (char *)"Service_num_conds_get", _wrap_Service_num_conds_get, METH_VARARGS, NULL},
6308	{ (char *)"Service_parameter_set", _wrap_Service_parameter_set, METH_VARARGS, NULL},
6309	{ (char *)"Service_parameter_get", _wrap_Service_parameter_get, METH_VARARGS, NULL},
6310	{ (char *)"Service_input_set", _wrap_Service_input_set, METH_VARARGS, NULL},
6311	{ (char *)"Service_input_get", _wrap_Service_input_get, METH_VARARGS, NULL},
6312	{ (char *)"Service_output_set", _wrap_Service_output_set, METH_VARARGS, NULL},
6313	{ (char *)"Service_output_get", _wrap_Service_output_get, METH_VARARGS, NULL},
6314	{ (char *)"new_Service", _wrap_new_Service, METH_VARARGS, NULL},
6315	{ (char *)"delete_Service", _wrap_delete_Service, METH_VARARGS, NULL},
6316	{ (char *)"Service_swigregister", Service_swigregister, METH_VARARGS, NULL},
6317	{ (char *)"Mission_name_set", _wrap_Mission_name_set, METH_VARARGS, NULL},
6318	{ (char *)"Mission_name_get", _wrap_Mission_name_get, METH_VARARGS, NULL},
6319	{ (char *)"Mission_missionID_set", _wrap_Mission_missionID_set, METH_VARARGS, NULL},
6320	{ (char *)"Mission_missionID_get", _wrap_Mission_missionID_get, METH_VARARGS, NULL},
6321	{ (char *)"Mission_numServices_set", _wrap_Mission_numServices_set, METH_VARARGS, NULL},
6322	{ (char *)"Mission_numServices_get", _wrap_Mission_numServices_get, METH_VARARGS, NULL},
6323	{ (char *)"Mission_services_set", _wrap_Mission_services_set, METH_VARARGS, NULL},
6324	{ (char *)"Mission_services_get", _wrap_Mission_services_get, METH_VARARGS, NULL},
6325	{ (char *)"Mission_input_set", _wrap_Mission_input_set, METH_VARARGS, NULL},
6326	{ (char *)"Mission_input_get", _wrap_Mission_input_get, METH_VARARGS, NULL},
6327	{ (char *)"Mission_output_set", _wrap_Mission_output_set, METH_VARARGS, NULL},
6328	{ (char *)"Mission_output_get", _wrap_Mission_output_get, METH_VARARGS, NULL},
6329	{ (char *)"new_Mission", _wrap_new_Mission, METH_VARARGS, NULL},
6330	{ (char *)"delete_Mission", _wrap_delete_Mission, METH_VARARGS, NULL},
6331	{ (char *)"Mission_swigregister", Mission_swigregister, METH_VARARGS, NULL},
6332	{ (char *)"CE_Reg_ID_num_set", _wrap_CE_Reg_ID_num_set, METH_VARARGS, NULL},
6333	{ (char *)"CE_Reg_ID_num_get", _wrap_CE_Reg_ID_num_get, METH_VARARGS, NULL},
6334	{ (char *)"CE_Reg_FD_set", _wrap_CE_Reg_FD_set, METH_VARARGS, NULL},
6335	{ (char *)"CE_Reg_FD_get", _wrap_CE_Reg_FD_get, METH_VARARGS, NULL},
6336	{ (char *)"new_CE_Reg", _wrap_new_CE_Reg, METH_VARARGS, NULL},
6337	{ (char *)"delete_CE_Reg", _wrap_delete_CE_Reg, METH_VARARGS, NULL},
6338	{ (char *)"CE_Reg_swigregister", CE_Reg_swigregister, METH_VARARGS, NULL},
6339	{ (char *)"ParseRadioConfiguration", _wrap_ParseRadioConfiguration, METH_VARARGS, NULL},
6340	{ (char *)"ListCurrentRadioConfiguration", _wrap_ListCurrentRadioConfiguration, METH_VARARGS, NULL},
6341	{ (char *)"GetRadioObservables", _wrap_GetRadioObservables, METH_VARARGS, NULL},
6342	{ (char *)"GetRadioParameters", _wrap_GetRadioParameters, METH_VARARGS, NULL},
6343	{ (char *)"GetRadioUtilities", _wrap_GetRadioUtilities, METH_VARARGS, NULL},
6344	{ (char *)"GetConnectedCognitiveEngines", _wrap_GetConnectedCognitiveEngines, METH_VARARGS, NULL},
6345	{ (char *)"GetConnectedPolicyEngines", _wrap_GetConnectedPolicyEngines, METH_VARARGS, NULL},
6346	{ (char *)"GetConnectedManagementServiceLayers", _wrap_GetConnectedManagementServiceLayers, METH_VARARGS, NULL},
6347	{ (char *)"GetConnectedComponents", _wrap_GetConnectedComponents, METH_VARARGS, NULL},
6348	{ (char *)"GetComponentInformation", _wrap_GetComponentInformation, METH_VARARGS, NULL},
6349	{ (char *)"GetOptimalParameters", _wrap_GetOptimalParameters, METH_VARARGS, NULL},
6350	{ (char *)"UpdateParameterPerformance", _wrap_UpdateParameterPerformance, METH_VARARGS, NULL},
6351	{ (char *)"ActivateComponent", _wrap_ActivateComponent, METH_VARARGS, NULL},
6352	{ (char *)"DeactivateComponent", _wrap_DeactivateComponent, METH_VARARGS, NULL},
6353	{ (char *)"DisconnectComponent", _wrap_DisconnectComponent, METH_VARARGS, NULL},
6354	{ (char *)"SetActiveMission", _wrap_SetActiveMission, METH_VARARGS, NULL},
6355	{ (char *)"Shutdown", _wrap_Shutdown, METH_VARARGS, NULL},
6356	{ (char *)"GetNumParameters", _wrap_GetNumParameters, METH_VARARGS, NULL},
6357	{ (char *)"GetNumObservables", _wrap_GetNumObservables, METH_VARARGS, NULL},
6358	{ (char *)"GetNumUtilities", _wrap_GetNumUtilities, METH_VARARGS, NULL},
6359	{ NULL, NULL, 0, NULL }
6360	};
6361
6362
6363	/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6364
6365	static swig_type_info _swigt__p_Affect = {"_p_Affect", "Affect ", 0, 0, (void)0, 0};
6366	static swig_type_info _swigt__p_CE_Reg = {"_p_CE_Reg", "CE_Reg ", 0, 0, (void)0, 0};
6367	static swig_type_info _swigt__p_Component = {"_p_Component", "Component ", 0, 0, (void)0, 0};
6368	static swig_type_info _swigt__p_Mission = {"_p_Mission", "Mission ", 0, 0, (void)0, 0};
6369	static swig_type_info _swigt__p_Observable = {"_p_Observable", "Observable ", 0, 0, (void)0, 0};
6370	static swig_type_info _swigt__p_Parameter = {"_p_Parameter", "Parameter ", 0, 0, (void)0, 0};
6371	static swig_type_info _swigt__p_Radio_Info = {"_p_Radio_Info", "Radio_Info ", 0, 0, (void)0, 0};
6372	static swig_type_info _swigt__p_Service = {"_p_Service", "Service ", 0, 0, (void)0, 0};
6373	static swig_type_info _swigt__p_Utility = {"_p_Utility", "Utility ", 0, 0, (void)0, 0};
6374	static swig_type_info _swigt__p_char = {"_p_char", "char ", 0, 0, (void)0, 0};
6375	static swig_type_info _swigt__p_int32_t = {"_p_int32_t", "int32_t ", 0, 0, (void)0, 0};
6376	static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string ", 0, 0, (void)0, 0};
6377	static swig_type_info _swigt__p_uint16_t = {"_p_uint16_t", "uint16_t ", 0, 0, (void)0, 0};
6378	static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t ", 0, 0, (void)0, 0};
6379
6380	static swig_type_info *swig_type_initial[] = {
6381	&_swigt__p_Affect,
6382	&_swigt__p_CE_Reg,
6383	&_swigt__p_Component,
6384	&_swigt__p_Mission,
6385	&_swigt__p_Observable,
6386	&_swigt__p_Parameter,
6387	&_swigt__p_Radio_Info,
6388	&_swigt__p_Service,
6389	&_swigt__p_Utility,
6390	&_swigt__p_char,
6391	&_swigt__p_int32_t,
6392	&_swigt__p_std__string,
6393	&_swigt__p_uint16_t,
6394	&_swigt__p_uint32_t,
6395	};
6396
6397	static swig_cast_info _swigc__p_Affect[] = { {&_swigt__p_Affect, 0, 0, 0},{0, 0, 0, 0}};
6398	static swig_cast_info _swigc__p_CE_Reg[] = { {&_swigt__p_CE_Reg, 0, 0, 0},{0, 0, 0, 0}};
6399	static swig_cast_info _swigc__p_Component[] = { {&_swigt__p_Component, 0, 0, 0},{0, 0, 0, 0}};
6400	static swig_cast_info _swigc__p_Mission[] = { {&_swigt__p_Mission, 0, 0, 0},{0, 0, 0, 0}};
6401	static swig_cast_info _swigc__p_Observable[] = { {&_swigt__p_Observable, 0, 0, 0},{0, 0, 0, 0}};
6402	static swig_cast_info _swigc__p_Parameter[] = { {&_swigt__p_Parameter, 0, 0, 0},{0, 0, 0, 0}};
6403	static swig_cast_info _swigc__p_Radio_Info[] = { {&_swigt__p_Radio_Info, 0, 0, 0},{0, 0, 0, 0}};
6404	static swig_cast_info _swigc__p_Service[] = { {&_swigt__p_Service, 0, 0, 0},{0, 0, 0, 0}};
6405	static swig_cast_info _swigc__p_Utility[] = { {&_swigt__p_Utility, 0, 0, 0},{0, 0, 0, 0}};
6406	static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
6407	static swig_cast_info _swigc__p_int32_t[] = { {&_swigt__p_int32_t, 0, 0, 0},{0, 0, 0, 0}};
6408	static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
6409	static swig_cast_info _swigc__p_uint16_t[] = { {&_swigt__p_uint16_t, 0, 0, 0},{0, 0, 0, 0}};
6410	static swig_cast_info _swigc__p_uint32_t[] = { {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}};
6411
6412	static swig_cast_info *swig_cast_initial[] = {
6413	_swigc__p_Affect,
6414	_swigc__p_CE_Reg,
6415	_swigc__p_Component,
6416	_swigc__p_Mission,
6417	_swigc__p_Observable,
6418	_swigc__p_Parameter,
6419	_swigc__p_Radio_Info,
6420	_swigc__p_Service,
6421	_swigc__p_Utility,
6422	_swigc__p_char,
6423	_swigc__p_int32_t,
6424	_swigc__p_std__string,
6425	_swigc__p_uint16_t,
6426	_swigc__p_uint32_t,
6427	};
6428
6429
6430	/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
6431
6432	static swig_const_info swig_const_table[] = {
6433	{0, 0, 0, 0.0, 0, 0}};
6434
6435	#ifdef __cplusplus
6436	}
6437	#endif
6438	/* -----------------------------------------------------------------------------
6439	* Type initialization:
6440	* This problem is tough by the requirement that no dynamic
6441	* memory is used. Also, since swig_type_info structures store pointers to
6442	* swig_cast_info structures and swig_cast_info structures store pointers back
6443	* to swig_type_info structures, we need some lookup code at initialization.
6444	* The idea is that swig generates all the structures that are needed.
6445	* The runtime then collects these partially filled structures.
6446	* The SWIG_InitializeModule function takes these initial arrays out of
6447	* swig_module, and does all the lookup, filling in the swig_module.types
6448	* array with the correct data and linking the correct swig_cast_info
6449	* structures together.
6450	*
6451	* The generated swig_type_info structures are assigned staticly to an initial
6452	* array. We just loop through that array, and handle each type individually.
6453	* First we lookup if this type has been already loaded, and if so, use the
6454	* loaded structure instead of the generated one. Then we have to fill in the
6455	* cast linked list. The cast data is initially stored in something like a
6456	* two-dimensional array. Each row corresponds to a type (there are the same
6457	* number of rows as there are in the swig_type_initial array). Each entry in
6458	* a column is one of the swig_cast_info structures for that type.
6459	* The cast_initial array is actually an array of arrays, because each row has
6460	* a variable number of columns. So to actually build the cast linked list,
6461	* we find the array of casts associated with the type, and loop through it
6462	* adding the casts to the list. The one last trick we need to do is making
6463	* sure the type pointer in the swig_cast_info struct is correct.
6464	*
6465	* First off, we lookup the cast->type name to see if it is already loaded.
6466	* There are three cases to handle:
6467	* 1) If the cast->type has already been loaded AND the type we are adding
6468	* casting info to has not been loaded (it is in this module), THEN we
6469	* replace the cast->type pointer with the type pointer that has already
6470	* been loaded.
6471	* 2) If BOTH types (the one we are adding casting info to, and the
6472	* cast->type) are loaded, THEN the cast info has already been loaded by
6473	* the previous module so we just ignore it.
6474	* 3) Finally, if cast->type has not already been loaded, then we add that
6475	* swig_cast_info to the linked list (because the cast->type) pointer will
6476	* be correct.
6477	* ----------------------------------------------------------------------------- */
6478
6479	#ifdef __cplusplus
6480	extern "C" {
6481	#if 0
6482	} /* c-mode */
6483	#endif
6484	#endif
6485
6486	#if 0
6487	#define SWIGRUNTIME_DEBUG
6488	#endif
6489
6490
6491	SWIGRUNTIME void
6492	SWIG_InitializeModule(void *clientdata) {
6493	size_t i;
6494	swig_module_info module_head, iter;
6495	int found, init;
6496
6497	clientdata = clientdata;
6498
6499	/* check to see if the circular list has been setup, if not, set it up */
6500	if (swig_module.next==0) {
6501	/* Initialize the swig_module */
6502	swig_module.type_initial = swig_type_initial;
6503	swig_module.cast_initial = swig_cast_initial;
6504	swig_module.next = &swig_module;
6505	init = 1;
6506	} else {
6507	init = 0;
6508	}
6509
6510	/* Try and load any already created modules */
6511	module_head = SWIG_GetModule(clientdata);
6512	if (!module_head) {
6513	/* This is the first module loaded for this interpreter */
6514	/* so set the swig module into the interpreter */
6515	SWIG_SetModule(clientdata, &swig_module);
6516	module_head = &swig_module;
6517	} else {
6518	/* the interpreter has loaded a SWIG module, but has it loaded this one? */
6519	found=0;
6520	iter=module_head;
6521	do {
6522	if (iter==&swig_module) {
6523	found=1;
6524	break;
6525	}
6526	iter=iter->next;
6527	} while (iter!= module_head);
6528
6529	/* if the is found in the list, then all is done and we may leave */
6530	if (found) return;
6531	/* otherwise we must add out module into the list */
6532	swig_module.next = module_head->next;
6533	module_head->next = &swig_module;
6534	}
6535
6536	/* When multiple interpeters are used, a module could have already been initialized in
6537	a different interpreter, but not yet have a pointer in this interpreter.
6538	In this case, we do not want to continue adding types... everything should be
6539	set up already */
6540	if (init == 0) return;
6541
6542	/* Now work on filling in swig_module.types */
6543	#ifdef SWIGRUNTIME_DEBUG
6544	printf("SWIG_InitializeModule: size %d\n", swig_module.size);
6545	#endif
6546	for (i = 0; i < swig_module.size; ++i) {
6547	swig_type_info *type = 0;
6548	swig_type_info *ret;
6549	swig_cast_info *cast;
6550
6551	#ifdef SWIGRUNTIME_DEBUG
6552	printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6553	#endif
6554
6555	/* if there is another module already loaded */
6556	if (swig_module.next != &swig_module) {
6557	type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
6558	}
6559	if (type) {
6560	/* Overwrite clientdata field */
6561	#ifdef SWIGRUNTIME_DEBUG
6562	printf("SWIG_InitializeModule: found type %s\n", type->name);
6563	#endif
6564	if (swig_module.type_initial[i]->clientdata) {
6565	type->clientdata = swig_module.type_initial[i]->clientdata;
6566	#ifdef SWIGRUNTIME_DEBUG
6567	printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
6568	#endif
6569	}
6570	} else {
6571	type = swig_module.type_initial[i];
6572	}
6573
6574	/* Insert casting types */
6575	cast = swig_module.cast_initial[i];
6576	while (cast->type) {
6577	/* Don't need to add information already in the list */
6578	ret = 0;
6579	#ifdef SWIGRUNTIME_DEBUG
6580	printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
6581	#endif
6582	if (swig_module.next != &swig_module) {
6583	ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
6584	#ifdef SWIGRUNTIME_DEBUG
6585	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
6586	#endif
6587	}
6588	if (ret) {
6589	if (type == swig_module.type_initial[i]) {
6590	#ifdef SWIGRUNTIME_DEBUG
6591	printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
6592	#endif
6593	cast->type = ret;
6594	ret = 0;
6595	} else {
6596	/* Check for casting already in the list */
6597	swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
6598	#ifdef SWIGRUNTIME_DEBUG
6599	if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
6600	#endif
6601	if (!ocast) ret = 0;
6602	}
6603	}
6604
6605	if (!ret) {
6606	#ifdef SWIGRUNTIME_DEBUG
6607	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
6608	#endif
6609	if (type->cast) {
6610	type->cast->prev = cast;
6611	cast->next = type->cast;
6612	}
6613	type->cast = cast;
6614	}
6615	cast++;
6616	}
6617	/* Set entry in modules->types array equal to the type */
6618	swig_module.types[i] = type;
6619	}
6620	swig_module.types[i] = 0;
6621
6622	#ifdef SWIGRUNTIME_DEBUG
6623	printf("** SWIG_InitializeModule: Cast List ****\n");
6624	for (i = 0; i < swig_module.size; ++i) {
6625	int j = 0;
6626	swig_cast_info *cast = swig_module.cast_initial[i];
6627	printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6628	while (cast->type) {
6629	printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
6630	cast++;
6631	++j;
6632	}
6633	printf("---- Total casts: %d\n",j);
6634	}
6635	printf("** SWIG_InitializeModule: Cast List ****\n");
6636	#endif
6637	}
6638
6639	/* This function will propagate the clientdata field of type to
6640	* any new swig_type_info structures that have been added into the list
6641	* of equivalent types. It is like calling
6642	* SWIG_TypeClientData(type, clientdata) a second time.
6643	*/
6644	SWIGRUNTIME void
6645	SWIG_PropagateClientData(void) {
6646	size_t i;
6647	swig_cast_info *equiv;
6648	static int init_run = 0;
6649
6650	if (init_run) return;
6651	init_run = 1;
6652
6653	for (i = 0; i < swig_module.size; i++) {
6654	if (swig_module.types[i]->clientdata) {
6655	equiv = swig_module.types[i]->cast;
6656	while (equiv) {
6657	if (!equiv->converter) {
6658	if (equiv->type && !equiv->type->clientdata)
6659	SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
6660	}
6661	equiv = equiv->next;
6662	}
6663	}
6664	}
6665	}
6666
6667	#ifdef __cplusplus
6668	#if 0
6669	{
6670	/* c-mode */
6671	#endif
6672	}
6673	#endif
6674
6675
6676
6677	#ifdef __cplusplus
6678	extern "C" {
6679	#endif
6680
6681	/* Python-specific SWIG API */
6682	#define SWIG_newvarlink() SWIG_Python_newvarlink()
6683	#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
6684	#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
6685
6686	/* -----------------------------------------------------------------------------
6687	* global variable support code.
6688	* ----------------------------------------------------------------------------- */
6689
6690	typedef struct swig_globalvar {
6691	char name; / Name of global variable */
6692	PyObject (get_attr)(void); /* Return the current value */
6693	int (set_attr)(PyObject ); /* Set the value */
6694	struct swig_globalvar *next;
6695	} swig_globalvar;
6696
6697	typedef struct swig_varlinkobject {
6698	PyObject_HEAD
6699	swig_globalvar *vars;
6700	} swig_varlinkobject;
6701
6702	SWIGINTERN PyObject *
6703	swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
6704	#if PY_VERSION_HEX >= 0x03000000
6705	return PyUnicode_InternFromString("<Swig global variables>");
6706	#else
6707	return PyString_FromString("<Swig global variables>");
6708	#endif
6709	}
6710
6711	SWIGINTERN PyObject *
6712	swig_varlink_str(swig_varlinkobject *v) {
6713	#if PY_VERSION_HEX >= 0x03000000
6714	PyObject *str = PyUnicode_InternFromString("(");
6715	PyObject *tail;
6716	PyObject *joined;
6717	swig_globalvar *var;
6718	for (var = v->vars; var; var=var->next) {
6719	tail = PyUnicode_FromString(var->name);
6720	joined = PyUnicode_Concat(str, tail);
6721	Py_DecRef(str);
6722	Py_DecRef(tail);
6723	str = joined;
6724	if (var->next) {
6725	tail = PyUnicode_InternFromString(", ");
6726	joined = PyUnicode_Concat(str, tail);
6727	Py_DecRef(str);
6728	Py_DecRef(tail);
6729	str = joined;
6730	}
6731	}
6732	tail = PyUnicode_InternFromString(")");
6733	joined = PyUnicode_Concat(str, tail);
6734	Py_DecRef(str);
6735	Py_DecRef(tail);
6736	str = joined;
6737	#else
6738	PyObject *str = PyString_FromString("(");
6739	swig_globalvar *var;
6740	for (var = v->vars; var; var=var->next) {
6741	PyString_ConcatAndDel(&str,PyString_FromString(var->name));
6742	if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
6743	}
6744	PyString_ConcatAndDel(&str,PyString_FromString(")"));
6745	#endif
6746	return str;
6747	}
6748
6749	SWIGINTERN int
6750	swig_varlink_print(swig_varlinkobject v, FILE fp, int SWIGUNUSEDPARM(flags)) {
6751	char *tmp;
6752	PyObject *str = swig_varlink_str(v);
6753	fprintf(fp,"Swig global variables ");
6754	fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
6755	SWIG_Python_str_DelForPy3(tmp);
6756	Py_DECREF(str);
6757	return 0;
6758	}
6759
6760	SWIGINTERN void
6761	swig_varlink_dealloc(swig_varlinkobject *v) {
6762	swig_globalvar *var = v->vars;
6763	while (var) {
6764	swig_globalvar *n = var->next;
6765	free(var->name);
6766	free(var);
6767	var = n;
6768	}
6769	}
6770
6771	SWIGINTERN PyObject *
6772	swig_varlink_getattr(swig_varlinkobject v, char n) {
6773	PyObject *res = NULL;
6774	swig_globalvar *var = v->vars;
6775	while (var) {
6776	if (strcmp(var->name,n) == 0) {
6777	res = (*var->get_attr)();
6778	break;
6779	}
6780	var = var->next;
6781	}
6782	if (res == NULL && !PyErr_Occurred()) {
6783	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
6784	}
6785	return res;
6786	}
6787
6788	SWIGINTERN int
6789	swig_varlink_setattr(swig_varlinkobject v, char n, PyObject *p) {
6790	int res = 1;
6791	swig_globalvar *var = v->vars;
6792	while (var) {
6793	if (strcmp(var->name,n) == 0) {
6794	res = (*var->set_attr)(p);
6795	break;
6796	}
6797	var = var->next;
6798	}
6799	if (res == 1 && !PyErr_Occurred()) {
6800	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
6801	}
6802	return res;
6803	}
6804
6805	SWIGINTERN PyTypeObject*
6806	swig_varlink_type(void) {
6807	static char varlink__doc__[] = "Swig var link object";
6808	static PyTypeObject varlink_type;
6809	static int type_init = 0;
6810	if (!type_init) {
6811	const PyTypeObject tmp
6812	= {
6813	/* PyObject header changed in Python 3 */
6814	#if PY_VERSION_HEX >= 0x03000000
6815	PyVarObject_HEAD_INIT(&PyType_Type, 0)
6816	#else
6817	PyObject_HEAD_INIT(NULL)
6818	0, /* Number of items in variable part (ob_size) */
6819	#endif
6820	(char )"swigvarlink", / Type name (tp_name) */
6821	sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
6822	0, /* Itemsize (tp_itemsize) */
6823	(destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
6824	(printfunc) swig_varlink_print, /* Print (tp_print) */
6825	(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
6826	(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
6827	0, /* tp_compare */
6828	(reprfunc) swig_varlink_repr, /* tp_repr */
6829	0, /* tp_as_number */
6830	0, /* tp_as_sequence */
6831	0, /* tp_as_mapping */
6832	0, /* tp_hash */
6833	0, /* tp_call */
6834	(reprfunc)swig_varlink_str, /* tp_str */
6835	0, /* tp_getattro */
6836	0, /* tp_setattro */
6837	0, /* tp_as_buffer */
6838	0, /* tp_flags */
6839	varlink__doc__, /* tp_doc */
6840	0, /* tp_traverse */
6841	0, /* tp_clear */
6842	0, /* tp_richcompare */
6843	0, /* tp_weaklistoffset */
6844	#if PY_VERSION_HEX >= 0x02020000
6845	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
6846	#endif
6847	#if PY_VERSION_HEX >= 0x02030000
6848	0, /* tp_del */
6849	#endif
6850	#ifdef COUNT_ALLOCS
6851	0,0,0,0 /* tp_alloc -> tp_next */
6852	#endif
6853	};
6854	varlink_type = tmp;
6855	/* for Python 3 we already assigned the ob_type in PyVarObject_HEAD_INIT() */
6856	#if PY_VERSION_HEX < 0x03000000
6857	varlink_type.ob_type = &PyType_Type;
6858	#endif
6859	type_init = 1;
6860	}
6861	return &varlink_type;
6862	}
6863
6864	/* Create a variable linking object for use later */
6865	SWIGINTERN PyObject *
6866	SWIG_Python_newvarlink(void) {
6867	swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
6868	if (result) {
6869	result->vars = 0;
6870	}
6871	return ((PyObject*) result);
6872	}
6873
6874	SWIGINTERN void
6875	SWIG_Python_addvarlink(PyObject p, char name, PyObject (get_attr)(void), int (set_attr)(PyObject p)) {
6876	swig_varlinkobject v = (swig_varlinkobject ) p;
6877	swig_globalvar gv = (swig_globalvar ) malloc(sizeof(swig_globalvar));
6878	if (gv) {
6879	size_t size = strlen(name)+1;
6880	gv->name = (char *)malloc(size);
6881	if (gv->name) {
6882	strncpy(gv->name,name,size);
6883	gv->get_attr = get_attr;
6884	gv->set_attr = set_attr;
6885	gv->next = v->vars;
6886	}
6887	}
6888	v->vars = gv;
6889	}
6890
6891	SWIGINTERN PyObject *
6892	SWIG_globals(void) {
6893	static PyObject *_SWIG_globals = 0;
6894	if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
6895	return _SWIG_globals;
6896	}
6897
6898	/* -----------------------------------------------------------------------------
6899	* constants/methods manipulation
6900	* ----------------------------------------------------------------------------- */
6901
6902	/* Install Constants */
6903	SWIGINTERN void
6904	SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
6905	PyObject *obj = 0;
6906	size_t i;
6907	for (i = 0; constants[i].type; ++i) {
6908	switch(constants[i].type) {
6909	case SWIG_PY_POINTER:
6910	obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
6911	break;
6912	case SWIG_PY_BINARY:
6913	obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
6914	break;
6915	default:
6916	obj = 0;
6917	break;
6918	}
6919	if (obj) {
6920	PyDict_SetItemString(d, constants[i].name, obj);
6921	Py_DECREF(obj);
6922	}
6923	}
6924	}
6925
6926	/* -----------------------------------------------------------------------------*/
6927	/* Fix SwigMethods to carry the callback ptrs when needed */
6928	/* -----------------------------------------------------------------------------*/
6929
6930	SWIGINTERN void
6931	SWIG_Python_FixMethods(PyMethodDef *methods,
6932	swig_const_info *const_table,
6933	swig_type_info **types,
6934	swig_type_info **types_initial) {
6935	size_t i;
6936	for (i = 0; methods[i].ml_name; ++i) {
6937	const char *c = methods[i].ml_doc;
6938	if (c && (c = strstr(c, "swig_ptr: "))) {
6939	int j;
6940	swig_const_info *ci = 0;
6941	const char *name = c + 10;
6942	for (j = 0; const_table[j].type; ++j) {
6943	if (strncmp(const_table[j].name, name,
6944	strlen(const_table[j].name)) == 0) {
6945	ci = &(const_table[j]);
6946	break;
6947	}
6948	}
6949	if (ci) {
6950	size_t shift = (ci->ptype) - types;
6951	swig_type_info *ty = types_initial[shift];
6952	size_t ldoc = (c - methods[i].ml_doc);
6953	size_t lptr = strlen(ty->name)+2sizeof(void)+2;
6954	char ndoc = (char)malloc(ldoc + lptr + 10);
6955	if (ndoc) {
6956	char *buff = ndoc;
6957	void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
6958	if (ptr) {
6959	strncpy(buff, methods[i].ml_doc, ldoc);
6960	buff += ldoc;
6961	strncpy(buff, "swig_ptr: ", 10);
6962	buff += 10;
6963	SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
6964	methods[i].ml_doc = ndoc;
6965	}
6966	}
6967	}
6968	}
6969	}
6970	}
6971
6972	#ifdef __cplusplus
6973	}
6974	#endif
6975
6976	/* -----------------------------------------------------------------------------*
6977	* Partial Init method
6978	* -----------------------------------------------------------------------------*/
6979
6980	#ifdef __cplusplus
6981	extern "C"
6982	#endif
6983
6984	SWIGEXPORT
6985	#if PY_VERSION_HEX >= 0x03000000
6986	PyObject*
6987	#else
6988	void
6989	#endif
6990	SWIG_init(void) {
6991	PyObject m, d;
6992	#if PY_VERSION_HEX >= 0x03000000
6993	static struct PyModuleDef SWIG_module = {
6994	PyModuleDef_HEAD_INIT,
6995	(char *) SWIG_name,
6996	NULL,
6997	-1,
6998	SwigMethods,
6999	NULL,
7000	NULL,
7001	NULL,
7002	NULL
7003	};
7004	#endif
7005
7006	/* Fix SwigMethods to carry the callback ptrs when needed */
7007	SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
7008
7009	#if PY_VERSION_HEX >= 0x03000000
7010	m = PyModule_Create(&SWIG_module);
7011	#else
7012	m = Py_InitModule((char *) SWIG_name, SwigMethods);
7013	#endif
7014	d = PyModule_GetDict(m);
7015
7016	SWIG_InitializeModule(0);
7017	SWIG_InstallConstants(d,swig_const_table);
7018
7019
7020	#if PY_VERSION_HEX >= 0x03000000
7021	return m;
7022	#else
7023	return;
7024	#endif
7025	}
7026

Note: See TracBrowser for help on using the browser.

Context Navigation

root/vtcross/trunk/src/libvtcross/swig/libvtcross_wrap.cpp @ 466

Download in other formats: