~ubuntu-branches/ubuntu/maverick/speech-tools/maverick
» Revision
19
: wrappers/python/EST_FVector_wrap.cc
« back to all changes in this revision
Viewing changes to wrappers/python/EST_FVector_wrap.cc
- browse files at revision 19
- compare with another revision
- compare with revision 19
- download diff
- download tarball
- view history from revision 19
- Committer: Bazaar Package Importer
- Author(s): Kumar Appaiah, Kartik Mistry, Kumar Appaiah
- Date: 2010-07-17 11:32:04 UTC
- mfrom: (3.1.6 sid)
- Revision ID: james.westby@ubuntu.com-20100717113204-mnse3jo236j107q8
Tags: 1:2.0.95~beta-1
[ Kartik Mistry ]
* debian/control:
+ [Lintian] Added missing ${misc:Depends}
+ Updated Standards-Version to 3.8.4 (no changes needed)
* debian/patches/const_char.diff:
+ Added missing patch header
* Removed unused patch invalid_const_char_conversion_fixes.diff
[ Kumar Appaiah ]
* New upstream release.
* Standards Version is now 3.9.0 (No changes needed)
* Update debian/rules to specify version numbers.
* debian/control:
+ [Lintian] Added missing ${misc:Depends}
+ Updated Standards-Version to 3.8.4 (no changes needed)
* debian/patches/const_char.diff:
+ Added missing patch header
* Removed unused patch invalid_const_char_conversion_fixes.diff
[ Kumar Appaiah ]
* New upstream release.
* Standards Version is now 3.9.0 (No changes needed)
* Update debian/rules to specify version numbers.
- files added:
- audio/linux_sound.cc
- wrappers
- wrappers/interface
- wrappers/interface/perl5
- wrappers/interface/python
- wrappers/perl5
- wrappers/python
- files removed:
- audio/voxware.cc
- files modified:
- .time-stamp
added
removed
wrappers/python/EST_FVector_wrap.cc
1
/* ----------------------------------------------------------------------------
2
* This file was automatically generated by SWIG (http://www.swig.org).
3
* Version 1.3.40
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 ((2*sizeof(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 macros 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
Py_ssize_t 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 *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", name, v);
1476
if (v->next) {
1477
#ifdef METH_NOARGS
1478
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1479
#else
1480
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1481
#endif
1482
#if PY_VERSION_HEX >= 0x03000000
1483
PyObject *joined = PyUnicode_Concat(repr, nrep);
1484
Py_DecRef(repr);
1485
Py_DecRef(nrep);
1486
repr = joined;
1487
#else
1488
PyString_ConcatAndDel(&repr,nrep);
1489
#endif
1490
}
1491
return repr;
1492
}
1493
1494
SWIGRUNTIME int
1495
SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1496
{
1497
char *str;
1498
#ifdef METH_NOARGS
1499
PyObject *repr = SwigPyObject_repr(v);
1500
#else
1501
PyObject *repr = SwigPyObject_repr(v, NULL);
1502
#endif
1503
if (repr) {
1504
str = SWIG_Python_str_AsChar(repr);
1505
fputs(str, fp);
1506
SWIG_Python_str_DelForPy3(str);
1507
Py_DECREF(repr);
1508
return 0;
1509
} else {
1510
return 1;
1511
}
1512
}
1513
1514
SWIGRUNTIME PyObject *
1515
SwigPyObject_str(SwigPyObject *v)
1516
{
1517
char result[SWIG_BUFFER_SIZE];
1518
return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1519
SWIG_Python_str_FromChar(result) : 0;
1520
}
1521
1522
SWIGRUNTIME int
1523
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1524
{
1525
void *i = v->ptr;
1526
void *j = w->ptr;
1527
return (i < j) ? -1 : ((i > j) ? 1 : 0);
1528
}
1529
1530
/* Added for Python 3.x, would it also be useful for Python 2.x? */
1531
SWIGRUNTIME PyObject*
1532
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1533
{
1534
PyObject* res;
1535
if( op != Py_EQ && op != Py_NE ) {
1536
Py_INCREF(Py_NotImplemented);
1537
return Py_NotImplemented;
1538
}
1539
if( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) )
1540
res = Py_True;
1541
else
1542
res = Py_False;
1543
Py_INCREF(res);
1544
return res;
1545
}
1546
1547
1548
SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1549
1550
SWIGRUNTIME PyTypeObject*
1551
SwigPyObject_type(void) {
1552
static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1553
return type;
1554
}
1555
1556
SWIGRUNTIMEINLINE int
1557
SwigPyObject_Check(PyObject *op) {
1558
return (Py_TYPE(op) == SwigPyObject_type())
1559
|| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1560
}
1561
1562
SWIGRUNTIME PyObject *
1563
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1564
1565
SWIGRUNTIME void
1566
SwigPyObject_dealloc(PyObject *v)
1567
{
1568
SwigPyObject *sobj = (SwigPyObject *) v;
1569
PyObject *next = sobj->next;
1570
if (sobj->own == SWIG_POINTER_OWN) {
1571
swig_type_info *ty = sobj->ty;
1572
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1573
PyObject *destroy = data ? data->destroy : 0;
1574
if (destroy) {
1575
/* destroy is always a VARARGS method */
1576
PyObject *res;
1577
if (data->delargs) {
1578
/* we need to create a temporary object to carry the destroy operation */
1579
PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1580
res = SWIG_Python_CallFunctor(destroy, tmp);
1581
Py_DECREF(tmp);
1582
} else {
1583
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1584
PyObject *mself = PyCFunction_GET_SELF(destroy);
1585
res = ((*meth)(mself, v));
1586
}
1587
Py_XDECREF(res);
1588
}
1589
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1590
else {
1591
const char *name = SWIG_TypePrettyName(ty);
1592
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1593
}
1594
#endif
1595
}
1596
Py_XDECREF(next);
1597
PyObject_DEL(v);
1598
}
1599
1600
SWIGRUNTIME PyObject*
1601
SwigPyObject_append(PyObject* v, PyObject* next)
1602
{
1603
SwigPyObject *sobj = (SwigPyObject *) v;
1604
#ifndef METH_O
1605
PyObject *tmp = 0;
1606
if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1607
next = tmp;
1608
#endif
1609
if (!SwigPyObject_Check(next)) {
1610
return NULL;
1611
}
1612
sobj->next = next;
1613
Py_INCREF(next);
1614
return SWIG_Py_Void();
1615
}
1616
1617
SWIGRUNTIME PyObject*
1618
#ifdef METH_NOARGS
1619
SwigPyObject_next(PyObject* v)
1620
#else
1621
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1622
#endif
1623
{
1624
SwigPyObject *sobj = (SwigPyObject *) v;
1625
if (sobj->next) {
1626
Py_INCREF(sobj->next);
1627
return sobj->next;
1628
} else {
1629
return SWIG_Py_Void();
1630
}
1631
}
1632
1633
SWIGINTERN PyObject*
1634
#ifdef METH_NOARGS
1635
SwigPyObject_disown(PyObject *v)
1636
#else
1637
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1638
#endif
1639
{
1640
SwigPyObject *sobj = (SwigPyObject *)v;
1641
sobj->own = 0;
1642
return SWIG_Py_Void();
1643
}
1644
1645
SWIGINTERN PyObject*
1646
#ifdef METH_NOARGS
1647
SwigPyObject_acquire(PyObject *v)
1648
#else
1649
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1650
#endif
1651
{
1652
SwigPyObject *sobj = (SwigPyObject *)v;
1653
sobj->own = SWIG_POINTER_OWN;
1654
return SWIG_Py_Void();
1655
}
1656
1657
SWIGINTERN PyObject*
1658
SwigPyObject_own(PyObject *v, PyObject *args)
1659
{
1660
PyObject *val = 0;
1661
#if (PY_VERSION_HEX < 0x02020000)
1662
if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1663
#else
1664
if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1665
#endif
1666
{
1667
return NULL;
1668
}
1669
else
1670
{
1671
SwigPyObject *sobj = (SwigPyObject *)v;
1672
PyObject *obj = PyBool_FromLong(sobj->own);
1673
if (val) {
1674
#ifdef METH_NOARGS
1675
if (PyObject_IsTrue(val)) {
1676
SwigPyObject_acquire(v);
1677
} else {
1678
SwigPyObject_disown(v);
1679
}
1680
#else
1681
if (PyObject_IsTrue(val)) {
1682
SwigPyObject_acquire(v,args);
1683
} else {
1684
SwigPyObject_disown(v,args);
1685
}
1686
#endif
1687
}
1688
return obj;
1689
}
1690
}
1691
1692
#ifdef METH_O
1693
static PyMethodDef
1694
swigobject_methods[] = {
1695
{(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1696
{(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1697
{(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1698
{(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1699
{(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1700
{(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1701
{0, 0, 0, 0}
1702
};
1703
#else
1704
static PyMethodDef
1705
swigobject_methods[] = {
1706
{(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1707
{(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1708
{(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1709
{(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1710
{(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1711
{(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1712
{0, 0, 0, 0}
1713
};
1714
#endif
1715
1716
#if PY_VERSION_HEX < 0x02020000
1717
SWIGINTERN PyObject *
1718
SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1719
{
1720
return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1721
}
1722
#endif
1723
1724
SWIGRUNTIME PyTypeObject*
1725
_PySwigObject_type(void) {
1726
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1727
1728
static PyNumberMethods SwigPyObject_as_number = {
1729
(binaryfunc)0, /*nb_add*/
1730
(binaryfunc)0, /*nb_subtract*/
1731
(binaryfunc)0, /*nb_multiply*/
1732
/* nb_divide removed in Python 3 */
1733
#if PY_VERSION_HEX < 0x03000000
1734
(binaryfunc)0, /*nb_divide*/
1735
#endif
1736
(binaryfunc)0, /*nb_remainder*/
1737
(binaryfunc)0, /*nb_divmod*/
1738
(ternaryfunc)0,/*nb_power*/
1739
(unaryfunc)0, /*nb_negative*/
1740
(unaryfunc)0, /*nb_positive*/
1741
(unaryfunc)0, /*nb_absolute*/
1742
(inquiry)0, /*nb_nonzero*/
1743
0, /*nb_invert*/
1744
0, /*nb_lshift*/
1745
0, /*nb_rshift*/
1746
0, /*nb_and*/
1747
0, /*nb_xor*/
1748
0, /*nb_or*/
1749
#if PY_VERSION_HEX < 0x03000000
1750
0, /*nb_coerce*/
1751
#endif
1752
(unaryfunc)SwigPyObject_long, /*nb_int*/
1753
#if PY_VERSION_HEX < 0x03000000
1754
(unaryfunc)SwigPyObject_long, /*nb_long*/
1755
#else
1756
0, /*nb_reserved*/
1757
#endif
1758
(unaryfunc)0, /*nb_float*/
1759
#if PY_VERSION_HEX < 0x03000000
1760
(unaryfunc)SwigPyObject_oct, /*nb_oct*/
1761
(unaryfunc)SwigPyObject_hex, /*nb_hex*/
1762
#endif
1763
#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1764
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1765
#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1766
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1767
#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1768
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1769
#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1770
0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1771
#endif
1772
};
1773
1774
static PyTypeObject swigpyobject_type;
1775
static int type_init = 0;
1776
if (!type_init) {
1777
const PyTypeObject tmp
1778
= {
1779
/* PyObject header changed in Python 3 */
1780
#if PY_VERSION_HEX >= 0x03000000
1781
PyVarObject_HEAD_INIT(&PyType_Type, 0)
1782
#else
1783
PyObject_HEAD_INIT(NULL)
1784
0, /* ob_size */
1785
#endif
1786
(char *)"SwigPyObject", /* tp_name */
1787
sizeof(SwigPyObject), /* tp_basicsize */
1788
0, /* tp_itemsize */
1789
(destructor)SwigPyObject_dealloc, /* tp_dealloc */
1790
(printfunc)SwigPyObject_print, /* tp_print */
1791
#if PY_VERSION_HEX < 0x02020000
1792
(getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1793
#else
1794
(getattrfunc)0, /* tp_getattr */
1795
#endif
1796
(setattrfunc)0, /* tp_setattr */
1797
#if PY_VERSION_HEX >= 0x03000000
1798
0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1799
#else
1800
(cmpfunc)SwigPyObject_compare, /* tp_compare */
1801
#endif
1802
(reprfunc)SwigPyObject_repr, /* tp_repr */
1803
&SwigPyObject_as_number, /* tp_as_number */
1804
0, /* tp_as_sequence */
1805
0, /* tp_as_mapping */
1806
(hashfunc)0, /* tp_hash */
1807
(ternaryfunc)0, /* tp_call */
1808
(reprfunc)SwigPyObject_str, /* tp_str */
1809
PyObject_GenericGetAttr, /* tp_getattro */
1810
0, /* tp_setattro */
1811
0, /* tp_as_buffer */
1812
Py_TPFLAGS_DEFAULT, /* tp_flags */
1813
swigobject_doc, /* tp_doc */
1814
0, /* tp_traverse */
1815
0, /* tp_clear */
1816
(richcmpfunc)SwigPyObject_richcompare, /* tp_richcompare */
1817
0, /* tp_weaklistoffset */
1818
#if PY_VERSION_HEX >= 0x02020000
1819
0, /* tp_iter */
1820
0, /* tp_iternext */
1821
swigobject_methods, /* tp_methods */
1822
0, /* tp_members */
1823
0, /* tp_getset */
1824
0, /* tp_base */
1825
0, /* tp_dict */
1826
0, /* tp_descr_get */
1827
0, /* tp_descr_set */
1828
0, /* tp_dictoffset */
1829
0, /* tp_init */
1830
0, /* tp_alloc */
1831
0, /* tp_new */
1832
0, /* tp_free */
1833
0, /* tp_is_gc */
1834
0, /* tp_bases */
1835
0, /* tp_mro */
1836
0, /* tp_cache */
1837
0, /* tp_subclasses */
1838
0, /* tp_weaklist */
1839
#endif
1840
#if PY_VERSION_HEX >= 0x02030000
1841
0, /* tp_del */
1842
#endif
1843
#ifdef COUNT_ALLOCS
1844
0,0,0,0 /* tp_alloc -> tp_next */
1845
#endif
1846
};
1847
swigpyobject_type = tmp;
1848
/* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
1849
#if PY_VERSION_HEX < 0x03000000
1850
swigpyobject_type.ob_type = &PyType_Type;
1851
#endif
1852
type_init = 1;
1853
}
1854
return &swigpyobject_type;
1855
}
1856
1857
SWIGRUNTIME PyObject *
1858
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1859
{
1860
SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1861
if (sobj) {
1862
sobj->ptr = ptr;
1863
sobj->ty = ty;
1864
sobj->own = own;
1865
sobj->next = 0;
1866
}
1867
return (PyObject *)sobj;
1868
}
1869
1870
/* -----------------------------------------------------------------------------
1871
* Implements a simple Swig Packed type, and use it instead of string
1872
* ----------------------------------------------------------------------------- */
1873
1874
typedef struct {
1875
PyObject_HEAD
1876
void *pack;
1877
swig_type_info *ty;
1878
size_t size;
1879
} SwigPyPacked;
1880
1881
SWIGRUNTIME int
1882
SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1883
{
1884
char result[SWIG_BUFFER_SIZE];
1885
fputs("<Swig Packed ", fp);
1886
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1887
fputs("at ", fp);
1888
fputs(result, fp);
1889
}
1890
fputs(v->ty->name,fp);
1891
fputs(">", fp);
1892
return 0;
1893
}
1894
1895
SWIGRUNTIME PyObject *
1896
SwigPyPacked_repr(SwigPyPacked *v)
1897
{
1898
char result[SWIG_BUFFER_SIZE];
1899
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1900
return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1901
} else {
1902
return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1903
}
1904
}
1905
1906
SWIGRUNTIME PyObject *
1907
SwigPyPacked_str(SwigPyPacked *v)
1908
{
1909
char result[SWIG_BUFFER_SIZE];
1910
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1911
return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1912
} else {
1913
return SWIG_Python_str_FromChar(v->ty->name);
1914
}
1915
}
1916
1917
SWIGRUNTIME int
1918
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
1919
{
1920
size_t i = v->size;
1921
size_t j = w->size;
1922
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1923
return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1924
}
1925
1926
SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1927
1928
SWIGRUNTIME PyTypeObject*
1929
SwigPyPacked_type(void) {
1930
static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1931
return type;
1932
}
1933
1934
SWIGRUNTIMEINLINE int
1935
SwigPyPacked_Check(PyObject *op) {
1936
return ((op)->ob_type == _PySwigPacked_type())
1937
|| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
1938
}
1939
1940
SWIGRUNTIME void
1941
SwigPyPacked_dealloc(PyObject *v)
1942
{
1943
if (SwigPyPacked_Check(v)) {
1944
SwigPyPacked *sobj = (SwigPyPacked *) v;
1945
free(sobj->pack);
1946
}
1947
PyObject_DEL(v);
1948
}
1949
1950
SWIGRUNTIME PyTypeObject*
1951
_PySwigPacked_type(void) {
1952
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1953
static PyTypeObject swigpypacked_type;
1954
static int type_init = 0;
1955
if (!type_init) {
1956
const PyTypeObject tmp
1957
= {
1958
/* PyObject header changed in Python 3 */
1959
#if PY_VERSION_HEX>=0x03000000
1960
PyVarObject_HEAD_INIT(&PyType_Type, 0)
1961
#else
1962
PyObject_HEAD_INIT(NULL)
1963
0, /* ob_size */
1964
#endif
1965
(char *)"SwigPyPacked", /* tp_name */
1966
sizeof(SwigPyPacked), /* tp_basicsize */
1967
0, /* tp_itemsize */
1968
(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
1969
(printfunc)SwigPyPacked_print, /* tp_print */
1970
(getattrfunc)0, /* tp_getattr */
1971
(setattrfunc)0, /* tp_setattr */
1972
#if PY_VERSION_HEX>=0x03000000
1973
0, /* tp_reserved in 3.0.1 */
1974
#else
1975
(cmpfunc)SwigPyPacked_compare, /* tp_compare */
1976
#endif
1977
(reprfunc)SwigPyPacked_repr, /* tp_repr */
1978
0, /* tp_as_number */
1979
0, /* tp_as_sequence */
1980
0, /* tp_as_mapping */
1981
(hashfunc)0, /* tp_hash */
1982
(ternaryfunc)0, /* tp_call */
1983
(reprfunc)SwigPyPacked_str, /* tp_str */
1984
PyObject_GenericGetAttr, /* tp_getattro */
1985
0, /* tp_setattro */
1986
0, /* tp_as_buffer */
1987
Py_TPFLAGS_DEFAULT, /* tp_flags */
1988
swigpacked_doc, /* tp_doc */
1989
0, /* tp_traverse */
1990
0, /* tp_clear */
1991
0, /* tp_richcompare */
1992
0, /* tp_weaklistoffset */
1993
#if PY_VERSION_HEX >= 0x02020000
1994
0, /* tp_iter */
1995
0, /* tp_iternext */
1996
0, /* tp_methods */
1997
0, /* tp_members */
1998
0, /* tp_getset */
1999
0, /* tp_base */
2000
0, /* tp_dict */
2001
0, /* tp_descr_get */
2002
0, /* tp_descr_set */
2003
0, /* tp_dictoffset */
2004
0, /* tp_init */
2005
0, /* tp_alloc */
2006
0, /* tp_new */
2007
0, /* tp_free */
2008
0, /* tp_is_gc */
2009
0, /* tp_bases */
2010
0, /* tp_mro */
2011
0, /* tp_cache */
2012
0, /* tp_subclasses */
2013
0, /* tp_weaklist */
2014
#endif
2015
#if PY_VERSION_HEX >= 0x02030000
2016
0, /* tp_del */
2017
#endif
2018
#ifdef COUNT_ALLOCS
2019
0,0,0,0 /* tp_alloc -> tp_next */
2020
#endif
2021
};
2022
swigpypacked_type = tmp;
2023
/* for Python 3 the ob_type already assigned in PyVarObject_HEAD_INIT() */
2024
#if PY_VERSION_HEX < 0x03000000
2025
swigpypacked_type.ob_type = &PyType_Type;
2026
#endif
2027
type_init = 1;
2028
}
2029
return &swigpypacked_type;
2030
}
2031
2032
SWIGRUNTIME PyObject *
2033
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2034
{
2035
SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2036
if (sobj) {
2037
void *pack = malloc(size);
2038
if (pack) {
2039
memcpy(pack, ptr, size);
2040
sobj->pack = pack;
2041
sobj->ty = ty;
2042
sobj->size = size;
2043
} else {
2044
PyObject_DEL((PyObject *) sobj);
2045
sobj = 0;
2046
}
2047
}
2048
return (PyObject *) sobj;
2049
}
2050
2051
SWIGRUNTIME swig_type_info *
2052
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2053
{
2054
if (SwigPyPacked_Check(obj)) {
2055
SwigPyPacked *sobj = (SwigPyPacked *)obj;
2056
if (sobj->size != size) return 0;
2057
memcpy(ptr, sobj->pack, size);
2058
return sobj->ty;
2059
} else {
2060
return 0;
2061
}
2062
}
2063
2064
/* -----------------------------------------------------------------------------
2065
* pointers/data manipulation
2066
* ----------------------------------------------------------------------------- */
2067
2068
SWIGRUNTIMEINLINE PyObject *
2069
_SWIG_This(void)
2070
{
2071
return SWIG_Python_str_FromChar("this");
2072
}
2073
2074
SWIGRUNTIME PyObject *
2075
SWIG_This(void)
2076
{
2077
static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
2078
return swig_this;
2079
}
2080
2081
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2082
2083
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
2084
#if PY_VERSION_HEX>=0x03000000
2085
#define SWIG_PYTHON_SLOW_GETSET_THIS
2086
#endif
2087
2088
SWIGRUNTIME SwigPyObject *
2089
SWIG_Python_GetSwigThis(PyObject *pyobj)
2090
{
2091
if (SwigPyObject_Check(pyobj)) {
2092
return (SwigPyObject *) pyobj;
2093
} else {
2094
PyObject *obj = 0;
2095
#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2096
if (PyInstance_Check(pyobj)) {
2097
obj = _PyInstance_Lookup(pyobj, SWIG_This());
2098
} else {
2099
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2100
if (dictptr != NULL) {
2101
PyObject *dict = *dictptr;
2102
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2103
} else {
2104
#ifdef PyWeakref_CheckProxy
2105
if (PyWeakref_CheckProxy(pyobj)) {
2106
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2107
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2108
}
2109
#endif
2110
obj = PyObject_GetAttr(pyobj,SWIG_This());
2111
if (obj) {
2112
Py_DECREF(obj);
2113
} else {
2114
if (PyErr_Occurred()) PyErr_Clear();
2115
return 0;
2116
}
2117
}
2118
}
2119
#else
2120
obj = PyObject_GetAttr(pyobj,SWIG_This());
2121
if (obj) {
2122
Py_DECREF(obj);
2123
} else {
2124
if (PyErr_Occurred()) PyErr_Clear();
2125
return 0;
2126
}
2127
#endif
2128
if (obj && !SwigPyObject_Check(obj)) {
2129
/* a PyObject is called 'this', try to get the 'real this'
2130
SwigPyObject from it */
2131
return SWIG_Python_GetSwigThis(obj);
2132
}
2133
return (SwigPyObject *)obj;
2134
}
2135
}
2136
2137
/* Acquire a pointer value */
2138
2139
SWIGRUNTIME int
2140
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2141
if (own == SWIG_POINTER_OWN) {
2142
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2143
if (sobj) {
2144
int oldown = sobj->own;
2145
sobj->own = own;
2146
return oldown;
2147
}
2148
}
2149
return 0;
2150
}
2151
2152
/* Convert a pointer value */
2153
2154
SWIGRUNTIME int
2155
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2156
if (!obj) return SWIG_ERROR;
2157
if (obj == Py_None) {
2158
if (ptr) *ptr = 0;
2159
return SWIG_OK;
2160
} else {
2161
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2162
if (own)
2163
*own = 0;
2164
while (sobj) {
2165
void *vptr = sobj->ptr;
2166
if (ty) {
2167
swig_type_info *to = sobj->ty;
2168
if (to == ty) {
2169
/* no type cast needed */
2170
if (ptr) *ptr = vptr;
2171
break;
2172
} else {
2173
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2174
if (!tc) {
2175
sobj = (SwigPyObject *)sobj->next;
2176
} else {
2177
if (ptr) {
2178
int newmemory = 0;
2179
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2180
if (newmemory == SWIG_CAST_NEW_MEMORY) {
2181
assert(own);
2182
if (own)
2183
*own = *own | SWIG_CAST_NEW_MEMORY;
2184
}
2185
}
2186
break;
2187
}
2188
}
2189
} else {
2190
if (ptr) *ptr = vptr;
2191
break;
2192
}
2193
}
2194
if (sobj) {
2195
if (own)
2196
*own = *own | sobj->own;
2197
if (flags & SWIG_POINTER_DISOWN) {
2198
sobj->own = 0;
2199
}
2200
return SWIG_OK;
2201
} else {
2202
int res = SWIG_ERROR;
2203
if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2204
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2205
if (data && !data->implicitconv) {
2206
PyObject *klass = data->klass;
2207
if (klass) {
2208
PyObject *impconv;
2209
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2210
impconv = SWIG_Python_CallFunctor(klass, obj);
2211
data->implicitconv = 0;
2212
if (PyErr_Occurred()) {
2213
PyErr_Clear();
2214
impconv = 0;
2215
}
2216
if (impconv) {
2217
SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2218
if (iobj) {
2219
void *vptr;
2220
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2221
if (SWIG_IsOK(res)) {
2222
if (ptr) {
2223
*ptr = vptr;
2224
/* transfer the ownership to 'ptr' */
2225
iobj->own = 0;
2226
res = SWIG_AddCast(res);
2227
res = SWIG_AddNewMask(res);
2228
} else {
2229
res = SWIG_AddCast(res);
2230
}
2231
}
2232
}
2233
Py_DECREF(impconv);
2234
}
2235
}
2236
}
2237
}
2238
return res;
2239
}
2240
}
2241
}
2242
2243
/* Convert a function ptr value */
2244
2245
SWIGRUNTIME int
2246
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2247
if (!PyCFunction_Check(obj)) {
2248
return SWIG_ConvertPtr(obj, ptr, ty, 0);
2249
} else {
2250
void *vptr = 0;
2251
2252
/* here we get the method pointer for callbacks */
2253
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2254
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2255
if (desc)
2256
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2257
if (!desc)
2258
return SWIG_ERROR;
2259
if (ty) {
2260
swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2261
if (tc) {
2262
int newmemory = 0;
2263
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2264
assert(!newmemory); /* newmemory handling not yet implemented */
2265
} else {
2266
return SWIG_ERROR;
2267
}
2268
} else {
2269
*ptr = vptr;
2270
}
2271
return SWIG_OK;
2272
}
2273
}
2274
2275
/* Convert a packed value value */
2276
2277
SWIGRUNTIME int
2278
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2279
swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2280
if (!to) return SWIG_ERROR;
2281
if (ty) {
2282
if (to != ty) {
2283
/* check type cast? */
2284
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2285
if (!tc) return SWIG_ERROR;
2286
}
2287
}
2288
return SWIG_OK;
2289
}
2290
2291
/* -----------------------------------------------------------------------------
2292
* Create a new pointer object
2293
* ----------------------------------------------------------------------------- */
2294
2295
/*
2296
Create a new instance object, without calling __init__, and set the
2297
'this' attribute.
2298
*/
2299
2300
SWIGRUNTIME PyObject*
2301
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2302
{
2303
#if (PY_VERSION_HEX >= 0x02020000)
2304
PyObject *inst = 0;
2305
PyObject *newraw = data->newraw;
2306
if (newraw) {
2307
inst = PyObject_Call(newraw, data->newargs, NULL);
2308
if (inst) {
2309
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2310
PyObject **dictptr = _PyObject_GetDictPtr(inst);
2311
if (dictptr != NULL) {
2312
PyObject *dict = *dictptr;
2313
if (dict == NULL) {
2314
dict = PyDict_New();
2315
*dictptr = dict;
2316
PyDict_SetItem(dict, SWIG_This(), swig_this);
2317
}
2318
}
2319
#else
2320
PyObject *key = SWIG_This();
2321
PyObject_SetAttr(inst, key, swig_this);
2322
#endif
2323
}
2324
} else {
2325
#if PY_VERSION_HEX >= 0x03000000
2326
inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2327
PyObject_SetAttr(inst, SWIG_This(), swig_this);
2328
Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2329
#else
2330
PyObject *dict = PyDict_New();
2331
PyDict_SetItem(dict, SWIG_This(), swig_this);
2332
inst = PyInstance_NewRaw(data->newargs, dict);
2333
Py_DECREF(dict);
2334
#endif
2335
}
2336
return inst;
2337
#else
2338
#if (PY_VERSION_HEX >= 0x02010000)
2339
PyObject *inst;
2340
PyObject *dict = PyDict_New();
2341
PyDict_SetItem(dict, SWIG_This(), swig_this);
2342
inst = PyInstance_NewRaw(data->newargs, dict);
2343
Py_DECREF(dict);
2344
return (PyObject *) inst;
2345
#else
2346
PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2347
if (inst == NULL) {
2348
return NULL;
2349
}
2350
inst->in_class = (PyClassObject *)data->newargs;
2351
Py_INCREF(inst->in_class);
2352
inst->in_dict = PyDict_New();
2353
if (inst->in_dict == NULL) {
2354
Py_DECREF(inst);
2355
return NULL;
2356
}
2357
#ifdef Py_TPFLAGS_HAVE_WEAKREFS
2358
inst->in_weakreflist = NULL;
2359
#endif
2360
#ifdef Py_TPFLAGS_GC
2361
PyObject_GC_Init(inst);
2362
#endif
2363
PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2364
return (PyObject *) inst;
2365
#endif
2366
#endif
2367
}
2368
2369
SWIGRUNTIME void
2370
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2371
{
2372
PyObject *dict;
2373
#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2374
PyObject **dictptr = _PyObject_GetDictPtr(inst);
2375
if (dictptr != NULL) {
2376
dict = *dictptr;
2377
if (dict == NULL) {
2378
dict = PyDict_New();
2379
*dictptr = dict;
2380
}
2381
PyDict_SetItem(dict, SWIG_This(), swig_this);
2382
return;
2383
}
2384
#endif
2385
dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2386
PyDict_SetItem(dict, SWIG_This(), swig_this);
2387
Py_DECREF(dict);
2388
}
2389
2390
2391
SWIGINTERN PyObject *
2392
SWIG_Python_InitShadowInstance(PyObject *args) {
2393
PyObject *obj[2];
2394
if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2395
return NULL;
2396
} else {
2397
SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2398
if (sthis) {
2399
SwigPyObject_append((PyObject*) sthis, obj[1]);
2400
} else {
2401
SWIG_Python_SetSwigThis(obj[0], obj[1]);
2402
}
2403
return SWIG_Py_Void();
2404
}
2405
}
2406
2407
/* Create a new pointer object */
2408
2409
SWIGRUNTIME PyObject *
2410
SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2411
if (!ptr) {
2412
return SWIG_Py_Void();
2413
} else {
2414
int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2415
PyObject *robj = SwigPyObject_New(ptr, type, own);
2416
SwigPyClientData *clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2417
if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2418
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2419
if (inst) {
2420
Py_DECREF(robj);
2421
robj = inst;
2422
}
2423
}
2424
return robj;
2425
}
2426
}
2427
2428
/* Create a new packed object */
2429
2430
SWIGRUNTIMEINLINE PyObject *
2431
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2432
return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2433
}
2434
2435
/* -----------------------------------------------------------------------------*
2436
* Get type list
2437
* -----------------------------------------------------------------------------*/
2438
2439
#ifdef SWIG_LINK_RUNTIME
2440
void *SWIG_ReturnGlobalTypeList(void *);
2441
#endif
2442
2443
SWIGRUNTIME swig_module_info *
2444
SWIG_Python_GetModule(void) {
2445
static void *type_pointer = (void *)0;
2446
/* first check if module already created */
2447
if (!type_pointer) {
2448
#ifdef SWIG_LINK_RUNTIME
2449
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2450
#else
2451
type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2452
(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2453
if (PyErr_Occurred()) {
2454
PyErr_Clear();
2455
type_pointer = (void *)0;
2456
}
2457
#endif
2458
}
2459
return (swig_module_info *) type_pointer;
2460
}
2461
2462
#if PY_MAJOR_VERSION < 2
2463
/* PyModule_AddObject function was introduced in Python 2.0. The following function
2464
is copied out of Python/modsupport.c in python version 2.3.4 */
2465
SWIGINTERN int
2466
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2467
{
2468
PyObject *dict;
2469
if (!PyModule_Check(m)) {
2470
PyErr_SetString(PyExc_TypeError,
2471
"PyModule_AddObject() needs module as first arg");
2472
return SWIG_ERROR;
2473
}
2474
if (!o) {
2475
PyErr_SetString(PyExc_TypeError,
2476
"PyModule_AddObject() needs non-NULL value");
2477
return SWIG_ERROR;
2478
}
2479
2480
dict = PyModule_GetDict(m);
2481
if (dict == NULL) {
2482
/* Internal error -- modules must have a dict! */
2483
PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2484
PyModule_GetName(m));
2485
return SWIG_ERROR;
2486
}
2487
if (PyDict_SetItemString(dict, name, o))
2488
return SWIG_ERROR;
2489
Py_DECREF(o);
2490
return SWIG_OK;
2491
}
2492
#endif
2493
2494
SWIGRUNTIME void
2495
SWIG_Python_DestroyModule(void *vptr)
2496
{
2497
swig_module_info *swig_module = (swig_module_info *) vptr;
2498
swig_type_info **types = swig_module->types;
2499
size_t i;
2500
for (i =0; i < swig_module->size; ++i) {
2501
swig_type_info *ty = types[i];
2502
if (ty->owndata) {
2503
SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2504
if (data) SwigPyClientData_Del(data);
2505
}
2506
}
2507
Py_DECREF(SWIG_This());
2508
}
2509
2510
SWIGRUNTIME void
2511
SWIG_Python_SetModule(swig_module_info *swig_module) {
2512
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2513
2514
#if PY_VERSION_HEX >= 0x03000000
2515
/* Add a dummy module object into sys.modules */
2516
PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2517
#else
2518
PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2519
swig_empty_runtime_method_table);
2520
#endif
2521
PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2522
if (pointer && module) {
2523
PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2524
} else {
2525
Py_XDECREF(pointer);
2526
}
2527
}
2528
2529
/* The python cached type query */
2530
SWIGRUNTIME PyObject *
2531
SWIG_Python_TypeCache(void) {
2532
static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2533
return cache;
2534
}
2535
2536
SWIGRUNTIME swig_type_info *
2537
SWIG_Python_TypeQuery(const char *type)
2538
{
2539
PyObject *cache = SWIG_Python_TypeCache();
2540
PyObject *key = SWIG_Python_str_FromChar(type);
2541
PyObject *obj = PyDict_GetItem(cache, key);
2542
swig_type_info *descriptor;
2543
if (obj) {
2544
descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2545
} else {
2546
swig_module_info *swig_module = SWIG_Python_GetModule();
2547
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2548
if (descriptor) {
2549
obj = PyCObject_FromVoidPtr(descriptor, NULL);
2550
PyDict_SetItem(cache, key, obj);
2551
Py_DECREF(obj);
2552
}
2553
}
2554
Py_DECREF(key);
2555
return descriptor;
2556
}
2557
2558
/*
2559
For backward compatibility only
2560
*/
2561
#define SWIG_POINTER_EXCEPTION 0
2562
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2563
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2564
2565
SWIGRUNTIME int
2566
SWIG_Python_AddErrMesg(const char* mesg, int infront)
2567
{
2568
if (PyErr_Occurred()) {
2569
PyObject *type = 0;
2570
PyObject *value = 0;
2571
PyObject *traceback = 0;
2572
PyErr_Fetch(&type, &value, &traceback);
2573
if (value) {
2574
char *tmp;
2575
PyObject *old_str = PyObject_Str(value);
2576
Py_XINCREF(type);
2577
PyErr_Clear();
2578
if (infront) {
2579
PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2580
} else {
2581
PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2582
}
2583
SWIG_Python_str_DelForPy3(tmp);
2584
Py_DECREF(old_str);
2585
}
2586
return 1;
2587
} else {
2588
return 0;
2589
}
2590
}
2591
2592
SWIGRUNTIME int
2593
SWIG_Python_ArgFail(int argnum)
2594
{
2595
if (PyErr_Occurred()) {
2596
/* add information about failing argument */
2597
char mesg[256];
2598
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2599
return SWIG_Python_AddErrMesg(mesg, 1);
2600
} else {
2601
return 0;
2602
}
2603
}
2604
2605
SWIGRUNTIMEINLINE const char *
2606
SwigPyObject_GetDesc(PyObject *self)
2607
{
2608
SwigPyObject *v = (SwigPyObject *)self;
2609
swig_type_info *ty = v ? v->ty : 0;
2610
return ty ? ty->str : (char*)"";
2611
}
2612
2613
SWIGRUNTIME void
2614
SWIG_Python_TypeError(const char *type, PyObject *obj)
2615
{
2616
if (type) {
2617
#if defined(SWIG_COBJECT_TYPES)
2618
if (obj && SwigPyObject_Check(obj)) {
2619
const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2620
if (otype) {
2621
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2622
type, otype);
2623
return;
2624
}
2625
} else
2626
#endif
2627
{
2628
const char *otype = (obj ? obj->ob_type->tp_name : 0);
2629
if (otype) {
2630
PyObject *str = PyObject_Str(obj);
2631
const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2632
if (cstr) {
2633
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2634
type, otype, cstr);
2635
SWIG_Python_str_DelForPy3(cstr);
2636
} else {
2637
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2638
type, otype);
2639
}
2640
Py_XDECREF(str);
2641
return;
2642
}
2643
}
2644
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2645
} else {
2646
PyErr_Format(PyExc_TypeError, "unexpected type is received");
2647
}
2648
}
2649
2650
2651
/* Convert a pointer value, signal an exception on a type mismatch */
2652
SWIGRUNTIME void *
2653
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2654
void *result;
2655
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2656
PyErr_Clear();
2657
#if SWIG_POINTER_EXCEPTION
2658
if (flags) {
2659
SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2660
SWIG_Python_ArgFail(argnum);
2661
}
2662
#endif
2663
}
2664
return result;
2665
}
2666
2667
2668
#ifdef __cplusplus
2669
#if 0
2670
{ /* cc-mode */
2671
#endif
2672
}
2673
#endif
2674
2675
2676
2677
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2678
2679
#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2680
2681
2682
2683
/* -------- TYPES TABLE (BEGIN) -------- */
2684
2685
#define SWIGTYPE_p_EST_FVector swig_types[0]
2686
#define SWIGTYPE_p_EST_Item swig_types[1]
2687
#define SWIGTYPE_p_EST_TSimpleVectorT_float_t swig_types[2]
2688
#define SWIGTYPE_p_EST_TVectorT_float_t swig_types[3]
2689
#define SWIGTYPE_p_T swig_types[4]
2690
#define SWIGTYPE_p_char swig_types[5]
2691
#define SWIGTYPE_p_float swig_types[6]
2692
static swig_type_info *swig_types[8];
2693
static swig_module_info swig_module = {swig_types, 7, 0, 0, 0, 0};
2694
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2695
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2696
2697
/* -------- TYPES TABLE (END) -------- */
2698
2699
#if (PY_VERSION_HEX <= 0x02000000)
2700
# if !defined(SWIG_PYTHON_CLASSIC)
2701
# error "This python version requires swig to be run with the '-classic' option"
2702
# endif
2703
#endif
2704
2705
/*-----------------------------------------------
2706
@(target):= _EST_FVector.so
2707
------------------------------------------------*/
2708
#if PY_VERSION_HEX >= 0x03000000
2709
# define SWIG_init PyInit__EST_FVector
2710
2711
#else
2712
# define SWIG_init init_EST_FVector
2713
2714
#endif
2715
#define SWIG_name "_EST_FVector"
2716
2717
#define SWIGVERSION 0x010340
2718
#define SWIG_VERSION SWIGVERSION
2719
2720
2721
#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2722
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2723
2724
2725
#include <stdexcept>
2726
2727
2728
namespace swig {
2729
class SwigPtr_PyObject {
2730
protected:
2731
PyObject *_obj;
2732
2733
public:
2734
SwigPtr_PyObject() :_obj(0)
2735
{
2736
}
2737
2738
SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
2739
{
2740
Py_XINCREF(_obj);
2741
}
2742
2743
SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
2744
{
2745
if (initial_ref) {
2746
Py_XINCREF(_obj);
2747
}
2748
}
2749
2750
SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
2751
{
2752
Py_XINCREF(item._obj);
2753
Py_XDECREF(_obj);
2754
_obj = item._obj;
2755
return *this;
2756
}
2757
2758
~SwigPtr_PyObject()
2759
{
2760
Py_XDECREF(_obj);
2761
}
2762
2763
operator PyObject *() const
2764
{
2765
return _obj;
2766
}
2767
2768
PyObject *operator->() const
2769
{
2770
return _obj;
2771
}
2772
};
2773
}
2774
2775
2776
namespace swig {
2777
struct SwigVar_PyObject : SwigPtr_PyObject {
2778
SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
2779
2780
SwigVar_PyObject & operator = (PyObject* obj)
2781
{
2782
Py_XDECREF(_obj);
2783
_obj = obj;
2784
return *this;
2785
}
2786
};
2787
}
2788
2789
2790
#include "EST_FMatrix.h"
2791
2792
2793
#include "EST_rw_status.h"
2794
2795
2796
#define SWIG_From_long PyInt_FromLong
2797
2798
2799
SWIGINTERNINLINE PyObject *
2800
SWIG_From_int (int value)
2801
{
2802
return SWIG_From_long (value);
2803
}
2804
2805
2806
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
2807
typedef int Py_ssize_t;
2808
#define PY_SSIZE_T_MAX INT_MAX
2809
#define PY_SSIZE_T_MIN INT_MIN
2810
#endif
2811
2812
2813
#include "EST_TSimpleVector.h"
2814
2815
2816
#include "EST_TVector.h"
2817
2818
2819
#include <limits.h>
2820
#if !defined(SWIG_NO_LLONG_MAX)
2821
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2822
# define LLONG_MAX __LONG_LONG_MAX__
2823
# define LLONG_MIN (-LLONG_MAX - 1LL)
2824
# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2825
# endif
2826
#endif
2827
2828
2829
SWIGINTERN int
2830
SWIG_AsVal_double (PyObject *obj, double *val)
2831
{
2832
int res = SWIG_TypeError;
2833
if (PyFloat_Check(obj)) {
2834
if (val) *val = PyFloat_AsDouble(obj);
2835
return SWIG_OK;
2836
} else if (PyInt_Check(obj)) {
2837
if (val) *val = PyInt_AsLong(obj);
2838
return SWIG_OK;
2839
} else if (PyLong_Check(obj)) {
2840
double v = PyLong_AsDouble(obj);
2841
if (!PyErr_Occurred()) {
2842
if (val) *val = v;
2843
return SWIG_OK;
2844
} else {
2845
PyErr_Clear();
2846
}
2847
}
2848
#ifdef SWIG_PYTHON_CAST_MODE
2849
{
2850
int dispatch = 0;
2851
double d = PyFloat_AsDouble(obj);
2852
if (!PyErr_Occurred()) {
2853
if (val) *val = d;
2854
return SWIG_AddCast(SWIG_OK);
2855
} else {
2856
PyErr_Clear();
2857
}
2858
if (!dispatch) {
2859
long v = PyLong_AsLong(obj);
2860
if (!PyErr_Occurred()) {
2861
if (val) *val = v;
2862
return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2863
} else {
2864
PyErr_Clear();
2865
}
2866
}
2867
}
2868
#endif
2869
return res;
2870
}
2871
2872
2873
#include <float.h>
2874
2875
2876
#include <math.h>
2877
2878
2879
SWIGINTERNINLINE int
2880
SWIG_CanCastAsInteger(double *d, double min, double max) {
2881
double x = *d;
2882
if ((min <= x && x <= max)) {
2883
double fx = floor(x);
2884
double cx = ceil(x);
2885
double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2886
if ((errno == EDOM) || (errno == ERANGE)) {
2887
errno = 0;
2888
} else {
2889
double summ, reps, diff;
2890
if (rd < x) {
2891
diff = x - rd;
2892
} else if (rd > x) {
2893
diff = rd - x;
2894
} else {
2895
return 1;
2896
}
2897
summ = rd + x;
2898
reps = diff/summ;
2899
if (reps < 8*DBL_EPSILON) {
2900
*d = rd;
2901
return 1;
2902
}
2903
}
2904
}
2905
return 0;
2906
}
2907
2908
2909
SWIGINTERN int
2910
SWIG_AsVal_long (PyObject *obj, long* val)
2911
{
2912
if (PyInt_Check(obj)) {
2913
if (val) *val = PyInt_AsLong(obj);
2914
return SWIG_OK;
2915
} else if (PyLong_Check(obj)) {
2916
long v = PyLong_AsLong(obj);
2917
if (!PyErr_Occurred()) {
2918
if (val) *val = v;
2919
return SWIG_OK;
2920
} else {
2921
PyErr_Clear();
2922
}
2923
}
2924
#ifdef SWIG_PYTHON_CAST_MODE
2925
{
2926
int dispatch = 0;
2927
long v = PyInt_AsLong(obj);
2928
if (!PyErr_Occurred()) {
2929
if (val) *val = v;
2930
return SWIG_AddCast(SWIG_OK);
2931
} else {
2932
PyErr_Clear();
2933
}
2934
if (!dispatch) {
2935
double d;
2936
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2937
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2938
if (val) *val = (long)(d);
2939
return res;
2940
}
2941
}
2942
}
2943
#endif
2944
return SWIG_TypeError;
2945
}
2946
2947
2948
SWIGINTERN int
2949
SWIG_AsVal_int (PyObject * obj, int *val)
2950
{
2951
long v;
2952
int res = SWIG_AsVal_long (obj, &v);
2953
if (SWIG_IsOK(res)) {
2954
if ((v < INT_MIN || v > INT_MAX)) {
2955
return SWIG_OverflowError;
2956
} else {
2957
if (val) *val = static_cast< int >(v);
2958
}
2959
}
2960
return res;
2961
}
2962
2963
2964
#define SWIG_From_double PyFloat_FromDouble
2965
2966
2967
SWIGINTERNINLINE PyObject *
2968
SWIG_From_float (float value)
2969
{
2970
return SWIG_From_double (value);
2971
}
2972
2973
2974
SWIGINTERN int
2975
SWIG_AsVal_float (PyObject * obj, float *val)
2976
{
2977
double v;
2978
int res = SWIG_AsVal_double (obj, &v);
2979
if (SWIG_IsOK(res)) {
2980
if ((v < -FLT_MAX || v > FLT_MAX)) {
2981
return SWIG_OverflowError;
2982
} else {
2983
if (val) *val = static_cast< float >(v);
2984
}
2985
}
2986
return res;
2987
}
2988
2989
SWIGINTERN void EST_TVector_Sl_float_Sg__setitem(EST_TVector< float > *self,int i,float const &val){
2990
self->a_check(i) = val;
2991
}
2992
SWIGINTERN float const &EST_TVector_Sl_float_Sg__getitem(EST_TVector< float > *self,int i){
2993
return self->a_check(i);
2994
}
2995
2996
SWIGINTERN swig_type_info*
2997
SWIG_pchar_descriptor(void)
2998
{
2999
static int init = 0;
3000
static swig_type_info* info = 0;
3001
if (!init) {
3002
info = SWIG_TypeQuery("_p_char");
3003
init = 1;
3004
}
3005
return info;
3006
}
3007
3008
3009
SWIGINTERN int
3010
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3011
{
3012
#if PY_VERSION_HEX>=0x03000000
3013
if (PyUnicode_Check(obj))
3014
#else
3015
if (PyString_Check(obj))
3016
#endif
3017
{
3018
char *cstr; Py_ssize_t len;
3019
#if PY_VERSION_HEX>=0x03000000
3020
if (!alloc && cptr) {
3021
/* We can't allow converting without allocation, since the internal
3022
representation of string in Python 3 is UCS-2/UCS-4 but we require
3023
a UTF-8 representation.
3024
TODO(bhy) More detailed explanation */
3025
return SWIG_RuntimeError;
3026
}
3027
obj = PyUnicode_AsUTF8String(obj);
3028
PyBytes_AsStringAndSize(obj, &cstr, &len);
3029
if(alloc) *alloc = SWIG_NEWOBJ;
3030
#else
3031
PyString_AsStringAndSize(obj, &cstr, &len);
3032
#endif
3033
if (cptr) {
3034
if (alloc) {
3035
/*
3036
In python the user should not be able to modify the inner
3037
string representation. To warranty that, if you define
3038
SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3039
buffer is always returned.
3040
3041
The default behavior is just to return the pointer value,
3042
so, be careful.
3043
*/
3044
#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3045
if (*alloc != SWIG_OLDOBJ)
3046
#else
3047
if (*alloc == SWIG_NEWOBJ)
3048
#endif
3049
{
3050
*cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3051
*alloc = SWIG_NEWOBJ;
3052
}
3053
else {
3054
*cptr = cstr;
3055
*alloc = SWIG_OLDOBJ;
3056
}
3057
} else {
3058
#if PY_VERSION_HEX>=0x03000000
3059
assert(0); /* Should never reach here in Python 3 */
3060
#endif
3061
*cptr = SWIG_Python_str_AsChar(obj);
3062
}
3063
}
3064
if (psize) *psize = len + 1;
3065
#if PY_VERSION_HEX>=0x03000000
3066
Py_XDECREF(obj);
3067
#endif
3068
return SWIG_OK;
3069
} else {
3070
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3071
if (pchar_descriptor) {
3072
void* vptr = 0;
3073
if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3074
if (cptr) *cptr = (char *) vptr;
3075
if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3076
if (alloc) *alloc = SWIG_OLDOBJ;
3077
return SWIG_OK;
3078
}
3079
}
3080
}
3081
return SWIG_TypeError;
3082
}
3083
3084
3085
3086
3087
SWIGINTERN void EST_FVector_randomise(EST_FVector *self,float scale){
3088
make_random_vector( *self, scale );
3089
}
3090
SWIGINTERN float EST_FVector_sum(EST_FVector const *self){
3091
float sum = 0.0;
3092
int a_len = self->length();
3093
3094
for( int i=0; i<a_len; ++i )
3095
sum += self->a_no_check(i);
3096
3097
return sum;
3098
}
3099
3100
EST_FVector* sqrt( const EST_FVector &a ){
3101
int a_len = a.length();
3102
3103
EST_FVector *ans = new EST_FVector(a_len);
3104
3105
for( int i=0; i<a_len; ++i )
3106
ans->a_no_check(i) = sqrt( a.a_no_check(i) );
3107
3108
return ans;
3109
}
3110
3111
3112
EST_FVector* topower( const EST_FVector &a, float f ){
3113
int a_len = a.length();
3114
3115
EST_FVector *ans = new EST_FVector(a_len);
3116
3117
for( int i=0; i<a_len; ++i )
3118
ans->a_no_check(i) = pow( a.a_no_check(i), f );
3119
3120
return ans;
3121
}
3122
3123
3124
SWIGINTERNINLINE PyObject*
3125
SWIG_From_bool (bool value)
3126
{
3127
return PyBool_FromLong(value ? 1 : 0);
3128
}
3129
3130
#ifdef __cplusplus
3131
extern "C" {
3132
#endif
3133
SWIGINTERN PyObject *_wrap_new_floatvector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3134
PyObject *resultobj = 0;
3135
EST_TVector< float > *result = 0 ;
3136
3137
if (!PyArg_ParseTuple(args,(char *)":new_floatvector")) SWIG_fail;
3138
result = (EST_TVector< float > *)new EST_TVector< float >();
3139
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_TVectorT_float_t, SWIG_POINTER_NEW | 0 );
3140
return resultobj;
3141
fail:
3142
return NULL;
3143
}
3144
3145
3146
SWIGINTERN PyObject *_wrap_new_floatvector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3147
PyObject *resultobj = 0;
3148
EST_TVector< float > *arg1 = 0 ;
3149
void *argp1 = 0 ;
3150
int res1 = 0 ;
3151
PyObject * obj0 = 0 ;
3152
EST_TVector< float > *result = 0 ;
3153
3154
if (!PyArg_ParseTuple(args,(char *)"O:new_floatvector",&obj0)) SWIG_fail;
3155
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0);
3156
if (!SWIG_IsOK(res1)) {
3157
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_floatvector" "', argument " "1"" of type '" "EST_TVector< float > const &""'");
3158
}
3159
if (!argp1) {
3160
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_floatvector" "', argument " "1"" of type '" "EST_TVector< float > const &""'");
3161
}
3162
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3163
result = (EST_TVector< float > *)new EST_TVector< float >((EST_TVector< float > const &)*arg1);
3164
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_TVectorT_float_t, SWIG_POINTER_NEW | 0 );
3165
return resultobj;
3166
fail:
3167
return NULL;
3168
}
3169
3170
3171
SWIGINTERN PyObject *_wrap_new_floatvector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3172
PyObject *resultobj = 0;
3173
int arg1 ;
3174
int val1 ;
3175
int ecode1 = 0 ;
3176
PyObject * obj0 = 0 ;
3177
EST_TVector< float > *result = 0 ;
3178
3179
if (!PyArg_ParseTuple(args,(char *)"O:new_floatvector",&obj0)) SWIG_fail;
3180
ecode1 = SWIG_AsVal_int(obj0, &val1);
3181
if (!SWIG_IsOK(ecode1)) {
3182
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_floatvector" "', argument " "1"" of type '" "int""'");
3183
}
3184
arg1 = static_cast< int >(val1);
3185
result = (EST_TVector< float > *)new EST_TVector< float >(arg1);
3186
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_TVectorT_float_t, SWIG_POINTER_NEW | 0 );
3187
return resultobj;
3188
fail:
3189
return NULL;
3190
}
3191
3192
3193
SWIGINTERN PyObject *_wrap_new_floatvector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3194
PyObject *resultobj = 0;
3195
int arg1 ;
3196
float *arg2 = (float *) 0 ;
3197
int arg3 ;
3198
int arg4 ;
3199
int val1 ;
3200
int ecode1 = 0 ;
3201
void *argp2 = 0 ;
3202
int res2 = 0 ;
3203
int val3 ;
3204
int ecode3 = 0 ;
3205
int val4 ;
3206
int ecode4 = 0 ;
3207
PyObject * obj0 = 0 ;
3208
PyObject * obj1 = 0 ;
3209
PyObject * obj2 = 0 ;
3210
PyObject * obj3 = 0 ;
3211
EST_TVector< float > *result = 0 ;
3212
3213
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_floatvector",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3214
ecode1 = SWIG_AsVal_int(obj0, &val1);
3215
if (!SWIG_IsOK(ecode1)) {
3216
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_floatvector" "', argument " "1"" of type '" "int""'");
3217
}
3218
arg1 = static_cast< int >(val1);
3219
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
3220
if (!SWIG_IsOK(res2)) {
3221
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_floatvector" "', argument " "2"" of type '" "float *""'");
3222
}
3223
arg2 = reinterpret_cast< float * >(argp2);
3224
ecode3 = SWIG_AsVal_int(obj2, &val3);
3225
if (!SWIG_IsOK(ecode3)) {
3226
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_floatvector" "', argument " "3"" of type '" "int""'");
3227
}
3228
arg3 = static_cast< int >(val3);
3229
ecode4 = SWIG_AsVal_int(obj3, &val4);
3230
if (!SWIG_IsOK(ecode4)) {
3231
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_floatvector" "', argument " "4"" of type '" "int""'");
3232
}
3233
arg4 = static_cast< int >(val4);
3234
result = (EST_TVector< float > *)new EST_TVector< float >(arg1,arg2,arg3,arg4);
3235
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_TVectorT_float_t, SWIG_POINTER_NEW | 0 );
3236
return resultobj;
3237
fail:
3238
return NULL;
3239
}
3240
3241
3242
SWIGINTERN PyObject *_wrap_new_floatvector__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3243
PyObject *resultobj = 0;
3244
int arg1 ;
3245
float *arg2 = (float *) 0 ;
3246
int arg3 ;
3247
int val1 ;
3248
int ecode1 = 0 ;
3249
void *argp2 = 0 ;
3250
int res2 = 0 ;
3251
int val3 ;
3252
int ecode3 = 0 ;
3253
PyObject * obj0 = 0 ;
3254
PyObject * obj1 = 0 ;
3255
PyObject * obj2 = 0 ;
3256
EST_TVector< float > *result = 0 ;
3257
3258
if (!PyArg_ParseTuple(args,(char *)"OOO:new_floatvector",&obj0,&obj1,&obj2)) SWIG_fail;
3259
ecode1 = SWIG_AsVal_int(obj0, &val1);
3260
if (!SWIG_IsOK(ecode1)) {
3261
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_floatvector" "', argument " "1"" of type '" "int""'");
3262
}
3263
arg1 = static_cast< int >(val1);
3264
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
3265
if (!SWIG_IsOK(res2)) {
3266
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_floatvector" "', argument " "2"" of type '" "float *""'");
3267
}
3268
arg2 = reinterpret_cast< float * >(argp2);
3269
ecode3 = SWIG_AsVal_int(obj2, &val3);
3270
if (!SWIG_IsOK(ecode3)) {
3271
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_floatvector" "', argument " "3"" of type '" "int""'");
3272
}
3273
arg3 = static_cast< int >(val3);
3274
result = (EST_TVector< float > *)new EST_TVector< float >(arg1,arg2,arg3);
3275
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_TVectorT_float_t, SWIG_POINTER_NEW | 0 );
3276
return resultobj;
3277
fail:
3278
return NULL;
3279
}
3280
3281
3282
SWIGINTERN PyObject *_wrap_new_floatvector__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3283
PyObject *resultobj = 0;
3284
int arg1 ;
3285
float *arg2 = (float *) 0 ;
3286
int val1 ;
3287
int ecode1 = 0 ;
3288
void *argp2 = 0 ;
3289
int res2 = 0 ;
3290
PyObject * obj0 = 0 ;
3291
PyObject * obj1 = 0 ;
3292
EST_TVector< float > *result = 0 ;
3293
3294
if (!PyArg_ParseTuple(args,(char *)"OO:new_floatvector",&obj0,&obj1)) SWIG_fail;
3295
ecode1 = SWIG_AsVal_int(obj0, &val1);
3296
if (!SWIG_IsOK(ecode1)) {
3297
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_floatvector" "', argument " "1"" of type '" "int""'");
3298
}
3299
arg1 = static_cast< int >(val1);
3300
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
3301
if (!SWIG_IsOK(res2)) {
3302
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_floatvector" "', argument " "2"" of type '" "float *""'");
3303
}
3304
arg2 = reinterpret_cast< float * >(argp2);
3305
result = (EST_TVector< float > *)new EST_TVector< float >(arg1,arg2);
3306
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_TVectorT_float_t, SWIG_POINTER_NEW | 0 );
3307
return resultobj;
3308
fail:
3309
return NULL;
3310
}
3311
3312
3313
SWIGINTERN PyObject *_wrap_new_floatvector(PyObject *self, PyObject *args) {
3314
int argc;
3315
PyObject *argv[5];
3316
int ii;
3317
3318
if (!PyTuple_Check(args)) SWIG_fail;
3319
argc = (int)PyObject_Length(args);
3320
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
3321
argv[ii] = PyTuple_GET_ITEM(args,ii);
3322
}
3323
if (argc == 0) {
3324
return _wrap_new_floatvector__SWIG_0(self, args);
3325
}
3326
if (argc == 1) {
3327
int _v;
3328
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_EST_TVectorT_float_t, 0);
3329
_v = SWIG_CheckState(res);
3330
if (_v) {
3331
return _wrap_new_floatvector__SWIG_1(self, args);
3332
}
3333
}
3334
if (argc == 1) {
3335
int _v;
3336
{
3337
int res = SWIG_AsVal_int(argv[0], NULL);
3338
_v = SWIG_CheckState(res);
3339
}
3340
if (_v) {
3341
return _wrap_new_floatvector__SWIG_2(self, args);
3342
}
3343
}
3344
if (argc == 2) {
3345
int _v;
3346
{
3347
int res = SWIG_AsVal_int(argv[0], NULL);
3348
_v = SWIG_CheckState(res);
3349
}
3350
if (_v) {
3351
void *vptr = 0;
3352
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
3353
_v = SWIG_CheckState(res);
3354
if (_v) {
3355
return _wrap_new_floatvector__SWIG_5(self, args);
3356
}
3357
}
3358
}
3359
if (argc == 3) {
3360
int _v;
3361
{
3362
int res = SWIG_AsVal_int(argv[0], NULL);
3363
_v = SWIG_CheckState(res);
3364
}
3365
if (_v) {
3366
void *vptr = 0;
3367
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
3368
_v = SWIG_CheckState(res);
3369
if (_v) {
3370
{
3371
int res = SWIG_AsVal_int(argv[2], NULL);
3372
_v = SWIG_CheckState(res);
3373
}
3374
if (_v) {
3375
return _wrap_new_floatvector__SWIG_4(self, args);
3376
}
3377
}
3378
}
3379
}
3380
if (argc == 4) {
3381
int _v;
3382
{
3383
int res = SWIG_AsVal_int(argv[0], NULL);
3384
_v = SWIG_CheckState(res);
3385
}
3386
if (_v) {
3387
void *vptr = 0;
3388
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
3389
_v = SWIG_CheckState(res);
3390
if (_v) {
3391
{
3392
int res = SWIG_AsVal_int(argv[2], NULL);
3393
_v = SWIG_CheckState(res);
3394
}
3395
if (_v) {
3396
{
3397
int res = SWIG_AsVal_int(argv[3], NULL);
3398
_v = SWIG_CheckState(res);
3399
}
3400
if (_v) {
3401
return _wrap_new_floatvector__SWIG_3(self, args);
3402
}
3403
}
3404
}
3405
}
3406
}
3407
3408
fail:
3409
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_floatvector'.\n"
3410
" Possible C/C++ prototypes are:\n"
3411
" EST_TVector< float >()\n"
3412
" EST_TVector< float >(EST_TVector< float > const &)\n"
3413
" EST_TVector< float >(int)\n"
3414
" EST_TVector< float >(int,float *,int,int)\n"
3415
" EST_TVector< float >(int,float *,int)\n"
3416
" EST_TVector< float >(int,float *)\n");
3417
return NULL;
3418
}
3419
3420
3421
SWIGINTERN PyObject *_wrap_delete_floatvector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3422
PyObject *resultobj = 0;
3423
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3424
void *argp1 = 0 ;
3425
int res1 = 0 ;
3426
PyObject * obj0 = 0 ;
3427
3428
if (!PyArg_ParseTuple(args,(char *)"O:delete_floatvector",&obj0)) SWIG_fail;
3429
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, SWIG_POINTER_DISOWN | 0 );
3430
if (!SWIG_IsOK(res1)) {
3431
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_floatvector" "', argument " "1"" of type '" "EST_TVector< float > *""'");
3432
}
3433
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3434
delete arg1;
3435
resultobj = SWIG_Py_Void();
3436
return resultobj;
3437
fail:
3438
return NULL;
3439
}
3440
3441
3442
SWIGINTERN PyObject *_wrap_floatvector_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3443
PyObject *resultobj = 0;
3444
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3445
int arg2 ;
3446
int arg3 ;
3447
void *argp1 = 0 ;
3448
int res1 = 0 ;
3449
int val2 ;
3450
int ecode2 = 0 ;
3451
int val3 ;
3452
int ecode3 = 0 ;
3453
PyObject * obj0 = 0 ;
3454
PyObject * obj1 = 0 ;
3455
PyObject * obj2 = 0 ;
3456
3457
if (!PyArg_ParseTuple(args,(char *)"OOO:floatvector_resize",&obj0,&obj1,&obj2)) SWIG_fail;
3458
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3459
if (!SWIG_IsOK(res1)) {
3460
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_resize" "', argument " "1"" of type '" "EST_TVector< float > *""'");
3461
}
3462
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3463
ecode2 = SWIG_AsVal_int(obj1, &val2);
3464
if (!SWIG_IsOK(ecode2)) {
3465
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatvector_resize" "', argument " "2"" of type '" "int""'");
3466
}
3467
arg2 = static_cast< int >(val2);
3468
ecode3 = SWIG_AsVal_int(obj2, &val3);
3469
if (!SWIG_IsOK(ecode3)) {
3470
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatvector_resize" "', argument " "3"" of type '" "int""'");
3471
}
3472
arg3 = static_cast< int >(val3);
3473
(arg1)->resize(arg2,arg3);
3474
resultobj = SWIG_Py_Void();
3475
return resultobj;
3476
fail:
3477
return NULL;
3478
}
3479
3480
3481
SWIGINTERN PyObject *_wrap_floatvector_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3482
PyObject *resultobj = 0;
3483
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3484
int arg2 ;
3485
void *argp1 = 0 ;
3486
int res1 = 0 ;
3487
int val2 ;
3488
int ecode2 = 0 ;
3489
PyObject * obj0 = 0 ;
3490
PyObject * obj1 = 0 ;
3491
3492
if (!PyArg_ParseTuple(args,(char *)"OO:floatvector_resize",&obj0,&obj1)) SWIG_fail;
3493
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3494
if (!SWIG_IsOK(res1)) {
3495
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_resize" "', argument " "1"" of type '" "EST_TVector< float > *""'");
3496
}
3497
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3498
ecode2 = SWIG_AsVal_int(obj1, &val2);
3499
if (!SWIG_IsOK(ecode2)) {
3500
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatvector_resize" "', argument " "2"" of type '" "int""'");
3501
}
3502
arg2 = static_cast< int >(val2);
3503
(arg1)->resize(arg2);
3504
resultobj = SWIG_Py_Void();
3505
return resultobj;
3506
fail:
3507
return NULL;
3508
}
3509
3510
3511
SWIGINTERN PyObject *_wrap_floatvector_resize(PyObject *self, PyObject *args) {
3512
int argc;
3513
PyObject *argv[4];
3514
int ii;
3515
3516
if (!PyTuple_Check(args)) SWIG_fail;
3517
argc = (int)PyObject_Length(args);
3518
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
3519
argv[ii] = PyTuple_GET_ITEM(args,ii);
3520
}
3521
if (argc == 2) {
3522
int _v;
3523
void *vptr = 0;
3524
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TVectorT_float_t, 0);
3525
_v = SWIG_CheckState(res);
3526
if (_v) {
3527
{
3528
int res = SWIG_AsVal_int(argv[1], NULL);
3529
_v = SWIG_CheckState(res);
3530
}
3531
if (_v) {
3532
return _wrap_floatvector_resize__SWIG_1(self, args);
3533
}
3534
}
3535
}
3536
if (argc == 3) {
3537
int _v;
3538
void *vptr = 0;
3539
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TVectorT_float_t, 0);
3540
_v = SWIG_CheckState(res);
3541
if (_v) {
3542
{
3543
int res = SWIG_AsVal_int(argv[1], NULL);
3544
_v = SWIG_CheckState(res);
3545
}
3546
if (_v) {
3547
{
3548
int res = SWIG_AsVal_int(argv[2], NULL);
3549
_v = SWIG_CheckState(res);
3550
}
3551
if (_v) {
3552
return _wrap_floatvector_resize__SWIG_0(self, args);
3553
}
3554
}
3555
}
3556
}
3557
3558
fail:
3559
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'floatvector_resize'.\n"
3560
" Possible C/C++ prototypes are:\n"
3561
" resize(EST_TVector< float > *,int,int)\n"
3562
" resize(EST_TVector< float > *,int)\n");
3563
return NULL;
3564
}
3565
3566
3567
SWIGINTERN PyObject *_wrap_floatvector_num_columns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3568
PyObject *resultobj = 0;
3569
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3570
void *argp1 = 0 ;
3571
int res1 = 0 ;
3572
PyObject * obj0 = 0 ;
3573
int result;
3574
3575
if (!PyArg_ParseTuple(args,(char *)"O:floatvector_num_columns",&obj0)) SWIG_fail;
3576
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3577
if (!SWIG_IsOK(res1)) {
3578
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_num_columns" "', argument " "1"" of type '" "EST_TVector< float > const *""'");
3579
}
3580
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3581
result = (int)((EST_TVector< float > const *)arg1)->num_columns();
3582
resultobj = SWIG_From_int(static_cast< int >(result));
3583
return resultobj;
3584
fail:
3585
return NULL;
3586
}
3587
3588
3589
SWIGINTERN PyObject *_wrap_floatvector_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3590
PyObject *resultobj = 0;
3591
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3592
void *argp1 = 0 ;
3593
int res1 = 0 ;
3594
PyObject * obj0 = 0 ;
3595
int result;
3596
3597
if (!PyArg_ParseTuple(args,(char *)"O:floatvector_length",&obj0)) SWIG_fail;
3598
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3599
if (!SWIG_IsOK(res1)) {
3600
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_length" "', argument " "1"" of type '" "EST_TVector< float > const *""'");
3601
}
3602
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3603
result = (int)((EST_TVector< float > const *)arg1)->length();
3604
resultobj = SWIG_From_int(static_cast< int >(result));
3605
return resultobj;
3606
fail:
3607
return NULL;
3608
}
3609
3610
3611
SWIGINTERN PyObject *_wrap_floatvector_n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3612
PyObject *resultobj = 0;
3613
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3614
void *argp1 = 0 ;
3615
int res1 = 0 ;
3616
PyObject * obj0 = 0 ;
3617
int result;
3618
3619
if (!PyArg_ParseTuple(args,(char *)"O:floatvector_n",&obj0)) SWIG_fail;
3620
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3621
if (!SWIG_IsOK(res1)) {
3622
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_n" "', argument " "1"" of type '" "EST_TVector< float > const *""'");
3623
}
3624
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3625
result = (int)((EST_TVector< float > const *)arg1)->n();
3626
resultobj = SWIG_From_int(static_cast< int >(result));
3627
return resultobj;
3628
fail:
3629
return NULL;
3630
}
3631
3632
3633
SWIGINTERN PyObject *_wrap_floatvector_a_no_check(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3634
PyObject *resultobj = 0;
3635
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3636
int arg2 ;
3637
void *argp1 = 0 ;
3638
int res1 = 0 ;
3639
int val2 ;
3640
int ecode2 = 0 ;
3641
PyObject * obj0 = 0 ;
3642
PyObject * obj1 = 0 ;
3643
float *result = 0 ;
3644
3645
if (!PyArg_ParseTuple(args,(char *)"OO:floatvector_a_no_check",&obj0,&obj1)) SWIG_fail;
3646
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3647
if (!SWIG_IsOK(res1)) {
3648
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_a_no_check" "', argument " "1"" of type '" "EST_TVector< float > *""'");
3649
}
3650
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3651
ecode2 = SWIG_AsVal_int(obj1, &val2);
3652
if (!SWIG_IsOK(ecode2)) {
3653
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatvector_a_no_check" "', argument " "2"" of type '" "int""'");
3654
}
3655
arg2 = static_cast< int >(val2);
3656
result = (float *) &(arg1)->a_no_check(arg2);
3657
resultobj = SWIG_From_float(static_cast< float >(*result));
3658
return resultobj;
3659
fail:
3660
return NULL;
3661
}
3662
3663
3664
SWIGINTERN PyObject *_wrap_floatvector_a_no_check_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3665
PyObject *resultobj = 0;
3666
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3667
int arg2 ;
3668
void *argp1 = 0 ;
3669
int res1 = 0 ;
3670
int val2 ;
3671
int ecode2 = 0 ;
3672
PyObject * obj0 = 0 ;
3673
PyObject * obj1 = 0 ;
3674
float *result = 0 ;
3675
3676
if (!PyArg_ParseTuple(args,(char *)"OO:floatvector_a_no_check_1",&obj0,&obj1)) SWIG_fail;
3677
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3678
if (!SWIG_IsOK(res1)) {
3679
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_a_no_check_1" "', argument " "1"" of type '" "EST_TVector< float > *""'");
3680
}
3681
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3682
ecode2 = SWIG_AsVal_int(obj1, &val2);
3683
if (!SWIG_IsOK(ecode2)) {
3684
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatvector_a_no_check_1" "', argument " "2"" of type '" "int""'");
3685
}
3686
arg2 = static_cast< int >(val2);
3687
result = (float *) &(arg1)->a_no_check_1(arg2);
3688
resultobj = SWIG_From_float(static_cast< float >(*result));
3689
return resultobj;
3690
fail:
3691
return NULL;
3692
}
3693
3694
3695
SWIGINTERN PyObject *_wrap_floatvector_a_check(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3696
PyObject *resultobj = 0;
3697
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3698
int arg2 ;
3699
void *argp1 = 0 ;
3700
int res1 = 0 ;
3701
int val2 ;
3702
int ecode2 = 0 ;
3703
PyObject * obj0 = 0 ;
3704
PyObject * obj1 = 0 ;
3705
float *result = 0 ;
3706
3707
if (!PyArg_ParseTuple(args,(char *)"OO:floatvector_a_check",&obj0,&obj1)) SWIG_fail;
3708
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3709
if (!SWIG_IsOK(res1)) {
3710
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_a_check" "', argument " "1"" of type '" "EST_TVector< float > *""'");
3711
}
3712
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3713
ecode2 = SWIG_AsVal_int(obj1, &val2);
3714
if (!SWIG_IsOK(ecode2)) {
3715
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatvector_a_check" "', argument " "2"" of type '" "int""'");
3716
}
3717
arg2 = static_cast< int >(val2);
3718
result = (float *) &(arg1)->a_check(arg2);
3719
resultobj = SWIG_From_float(static_cast< float >(*result));
3720
return resultobj;
3721
fail:
3722
return NULL;
3723
}
3724
3725
3726
SWIGINTERN PyObject *_wrap_floatvector_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3727
PyObject *resultobj = 0;
3728
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3729
int arg2 ;
3730
void *argp1 = 0 ;
3731
int res1 = 0 ;
3732
int val2 ;
3733
int ecode2 = 0 ;
3734
PyObject * obj0 = 0 ;
3735
PyObject * obj1 = 0 ;
3736
float *result = 0 ;
3737
3738
if (!PyArg_ParseTuple(args,(char *)"OO:floatvector_a",&obj0,&obj1)) SWIG_fail;
3739
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3740
if (!SWIG_IsOK(res1)) {
3741
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_a" "', argument " "1"" of type '" "EST_TVector< float > *""'");
3742
}
3743
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3744
ecode2 = SWIG_AsVal_int(obj1, &val2);
3745
if (!SWIG_IsOK(ecode2)) {
3746
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatvector_a" "', argument " "2"" of type '" "int""'");
3747
}
3748
arg2 = static_cast< int >(val2);
3749
result = (float *) &(arg1)->a(arg2);
3750
resultobj = SWIG_From_float(static_cast< float >(*result));
3751
return resultobj;
3752
fail:
3753
return NULL;
3754
}
3755
3756
3757
SWIGINTERN PyObject *_wrap_floatvector_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3758
PyObject *resultobj = 0;
3759
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3760
float *arg2 = 0 ;
3761
void *argp1 = 0 ;
3762
int res1 = 0 ;
3763
float temp2 ;
3764
float val2 ;
3765
int ecode2 = 0 ;
3766
PyObject * obj0 = 0 ;
3767
PyObject * obj1 = 0 ;
3768
3769
if (!PyArg_ParseTuple(args,(char *)"OO:floatvector_fill",&obj0,&obj1)) SWIG_fail;
3770
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3771
if (!SWIG_IsOK(res1)) {
3772
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_fill" "', argument " "1"" of type '" "EST_TVector< float > *""'");
3773
}
3774
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3775
ecode2 = SWIG_AsVal_float(obj1, &val2);
3776
if (!SWIG_IsOK(ecode2)) {
3777
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatvector_fill" "', argument " "2"" of type '" "float""'");
3778
}
3779
temp2 = static_cast< float >(val2);
3780
arg2 = &temp2;
3781
(arg1)->fill((float const &)*arg2);
3782
resultobj = SWIG_Py_Void();
3783
return resultobj;
3784
fail:
3785
return NULL;
3786
}
3787
3788
3789
SWIGINTERN PyObject *_wrap_floatvector_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3790
PyObject *resultobj = 0;
3791
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3792
void *argp1 = 0 ;
3793
int res1 = 0 ;
3794
PyObject * obj0 = 0 ;
3795
3796
if (!PyArg_ParseTuple(args,(char *)"O:floatvector_empty",&obj0)) SWIG_fail;
3797
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3798
if (!SWIG_IsOK(res1)) {
3799
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_empty" "', argument " "1"" of type '" "EST_TVector< float > *""'");
3800
}
3801
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3802
(arg1)->empty();
3803
resultobj = SWIG_Py_Void();
3804
return resultobj;
3805
fail:
3806
return NULL;
3807
}
3808
3809
3810
SWIGINTERN PyObject *_wrap_floatvector___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3811
PyObject *resultobj = 0;
3812
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3813
EST_TVector< float > *arg2 = 0 ;
3814
void *argp1 = 0 ;
3815
int res1 = 0 ;
3816
void *argp2 = 0 ;
3817
int res2 = 0 ;
3818
PyObject * obj0 = 0 ;
3819
PyObject * obj1 = 0 ;
3820
int result;
3821
3822
if (!PyArg_ParseTuple(args,(char *)"OO:floatvector___eq__",&obj0,&obj1)) SWIG_fail;
3823
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3824
if (!SWIG_IsOK(res1)) {
3825
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector___eq__" "', argument " "1"" of type '" "EST_TVector< float > const *""'");
3826
}
3827
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3828
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0);
3829
if (!SWIG_IsOK(res2)) {
3830
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "floatvector___eq__" "', argument " "2"" of type '" "EST_TVector< float > const &""'");
3831
}
3832
if (!argp2) {
3833
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "floatvector___eq__" "', argument " "2"" of type '" "EST_TVector< float > const &""'");
3834
}
3835
arg2 = reinterpret_cast< EST_TVector< float > * >(argp2);
3836
result = (int)((EST_TVector< float > const *)arg1)->operator ==((EST_TVector< float > const &)*arg2);
3837
resultobj = SWIG_From_int(static_cast< int >(result));
3838
return resultobj;
3839
fail:
3840
return NULL;
3841
}
3842
3843
3844
SWIGINTERN PyObject *_wrap_floatvector___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3845
PyObject *resultobj = 0;
3846
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3847
EST_TVector< float > *arg2 = 0 ;
3848
void *argp1 = 0 ;
3849
int res1 = 0 ;
3850
void *argp2 = 0 ;
3851
int res2 = 0 ;
3852
PyObject * obj0 = 0 ;
3853
PyObject * obj1 = 0 ;
3854
int result;
3855
3856
if (!PyArg_ParseTuple(args,(char *)"OO:floatvector___ne__",&obj0,&obj1)) SWIG_fail;
3857
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3858
if (!SWIG_IsOK(res1)) {
3859
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector___ne__" "', argument " "1"" of type '" "EST_TVector< float > const *""'");
3860
}
3861
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3862
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0);
3863
if (!SWIG_IsOK(res2)) {
3864
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "floatvector___ne__" "', argument " "2"" of type '" "EST_TVector< float > const &""'");
3865
}
3866
if (!argp2) {
3867
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "floatvector___ne__" "', argument " "2"" of type '" "EST_TVector< float > const &""'");
3868
}
3869
arg2 = reinterpret_cast< EST_TVector< float > * >(argp2);
3870
result = (int)((EST_TVector< float > const *)arg1)->operator !=((EST_TVector< float > const &)*arg2);
3871
resultobj = SWIG_From_int(static_cast< int >(result));
3872
return resultobj;
3873
fail:
3874
return NULL;
3875
}
3876
3877
3878
SWIGINTERN PyObject *_wrap_floatvector___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3879
PyObject *resultobj = 0;
3880
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3881
int arg2 ;
3882
float *arg3 = 0 ;
3883
void *argp1 = 0 ;
3884
int res1 = 0 ;
3885
int val2 ;
3886
int ecode2 = 0 ;
3887
float temp3 ;
3888
float val3 ;
3889
int ecode3 = 0 ;
3890
PyObject * obj0 = 0 ;
3891
PyObject * obj1 = 0 ;
3892
PyObject * obj2 = 0 ;
3893
3894
if (!PyArg_ParseTuple(args,(char *)"OOO:floatvector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
3895
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3896
if (!SWIG_IsOK(res1)) {
3897
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector___setitem__" "', argument " "1"" of type '" "EST_TVector< float > *""'");
3898
}
3899
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3900
ecode2 = SWIG_AsVal_int(obj1, &val2);
3901
if (!SWIG_IsOK(ecode2)) {
3902
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatvector___setitem__" "', argument " "2"" of type '" "int""'");
3903
}
3904
arg2 = static_cast< int >(val2);
3905
ecode3 = SWIG_AsVal_float(obj2, &val3);
3906
if (!SWIG_IsOK(ecode3)) {
3907
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatvector___setitem__" "', argument " "3"" of type '" "float""'");
3908
}
3909
temp3 = static_cast< float >(val3);
3910
arg3 = &temp3;
3911
EST_TVector_Sl_float_Sg__setitem(arg1,arg2,(float const &)*arg3);
3912
resultobj = SWIG_Py_Void();
3913
return resultobj;
3914
fail:
3915
return NULL;
3916
}
3917
3918
3919
SWIGINTERN PyObject *_wrap_floatvector___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3920
PyObject *resultobj = 0;
3921
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3922
int arg2 ;
3923
void *argp1 = 0 ;
3924
int res1 = 0 ;
3925
int val2 ;
3926
int ecode2 = 0 ;
3927
PyObject * obj0 = 0 ;
3928
PyObject * obj1 = 0 ;
3929
float *result = 0 ;
3930
3931
if (!PyArg_ParseTuple(args,(char *)"OO:floatvector___getitem__",&obj0,&obj1)) SWIG_fail;
3932
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3933
if (!SWIG_IsOK(res1)) {
3934
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector___getitem__" "', argument " "1"" of type '" "EST_TVector< float > *""'");
3935
}
3936
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3937
ecode2 = SWIG_AsVal_int(obj1, &val2);
3938
if (!SWIG_IsOK(ecode2)) {
3939
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatvector___getitem__" "', argument " "2"" of type '" "int""'");
3940
}
3941
arg2 = static_cast< int >(val2);
3942
result = (float *) &EST_TVector_Sl_float_Sg__getitem(arg1,arg2);
3943
resultobj = SWIG_From_float(static_cast< float >(*result));
3944
return resultobj;
3945
fail:
3946
return NULL;
3947
}
3948
3949
3950
SWIGINTERN PyObject *_wrap_floatvector_copy_section__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3951
PyObject *resultobj = 0;
3952
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
3953
float *arg2 = (float *) 0 ;
3954
int arg3 ;
3955
int arg4 ;
3956
void *argp1 = 0 ;
3957
int res1 = 0 ;
3958
void *argp2 = 0 ;
3959
int res2 = 0 ;
3960
int val3 ;
3961
int ecode3 = 0 ;
3962
int val4 ;
3963
int ecode4 = 0 ;
3964
PyObject * obj0 = 0 ;
3965
PyObject * obj1 = 0 ;
3966
PyObject * obj2 = 0 ;
3967
PyObject * obj3 = 0 ;
3968
3969
if (!PyArg_ParseTuple(args,(char *)"OOOO:floatvector_copy_section",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3970
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
3971
if (!SWIG_IsOK(res1)) {
3972
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_copy_section" "', argument " "1"" of type '" "EST_TVector< float > const *""'");
3973
}
3974
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
3975
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
3976
if (!SWIG_IsOK(res2)) {
3977
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "floatvector_copy_section" "', argument " "2"" of type '" "float *""'");
3978
}
3979
arg2 = reinterpret_cast< float * >(argp2);
3980
ecode3 = SWIG_AsVal_int(obj2, &val3);
3981
if (!SWIG_IsOK(ecode3)) {
3982
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatvector_copy_section" "', argument " "3"" of type '" "int""'");
3983
}
3984
arg3 = static_cast< int >(val3);
3985
ecode4 = SWIG_AsVal_int(obj3, &val4);
3986
if (!SWIG_IsOK(ecode4)) {
3987
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "floatvector_copy_section" "', argument " "4"" of type '" "int""'");
3988
}
3989
arg4 = static_cast< int >(val4);
3990
((EST_TVector< float > const *)arg1)->copy_section(arg2,arg3,arg4);
3991
resultobj = SWIG_Py_Void();
3992
return resultobj;
3993
fail:
3994
return NULL;
3995
}
3996
3997
3998
SWIGINTERN PyObject *_wrap_floatvector_copy_section__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3999
PyObject *resultobj = 0;
4000
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
4001
float *arg2 = (float *) 0 ;
4002
int arg3 ;
4003
void *argp1 = 0 ;
4004
int res1 = 0 ;
4005
void *argp2 = 0 ;
4006
int res2 = 0 ;
4007
int val3 ;
4008
int ecode3 = 0 ;
4009
PyObject * obj0 = 0 ;
4010
PyObject * obj1 = 0 ;
4011
PyObject * obj2 = 0 ;
4012
4013
if (!PyArg_ParseTuple(args,(char *)"OOO:floatvector_copy_section",&obj0,&obj1,&obj2)) SWIG_fail;
4014
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
4015
if (!SWIG_IsOK(res1)) {
4016
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_copy_section" "', argument " "1"" of type '" "EST_TVector< float > const *""'");
4017
}
4018
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
4019
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
4020
if (!SWIG_IsOK(res2)) {
4021
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "floatvector_copy_section" "', argument " "2"" of type '" "float *""'");
4022
}
4023
arg2 = reinterpret_cast< float * >(argp2);
4024
ecode3 = SWIG_AsVal_int(obj2, &val3);
4025
if (!SWIG_IsOK(ecode3)) {
4026
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatvector_copy_section" "', argument " "3"" of type '" "int""'");
4027
}
4028
arg3 = static_cast< int >(val3);
4029
((EST_TVector< float > const *)arg1)->copy_section(arg2,arg3);
4030
resultobj = SWIG_Py_Void();
4031
return resultobj;
4032
fail:
4033
return NULL;
4034
}
4035
4036
4037
SWIGINTERN PyObject *_wrap_floatvector_copy_section__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4038
PyObject *resultobj = 0;
4039
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
4040
float *arg2 = (float *) 0 ;
4041
void *argp1 = 0 ;
4042
int res1 = 0 ;
4043
void *argp2 = 0 ;
4044
int res2 = 0 ;
4045
PyObject * obj0 = 0 ;
4046
PyObject * obj1 = 0 ;
4047
4048
if (!PyArg_ParseTuple(args,(char *)"OO:floatvector_copy_section",&obj0,&obj1)) SWIG_fail;
4049
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
4050
if (!SWIG_IsOK(res1)) {
4051
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_copy_section" "', argument " "1"" of type '" "EST_TVector< float > const *""'");
4052
}
4053
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
4054
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
4055
if (!SWIG_IsOK(res2)) {
4056
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "floatvector_copy_section" "', argument " "2"" of type '" "float *""'");
4057
}
4058
arg2 = reinterpret_cast< float * >(argp2);
4059
((EST_TVector< float > const *)arg1)->copy_section(arg2);
4060
resultobj = SWIG_Py_Void();
4061
return resultobj;
4062
fail:
4063
return NULL;
4064
}
4065
4066
4067
SWIGINTERN PyObject *_wrap_floatvector_copy_section(PyObject *self, PyObject *args) {
4068
int argc;
4069
PyObject *argv[5];
4070
int ii;
4071
4072
if (!PyTuple_Check(args)) SWIG_fail;
4073
argc = (int)PyObject_Length(args);
4074
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
4075
argv[ii] = PyTuple_GET_ITEM(args,ii);
4076
}
4077
if (argc == 2) {
4078
int _v;
4079
void *vptr = 0;
4080
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TVectorT_float_t, 0);
4081
_v = SWIG_CheckState(res);
4082
if (_v) {
4083
void *vptr = 0;
4084
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
4085
_v = SWIG_CheckState(res);
4086
if (_v) {
4087
return _wrap_floatvector_copy_section__SWIG_2(self, args);
4088
}
4089
}
4090
}
4091
if (argc == 3) {
4092
int _v;
4093
void *vptr = 0;
4094
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TVectorT_float_t, 0);
4095
_v = SWIG_CheckState(res);
4096
if (_v) {
4097
void *vptr = 0;
4098
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
4099
_v = SWIG_CheckState(res);
4100
if (_v) {
4101
{
4102
int res = SWIG_AsVal_int(argv[2], NULL);
4103
_v = SWIG_CheckState(res);
4104
}
4105
if (_v) {
4106
return _wrap_floatvector_copy_section__SWIG_1(self, args);
4107
}
4108
}
4109
}
4110
}
4111
if (argc == 4) {
4112
int _v;
4113
void *vptr = 0;
4114
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TVectorT_float_t, 0);
4115
_v = SWIG_CheckState(res);
4116
if (_v) {
4117
void *vptr = 0;
4118
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
4119
_v = SWIG_CheckState(res);
4120
if (_v) {
4121
{
4122
int res = SWIG_AsVal_int(argv[2], NULL);
4123
_v = SWIG_CheckState(res);
4124
}
4125
if (_v) {
4126
{
4127
int res = SWIG_AsVal_int(argv[3], NULL);
4128
_v = SWIG_CheckState(res);
4129
}
4130
if (_v) {
4131
return _wrap_floatvector_copy_section__SWIG_0(self, args);
4132
}
4133
}
4134
}
4135
}
4136
}
4137
4138
fail:
4139
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'floatvector_copy_section'.\n"
4140
" Possible C/C++ prototypes are:\n"
4141
" copy_section(EST_TVector< float > const *,float *,int,int)\n"
4142
" copy_section(EST_TVector< float > const *,float *,int)\n"
4143
" copy_section(EST_TVector< float > const *,float *)\n");
4144
return NULL;
4145
}
4146
4147
4148
SWIGINTERN PyObject *_wrap_floatvector_set_section__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4149
PyObject *resultobj = 0;
4150
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
4151
float *arg2 = (float *) 0 ;
4152
int arg3 ;
4153
int arg4 ;
4154
void *argp1 = 0 ;
4155
int res1 = 0 ;
4156
void *argp2 = 0 ;
4157
int res2 = 0 ;
4158
int val3 ;
4159
int ecode3 = 0 ;
4160
int val4 ;
4161
int ecode4 = 0 ;
4162
PyObject * obj0 = 0 ;
4163
PyObject * obj1 = 0 ;
4164
PyObject * obj2 = 0 ;
4165
PyObject * obj3 = 0 ;
4166
4167
if (!PyArg_ParseTuple(args,(char *)"OOOO:floatvector_set_section",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4168
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
4169
if (!SWIG_IsOK(res1)) {
4170
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_set_section" "', argument " "1"" of type '" "EST_TVector< float > *""'");
4171
}
4172
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
4173
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
4174
if (!SWIG_IsOK(res2)) {
4175
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "floatvector_set_section" "', argument " "2"" of type '" "float const *""'");
4176
}
4177
arg2 = reinterpret_cast< float * >(argp2);
4178
ecode3 = SWIG_AsVal_int(obj2, &val3);
4179
if (!SWIG_IsOK(ecode3)) {
4180
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatvector_set_section" "', argument " "3"" of type '" "int""'");
4181
}
4182
arg3 = static_cast< int >(val3);
4183
ecode4 = SWIG_AsVal_int(obj3, &val4);
4184
if (!SWIG_IsOK(ecode4)) {
4185
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "floatvector_set_section" "', argument " "4"" of type '" "int""'");
4186
}
4187
arg4 = static_cast< int >(val4);
4188
(arg1)->set_section((float const *)arg2,arg3,arg4);
4189
resultobj = SWIG_Py_Void();
4190
return resultobj;
4191
fail:
4192
return NULL;
4193
}
4194
4195
4196
SWIGINTERN PyObject *_wrap_floatvector_set_section__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4197
PyObject *resultobj = 0;
4198
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
4199
float *arg2 = (float *) 0 ;
4200
int arg3 ;
4201
void *argp1 = 0 ;
4202
int res1 = 0 ;
4203
void *argp2 = 0 ;
4204
int res2 = 0 ;
4205
int val3 ;
4206
int ecode3 = 0 ;
4207
PyObject * obj0 = 0 ;
4208
PyObject * obj1 = 0 ;
4209
PyObject * obj2 = 0 ;
4210
4211
if (!PyArg_ParseTuple(args,(char *)"OOO:floatvector_set_section",&obj0,&obj1,&obj2)) SWIG_fail;
4212
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
4213
if (!SWIG_IsOK(res1)) {
4214
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_set_section" "', argument " "1"" of type '" "EST_TVector< float > *""'");
4215
}
4216
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
4217
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
4218
if (!SWIG_IsOK(res2)) {
4219
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "floatvector_set_section" "', argument " "2"" of type '" "float const *""'");
4220
}
4221
arg2 = reinterpret_cast< float * >(argp2);
4222
ecode3 = SWIG_AsVal_int(obj2, &val3);
4223
if (!SWIG_IsOK(ecode3)) {
4224
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatvector_set_section" "', argument " "3"" of type '" "int""'");
4225
}
4226
arg3 = static_cast< int >(val3);
4227
(arg1)->set_section((float const *)arg2,arg3);
4228
resultobj = SWIG_Py_Void();
4229
return resultobj;
4230
fail:
4231
return NULL;
4232
}
4233
4234
4235
SWIGINTERN PyObject *_wrap_floatvector_set_section__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4236
PyObject *resultobj = 0;
4237
EST_TVector< float > *arg1 = (EST_TVector< float > *) 0 ;
4238
float *arg2 = (float *) 0 ;
4239
void *argp1 = 0 ;
4240
int res1 = 0 ;
4241
void *argp2 = 0 ;
4242
int res2 = 0 ;
4243
PyObject * obj0 = 0 ;
4244
PyObject * obj1 = 0 ;
4245
4246
if (!PyArg_ParseTuple(args,(char *)"OO:floatvector_set_section",&obj0,&obj1)) SWIG_fail;
4247
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TVectorT_float_t, 0 | 0 );
4248
if (!SWIG_IsOK(res1)) {
4249
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatvector_set_section" "', argument " "1"" of type '" "EST_TVector< float > *""'");
4250
}
4251
arg1 = reinterpret_cast< EST_TVector< float > * >(argp1);
4252
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
4253
if (!SWIG_IsOK(res2)) {
4254
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "floatvector_set_section" "', argument " "2"" of type '" "float const *""'");
4255
}
4256
arg2 = reinterpret_cast< float * >(argp2);
4257
(arg1)->set_section((float const *)arg2);
4258
resultobj = SWIG_Py_Void();
4259
return resultobj;
4260
fail:
4261
return NULL;
4262
}
4263
4264
4265
SWIGINTERN PyObject *_wrap_floatvector_set_section(PyObject *self, PyObject *args) {
4266
int argc;
4267
PyObject *argv[5];
4268
int ii;
4269
4270
if (!PyTuple_Check(args)) SWIG_fail;
4271
argc = (int)PyObject_Length(args);
4272
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
4273
argv[ii] = PyTuple_GET_ITEM(args,ii);
4274
}
4275
if (argc == 2) {
4276
int _v;
4277
void *vptr = 0;
4278
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TVectorT_float_t, 0);
4279
_v = SWIG_CheckState(res);
4280
if (_v) {
4281
void *vptr = 0;
4282
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
4283
_v = SWIG_CheckState(res);
4284
if (_v) {
4285
return _wrap_floatvector_set_section__SWIG_2(self, args);
4286
}
4287
}
4288
}
4289
if (argc == 3) {
4290
int _v;
4291
void *vptr = 0;
4292
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TVectorT_float_t, 0);
4293
_v = SWIG_CheckState(res);
4294
if (_v) {
4295
void *vptr = 0;
4296
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
4297
_v = SWIG_CheckState(res);
4298
if (_v) {
4299
{
4300
int res = SWIG_AsVal_int(argv[2], NULL);
4301
_v = SWIG_CheckState(res);
4302
}
4303
if (_v) {
4304
return _wrap_floatvector_set_section__SWIG_1(self, args);
4305
}
4306
}
4307
}
4308
}
4309
if (argc == 4) {
4310
int _v;
4311
void *vptr = 0;
4312
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TVectorT_float_t, 0);
4313
_v = SWIG_CheckState(res);
4314
if (_v) {
4315
void *vptr = 0;
4316
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
4317
_v = SWIG_CheckState(res);
4318
if (_v) {
4319
{
4320
int res = SWIG_AsVal_int(argv[2], NULL);
4321
_v = SWIG_CheckState(res);
4322
}
4323
if (_v) {
4324
{
4325
int res = SWIG_AsVal_int(argv[3], NULL);
4326
_v = SWIG_CheckState(res);
4327
}
4328
if (_v) {
4329
return _wrap_floatvector_set_section__SWIG_0(self, args);
4330
}
4331
}
4332
}
4333
}
4334
}
4335
4336
fail:
4337
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'floatvector_set_section'.\n"
4338
" Possible C/C++ prototypes are:\n"
4339
" set_section(EST_TVector< float > *,float const *,int,int)\n"
4340
" set_section(EST_TVector< float > *,float const *,int)\n"
4341
" set_section(EST_TVector< float > *,float const *)\n");
4342
return NULL;
4343
}
4344
4345
4346
SWIGINTERN PyObject *floatvector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4347
PyObject *obj;
4348
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4349
SWIG_TypeNewClientData(SWIGTYPE_p_EST_TVectorT_float_t, SWIG_NewClientData(obj));
4350
return SWIG_Py_Void();
4351
}
4352
4353
SWIGINTERN PyObject *_wrap_new_floatsimplevector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4354
PyObject *resultobj = 0;
4355
EST_TSimpleVector< float > *result = 0 ;
4356
4357
if (!PyArg_ParseTuple(args,(char *)":new_floatsimplevector")) SWIG_fail;
4358
result = (EST_TSimpleVector< float > *)new EST_TSimpleVector< float >();
4359
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_TSimpleVectorT_float_t, SWIG_POINTER_NEW | 0 );
4360
return resultobj;
4361
fail:
4362
return NULL;
4363
}
4364
4365
4366
SWIGINTERN PyObject *_wrap_new_floatsimplevector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4367
PyObject *resultobj = 0;
4368
EST_TSimpleVector< float > *arg1 = 0 ;
4369
void *argp1 = 0 ;
4370
int res1 = 0 ;
4371
PyObject * obj0 = 0 ;
4372
EST_TSimpleVector< float > *result = 0 ;
4373
4374
if (!PyArg_ParseTuple(args,(char *)"O:new_floatsimplevector",&obj0)) SWIG_fail;
4375
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0 | 0);
4376
if (!SWIG_IsOK(res1)) {
4377
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_floatsimplevector" "', argument " "1"" of type '" "EST_TSimpleVector< float > const &""'");
4378
}
4379
if (!argp1) {
4380
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_floatsimplevector" "', argument " "1"" of type '" "EST_TSimpleVector< float > const &""'");
4381
}
4382
arg1 = reinterpret_cast< EST_TSimpleVector< float > * >(argp1);
4383
result = (EST_TSimpleVector< float > *)new EST_TSimpleVector< float >((EST_TSimpleVector< float > const &)*arg1);
4384
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_TSimpleVectorT_float_t, SWIG_POINTER_NEW | 0 );
4385
return resultobj;
4386
fail:
4387
return NULL;
4388
}
4389
4390
4391
SWIGINTERN PyObject *_wrap_new_floatsimplevector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4392
PyObject *resultobj = 0;
4393
int arg1 ;
4394
int val1 ;
4395
int ecode1 = 0 ;
4396
PyObject * obj0 = 0 ;
4397
EST_TSimpleVector< float > *result = 0 ;
4398
4399
if (!PyArg_ParseTuple(args,(char *)"O:new_floatsimplevector",&obj0)) SWIG_fail;
4400
ecode1 = SWIG_AsVal_int(obj0, &val1);
4401
if (!SWIG_IsOK(ecode1)) {
4402
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_floatsimplevector" "', argument " "1"" of type '" "int""'");
4403
}
4404
arg1 = static_cast< int >(val1);
4405
result = (EST_TSimpleVector< float > *)new EST_TSimpleVector< float >(arg1);
4406
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_TSimpleVectorT_float_t, SWIG_POINTER_NEW | 0 );
4407
return resultobj;
4408
fail:
4409
return NULL;
4410
}
4411
4412
4413
SWIGINTERN PyObject *_wrap_new_floatsimplevector(PyObject *self, PyObject *args) {
4414
int argc;
4415
PyObject *argv[2];
4416
int ii;
4417
4418
if (!PyTuple_Check(args)) SWIG_fail;
4419
argc = (int)PyObject_Length(args);
4420
for (ii = 0; (ii < argc) && (ii < 1); ii++) {
4421
argv[ii] = PyTuple_GET_ITEM(args,ii);
4422
}
4423
if (argc == 0) {
4424
return _wrap_new_floatsimplevector__SWIG_0(self, args);
4425
}
4426
if (argc == 1) {
4427
int _v;
4428
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0);
4429
_v = SWIG_CheckState(res);
4430
if (_v) {
4431
return _wrap_new_floatsimplevector__SWIG_1(self, args);
4432
}
4433
}
4434
if (argc == 1) {
4435
int _v;
4436
{
4437
int res = SWIG_AsVal_int(argv[0], NULL);
4438
_v = SWIG_CheckState(res);
4439
}
4440
if (_v) {
4441
return _wrap_new_floatsimplevector__SWIG_2(self, args);
4442
}
4443
}
4444
4445
fail:
4446
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_floatsimplevector'.\n"
4447
" Possible C/C++ prototypes are:\n"
4448
" EST_TSimpleVector< float >()\n"
4449
" EST_TSimpleVector< float >(EST_TSimpleVector< float > const &)\n"
4450
" EST_TSimpleVector< float >(int)\n");
4451
return NULL;
4452
}
4453
4454
4455
SWIGINTERN PyObject *_wrap_floatsimplevector_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4456
PyObject *resultobj = 0;
4457
EST_TSimpleVector< float > *arg1 = (EST_TSimpleVector< float > *) 0 ;
4458
int arg2 ;
4459
int arg3 ;
4460
void *argp1 = 0 ;
4461
int res1 = 0 ;
4462
int val2 ;
4463
int ecode2 = 0 ;
4464
int val3 ;
4465
int ecode3 = 0 ;
4466
PyObject * obj0 = 0 ;
4467
PyObject * obj1 = 0 ;
4468
PyObject * obj2 = 0 ;
4469
4470
if (!PyArg_ParseTuple(args,(char *)"OOO:floatsimplevector_resize",&obj0,&obj1,&obj2)) SWIG_fail;
4471
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0 | 0 );
4472
if (!SWIG_IsOK(res1)) {
4473
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatsimplevector_resize" "', argument " "1"" of type '" "EST_TSimpleVector< float > *""'");
4474
}
4475
arg1 = reinterpret_cast< EST_TSimpleVector< float > * >(argp1);
4476
ecode2 = SWIG_AsVal_int(obj1, &val2);
4477
if (!SWIG_IsOK(ecode2)) {
4478
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatsimplevector_resize" "', argument " "2"" of type '" "int""'");
4479
}
4480
arg2 = static_cast< int >(val2);
4481
ecode3 = SWIG_AsVal_int(obj2, &val3);
4482
if (!SWIG_IsOK(ecode3)) {
4483
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatsimplevector_resize" "', argument " "3"" of type '" "int""'");
4484
}
4485
arg3 = static_cast< int >(val3);
4486
(arg1)->resize(arg2,arg3);
4487
resultobj = SWIG_Py_Void();
4488
return resultobj;
4489
fail:
4490
return NULL;
4491
}
4492
4493
4494
SWIGINTERN PyObject *_wrap_floatsimplevector_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4495
PyObject *resultobj = 0;
4496
EST_TSimpleVector< float > *arg1 = (EST_TSimpleVector< float > *) 0 ;
4497
int arg2 ;
4498
void *argp1 = 0 ;
4499
int res1 = 0 ;
4500
int val2 ;
4501
int ecode2 = 0 ;
4502
PyObject * obj0 = 0 ;
4503
PyObject * obj1 = 0 ;
4504
4505
if (!PyArg_ParseTuple(args,(char *)"OO:floatsimplevector_resize",&obj0,&obj1)) SWIG_fail;
4506
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0 | 0 );
4507
if (!SWIG_IsOK(res1)) {
4508
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatsimplevector_resize" "', argument " "1"" of type '" "EST_TSimpleVector< float > *""'");
4509
}
4510
arg1 = reinterpret_cast< EST_TSimpleVector< float > * >(argp1);
4511
ecode2 = SWIG_AsVal_int(obj1, &val2);
4512
if (!SWIG_IsOK(ecode2)) {
4513
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatsimplevector_resize" "', argument " "2"" of type '" "int""'");
4514
}
4515
arg2 = static_cast< int >(val2);
4516
(arg1)->resize(arg2);
4517
resultobj = SWIG_Py_Void();
4518
return resultobj;
4519
fail:
4520
return NULL;
4521
}
4522
4523
4524
SWIGINTERN PyObject *_wrap_floatsimplevector_resize(PyObject *self, PyObject *args) {
4525
int argc;
4526
PyObject *argv[4];
4527
int ii;
4528
4529
if (!PyTuple_Check(args)) SWIG_fail;
4530
argc = (int)PyObject_Length(args);
4531
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4532
argv[ii] = PyTuple_GET_ITEM(args,ii);
4533
}
4534
if (argc == 2) {
4535
int _v;
4536
void *vptr = 0;
4537
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0);
4538
_v = SWIG_CheckState(res);
4539
if (_v) {
4540
{
4541
int res = SWIG_AsVal_int(argv[1], NULL);
4542
_v = SWIG_CheckState(res);
4543
}
4544
if (_v) {
4545
return _wrap_floatsimplevector_resize__SWIG_1(self, args);
4546
}
4547
}
4548
}
4549
if (argc == 3) {
4550
int _v;
4551
void *vptr = 0;
4552
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0);
4553
_v = SWIG_CheckState(res);
4554
if (_v) {
4555
{
4556
int res = SWIG_AsVal_int(argv[1], NULL);
4557
_v = SWIG_CheckState(res);
4558
}
4559
if (_v) {
4560
{
4561
int res = SWIG_AsVal_int(argv[2], NULL);
4562
_v = SWIG_CheckState(res);
4563
}
4564
if (_v) {
4565
return _wrap_floatsimplevector_resize__SWIG_0(self, args);
4566
}
4567
}
4568
}
4569
}
4570
4571
fail:
4572
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'floatsimplevector_resize'.\n"
4573
" Possible C/C++ prototypes are:\n"
4574
" resize(EST_TSimpleVector< float > *,int,int)\n"
4575
" resize(EST_TSimpleVector< float > *,int)\n");
4576
return NULL;
4577
}
4578
4579
4580
SWIGINTERN PyObject *_wrap_floatsimplevector_copy_section__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4581
PyObject *resultobj = 0;
4582
EST_TSimpleVector< float > *arg1 = (EST_TSimpleVector< float > *) 0 ;
4583
float *arg2 = (float *) 0 ;
4584
int arg3 ;
4585
int arg4 ;
4586
void *argp1 = 0 ;
4587
int res1 = 0 ;
4588
void *argp2 = 0 ;
4589
int res2 = 0 ;
4590
int val3 ;
4591
int ecode3 = 0 ;
4592
int val4 ;
4593
int ecode4 = 0 ;
4594
PyObject * obj0 = 0 ;
4595
PyObject * obj1 = 0 ;
4596
PyObject * obj2 = 0 ;
4597
PyObject * obj3 = 0 ;
4598
4599
if (!PyArg_ParseTuple(args,(char *)"OOOO:floatsimplevector_copy_section",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4600
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0 | 0 );
4601
if (!SWIG_IsOK(res1)) {
4602
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatsimplevector_copy_section" "', argument " "1"" of type '" "EST_TSimpleVector< float > const *""'");
4603
}
4604
arg1 = reinterpret_cast< EST_TSimpleVector< float > * >(argp1);
4605
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
4606
if (!SWIG_IsOK(res2)) {
4607
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "floatsimplevector_copy_section" "', argument " "2"" of type '" "float *""'");
4608
}
4609
arg2 = reinterpret_cast< float * >(argp2);
4610
ecode3 = SWIG_AsVal_int(obj2, &val3);
4611
if (!SWIG_IsOK(ecode3)) {
4612
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatsimplevector_copy_section" "', argument " "3"" of type '" "int""'");
4613
}
4614
arg3 = static_cast< int >(val3);
4615
ecode4 = SWIG_AsVal_int(obj3, &val4);
4616
if (!SWIG_IsOK(ecode4)) {
4617
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "floatsimplevector_copy_section" "', argument " "4"" of type '" "int""'");
4618
}
4619
arg4 = static_cast< int >(val4);
4620
((EST_TSimpleVector< float > const *)arg1)->copy_section(arg2,arg3,arg4);
4621
resultobj = SWIG_Py_Void();
4622
return resultobj;
4623
fail:
4624
return NULL;
4625
}
4626
4627
4628
SWIGINTERN PyObject *_wrap_floatsimplevector_copy_section__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4629
PyObject *resultobj = 0;
4630
EST_TSimpleVector< float > *arg1 = (EST_TSimpleVector< float > *) 0 ;
4631
float *arg2 = (float *) 0 ;
4632
int arg3 ;
4633
void *argp1 = 0 ;
4634
int res1 = 0 ;
4635
void *argp2 = 0 ;
4636
int res2 = 0 ;
4637
int val3 ;
4638
int ecode3 = 0 ;
4639
PyObject * obj0 = 0 ;
4640
PyObject * obj1 = 0 ;
4641
PyObject * obj2 = 0 ;
4642
4643
if (!PyArg_ParseTuple(args,(char *)"OOO:floatsimplevector_copy_section",&obj0,&obj1,&obj2)) SWIG_fail;
4644
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0 | 0 );
4645
if (!SWIG_IsOK(res1)) {
4646
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatsimplevector_copy_section" "', argument " "1"" of type '" "EST_TSimpleVector< float > const *""'");
4647
}
4648
arg1 = reinterpret_cast< EST_TSimpleVector< float > * >(argp1);
4649
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
4650
if (!SWIG_IsOK(res2)) {
4651
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "floatsimplevector_copy_section" "', argument " "2"" of type '" "float *""'");
4652
}
4653
arg2 = reinterpret_cast< float * >(argp2);
4654
ecode3 = SWIG_AsVal_int(obj2, &val3);
4655
if (!SWIG_IsOK(ecode3)) {
4656
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatsimplevector_copy_section" "', argument " "3"" of type '" "int""'");
4657
}
4658
arg3 = static_cast< int >(val3);
4659
((EST_TSimpleVector< float > const *)arg1)->copy_section(arg2,arg3);
4660
resultobj = SWIG_Py_Void();
4661
return resultobj;
4662
fail:
4663
return NULL;
4664
}
4665
4666
4667
SWIGINTERN PyObject *_wrap_floatsimplevector_copy_section__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4668
PyObject *resultobj = 0;
4669
EST_TSimpleVector< float > *arg1 = (EST_TSimpleVector< float > *) 0 ;
4670
float *arg2 = (float *) 0 ;
4671
void *argp1 = 0 ;
4672
int res1 = 0 ;
4673
void *argp2 = 0 ;
4674
int res2 = 0 ;
4675
PyObject * obj0 = 0 ;
4676
PyObject * obj1 = 0 ;
4677
4678
if (!PyArg_ParseTuple(args,(char *)"OO:floatsimplevector_copy_section",&obj0,&obj1)) SWIG_fail;
4679
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0 | 0 );
4680
if (!SWIG_IsOK(res1)) {
4681
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatsimplevector_copy_section" "', argument " "1"" of type '" "EST_TSimpleVector< float > const *""'");
4682
}
4683
arg1 = reinterpret_cast< EST_TSimpleVector< float > * >(argp1);
4684
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
4685
if (!SWIG_IsOK(res2)) {
4686
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "floatsimplevector_copy_section" "', argument " "2"" of type '" "float *""'");
4687
}
4688
arg2 = reinterpret_cast< float * >(argp2);
4689
((EST_TSimpleVector< float > const *)arg1)->copy_section(arg2);
4690
resultobj = SWIG_Py_Void();
4691
return resultobj;
4692
fail:
4693
return NULL;
4694
}
4695
4696
4697
SWIGINTERN PyObject *_wrap_floatsimplevector_copy_section(PyObject *self, PyObject *args) {
4698
int argc;
4699
PyObject *argv[5];
4700
int ii;
4701
4702
if (!PyTuple_Check(args)) SWIG_fail;
4703
argc = (int)PyObject_Length(args);
4704
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
4705
argv[ii] = PyTuple_GET_ITEM(args,ii);
4706
}
4707
if (argc == 2) {
4708
int _v;
4709
void *vptr = 0;
4710
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0);
4711
_v = SWIG_CheckState(res);
4712
if (_v) {
4713
void *vptr = 0;
4714
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
4715
_v = SWIG_CheckState(res);
4716
if (_v) {
4717
return _wrap_floatsimplevector_copy_section__SWIG_2(self, args);
4718
}
4719
}
4720
}
4721
if (argc == 3) {
4722
int _v;
4723
void *vptr = 0;
4724
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0);
4725
_v = SWIG_CheckState(res);
4726
if (_v) {
4727
void *vptr = 0;
4728
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
4729
_v = SWIG_CheckState(res);
4730
if (_v) {
4731
{
4732
int res = SWIG_AsVal_int(argv[2], NULL);
4733
_v = SWIG_CheckState(res);
4734
}
4735
if (_v) {
4736
return _wrap_floatsimplevector_copy_section__SWIG_1(self, args);
4737
}
4738
}
4739
}
4740
}
4741
if (argc == 4) {
4742
int _v;
4743
void *vptr = 0;
4744
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0);
4745
_v = SWIG_CheckState(res);
4746
if (_v) {
4747
void *vptr = 0;
4748
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
4749
_v = SWIG_CheckState(res);
4750
if (_v) {
4751
{
4752
int res = SWIG_AsVal_int(argv[2], NULL);
4753
_v = SWIG_CheckState(res);
4754
}
4755
if (_v) {
4756
{
4757
int res = SWIG_AsVal_int(argv[3], NULL);
4758
_v = SWIG_CheckState(res);
4759
}
4760
if (_v) {
4761
return _wrap_floatsimplevector_copy_section__SWIG_0(self, args);
4762
}
4763
}
4764
}
4765
}
4766
}
4767
4768
fail:
4769
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'floatsimplevector_copy_section'.\n"
4770
" Possible C/C++ prototypes are:\n"
4771
" copy_section(EST_TSimpleVector< float > const *,float *,int,int)\n"
4772
" copy_section(EST_TSimpleVector< float > const *,float *,int)\n"
4773
" copy_section(EST_TSimpleVector< float > const *,float *)\n");
4774
return NULL;
4775
}
4776
4777
4778
SWIGINTERN PyObject *_wrap_floatsimplevector_set_section__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4779
PyObject *resultobj = 0;
4780
EST_TSimpleVector< float > *arg1 = (EST_TSimpleVector< float > *) 0 ;
4781
float *arg2 = (float *) 0 ;
4782
int arg3 ;
4783
int arg4 ;
4784
void *argp1 = 0 ;
4785
int res1 = 0 ;
4786
void *argp2 = 0 ;
4787
int res2 = 0 ;
4788
int val3 ;
4789
int ecode3 = 0 ;
4790
int val4 ;
4791
int ecode4 = 0 ;
4792
PyObject * obj0 = 0 ;
4793
PyObject * obj1 = 0 ;
4794
PyObject * obj2 = 0 ;
4795
PyObject * obj3 = 0 ;
4796
4797
if (!PyArg_ParseTuple(args,(char *)"OOOO:floatsimplevector_set_section",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4798
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0 | 0 );
4799
if (!SWIG_IsOK(res1)) {
4800
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatsimplevector_set_section" "', argument " "1"" of type '" "EST_TSimpleVector< float > *""'");
4801
}
4802
arg1 = reinterpret_cast< EST_TSimpleVector< float > * >(argp1);
4803
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
4804
if (!SWIG_IsOK(res2)) {
4805
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "floatsimplevector_set_section" "', argument " "2"" of type '" "float const *""'");
4806
}
4807
arg2 = reinterpret_cast< float * >(argp2);
4808
ecode3 = SWIG_AsVal_int(obj2, &val3);
4809
if (!SWIG_IsOK(ecode3)) {
4810
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatsimplevector_set_section" "', argument " "3"" of type '" "int""'");
4811
}
4812
arg3 = static_cast< int >(val3);
4813
ecode4 = SWIG_AsVal_int(obj3, &val4);
4814
if (!SWIG_IsOK(ecode4)) {
4815
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "floatsimplevector_set_section" "', argument " "4"" of type '" "int""'");
4816
}
4817
arg4 = static_cast< int >(val4);
4818
(arg1)->set_section((float const *)arg2,arg3,arg4);
4819
resultobj = SWIG_Py_Void();
4820
return resultobj;
4821
fail:
4822
return NULL;
4823
}
4824
4825
4826
SWIGINTERN PyObject *_wrap_floatsimplevector_set_section__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4827
PyObject *resultobj = 0;
4828
EST_TSimpleVector< float > *arg1 = (EST_TSimpleVector< float > *) 0 ;
4829
float *arg2 = (float *) 0 ;
4830
int arg3 ;
4831
void *argp1 = 0 ;
4832
int res1 = 0 ;
4833
void *argp2 = 0 ;
4834
int res2 = 0 ;
4835
int val3 ;
4836
int ecode3 = 0 ;
4837
PyObject * obj0 = 0 ;
4838
PyObject * obj1 = 0 ;
4839
PyObject * obj2 = 0 ;
4840
4841
if (!PyArg_ParseTuple(args,(char *)"OOO:floatsimplevector_set_section",&obj0,&obj1,&obj2)) SWIG_fail;
4842
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0 | 0 );
4843
if (!SWIG_IsOK(res1)) {
4844
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatsimplevector_set_section" "', argument " "1"" of type '" "EST_TSimpleVector< float > *""'");
4845
}
4846
arg1 = reinterpret_cast< EST_TSimpleVector< float > * >(argp1);
4847
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
4848
if (!SWIG_IsOK(res2)) {
4849
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "floatsimplevector_set_section" "', argument " "2"" of type '" "float const *""'");
4850
}
4851
arg2 = reinterpret_cast< float * >(argp2);
4852
ecode3 = SWIG_AsVal_int(obj2, &val3);
4853
if (!SWIG_IsOK(ecode3)) {
4854
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatsimplevector_set_section" "', argument " "3"" of type '" "int""'");
4855
}
4856
arg3 = static_cast< int >(val3);
4857
(arg1)->set_section((float const *)arg2,arg3);
4858
resultobj = SWIG_Py_Void();
4859
return resultobj;
4860
fail:
4861
return NULL;
4862
}
4863
4864
4865
SWIGINTERN PyObject *_wrap_floatsimplevector_set_section__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4866
PyObject *resultobj = 0;
4867
EST_TSimpleVector< float > *arg1 = (EST_TSimpleVector< float > *) 0 ;
4868
float *arg2 = (float *) 0 ;
4869
void *argp1 = 0 ;
4870
int res1 = 0 ;
4871
void *argp2 = 0 ;
4872
int res2 = 0 ;
4873
PyObject * obj0 = 0 ;
4874
PyObject * obj1 = 0 ;
4875
4876
if (!PyArg_ParseTuple(args,(char *)"OO:floatsimplevector_set_section",&obj0,&obj1)) SWIG_fail;
4877
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0 | 0 );
4878
if (!SWIG_IsOK(res1)) {
4879
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatsimplevector_set_section" "', argument " "1"" of type '" "EST_TSimpleVector< float > *""'");
4880
}
4881
arg1 = reinterpret_cast< EST_TSimpleVector< float > * >(argp1);
4882
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
4883
if (!SWIG_IsOK(res2)) {
4884
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "floatsimplevector_set_section" "', argument " "2"" of type '" "float const *""'");
4885
}
4886
arg2 = reinterpret_cast< float * >(argp2);
4887
(arg1)->set_section((float const *)arg2);
4888
resultobj = SWIG_Py_Void();
4889
return resultobj;
4890
fail:
4891
return NULL;
4892
}
4893
4894
4895
SWIGINTERN PyObject *_wrap_floatsimplevector_set_section(PyObject *self, PyObject *args) {
4896
int argc;
4897
PyObject *argv[5];
4898
int ii;
4899
4900
if (!PyTuple_Check(args)) SWIG_fail;
4901
argc = (int)PyObject_Length(args);
4902
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
4903
argv[ii] = PyTuple_GET_ITEM(args,ii);
4904
}
4905
if (argc == 2) {
4906
int _v;
4907
void *vptr = 0;
4908
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0);
4909
_v = SWIG_CheckState(res);
4910
if (_v) {
4911
void *vptr = 0;
4912
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
4913
_v = SWIG_CheckState(res);
4914
if (_v) {
4915
return _wrap_floatsimplevector_set_section__SWIG_2(self, args);
4916
}
4917
}
4918
}
4919
if (argc == 3) {
4920
int _v;
4921
void *vptr = 0;
4922
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0);
4923
_v = SWIG_CheckState(res);
4924
if (_v) {
4925
void *vptr = 0;
4926
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
4927
_v = SWIG_CheckState(res);
4928
if (_v) {
4929
{
4930
int res = SWIG_AsVal_int(argv[2], NULL);
4931
_v = SWIG_CheckState(res);
4932
}
4933
if (_v) {
4934
return _wrap_floatsimplevector_set_section__SWIG_1(self, args);
4935
}
4936
}
4937
}
4938
}
4939
if (argc == 4) {
4940
int _v;
4941
void *vptr = 0;
4942
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0);
4943
_v = SWIG_CheckState(res);
4944
if (_v) {
4945
void *vptr = 0;
4946
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
4947
_v = SWIG_CheckState(res);
4948
if (_v) {
4949
{
4950
int res = SWIG_AsVal_int(argv[2], NULL);
4951
_v = SWIG_CheckState(res);
4952
}
4953
if (_v) {
4954
{
4955
int res = SWIG_AsVal_int(argv[3], NULL);
4956
_v = SWIG_CheckState(res);
4957
}
4958
if (_v) {
4959
return _wrap_floatsimplevector_set_section__SWIG_0(self, args);
4960
}
4961
}
4962
}
4963
}
4964
}
4965
4966
fail:
4967
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'floatsimplevector_set_section'.\n"
4968
" Possible C/C++ prototypes are:\n"
4969
" set_section(EST_TSimpleVector< float > *,float const *,int,int)\n"
4970
" set_section(EST_TSimpleVector< float > *,float const *,int)\n"
4971
" set_section(EST_TSimpleVector< float > *,float const *)\n");
4972
return NULL;
4973
}
4974
4975
4976
SWIGINTERN PyObject *_wrap_floatsimplevector_zero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4977
PyObject *resultobj = 0;
4978
EST_TSimpleVector< float > *arg1 = (EST_TSimpleVector< float > *) 0 ;
4979
void *argp1 = 0 ;
4980
int res1 = 0 ;
4981
PyObject * obj0 = 0 ;
4982
4983
if (!PyArg_ParseTuple(args,(char *)"O:floatsimplevector_zero",&obj0)) SWIG_fail;
4984
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0 | 0 );
4985
if (!SWIG_IsOK(res1)) {
4986
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatsimplevector_zero" "', argument " "1"" of type '" "EST_TSimpleVector< float > *""'");
4987
}
4988
arg1 = reinterpret_cast< EST_TSimpleVector< float > * >(argp1);
4989
(arg1)->zero();
4990
resultobj = SWIG_Py_Void();
4991
return resultobj;
4992
fail:
4993
return NULL;
4994
}
4995
4996
4997
SWIGINTERN PyObject *_wrap_floatsimplevector_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4998
PyObject *resultobj = 0;
4999
EST_TSimpleVector< float > *arg1 = (EST_TSimpleVector< float > *) 0 ;
5000
void *argp1 = 0 ;
5001
int res1 = 0 ;
5002
PyObject * obj0 = 0 ;
5003
5004
if (!PyArg_ParseTuple(args,(char *)"O:floatsimplevector_empty",&obj0)) SWIG_fail;
5005
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TSimpleVectorT_float_t, 0 | 0 );
5006
if (!SWIG_IsOK(res1)) {
5007
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatsimplevector_empty" "', argument " "1"" of type '" "EST_TSimpleVector< float > *""'");
5008
}
5009
arg1 = reinterpret_cast< EST_TSimpleVector< float > * >(argp1);
5010
(arg1)->empty();
5011
resultobj = SWIG_Py_Void();
5012
return resultobj;
5013
fail:
5014
return NULL;
5015
}
5016
5017
5018
SWIGINTERN PyObject *_wrap_delete_floatsimplevector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5019
PyObject *resultobj = 0;
5020
EST_TSimpleVector< float > *arg1 = (EST_TSimpleVector< float > *) 0 ;
5021
void *argp1 = 0 ;
5022
int res1 = 0 ;
5023
PyObject * obj0 = 0 ;
5024
5025
if (!PyArg_ParseTuple(args,(char *)"O:delete_floatsimplevector",&obj0)) SWIG_fail;
5026
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_TSimpleVectorT_float_t, SWIG_POINTER_DISOWN | 0 );
5027
if (!SWIG_IsOK(res1)) {
5028
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_floatsimplevector" "', argument " "1"" of type '" "EST_TSimpleVector< float > *""'");
5029
}
5030
arg1 = reinterpret_cast< EST_TSimpleVector< float > * >(argp1);
5031
delete arg1;
5032
resultobj = SWIG_Py_Void();
5033
return resultobj;
5034
fail:
5035
return NULL;
5036
}
5037
5038
5039
SWIGINTERN PyObject *floatsimplevector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5040
PyObject *obj;
5041
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5042
SWIG_TypeNewClientData(SWIGTYPE_p_EST_TSimpleVectorT_float_t, SWIG_NewClientData(obj));
5043
return SWIG_Py_Void();
5044
}
5045
5046
SWIGINTERN PyObject *_wrap_new_EST_FVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5047
PyObject *resultobj = 0;
5048
EST_FVector *result = 0 ;
5049
5050
if (!PyArg_ParseTuple(args,(char *)":new_EST_FVector")) SWIG_fail;
5051
result = (EST_FVector *)new EST_FVector();
5052
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_FVector, SWIG_POINTER_NEW | 0 );
5053
return resultobj;
5054
fail:
5055
return NULL;
5056
}
5057
5058
5059
SWIGINTERN PyObject *_wrap_new_EST_FVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5060
PyObject *resultobj = 0;
5061
EST_FVector *arg1 = 0 ;
5062
void *argp1 = 0 ;
5063
int res1 = 0 ;
5064
PyObject * obj0 = 0 ;
5065
EST_FVector *result = 0 ;
5066
5067
if (!PyArg_ParseTuple(args,(char *)"O:new_EST_FVector",&obj0)) SWIG_fail;
5068
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_FVector, 0 | 0);
5069
if (!SWIG_IsOK(res1)) {
5070
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EST_FVector" "', argument " "1"" of type '" "EST_FVector const &""'");
5071
}
5072
if (!argp1) {
5073
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EST_FVector" "', argument " "1"" of type '" "EST_FVector const &""'");
5074
}
5075
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5076
result = (EST_FVector *)new EST_FVector((EST_FVector const &)*arg1);
5077
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_FVector, SWIG_POINTER_NEW | 0 );
5078
return resultobj;
5079
fail:
5080
return NULL;
5081
}
5082
5083
5084
SWIGINTERN PyObject *_wrap_new_EST_FVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5085
PyObject *resultobj = 0;
5086
int arg1 ;
5087
int val1 ;
5088
int ecode1 = 0 ;
5089
PyObject * obj0 = 0 ;
5090
EST_FVector *result = 0 ;
5091
5092
if (!PyArg_ParseTuple(args,(char *)"O:new_EST_FVector",&obj0)) SWIG_fail;
5093
ecode1 = SWIG_AsVal_int(obj0, &val1);
5094
if (!SWIG_IsOK(ecode1)) {
5095
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EST_FVector" "', argument " "1"" of type '" "int""'");
5096
}
5097
arg1 = static_cast< int >(val1);
5098
result = (EST_FVector *)new EST_FVector(arg1);
5099
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_FVector, SWIG_POINTER_NEW | 0 );
5100
return resultobj;
5101
fail:
5102
return NULL;
5103
}
5104
5105
5106
SWIGINTERN PyObject *_wrap_new_EST_FVector(PyObject *self, PyObject *args) {
5107
int argc;
5108
PyObject *argv[2];
5109
int ii;
5110
5111
if (!PyTuple_Check(args)) SWIG_fail;
5112
argc = (int)PyObject_Length(args);
5113
for (ii = 0; (ii < argc) && (ii < 1); ii++) {
5114
argv[ii] = PyTuple_GET_ITEM(args,ii);
5115
}
5116
if (argc == 0) {
5117
return _wrap_new_EST_FVector__SWIG_0(self, args);
5118
}
5119
if (argc == 1) {
5120
int _v;
5121
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_EST_FVector, 0);
5122
_v = SWIG_CheckState(res);
5123
if (_v) {
5124
return _wrap_new_EST_FVector__SWIG_1(self, args);
5125
}
5126
}
5127
if (argc == 1) {
5128
int _v;
5129
{
5130
int res = SWIG_AsVal_int(argv[0], NULL);
5131
_v = SWIG_CheckState(res);
5132
}
5133
if (_v) {
5134
return _wrap_new_EST_FVector__SWIG_2(self, args);
5135
}
5136
}
5137
5138
fail:
5139
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EST_FVector'.\n"
5140
" Possible C/C++ prototypes are:\n"
5141
" EST_FVector()\n"
5142
" EST_FVector(EST_FVector const &)\n"
5143
" EST_FVector(int)\n");
5144
return NULL;
5145
}
5146
5147
5148
SWIGINTERN PyObject *_wrap_EST_FVector___imul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5149
PyObject *resultobj = 0;
5150
EST_FVector *arg1 = (EST_FVector *) 0 ;
5151
EST_FVector *arg2 = 0 ;
5152
void *argp1 = 0 ;
5153
int res1 = 0 ;
5154
void *argp2 = 0 ;
5155
int res2 = 0 ;
5156
PyObject * obj0 = 0 ;
5157
PyObject * obj1 = 0 ;
5158
EST_FVector *result = 0 ;
5159
5160
if (!PyArg_ParseTuple(args,(char *)"OO:EST_FVector___imul__",&obj0,&obj1)) SWIG_fail;
5161
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_FVector, SWIG_POINTER_DISOWN | 0 );
5162
if (!SWIG_IsOK(res1)) {
5163
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_FVector___imul__" "', argument " "1"" of type '" "EST_FVector *""'");
5164
}
5165
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5166
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_FVector, 0 | 0);
5167
if (!SWIG_IsOK(res2)) {
5168
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EST_FVector___imul__" "', argument " "2"" of type '" "EST_FVector const &""'");
5169
}
5170
if (!argp2) {
5171
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EST_FVector___imul__" "', argument " "2"" of type '" "EST_FVector const &""'");
5172
}
5173
arg2 = reinterpret_cast< EST_FVector * >(argp2);
5174
result = (EST_FVector *) &(arg1)->operator *=((EST_FVector const &)*arg2);
5175
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_FVector, SWIG_POINTER_OWN | 0 );
5176
return resultobj;
5177
fail:
5178
return NULL;
5179
}
5180
5181
5182
SWIGINTERN PyObject *_wrap_EST_FVector___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5183
PyObject *resultobj = 0;
5184
EST_FVector *arg1 = (EST_FVector *) 0 ;
5185
EST_FVector *arg2 = 0 ;
5186
void *argp1 = 0 ;
5187
int res1 = 0 ;
5188
void *argp2 = 0 ;
5189
int res2 = 0 ;
5190
PyObject * obj0 = 0 ;
5191
PyObject * obj1 = 0 ;
5192
EST_FVector *result = 0 ;
5193
5194
if (!PyArg_ParseTuple(args,(char *)"OO:EST_FVector___iadd__",&obj0,&obj1)) SWIG_fail;
5195
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_FVector, SWIG_POINTER_DISOWN | 0 );
5196
if (!SWIG_IsOK(res1)) {
5197
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_FVector___iadd__" "', argument " "1"" of type '" "EST_FVector *""'");
5198
}
5199
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5200
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_FVector, 0 | 0);
5201
if (!SWIG_IsOK(res2)) {
5202
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EST_FVector___iadd__" "', argument " "2"" of type '" "EST_FVector const &""'");
5203
}
5204
if (!argp2) {
5205
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EST_FVector___iadd__" "', argument " "2"" of type '" "EST_FVector const &""'");
5206
}
5207
arg2 = reinterpret_cast< EST_FVector * >(argp2);
5208
result = (EST_FVector *) &(arg1)->operator +=((EST_FVector const &)*arg2);
5209
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_FVector, SWIG_POINTER_OWN | 0 );
5210
return resultobj;
5211
fail:
5212
return NULL;
5213
}
5214
5215
5216
SWIGINTERN PyObject *_wrap_EST_FVector___imul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5217
PyObject *resultobj = 0;
5218
EST_FVector *arg1 = (EST_FVector *) 0 ;
5219
float arg2 ;
5220
void *argp1 = 0 ;
5221
int res1 = 0 ;
5222
float val2 ;
5223
int ecode2 = 0 ;
5224
PyObject * obj0 = 0 ;
5225
PyObject * obj1 = 0 ;
5226
EST_FVector *result = 0 ;
5227
5228
if (!PyArg_ParseTuple(args,(char *)"OO:EST_FVector___imul__",&obj0,&obj1)) SWIG_fail;
5229
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_FVector, SWIG_POINTER_DISOWN | 0 );
5230
if (!SWIG_IsOK(res1)) {
5231
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_FVector___imul__" "', argument " "1"" of type '" "EST_FVector *""'");
5232
}
5233
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5234
ecode2 = SWIG_AsVal_float(obj1, &val2);
5235
if (!SWIG_IsOK(ecode2)) {
5236
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_FVector___imul__" "', argument " "2"" of type '" "float""'");
5237
}
5238
arg2 = static_cast< float >(val2);
5239
result = (EST_FVector *) &(arg1)->operator *=(arg2);
5240
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_FVector, SWIG_POINTER_OWN | 0 );
5241
return resultobj;
5242
fail:
5243
return NULL;
5244
}
5245
5246
5247
SWIGINTERN PyObject *_wrap_EST_FVector___imul__(PyObject *self, PyObject *args) {
5248
int argc;
5249
PyObject *argv[3];
5250
int ii;
5251
5252
if (!PyTuple_Check(args)) SWIG_fail;
5253
argc = (int)PyObject_Length(args);
5254
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5255
argv[ii] = PyTuple_GET_ITEM(args,ii);
5256
}
5257
if (argc == 2) {
5258
int _v;
5259
void *vptr = 0;
5260
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_FVector, 0);
5261
_v = SWIG_CheckState(res);
5262
if (_v) {
5263
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_EST_FVector, 0);
5264
_v = SWIG_CheckState(res);
5265
if (_v) {
5266
return _wrap_EST_FVector___imul____SWIG_0(self, args);
5267
}
5268
}
5269
}
5270
if (argc == 2) {
5271
int _v;
5272
void *vptr = 0;
5273
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_FVector, 0);
5274
_v = SWIG_CheckState(res);
5275
if (_v) {
5276
{
5277
int res = SWIG_AsVal_float(argv[1], NULL);
5278
_v = SWIG_CheckState(res);
5279
}
5280
if (_v) {
5281
return _wrap_EST_FVector___imul____SWIG_1(self, args);
5282
}
5283
}
5284
}
5285
5286
fail:
5287
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EST_FVector___imul__'.\n"
5288
" Possible C/C++ prototypes are:\n"
5289
" operator *=(EST_FVector *,EST_FVector const &)\n"
5290
" operator *=(EST_FVector *,float)\n");
5291
return NULL;
5292
}
5293
5294
5295
SWIGINTERN PyObject *_wrap_EST_FVector___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5296
PyObject *resultobj = 0;
5297
EST_FVector *arg1 = (EST_FVector *) 0 ;
5298
float arg2 ;
5299
void *argp1 = 0 ;
5300
int res1 = 0 ;
5301
float val2 ;
5302
int ecode2 = 0 ;
5303
PyObject * obj0 = 0 ;
5304
PyObject * obj1 = 0 ;
5305
EST_FVector *result = 0 ;
5306
5307
if (!PyArg_ParseTuple(args,(char *)"OO:EST_FVector___idiv__",&obj0,&obj1)) SWIG_fail;
5308
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_FVector, SWIG_POINTER_DISOWN | 0 );
5309
if (!SWIG_IsOK(res1)) {
5310
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_FVector___idiv__" "', argument " "1"" of type '" "EST_FVector *""'");
5311
}
5312
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5313
ecode2 = SWIG_AsVal_float(obj1, &val2);
5314
if (!SWIG_IsOK(ecode2)) {
5315
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_FVector___idiv__" "', argument " "2"" of type '" "float""'");
5316
}
5317
arg2 = static_cast< float >(val2);
5318
result = (EST_FVector *) &(arg1)->operator /=(arg2);
5319
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_FVector, SWIG_POINTER_OWN | 0 );
5320
return resultobj;
5321
fail:
5322
return NULL;
5323
}
5324
5325
5326
SWIGINTERN PyObject *_wrap_EST_FVector_est_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5327
PyObject *resultobj = 0;
5328
EST_FVector *arg1 = (EST_FVector *) 0 ;
5329
EST_String *arg2 = 0 ;
5330
EST_String *arg3 = 0 ;
5331
void *argp1 = 0 ;
5332
int res1 = 0 ;
5333
EST_String temp2 ;
5334
EST_String temp3 ;
5335
PyObject * obj0 = 0 ;
5336
PyObject * obj1 = 0 ;
5337
PyObject * obj2 = 0 ;
5338
EST_write_status result;
5339
5340
if (!PyArg_ParseTuple(args,(char *)"OOO:EST_FVector_est_save",&obj0,&obj1,&obj2)) SWIG_fail;
5341
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_FVector, 0 | 0 );
5342
if (!SWIG_IsOK(res1)) {
5343
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_FVector_est_save" "', argument " "1"" of type '" "EST_FVector *""'");
5344
}
5345
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5346
{
5347
char *str; Py_ssize_t len;
5348
PyString_AsStringAndSize(obj1, &str, &len);
5349
temp2 = EST_String( str, len, 0, len );
5350
arg2 = &temp2;
5351
}
5352
{
5353
char *str; Py_ssize_t len;
5354
PyString_AsStringAndSize(obj2, &str, &len);
5355
temp3 = EST_String( str, len, 0, len );
5356
arg3 = &temp3;
5357
}
5358
result = (EST_write_status)(arg1)->est_save((EST_String const &)*arg2,(EST_String const &)*arg3);
5359
resultobj = SWIG_From_int(static_cast< int >(result));
5360
return resultobj;
5361
fail:
5362
return NULL;
5363
}
5364
5365
5366
SWIGINTERN PyObject *_wrap_EST_FVector_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5367
PyObject *resultobj = 0;
5368
EST_FVector *arg1 = (EST_FVector *) 0 ;
5369
EST_String *arg2 = 0 ;
5370
EST_String *arg3 = 0 ;
5371
void *argp1 = 0 ;
5372
int res1 = 0 ;
5373
EST_String temp2 ;
5374
EST_String temp3 ;
5375
PyObject * obj0 = 0 ;
5376
PyObject * obj1 = 0 ;
5377
PyObject * obj2 = 0 ;
5378
EST_write_status result;
5379
5380
if (!PyArg_ParseTuple(args,(char *)"OOO:EST_FVector_save",&obj0,&obj1,&obj2)) SWIG_fail;
5381
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_FVector, 0 | 0 );
5382
if (!SWIG_IsOK(res1)) {
5383
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_FVector_save" "', argument " "1"" of type '" "EST_FVector *""'");
5384
}
5385
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5386
{
5387
char *str; Py_ssize_t len;
5388
PyString_AsStringAndSize(obj1, &str, &len);
5389
temp2 = EST_String( str, len, 0, len );
5390
arg2 = &temp2;
5391
}
5392
{
5393
char *str; Py_ssize_t len;
5394
PyString_AsStringAndSize(obj2, &str, &len);
5395
temp3 = EST_String( str, len, 0, len );
5396
arg3 = &temp3;
5397
}
5398
result = (EST_write_status)(arg1)->save((EST_String const &)*arg2,(EST_String const &)*arg3);
5399
resultobj = SWIG_From_int(static_cast< int >(result));
5400
return resultobj;
5401
fail:
5402
return NULL;
5403
}
5404
5405
5406
SWIGINTERN PyObject *_wrap_EST_FVector_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5407
PyObject *resultobj = 0;
5408
EST_FVector *arg1 = (EST_FVector *) 0 ;
5409
EST_String *arg2 = 0 ;
5410
void *argp1 = 0 ;
5411
int res1 = 0 ;
5412
EST_String temp2 ;
5413
PyObject * obj0 = 0 ;
5414
PyObject * obj1 = 0 ;
5415
EST_read_status result;
5416
5417
if (!PyArg_ParseTuple(args,(char *)"OO:EST_FVector_load",&obj0,&obj1)) SWIG_fail;
5418
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_FVector, 0 | 0 );
5419
if (!SWIG_IsOK(res1)) {
5420
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_FVector_load" "', argument " "1"" of type '" "EST_FVector *""'");
5421
}
5422
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5423
{
5424
char *str; Py_ssize_t len;
5425
PyString_AsStringAndSize(obj1, &str, &len);
5426
temp2 = EST_String( str, len, 0, len );
5427
arg2 = &temp2;
5428
}
5429
result = (EST_read_status)(arg1)->load((EST_String const &)*arg2);
5430
resultobj = SWIG_From_int(static_cast< int >(result));
5431
return resultobj;
5432
fail:
5433
return NULL;
5434
}
5435
5436
5437
SWIGINTERN PyObject *_wrap_EST_FVector_est_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5438
PyObject *resultobj = 0;
5439
EST_FVector *arg1 = (EST_FVector *) 0 ;
5440
EST_String *arg2 = 0 ;
5441
void *argp1 = 0 ;
5442
int res1 = 0 ;
5443
EST_String temp2 ;
5444
PyObject * obj0 = 0 ;
5445
PyObject * obj1 = 0 ;
5446
EST_read_status result;
5447
5448
if (!PyArg_ParseTuple(args,(char *)"OO:EST_FVector_est_load",&obj0,&obj1)) SWIG_fail;
5449
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_FVector, 0 | 0 );
5450
if (!SWIG_IsOK(res1)) {
5451
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_FVector_est_load" "', argument " "1"" of type '" "EST_FVector *""'");
5452
}
5453
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5454
{
5455
char *str; Py_ssize_t len;
5456
PyString_AsStringAndSize(obj1, &str, &len);
5457
temp2 = EST_String( str, len, 0, len );
5458
arg2 = &temp2;
5459
}
5460
result = (EST_read_status)(arg1)->est_load((EST_String const &)*arg2);
5461
resultobj = SWIG_From_int(static_cast< int >(result));
5462
return resultobj;
5463
fail:
5464
return NULL;
5465
}
5466
5467
5468
SWIGINTERN PyObject *_wrap_EST_FVector_randomise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5469
PyObject *resultobj = 0;
5470
EST_FVector *arg1 = (EST_FVector *) 0 ;
5471
float arg2 ;
5472
void *argp1 = 0 ;
5473
int res1 = 0 ;
5474
float val2 ;
5475
int ecode2 = 0 ;
5476
PyObject * obj0 = 0 ;
5477
PyObject * obj1 = 0 ;
5478
5479
if (!PyArg_ParseTuple(args,(char *)"OO:EST_FVector_randomise",&obj0,&obj1)) SWIG_fail;
5480
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_FVector, 0 | 0 );
5481
if (!SWIG_IsOK(res1)) {
5482
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_FVector_randomise" "', argument " "1"" of type '" "EST_FVector *""'");
5483
}
5484
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5485
ecode2 = SWIG_AsVal_float(obj1, &val2);
5486
if (!SWIG_IsOK(ecode2)) {
5487
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_FVector_randomise" "', argument " "2"" of type '" "float""'");
5488
}
5489
arg2 = static_cast< float >(val2);
5490
EST_FVector_randomise(arg1,arg2);
5491
resultobj = SWIG_Py_Void();
5492
return resultobj;
5493
fail:
5494
return NULL;
5495
}
5496
5497
5498
SWIGINTERN PyObject *_wrap_EST_FVector_sum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5499
PyObject *resultobj = 0;
5500
EST_FVector *arg1 = (EST_FVector *) 0 ;
5501
void *argp1 = 0 ;
5502
int res1 = 0 ;
5503
PyObject * obj0 = 0 ;
5504
float result;
5505
5506
if (!PyArg_ParseTuple(args,(char *)"O:EST_FVector_sum",&obj0)) SWIG_fail;
5507
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_FVector, 0 | 0 );
5508
if (!SWIG_IsOK(res1)) {
5509
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_FVector_sum" "', argument " "1"" of type '" "EST_FVector const *""'");
5510
}
5511
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5512
result = (float)EST_FVector_sum((EST_FVector const *)arg1);
5513
resultobj = SWIG_From_float(static_cast< float >(result));
5514
return resultobj;
5515
fail:
5516
return NULL;
5517
}
5518
5519
5520
SWIGINTERN PyObject *_wrap_delete_EST_FVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5521
PyObject *resultobj = 0;
5522
EST_FVector *arg1 = (EST_FVector *) 0 ;
5523
void *argp1 = 0 ;
5524
int res1 = 0 ;
5525
PyObject * obj0 = 0 ;
5526
5527
if (!PyArg_ParseTuple(args,(char *)"O:delete_EST_FVector",&obj0)) SWIG_fail;
5528
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_FVector, SWIG_POINTER_DISOWN | 0 );
5529
if (!SWIG_IsOK(res1)) {
5530
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EST_FVector" "', argument " "1"" of type '" "EST_FVector *""'");
5531
}
5532
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5533
delete arg1;
5534
resultobj = SWIG_Py_Void();
5535
return resultobj;
5536
fail:
5537
return NULL;
5538
}
5539
5540
5541
SWIGINTERN PyObject *EST_FVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5542
PyObject *obj;
5543
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5544
SWIG_TypeNewClientData(SWIGTYPE_p_EST_FVector, SWIG_NewClientData(obj));
5545
return SWIG_Py_Void();
5546
}
5547
5548
SWIGINTERN PyObject *_wrap_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5549
PyObject *resultobj = 0;
5550
EST_FVector *arg1 = 0 ;
5551
EST_FVector *arg2 = 0 ;
5552
void *argp1 = 0 ;
5553
int res1 = 0 ;
5554
void *argp2 = 0 ;
5555
int res2 = 0 ;
5556
PyObject * obj0 = 0 ;
5557
PyObject * obj1 = 0 ;
5558
EST_FVector result;
5559
5560
if (!PyArg_ParseTuple(args,(char *)"OO:add",&obj0,&obj1)) SWIG_fail;
5561
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_FVector, 0 | 0);
5562
if (!SWIG_IsOK(res1)) {
5563
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "add" "', argument " "1"" of type '" "EST_FVector const &""'");
5564
}
5565
if (!argp1) {
5566
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "add" "', argument " "1"" of type '" "EST_FVector const &""'");
5567
}
5568
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5569
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_FVector, 0 | 0);
5570
if (!SWIG_IsOK(res2)) {
5571
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "add" "', argument " "2"" of type '" "EST_FVector const &""'");
5572
}
5573
if (!argp2) {
5574
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "add" "', argument " "2"" of type '" "EST_FVector const &""'");
5575
}
5576
arg2 = reinterpret_cast< EST_FVector * >(argp2);
5577
result = add((EST_FVector const &)*arg1,(EST_FVector const &)*arg2);
5578
resultobj = SWIG_NewPointerObj((new EST_FVector(static_cast< const EST_FVector& >(result))), SWIGTYPE_p_EST_FVector, SWIG_POINTER_OWN | 0 );
5579
return resultobj;
5580
fail:
5581
return NULL;
5582
}
5583
5584
5585
SWIGINTERN PyObject *_wrap_subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5586
PyObject *resultobj = 0;
5587
EST_FVector *arg1 = 0 ;
5588
EST_FVector *arg2 = 0 ;
5589
void *argp1 = 0 ;
5590
int res1 = 0 ;
5591
void *argp2 = 0 ;
5592
int res2 = 0 ;
5593
PyObject * obj0 = 0 ;
5594
PyObject * obj1 = 0 ;
5595
EST_FVector result;
5596
5597
if (!PyArg_ParseTuple(args,(char *)"OO:subtract",&obj0,&obj1)) SWIG_fail;
5598
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_FVector, 0 | 0);
5599
if (!SWIG_IsOK(res1)) {
5600
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "subtract" "', argument " "1"" of type '" "EST_FVector const &""'");
5601
}
5602
if (!argp1) {
5603
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "subtract" "', argument " "1"" of type '" "EST_FVector const &""'");
5604
}
5605
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5606
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_FVector, 0 | 0);
5607
if (!SWIG_IsOK(res2)) {
5608
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "subtract" "', argument " "2"" of type '" "EST_FVector const &""'");
5609
}
5610
if (!argp2) {
5611
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "subtract" "', argument " "2"" of type '" "EST_FVector const &""'");
5612
}
5613
arg2 = reinterpret_cast< EST_FVector * >(argp2);
5614
result = subtract((EST_FVector const &)*arg1,(EST_FVector const &)*arg2);
5615
resultobj = SWIG_NewPointerObj((new EST_FVector(static_cast< const EST_FVector& >(result))), SWIGTYPE_p_EST_FVector, SWIG_POINTER_OWN | 0 );
5616
return resultobj;
5617
fail:
5618
return NULL;
5619
}
5620
5621
5622
SWIGINTERN PyObject *_wrap_sqrt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5623
PyObject *resultobj = 0;
5624
EST_FVector *arg1 = 0 ;
5625
void *argp1 = 0 ;
5626
int res1 = 0 ;
5627
PyObject * obj0 = 0 ;
5628
EST_FVector *result = 0 ;
5629
5630
if (!PyArg_ParseTuple(args,(char *)"O:sqrt",&obj0)) SWIG_fail;
5631
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_FVector, 0 | 0);
5632
if (!SWIG_IsOK(res1)) {
5633
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqrt" "', argument " "1"" of type '" "EST_FVector const &""'");
5634
}
5635
if (!argp1) {
5636
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sqrt" "', argument " "1"" of type '" "EST_FVector const &""'");
5637
}
5638
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5639
result = (EST_FVector *)sqrt((EST_FVector const &)*arg1);
5640
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_FVector, SWIG_POINTER_OWN | 0 );
5641
return resultobj;
5642
fail:
5643
return NULL;
5644
}
5645
5646
5647
SWIGINTERN PyObject *_wrap_topower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5648
PyObject *resultobj = 0;
5649
EST_FVector *arg1 = 0 ;
5650
float arg2 ;
5651
void *argp1 = 0 ;
5652
int res1 = 0 ;
5653
float val2 ;
5654
int ecode2 = 0 ;
5655
PyObject * obj0 = 0 ;
5656
PyObject * obj1 = 0 ;
5657
EST_FVector *result = 0 ;
5658
5659
if (!PyArg_ParseTuple(args,(char *)"OO:topower",&obj0,&obj1)) SWIG_fail;
5660
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_FVector, 0 | 0);
5661
if (!SWIG_IsOK(res1)) {
5662
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "topower" "', argument " "1"" of type '" "EST_FVector const &""'");
5663
}
5664
if (!argp1) {
5665
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "topower" "', argument " "1"" of type '" "EST_FVector const &""'");
5666
}
5667
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5668
ecode2 = SWIG_AsVal_float(obj1, &val2);
5669
if (!SWIG_IsOK(ecode2)) {
5670
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "topower" "', argument " "2"" of type '" "float""'");
5671
}
5672
arg2 = static_cast< float >(val2);
5673
result = (EST_FVector *)topower((EST_FVector const &)*arg1,arg2);
5674
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_FVector, SWIG_POINTER_OWN | 0 );
5675
return resultobj;
5676
fail:
5677
return NULL;
5678
}
5679
5680
5681
SWIGINTERN PyObject *_wrap_polynomial_fit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5682
PyObject *resultobj = 0;
5683
EST_FVector *arg1 = 0 ;
5684
EST_FVector *arg2 = 0 ;
5685
EST_FVector *arg3 = 0 ;
5686
int arg4 ;
5687
void *argp1 = 0 ;
5688
int res1 = 0 ;
5689
void *argp2 = 0 ;
5690
int res2 = 0 ;
5691
void *argp3 = 0 ;
5692
int res3 = 0 ;
5693
int val4 ;
5694
int ecode4 = 0 ;
5695
PyObject * obj0 = 0 ;
5696
PyObject * obj1 = 0 ;
5697
PyObject * obj2 = 0 ;
5698
PyObject * obj3 = 0 ;
5699
bool result;
5700
5701
if (!PyArg_ParseTuple(args,(char *)"OOOO:polynomial_fit",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5702
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_FVector, 0 );
5703
if (!SWIG_IsOK(res1)) {
5704
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "polynomial_fit" "', argument " "1"" of type '" "EST_FVector &""'");
5705
}
5706
if (!argp1) {
5707
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polynomial_fit" "', argument " "1"" of type '" "EST_FVector &""'");
5708
}
5709
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5710
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_FVector, 0 );
5711
if (!SWIG_IsOK(res2)) {
5712
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "polynomial_fit" "', argument " "2"" of type '" "EST_FVector &""'");
5713
}
5714
if (!argp2) {
5715
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polynomial_fit" "', argument " "2"" of type '" "EST_FVector &""'");
5716
}
5717
arg2 = reinterpret_cast< EST_FVector * >(argp2);
5718
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_EST_FVector, 0 );
5719
if (!SWIG_IsOK(res3)) {
5720
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "polynomial_fit" "', argument " "3"" of type '" "EST_FVector &""'");
5721
}
5722
if (!argp3) {
5723
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polynomial_fit" "', argument " "3"" of type '" "EST_FVector &""'");
5724
}
5725
arg3 = reinterpret_cast< EST_FVector * >(argp3);
5726
ecode4 = SWIG_AsVal_int(obj3, &val4);
5727
if (!SWIG_IsOK(ecode4)) {
5728
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "polynomial_fit" "', argument " "4"" of type '" "int""'");
5729
}
5730
arg4 = static_cast< int >(val4);
5731
result = (bool)polynomial_fit(*arg1,*arg2,*arg3,arg4);
5732
resultobj = SWIG_From_bool(static_cast< bool >(result));
5733
return resultobj;
5734
fail:
5735
return NULL;
5736
}
5737
5738
5739
SWIGINTERN PyObject *_wrap_polynomial_fit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5740
PyObject *resultobj = 0;
5741
EST_FVector *arg1 = 0 ;
5742
EST_FVector *arg2 = 0 ;
5743
EST_FVector *arg3 = 0 ;
5744
EST_FVector *arg4 = 0 ;
5745
int arg5 ;
5746
void *argp1 = 0 ;
5747
int res1 = 0 ;
5748
void *argp2 = 0 ;
5749
int res2 = 0 ;
5750
void *argp3 = 0 ;
5751
int res3 = 0 ;
5752
void *argp4 = 0 ;
5753
int res4 = 0 ;
5754
int val5 ;
5755
int ecode5 = 0 ;
5756
PyObject * obj0 = 0 ;
5757
PyObject * obj1 = 0 ;
5758
PyObject * obj2 = 0 ;
5759
PyObject * obj3 = 0 ;
5760
PyObject * obj4 = 0 ;
5761
bool result;
5762
5763
if (!PyArg_ParseTuple(args,(char *)"OOOOO:polynomial_fit",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5764
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_FVector, 0 );
5765
if (!SWIG_IsOK(res1)) {
5766
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "polynomial_fit" "', argument " "1"" of type '" "EST_FVector &""'");
5767
}
5768
if (!argp1) {
5769
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polynomial_fit" "', argument " "1"" of type '" "EST_FVector &""'");
5770
}
5771
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5772
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_FVector, 0 );
5773
if (!SWIG_IsOK(res2)) {
5774
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "polynomial_fit" "', argument " "2"" of type '" "EST_FVector &""'");
5775
}
5776
if (!argp2) {
5777
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polynomial_fit" "', argument " "2"" of type '" "EST_FVector &""'");
5778
}
5779
arg2 = reinterpret_cast< EST_FVector * >(argp2);
5780
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_EST_FVector, 0 );
5781
if (!SWIG_IsOK(res3)) {
5782
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "polynomial_fit" "', argument " "3"" of type '" "EST_FVector &""'");
5783
}
5784
if (!argp3) {
5785
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polynomial_fit" "', argument " "3"" of type '" "EST_FVector &""'");
5786
}
5787
arg3 = reinterpret_cast< EST_FVector * >(argp3);
5788
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_EST_FVector, 0 );
5789
if (!SWIG_IsOK(res4)) {
5790
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "polynomial_fit" "', argument " "4"" of type '" "EST_FVector &""'");
5791
}
5792
if (!argp4) {
5793
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polynomial_fit" "', argument " "4"" of type '" "EST_FVector &""'");
5794
}
5795
arg4 = reinterpret_cast< EST_FVector * >(argp4);
5796
ecode5 = SWIG_AsVal_int(obj4, &val5);
5797
if (!SWIG_IsOK(ecode5)) {
5798
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "polynomial_fit" "', argument " "5"" of type '" "int""'");
5799
}
5800
arg5 = static_cast< int >(val5);
5801
result = (bool)polynomial_fit(*arg1,*arg2,*arg3,*arg4,arg5);
5802
resultobj = SWIG_From_bool(static_cast< bool >(result));
5803
return resultobj;
5804
fail:
5805
return NULL;
5806
}
5807
5808
5809
SWIGINTERN PyObject *_wrap_polynomial_fit(PyObject *self, PyObject *args) {
5810
int argc;
5811
PyObject *argv[6];
5812
int ii;
5813
5814
if (!PyTuple_Check(args)) SWIG_fail;
5815
argc = (int)PyObject_Length(args);
5816
for (ii = 0; (ii < argc) && (ii < 5); ii++) {
5817
argv[ii] = PyTuple_GET_ITEM(args,ii);
5818
}
5819
if (argc == 4) {
5820
int _v;
5821
void *vptr = 0;
5822
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_FVector, 0);
5823
_v = SWIG_CheckState(res);
5824
if (_v) {
5825
void *vptr = 0;
5826
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_EST_FVector, 0);
5827
_v = SWIG_CheckState(res);
5828
if (_v) {
5829
void *vptr = 0;
5830
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_EST_FVector, 0);
5831
_v = SWIG_CheckState(res);
5832
if (_v) {
5833
{
5834
int res = SWIG_AsVal_int(argv[3], NULL);
5835
_v = SWIG_CheckState(res);
5836
}
5837
if (_v) {
5838
return _wrap_polynomial_fit__SWIG_0(self, args);
5839
}
5840
}
5841
}
5842
}
5843
}
5844
if (argc == 5) {
5845
int _v;
5846
void *vptr = 0;
5847
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_FVector, 0);
5848
_v = SWIG_CheckState(res);
5849
if (_v) {
5850
void *vptr = 0;
5851
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_EST_FVector, 0);
5852
_v = SWIG_CheckState(res);
5853
if (_v) {
5854
void *vptr = 0;
5855
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_EST_FVector, 0);
5856
_v = SWIG_CheckState(res);
5857
if (_v) {
5858
void *vptr = 0;
5859
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_EST_FVector, 0);
5860
_v = SWIG_CheckState(res);
5861
if (_v) {
5862
{
5863
int res = SWIG_AsVal_int(argv[4], NULL);
5864
_v = SWIG_CheckState(res);
5865
}
5866
if (_v) {
5867
return _wrap_polynomial_fit__SWIG_1(self, args);
5868
}
5869
}
5870
}
5871
}
5872
}
5873
}
5874
5875
fail:
5876
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'polynomial_fit'.\n"
5877
" Possible C/C++ prototypes are:\n"
5878
" polynomial_fit(EST_FVector &,EST_FVector &,EST_FVector &,int)\n"
5879
" polynomial_fit(EST_FVector &,EST_FVector &,EST_FVector &,EST_FVector &,int)\n");
5880
return NULL;
5881
}
5882
5883
5884
SWIGINTERN PyObject *_wrap_polynomial_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5885
PyObject *resultobj = 0;
5886
EST_FVector *arg1 = 0 ;
5887
float arg2 ;
5888
void *argp1 = 0 ;
5889
int res1 = 0 ;
5890
float val2 ;
5891
int ecode2 = 0 ;
5892
PyObject * obj0 = 0 ;
5893
PyObject * obj1 = 0 ;
5894
float result;
5895
5896
if (!PyArg_ParseTuple(args,(char *)"OO:polynomial_value",&obj0,&obj1)) SWIG_fail;
5897
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_FVector, 0 | 0);
5898
if (!SWIG_IsOK(res1)) {
5899
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "polynomial_value" "', argument " "1"" of type '" "EST_FVector const &""'");
5900
}
5901
if (!argp1) {
5902
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "polynomial_value" "', argument " "1"" of type '" "EST_FVector const &""'");
5903
}
5904
arg1 = reinterpret_cast< EST_FVector * >(argp1);
5905
ecode2 = SWIG_AsVal_float(obj1, &val2);
5906
if (!SWIG_IsOK(ecode2)) {
5907
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "polynomial_value" "', argument " "2"" of type '" "float""'");
5908
}
5909
arg2 = static_cast< float >(val2);
5910
result = (float)polynomial_value((EST_FVector const &)*arg1,arg2);
5911
resultobj = SWIG_From_float(static_cast< float >(result));
5912
return resultobj;
5913
fail:
5914
return NULL;
5915
}
5916
5917
5918
static PyMethodDef SwigMethods[] = {
5919
{ (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
5920
{ (char *)"new_floatvector", _wrap_new_floatvector, METH_VARARGS, NULL},
5921
{ (char *)"delete_floatvector", _wrap_delete_floatvector, METH_VARARGS, NULL},
5922
{ (char *)"floatvector_resize", _wrap_floatvector_resize, METH_VARARGS, NULL},
5923
{ (char *)"floatvector_num_columns", _wrap_floatvector_num_columns, METH_VARARGS, NULL},
5924
{ (char *)"floatvector_length", _wrap_floatvector_length, METH_VARARGS, NULL},
5925
{ (char *)"floatvector_n", _wrap_floatvector_n, METH_VARARGS, NULL},
5926
{ (char *)"floatvector_a_no_check", _wrap_floatvector_a_no_check, METH_VARARGS, NULL},
5927
{ (char *)"floatvector_a_no_check_1", _wrap_floatvector_a_no_check_1, METH_VARARGS, NULL},
5928
{ (char *)"floatvector_a_check", _wrap_floatvector_a_check, METH_VARARGS, NULL},
5929
{ (char *)"floatvector_a", _wrap_floatvector_a, METH_VARARGS, NULL},
5930
{ (char *)"floatvector_fill", _wrap_floatvector_fill, METH_VARARGS, NULL},
5931
{ (char *)"floatvector_empty", _wrap_floatvector_empty, METH_VARARGS, NULL},
5932
{ (char *)"floatvector___eq__", _wrap_floatvector___eq__, METH_VARARGS, NULL},
5933
{ (char *)"floatvector___ne__", _wrap_floatvector___ne__, METH_VARARGS, NULL},
5934
{ (char *)"floatvector___setitem__", _wrap_floatvector___setitem__, METH_VARARGS, NULL},
5935
{ (char *)"floatvector___getitem__", _wrap_floatvector___getitem__, METH_VARARGS, NULL},
5936
{ (char *)"floatvector_copy_section", _wrap_floatvector_copy_section, METH_VARARGS, NULL},
5937
{ (char *)"floatvector_set_section", _wrap_floatvector_set_section, METH_VARARGS, NULL},
5938
{ (char *)"floatvector_swigregister", floatvector_swigregister, METH_VARARGS, NULL},
5939
{ (char *)"new_floatsimplevector", _wrap_new_floatsimplevector, METH_VARARGS, NULL},
5940
{ (char *)"floatsimplevector_resize", _wrap_floatsimplevector_resize, METH_VARARGS, NULL},
5941
{ (char *)"floatsimplevector_copy_section", _wrap_floatsimplevector_copy_section, METH_VARARGS, NULL},
5942
{ (char *)"floatsimplevector_set_section", _wrap_floatsimplevector_set_section, METH_VARARGS, NULL},
5943
{ (char *)"floatsimplevector_zero", _wrap_floatsimplevector_zero, METH_VARARGS, NULL},
5944
{ (char *)"floatsimplevector_empty", _wrap_floatsimplevector_empty, METH_VARARGS, NULL},
5945
{ (char *)"delete_floatsimplevector", _wrap_delete_floatsimplevector, METH_VARARGS, NULL},
5946
{ (char *)"floatsimplevector_swigregister", floatsimplevector_swigregister, METH_VARARGS, NULL},
5947
{ (char *)"new_EST_FVector", _wrap_new_EST_FVector, METH_VARARGS, NULL},
5948
{ (char *)"EST_FVector___iadd__", _wrap_EST_FVector___iadd__, METH_VARARGS, NULL},
5949
{ (char *)"EST_FVector___imul__", _wrap_EST_FVector___imul__, METH_VARARGS, NULL},
5950
{ (char *)"EST_FVector___idiv__", _wrap_EST_FVector___idiv__, METH_VARARGS, NULL},
5951
{ (char *)"EST_FVector_est_save", _wrap_EST_FVector_est_save, METH_VARARGS, NULL},
5952
{ (char *)"EST_FVector_save", _wrap_EST_FVector_save, METH_VARARGS, NULL},
5953
{ (char *)"EST_FVector_load", _wrap_EST_FVector_load, METH_VARARGS, NULL},
5954
{ (char *)"EST_FVector_est_load", _wrap_EST_FVector_est_load, METH_VARARGS, NULL},
5955
{ (char *)"EST_FVector_randomise", _wrap_EST_FVector_randomise, METH_VARARGS, NULL},
5956
{ (char *)"EST_FVector_sum", _wrap_EST_FVector_sum, METH_VARARGS, NULL},
5957
{ (char *)"delete_EST_FVector", _wrap_delete_EST_FVector, METH_VARARGS, NULL},
5958
{ (char *)"EST_FVector_swigregister", EST_FVector_swigregister, METH_VARARGS, NULL},
5959
{ (char *)"add", _wrap_add, METH_VARARGS, NULL},
5960
{ (char *)"subtract", _wrap_subtract, METH_VARARGS, NULL},
5961
{ (char *)"sqrt", _wrap_sqrt, METH_VARARGS, NULL},
5962
{ (char *)"topower", _wrap_topower, METH_VARARGS, NULL},
5963
{ (char *)"polynomial_fit", _wrap_polynomial_fit, METH_VARARGS, NULL},
5964
{ (char *)"polynomial_value", _wrap_polynomial_value, METH_VARARGS, NULL},
5965
{ NULL, NULL, 0, NULL }
5966
};
5967
5968
5969
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5970
5971
static void *_p_EST_FVectorTo_p_EST_TVectorT_float_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5972
return (void *)((EST_TVector< float > *) (EST_TSimpleVector< float > *) ((EST_FVector *) x));
5973
}
5974
static void *_p_EST_TSimpleVectorT_float_tTo_p_EST_TVectorT_float_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5975
return (void *)((EST_TVector< float > *) ((EST_TSimpleVector< float > *) x));
5976
}
5977
static void *_p_EST_FVectorTo_p_EST_TSimpleVectorT_float_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5978
return (void *)((EST_TSimpleVector< float > *) ((EST_FVector *) x));
5979
}
5980
static swig_type_info _swigt__p_EST_FVector = {"_p_EST_FVector", "EST_FVector *", 0, 0, (void*)0, 0};
5981
static swig_type_info _swigt__p_EST_Item = {"_p_EST_Item", "EST_Item *", 0, 0, (void*)0, 0};
5982
static swig_type_info _swigt__p_EST_TSimpleVectorT_float_t = {"_p_EST_TSimpleVectorT_float_t", "EST_TSimpleVector< float > *", 0, 0, (void*)0, 0};
5983
static swig_type_info _swigt__p_EST_TVectorT_float_t = {"_p_EST_TVectorT_float_t", "EST_TVector< float > *", 0, 0, (void*)0, 0};
5984
static swig_type_info _swigt__p_T = {"_p_T", "T *", 0, 0, (void*)0, 0};
5985
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
5986
static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0};
5987
5988
static swig_type_info *swig_type_initial[] = {
5989
&_swigt__p_EST_FVector,
5990
&_swigt__p_EST_Item,
5991
&_swigt__p_EST_TSimpleVectorT_float_t,
5992
&_swigt__p_EST_TVectorT_float_t,
5993
&_swigt__p_T,
5994
&_swigt__p_char,
5995
&_swigt__p_float,
5996
};
5997
5998
static swig_cast_info _swigc__p_EST_FVector[] = { {&_swigt__p_EST_FVector, 0, 0, 0},{0, 0, 0, 0}};
5999
static swig_cast_info _swigc__p_EST_Item[] = { {&_swigt__p_EST_Item, 0, 0, 0},{0, 0, 0, 0}};
6000
static swig_cast_info _swigc__p_EST_TSimpleVectorT_float_t[] = { {&_swigt__p_EST_FVector, _p_EST_FVectorTo_p_EST_TSimpleVectorT_float_t, 0, 0}, {&_swigt__p_EST_TSimpleVectorT_float_t, 0, 0, 0},{0, 0, 0, 0}};
6001
static swig_cast_info _swigc__p_EST_TVectorT_float_t[] = { {&_swigt__p_EST_FVector, _p_EST_FVectorTo_p_EST_TVectorT_float_t, 0, 0}, {&_swigt__p_EST_TVectorT_float_t, 0, 0, 0}, {&_swigt__p_EST_TSimpleVectorT_float_t, _p_EST_TSimpleVectorT_float_tTo_p_EST_TVectorT_float_t, 0, 0},{0, 0, 0, 0}};
6002
static swig_cast_info _swigc__p_T[] = { {&_swigt__p_T, 0, 0, 0},{0, 0, 0, 0}};
6003
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
6004
static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
6005
6006
static swig_cast_info *swig_cast_initial[] = {
6007
_swigc__p_EST_FVector,
6008
_swigc__p_EST_Item,
6009
_swigc__p_EST_TSimpleVectorT_float_t,
6010
_swigc__p_EST_TVectorT_float_t,
6011
_swigc__p_T,
6012
_swigc__p_char,
6013
_swigc__p_float,
6014
};
6015
6016
6017
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
6018
6019
static swig_const_info swig_const_table[] = {
6020
{0, 0, 0, 0.0, 0, 0}};
6021
6022
#ifdef __cplusplus
6023
}
6024
#endif
6025
/* -----------------------------------------------------------------------------
6026
* Type initialization:
6027
* This problem is tough by the requirement that no dynamic
6028
* memory is used. Also, since swig_type_info structures store pointers to
6029
* swig_cast_info structures and swig_cast_info structures store pointers back
6030
* to swig_type_info structures, we need some lookup code at initialization.
6031
* The idea is that swig generates all the structures that are needed.
6032
* The runtime then collects these partially filled structures.
6033
* The SWIG_InitializeModule function takes these initial arrays out of
6034
* swig_module, and does all the lookup, filling in the swig_module.types
6035
* array with the correct data and linking the correct swig_cast_info
6036
* structures together.
6037
*
6038
* The generated swig_type_info structures are assigned staticly to an initial
6039
* array. We just loop through that array, and handle each type individually.
6040
* First we lookup if this type has been already loaded, and if so, use the
6041
* loaded structure instead of the generated one. Then we have to fill in the
6042
* cast linked list. The cast data is initially stored in something like a
6043
* two-dimensional array. Each row corresponds to a type (there are the same
6044
* number of rows as there are in the swig_type_initial array). Each entry in
6045
* a column is one of the swig_cast_info structures for that type.
6046
* The cast_initial array is actually an array of arrays, because each row has
6047
* a variable number of columns. So to actually build the cast linked list,
6048
* we find the array of casts associated with the type, and loop through it
6049
* adding the casts to the list. The one last trick we need to do is making
6050
* sure the type pointer in the swig_cast_info struct is correct.
6051
*
6052
* First off, we lookup the cast->type name to see if it is already loaded.
6053
* There are three cases to handle:
6054
* 1) If the cast->type has already been loaded AND the type we are adding
6055
* casting info to has not been loaded (it is in this module), THEN we
6056
* replace the cast->type pointer with the type pointer that has already
6057
* been loaded.
6058
* 2) If BOTH types (the one we are adding casting info to, and the
6059
* cast->type) are loaded, THEN the cast info has already been loaded by
6060
* the previous module so we just ignore it.
6061
* 3) Finally, if cast->type has not already been loaded, then we add that
6062
* swig_cast_info to the linked list (because the cast->type) pointer will
6063
* be correct.
6064
* ----------------------------------------------------------------------------- */
6065
6066
#ifdef __cplusplus
6067
extern "C" {
6068
#if 0
6069
} /* c-mode */
6070
#endif
6071
#endif
6072
6073
#if 0
6074
#define SWIGRUNTIME_DEBUG
6075
#endif
6076
6077
6078
SWIGRUNTIME void
6079
SWIG_InitializeModule(void *clientdata) {
6080
size_t i;
6081
swig_module_info *module_head, *iter;
6082
int found, init;
6083
6084
clientdata = clientdata;
6085
6086
/* check to see if the circular list has been setup, if not, set it up */
6087
if (swig_module.next==0) {
6088
/* Initialize the swig_module */
6089
swig_module.type_initial = swig_type_initial;
6090
swig_module.cast_initial = swig_cast_initial;
6091
swig_module.next = &swig_module;
6092
init = 1;
6093
} else {
6094
init = 0;
6095
}
6096
6097
/* Try and load any already created modules */
6098
module_head = SWIG_GetModule(clientdata);
6099
if (!module_head) {
6100
/* This is the first module loaded for this interpreter */
6101
/* so set the swig module into the interpreter */
6102
SWIG_SetModule(clientdata, &swig_module);
6103
module_head = &swig_module;
6104
} else {
6105
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
6106
found=0;
6107
iter=module_head;
6108
do {
6109
if (iter==&swig_module) {
6110
found=1;
6111
break;
6112
}
6113
iter=iter->next;
6114
} while (iter!= module_head);
6115
6116
/* if the is found in the list, then all is done and we may leave */
6117
if (found) return;
6118
/* otherwise we must add out module into the list */
6119
swig_module.next = module_head->next;
6120
module_head->next = &swig_module;
6121
}
6122
6123
/* When multiple interpeters are used, a module could have already been initialized in
6124
a different interpreter, but not yet have a pointer in this interpreter.
6125
In this case, we do not want to continue adding types... everything should be
6126
set up already */
6127
if (init == 0) return;
6128
6129
/* Now work on filling in swig_module.types */
6130
#ifdef SWIGRUNTIME_DEBUG
6131
printf("SWIG_InitializeModule: size %d\n", swig_module.size);
6132
#endif
6133
for (i = 0; i < swig_module.size; ++i) {
6134
swig_type_info *type = 0;
6135
swig_type_info *ret;
6136
swig_cast_info *cast;
6137
6138
#ifdef SWIGRUNTIME_DEBUG
6139
printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6140
#endif
6141
6142
/* if there is another module already loaded */
6143
if (swig_module.next != &swig_module) {
6144
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
6145
}
6146
if (type) {
6147
/* Overwrite clientdata field */
6148
#ifdef SWIGRUNTIME_DEBUG
6149
printf("SWIG_InitializeModule: found type %s\n", type->name);
6150
#endif
6151
if (swig_module.type_initial[i]->clientdata) {
6152
type->clientdata = swig_module.type_initial[i]->clientdata;
6153
#ifdef SWIGRUNTIME_DEBUG
6154
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
6155
#endif
6156
}
6157
} else {
6158
type = swig_module.type_initial[i];
6159
}
6160
6161
/* Insert casting types */
6162
cast = swig_module.cast_initial[i];
6163
while (cast->type) {
6164
/* Don't need to add information already in the list */
6165
ret = 0;
6166
#ifdef SWIGRUNTIME_DEBUG
6167
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
6168
#endif
6169
if (swig_module.next != &swig_module) {
6170
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
6171
#ifdef SWIGRUNTIME_DEBUG
6172
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
6173
#endif
6174
}
6175
if (ret) {
6176
if (type == swig_module.type_initial[i]) {
6177
#ifdef SWIGRUNTIME_DEBUG
6178
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
6179
#endif
6180
cast->type = ret;
6181
ret = 0;
6182
} else {
6183
/* Check for casting already in the list */
6184
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
6185
#ifdef SWIGRUNTIME_DEBUG
6186
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
6187
#endif
6188
if (!ocast) ret = 0;
6189
}
6190
}
6191
6192
if (!ret) {
6193
#ifdef SWIGRUNTIME_DEBUG
6194
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
6195
#endif
6196
if (type->cast) {
6197
type->cast->prev = cast;
6198
cast->next = type->cast;
6199
}
6200
type->cast = cast;
6201
}
6202
cast++;
6203
}
6204
/* Set entry in modules->types array equal to the type */
6205
swig_module.types[i] = type;
6206
}
6207
swig_module.types[i] = 0;
6208
6209
#ifdef SWIGRUNTIME_DEBUG
6210
printf("**** SWIG_InitializeModule: Cast List ******\n");
6211
for (i = 0; i < swig_module.size; ++i) {
6212
int j = 0;
6213
swig_cast_info *cast = swig_module.cast_initial[i];
6214
printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6215
while (cast->type) {
6216
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
6217
cast++;
6218
++j;
6219
}
6220
printf("---- Total casts: %d\n",j);
6221
}
6222
printf("**** SWIG_InitializeModule: Cast List ******\n");
6223
#endif
6224
}
6225
6226
/* This function will propagate the clientdata field of type to
6227
* any new swig_type_info structures that have been added into the list
6228
* of equivalent types. It is like calling
6229
* SWIG_TypeClientData(type, clientdata) a second time.
6230
*/
6231
SWIGRUNTIME void
6232
SWIG_PropagateClientData(void) {
6233
size_t i;
6234
swig_cast_info *equiv;
6235
static int init_run = 0;
6236
6237
if (init_run) return;
6238
init_run = 1;
6239
6240
for (i = 0; i < swig_module.size; i++) {
6241
if (swig_module.types[i]->clientdata) {
6242
equiv = swig_module.types[i]->cast;
6243
while (equiv) {
6244
if (!equiv->converter) {
6245
if (equiv->type && !equiv->type->clientdata)
6246
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
6247
}
6248
equiv = equiv->next;
6249
}
6250
}
6251
}
6252
}
6253
6254
#ifdef __cplusplus
6255
#if 0
6256
{
6257
/* c-mode */
6258
#endif
6259
}
6260
#endif
6261
6262
6263
6264
#ifdef __cplusplus
6265
extern "C" {
6266
#endif
6267
6268
/* Python-specific SWIG API */
6269
#define SWIG_newvarlink() SWIG_Python_newvarlink()
6270
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
6271
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
6272
6273
/* -----------------------------------------------------------------------------
6274
* global variable support code.
6275
* ----------------------------------------------------------------------------- */
6276
6277
typedef struct swig_globalvar {
6278
char *name; /* Name of global variable */
6279
PyObject *(*get_attr)(void); /* Return the current value */
6280
int (*set_attr)(PyObject *); /* Set the value */
6281
struct swig_globalvar *next;
6282
} swig_globalvar;
6283
6284
typedef struct swig_varlinkobject {
6285
PyObject_HEAD
6286
swig_globalvar *vars;
6287
} swig_varlinkobject;
6288
6289
SWIGINTERN PyObject *
6290
swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
6291
#if PY_VERSION_HEX >= 0x03000000
6292
return PyUnicode_InternFromString("<Swig global variables>");
6293
#else
6294
return PyString_FromString("<Swig global variables>");
6295
#endif
6296
}
6297
6298
SWIGINTERN PyObject *
6299
swig_varlink_str(swig_varlinkobject *v) {
6300
#if PY_VERSION_HEX >= 0x03000000
6301
PyObject *str = PyUnicode_InternFromString("(");
6302
PyObject *tail;
6303
PyObject *joined;
6304
swig_globalvar *var;
6305
for (var = v->vars; var; var=var->next) {
6306
tail = PyUnicode_FromString(var->name);
6307
joined = PyUnicode_Concat(str, tail);
6308
Py_DecRef(str);
6309
Py_DecRef(tail);
6310
str = joined;
6311
if (var->next) {
6312
tail = PyUnicode_InternFromString(", ");
6313
joined = PyUnicode_Concat(str, tail);
6314
Py_DecRef(str);
6315
Py_DecRef(tail);
6316
str = joined;
6317
}
6318
}
6319
tail = PyUnicode_InternFromString(")");
6320
joined = PyUnicode_Concat(str, tail);
6321
Py_DecRef(str);
6322
Py_DecRef(tail);
6323
str = joined;
6324
#else
6325
PyObject *str = PyString_FromString("(");
6326
swig_globalvar *var;
6327
for (var = v->vars; var; var=var->next) {
6328
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
6329
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
6330
}
6331
PyString_ConcatAndDel(&str,PyString_FromString(")"));
6332
#endif
6333
return str;
6334
}
6335
6336
SWIGINTERN int
6337
swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
6338
char *tmp;
6339
PyObject *str = swig_varlink_str(v);
6340
fprintf(fp,"Swig global variables ");
6341
fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
6342
SWIG_Python_str_DelForPy3(tmp);
6343
Py_DECREF(str);
6344
return 0;
6345
}
6346
6347
SWIGINTERN void
6348
swig_varlink_dealloc(swig_varlinkobject *v) {
6349
swig_globalvar *var = v->vars;
6350
while (var) {
6351
swig_globalvar *n = var->next;
6352
free(var->name);
6353
free(var);
6354
var = n;
6355
}
6356
}
6357
6358
SWIGINTERN PyObject *
6359
swig_varlink_getattr(swig_varlinkobject *v, char *n) {
6360
PyObject *res = NULL;
6361
swig_globalvar *var = v->vars;
6362
while (var) {
6363
if (strcmp(var->name,n) == 0) {
6364
res = (*var->get_attr)();
6365
break;
6366
}
6367
var = var->next;
6368
}
6369
if (res == NULL && !PyErr_Occurred()) {
6370
PyErr_SetString(PyExc_NameError,"Unknown C global variable");
6371
}
6372
return res;
6373
}
6374
6375
SWIGINTERN int
6376
swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
6377
int res = 1;
6378
swig_globalvar *var = v->vars;
6379
while (var) {
6380
if (strcmp(var->name,n) == 0) {
6381
res = (*var->set_attr)(p);
6382
break;
6383
}
6384
var = var->next;
6385
}
6386
if (res == 1 && !PyErr_Occurred()) {
6387
PyErr_SetString(PyExc_NameError,"Unknown C global variable");
6388
}
6389
return res;
6390
}
6391
6392
SWIGINTERN PyTypeObject*
6393
swig_varlink_type(void) {
6394
static char varlink__doc__[] = "Swig var link object";
6395
static PyTypeObject varlink_type;
6396
static int type_init = 0;
6397
if (!type_init) {
6398
const PyTypeObject tmp
6399
= {
6400
/* PyObject header changed in Python 3 */
6401
#if PY_VERSION_HEX >= 0x03000000
6402
PyVarObject_HEAD_INIT(&PyType_Type, 0)
6403
#else
6404
PyObject_HEAD_INIT(NULL)
6405
0, /* Number of items in variable part (ob_size) */
6406
#endif
6407
(char *)"swigvarlink", /* Type name (tp_name) */
6408
sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
6409
0, /* Itemsize (tp_itemsize) */
6410
(destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
6411
(printfunc) swig_varlink_print, /* Print (tp_print) */
6412
(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
6413
(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
6414
0, /* tp_compare */
6415
(reprfunc) swig_varlink_repr, /* tp_repr */
6416
0, /* tp_as_number */
6417
0, /* tp_as_sequence */
6418
0, /* tp_as_mapping */
6419
0, /* tp_hash */
6420
0, /* tp_call */
6421
(reprfunc) swig_varlink_str, /* tp_str */
6422
0, /* tp_getattro */
6423
0, /* tp_setattro */
6424
0, /* tp_as_buffer */
6425
0, /* tp_flags */
6426
varlink__doc__, /* tp_doc */
6427
0, /* tp_traverse */
6428
0, /* tp_clear */
6429
0, /* tp_richcompare */
6430
0, /* tp_weaklistoffset */
6431
#if PY_VERSION_HEX >= 0x02020000
6432
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
6433
#endif
6434
#if PY_VERSION_HEX >= 0x02030000
6435
0, /* tp_del */
6436
#endif
6437
#ifdef COUNT_ALLOCS
6438
0,0,0,0 /* tp_alloc -> tp_next */
6439
#endif
6440
};
6441
varlink_type = tmp;
6442
/* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
6443
#if PY_VERSION_HEX < 0x03000000
6444
varlink_type.ob_type = &PyType_Type;
6445
#endif
6446
type_init = 1;
6447
}
6448
return &varlink_type;
6449
}
6450
6451
/* Create a variable linking object for use later */
6452
SWIGINTERN PyObject *
6453
SWIG_Python_newvarlink(void) {
6454
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
6455
if (result) {
6456
result->vars = 0;
6457
}
6458
return ((PyObject*) result);
6459
}
6460
6461
SWIGINTERN void
6462
SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
6463
swig_varlinkobject *v = (swig_varlinkobject *) p;
6464
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
6465
if (gv) {
6466
size_t size = strlen(name)+1;
6467
gv->name = (char *)malloc(size);
6468
if (gv->name) {
6469
strncpy(gv->name,name,size);
6470
gv->get_attr = get_attr;
6471
gv->set_attr = set_attr;
6472
gv->next = v->vars;
6473
}
6474
}
6475
v->vars = gv;
6476
}
6477
6478
SWIGINTERN PyObject *
6479
SWIG_globals(void) {
6480
static PyObject *_SWIG_globals = 0;
6481
if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
6482
return _SWIG_globals;
6483
}
6484
6485
/* -----------------------------------------------------------------------------
6486
* constants/methods manipulation
6487
* ----------------------------------------------------------------------------- */
6488
6489
/* Install Constants */
6490
SWIGINTERN void
6491
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
6492
PyObject *obj = 0;
6493
size_t i;
6494
for (i = 0; constants[i].type; ++i) {
6495
switch(constants[i].type) {
6496
case SWIG_PY_POINTER:
6497
obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
6498
break;
6499
case SWIG_PY_BINARY:
6500
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
6501
break;
6502
default:
6503
obj = 0;
6504
break;
6505
}
6506
if (obj) {
6507
PyDict_SetItemString(d, constants[i].name, obj);
6508
Py_DECREF(obj);
6509
}
6510
}
6511
}
6512
6513
/* -----------------------------------------------------------------------------*/
6514
/* Fix SwigMethods to carry the callback ptrs when needed */
6515
/* -----------------------------------------------------------------------------*/
6516
6517
SWIGINTERN void
6518
SWIG_Python_FixMethods(PyMethodDef *methods,
6519
swig_const_info *const_table,
6520
swig_type_info **types,
6521
swig_type_info **types_initial) {
6522
size_t i;
6523
for (i = 0; methods[i].ml_name; ++i) {
6524
const char *c = methods[i].ml_doc;
6525
if (c && (c = strstr(c, "swig_ptr: "))) {
6526
int j;
6527
swig_const_info *ci = 0;
6528
const char *name = c + 10;
6529
for (j = 0; const_table[j].type; ++j) {
6530
if (strncmp(const_table[j].name, name,
6531
strlen(const_table[j].name)) == 0) {
6532
ci = &(const_table[j]);
6533
break;
6534
}
6535
}
6536
if (ci) {
6537
size_t shift = (ci->ptype) - types;
6538
swig_type_info *ty = types_initial[shift];
6539
size_t ldoc = (c - methods[i].ml_doc);
6540
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
6541
char *ndoc = (char*)malloc(ldoc + lptr + 10);
6542
if (ndoc) {
6543
char *buff = ndoc;
6544
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
6545
if (ptr) {
6546
strncpy(buff, methods[i].ml_doc, ldoc);
6547
buff += ldoc;
6548
strncpy(buff, "swig_ptr: ", 10);
6549
buff += 10;
6550
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
6551
methods[i].ml_doc = ndoc;
6552
}
6553
}
6554
}
6555
}
6556
}
6557
}
6558
6559
#ifdef __cplusplus
6560
}
6561
#endif
6562
6563
/* -----------------------------------------------------------------------------*
6564
* Partial Init method
6565
* -----------------------------------------------------------------------------*/
6566
6567
#ifdef __cplusplus
6568
extern "C"
6569
#endif
6570
6571
SWIGEXPORT
6572
#if PY_VERSION_HEX >= 0x03000000
6573
PyObject*
6574
#else
6575
void
6576
#endif
6577
SWIG_init(void) {
6578
PyObject *m, *d;
6579
#if PY_VERSION_HEX >= 0x03000000
6580
static struct PyModuleDef SWIG_module = {
6581
PyModuleDef_HEAD_INIT,
6582
(char *) SWIG_name,
6583
NULL,
6584
-1,
6585
SwigMethods,
6586
NULL,
6587
NULL,
6588
NULL,
6589
NULL
6590
};
6591
#endif
6592
6593
/* Fix SwigMethods to carry the callback ptrs when needed */
6594
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
6595
6596
#if PY_VERSION_HEX >= 0x03000000
6597
m = PyModule_Create(&SWIG_module);
6598
#else
6599
m = Py_InitModule((char *) SWIG_name, SwigMethods);
6600
#endif
6601
d = PyModule_GetDict(m);
6602
6603
SWIG_InitializeModule(0);
6604
SWIG_InstallConstants(d,swig_const_table);
6605
6606
6607
SWIG_Python_SetConstant(d, "read_ok",SWIG_From_int(static_cast< int >(read_ok)));
6608
SWIG_Python_SetConstant(d, "read_format_error",SWIG_From_int(static_cast< int >(read_format_error)));
6609
SWIG_Python_SetConstant(d, "read_not_found_error",SWIG_From_int(static_cast< int >(read_not_found_error)));
6610
SWIG_Python_SetConstant(d, "read_error",SWIG_From_int(static_cast< int >(read_error)));
6611
SWIG_Python_SetConstant(d, "write_ok",SWIG_From_int(static_cast< int >(write_ok)));
6612
SWIG_Python_SetConstant(d, "write_fail",SWIG_From_int(static_cast< int >(write_fail)));
6613
SWIG_Python_SetConstant(d, "write_error",SWIG_From_int(static_cast< int >(write_error)));
6614
SWIG_Python_SetConstant(d, "write_partial",SWIG_From_int(static_cast< int >(write_partial)));
6615
SWIG_Python_SetConstant(d, "connect_ok",SWIG_From_int(static_cast< int >(connect_ok)));
6616
SWIG_Python_SetConstant(d, "connect_not_found_error",SWIG_From_int(static_cast< int >(connect_not_found_error)));
6617
SWIG_Python_SetConstant(d, "connect_not_allowed_error",SWIG_From_int(static_cast< int >(connect_not_allowed_error)));
6618
SWIG_Python_SetConstant(d, "connect_system_error",SWIG_From_int(static_cast< int >(connect_system_error)));
6619
SWIG_Python_SetConstant(d, "connect_error",SWIG_From_int(static_cast< int >(connect_error)));
6620
#if PY_VERSION_HEX >= 0x03000000
6621
return m;
6622
#else
6623
return;
6624
#endif
6625
}
6626
Loggerhead is a web-based interface for Breezy
Version: 2.0.1