« back to all changes in this revision
Viewing changes to debian/patches/swig.dpatch
- browse files at revision 15
- compare with another revision
- download diff
- download tarball
- view history from revision 15
- Committer: Bazaar Package Importer
- Author(s): Francesco Paolo Lovergine
- Date: 2011-04-13 17:08:41 UTC
- mfrom: (8.1.7 sid)
- Revision ID: james.westby@ubuntu.com-20110413170841-ss1t9bic0d0uq0gz
Tags: 6.4.1-1
* New upstream version.
* Now build-dep on libjpeg-dev and current libreadline6-dev.
* Removed patch swig: obsolete.
* Policy bumped to 3.9.2, without changes.
* Now build-dep on libjpeg-dev and current libreadline6-dev.
* Removed patch swig: obsolete.
* Policy bumped to 3.9.2, without changes.
- files added:
- .pc
- .pc/htmlgen-fakeroot
- .pc/htmlgen-fakeroot/include
- .pc/htmlgen-fakeroot/include/Make
- .pc/instdir
- .pc/pager
- .pc/pager/lib
- .pc/pager/lib/init
- .pc/www-browser
- .pc/www-browser/lib
- .pc/www-browser/lib/init
- .pc/xterm
- .pc/xterm/lib
- .pc/xterm/lib/init
- debian/source
- imagery/i.atcorr/sensors_csv
- imagery/i.ortho.photo/i.photo.2image
- imagery/i.ortho.photo/i.photo.2target
- imagery/i.ortho.photo/i.photo.camera
- imagery/i.ortho.photo/i.photo.elev
- imagery/i.ortho.photo/i.photo.init
- imagery/i.ortho.photo/i.photo.rectify
- imagery/i.ortho.photo/i.photo.target
- raster/r.colors.out
- raster/r.li/r.li.pielou
- raster/r.li/r.li.renyi
- scripts/g.extension
- scripts/v.in.lines
- files removed:
- debian/patches/00list
- gui/wxpython/nviz
- imagery/i.ortho.photo/photo.2image
- imagery/i.ortho.photo/photo.2target
- imagery/i.ortho.photo/photo.camera
- imagery/i.ortho.photo/photo.elev
- imagery/i.ortho.photo/photo.init
- imagery/i.ortho.photo/photo.rectify
- imagery/i.ortho.photo/photo.target
- swig
- swig/include
- swig/include/python
- swig/perl
- swig/perl/R_slope_aspect
- swig/perl/R_slope_aspect/lib
- swig/perl/R_slope_aspect/r_slope_aspect
- swig/perl/fallback
- swig/perl/t
- swig/perl2
- swig/python
- swig/python/NumPtr
- swig/python/NumPtr/lib
- swig/python/NumPtr/src
- swig/python/examples
- files modified:
- AUTHORS
- debian/fixpaths.sh *
- debian/fixscripts.sh *
- debian/x-grass *
- install-sh *
added
removed
debian/patches/swig.dpatch
1
#! /bin/sh /usr/share/dpatch/dpatch-run
2
## swig.dpatch by Francesco Paolo Lovergine <frankie@debian.org>
3
##
4
## All lines beginning with `## DP:' are a description of the patch.
5
## DP: No description.
6
7
@DPATCH@
8
diff -urNad grass-6.4.0~rc5+39426~/gui/wxpython/nviz/Makefile grass-6.4.0~rc5+39426/gui/wxpython/nviz/Makefile
9
--- grass-6.4.0~rc5+39426~/gui/wxpython/nviz/Makefile 2009-10-07 10:48:15.000000000 +0200
10
+++ grass-6.4.0~rc5+39426/gui/wxpython/nviz/Makefile 2009-10-08 00:03:54.000000000 +0200
11
@@ -34,7 +34,7 @@
12
13
$(LIB_NAME).py: $(SHLIB)
14
15
-$(SHLIB): $(LIB_NAME).i
16
+$(SHLIB): $(LIB_NAME)_wrap.cpp
17
python setup.py build_ext --swig=$(SWIG) --swig-opts=-c++ --build-lib=$(OBJDIR) --build-temp=$(OBJDIR)
18
19
.NOTPARALLEL: $(LIB_NAME).py $(LIB_NAME)_wrap.cpp
20
diff -urNad grass-6.4.0~rc5+39426~/gui/wxpython/nviz/grass6_wxnviz.i grass-6.4.0~rc5+39426/gui/wxpython/nviz/grass6_wxnviz.i
21
--- grass-6.4.0~rc5+39426~/gui/wxpython/nviz/grass6_wxnviz.i 1970-01-01 01:00:00.000000000 +0100
22
+++ grass-6.4.0~rc5+39426/gui/wxpython/nviz/grass6_wxnviz.i 2009-10-08 00:01:13.000000000 +0200
23
@@ -0,0 +1,199 @@
24
+/* File: nviz.i */
25
+
26
+%module grass6_wxnviz
27
+%{
28
+#include "nviz.h"
29
+#include <grass/gsurf.h>
30
+#include <grass/gstypes.h>
31
+#undef check
32
+%}
33
+
34
+%include "std_vector.i"
35
+namespace std {
36
+ %template(IntVector) vector<int>;
37
+ %template(DoubleVector) vector<double>;
38
+}
39
+%include "std_map.i"
40
+namespace std {
41
+ %template(IntVecIntMap) map<int, vector<int> >;
42
+}
43
+
44
+%include "nviz.h"
45
+/* extracted from include/vect/dig_defines.h */
46
+
47
+#define GV_POINT 0x01
48
+#define GV_LINE 0x02
49
+#define GV_BOUNDARY 0x04
50
+#define GV_CENTROID 0x08
51
+#define GV_FACE 0x10
52
+#define GV_KERNEL 0x20
53
+#define GV_AREA 0x40
54
+#define GV_VOLUME 0x80
55
+
56
+#define GV_POINTS (GV_POINT | GV_CENTROID )
57
+#define GV_LINES (GV_LINE | GV_BOUNDARY )
58
+
59
+#define PORT_DOUBLE_MAX 1.7976931348623157e+308
60
+
61
+/* extracted from gui/wxpython/nviz/nviz.h */
62
+
63
+#define VIEW_DEFAULT_POS_X 0.85
64
+#define VIEW_DEFAULT_POS_Y 0.85
65
+#define VIEW_DEFAULT_PERSP 40.0
66
+#define VIEW_DEFAULT_TWIST 0.0
67
+#define VIEW_DEFAULT_ZEXAG 1.0
68
+
69
+/* extracted from include/gsurf.h */
70
+#define DM_GOURAUD 0x00000100
71
+#define DM_FLAT 0x00000200
72
+
73
+#define DM_FRINGE 0x00000010
74
+
75
+#define DM_WIRE 0x00000001
76
+#define DM_COL_WIRE 0x00000002
77
+#define DM_POLY 0x00000004
78
+#define DM_WIRE_POLY 0x00000008
79
+
80
+#define DM_GRID_WIRE 0x00000400
81
+#define DM_GRID_SURF 0x00000800
82
+
83
+/* site markers */
84
+#define ST_X 1
85
+#define ST_BOX 2
86
+#define ST_SPHERE 3
87
+#define ST_CUBE 4
88
+#define ST_DIAMOND 5
89
+#define ST_DEC_TREE 6
90
+#define ST_CON_TREE 7
91
+#define ST_ASTER 8
92
+#define ST_GYRO 9
93
+#define ST_HISTOGRAM 10
94
+
95
+#define MAX_ISOSURFS 12
96
+#define MAX_SLICES 12
97
+
98
+/* extracted from include/nviz.h */
99
+/* quick draw mode */
100
+#define DRAW_QUICK_SURFACE 0x01
101
+#define DRAW_QUICK_VLINES 0x02
102
+#define DRAW_QUICK_VPOINTS 0x04
103
+#define DRAW_QUICK_VOLUME 0x08
104
+/* auto-generated swig typedef file */
105
+#ifndef WXNVIZ_H
106
+#define WXNVIZ_H
107
+
108
+// For compilers that support precompilation, includes "wx.h".
109
+#include <wx/wxprec.h>
110
+
111
+#include <vector>
112
+
113
+extern "C" {
114
+#include <grass/gis.h>
115
+#include <grass/nviz.h>
116
+#include <grass/gsurf.h>
117
+#include <grass/gstypes.h>
118
+}
119
+
120
+
121
+#ifdef __BORLANDC__
122
+#pragma hdrstop
123
+#endif
124
+
125
+#ifndef WX_PRECOMP
126
+// Include your minimal set of headers here, or wx.h
127
+#include <wx/wx.h>
128
+#endif
129
+
130
+#include <wx/glcanvas.h>
131
+
132
+#include <Python.h>
133
+
134
+class Nviz
135
+{
136
+private:
137
+ nv_data *data;
138
+ wxGLCanvas *glCanvas;
139
+
140
+ /* surface.cpp */
141
+ int SetSurfaceAttr(int, int, bool, const char *);
142
+ int UnsetSurfaceAttr(int, int);
143
+
144
+ /* volume.cpp */
145
+ int SetIsosurfaceAttr(int, int, int, bool, const char *);
146
+ int UnsetIsosurfaceAttr(int, int, int);
147
+
148
+public:
149
+ /* constructor */
150
+ Nviz(PyObject *);
151
+
152
+ /* destructor */
153
+ ~Nviz();
154
+
155
+ /* change_view.cpp */
156
+ int ResizeWindow(int, int);
157
+ std::vector<double> SetViewDefault();
158
+ int SetView(float, float,
159
+ float, float, float);
160
+ int SetZExag(float);
161
+
162
+ /* init.cpp */
163
+ int SetDisplay(void *);
164
+ void InitView();
165
+ void SetBgColor(const char *);
166
+
167
+ /* lights.cpp */
168
+ void SetLightsDefault();
169
+
170
+ /* load.cpp */
171
+ int LoadSurface(const char*, const char *, const char *);
172
+ int UnloadSurface(int);
173
+ int LoadVector(const char *, bool);
174
+ int UnloadVector(int, bool);
175
+ int LoadVolume(const char*, const char *, const char *);
176
+ int UnloadVolume(int);
177
+
178
+ /* draw.cpp */
179
+ void Draw(bool, int);
180
+ void EraseMap();
181
+
182
+ /* surface.cpp */
183
+ int SetSurfaceTopo(int, bool, const char *);
184
+ int SetSurfaceColor(int, bool, const char *);
185
+ int SetSurfaceMask(int, bool, const char *);
186
+ int SetSurfaceTransp(int, bool, const char *);
187
+ int SetSurfaceShine(int, bool, const char *);
188
+ int SetSurfaceEmit(int, bool, const char *);
189
+ int UnsetSurfaceMask(int);
190
+ int UnsetSurfaceTransp(int);
191
+ int UnsetSurfaceEmit(int);
192
+ int SetSurfaceRes(int, int, int);
193
+ int SetSurfaceStyle(int, int);
194
+ int SetWireColor(int, const char *);
195
+ std::vector<double> GetSurfacePosition(int);
196
+ int SetSurfacePosition(int, float, float, float);
197
+
198
+ /* vector */
199
+ int SetVectorLineMode(int, const char *, int, int);
200
+ int SetVectorLineHeight(int, float);
201
+ int SetVectorLineSurface(int, int);
202
+ int SetVectorPointMode(int, const char*, int, float, int);
203
+ int SetVectorPointHeight(int, float);
204
+ int SetVectorPointSurface(int, int);
205
+
206
+ /* volume */
207
+ int AddIsosurface(int, int);
208
+ int DeleteIsosurface(int, int);
209
+ int MoveIsosurface(int, int, bool);
210
+ int SetIsosurfaceColor(int, int, bool, const char *);
211
+ int SetIsosurfaceMask(int, int, bool, const char *);
212
+ int SetIsosurfaceTransp(int, int, bool, const char *);
213
+ int SetIsosurfaceShine(int, int, bool, const char *);
214
+ int SetIsosurfaceEmit(int, int, bool, const char *);
215
+ int UnsetIsosurfaceMask(int, int);
216
+ int UnsetIsosurfaceTransp(int, int);
217
+ int UnsetIsosurfaceEmit(int, int);
218
+ int SetIsosurfaceMode(int, int);
219
+ int SetIsosurfaceRes(int, int);
220
+};
221
+
222
+#endif /* WXNVIZ_H */
223
diff -urNad grass-6.4.0~rc5+39426~/gui/wxpython/nviz/grass6_wxnviz.py grass-6.4.0~rc5+39426/gui/wxpython/nviz/grass6_wxnviz.py
224
--- grass-6.4.0~rc5+39426~/gui/wxpython/nviz/grass6_wxnviz.py 1970-01-01 01:00:00.000000000 +0100
225
+++ grass-6.4.0~rc5+39426/gui/wxpython/nviz/grass6_wxnviz.py 2009-10-08 00:01:13.000000000 +0200
226
@@ -0,0 +1,324 @@
227
+# This file was automatically generated by SWIG (http://www.swig.org).
228
+# Version 1.3.36
229
+#
230
+# Don't modify this file, modify the SWIG interface instead.
231
+# This file is compatible with both classic and new-style classes.
232
+
233
+import _grass6_wxnviz
234
+import new
235
+new_instancemethod = new.instancemethod
236
+try:
237
+ _swig_property = property
238
+except NameError:
239
+ pass # Python < 2.2 doesn't have 'property'.
240
+def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
241
+ if (name == "thisown"): return self.this.own(value)
242
+ if (name == "this"):
243
+ if type(value).__name__ == 'PySwigObject':
244
+ self.__dict__[name] = value
245
+ return
246
+ method = class_type.__swig_setmethods__.get(name,None)
247
+ if method: return method(self,value)
248
+ if (not static) or hasattr(self,name):
249
+ self.__dict__[name] = value
250
+ else:
251
+ raise AttributeError("You cannot add attributes to %s" % self)
252
+
253
+def _swig_setattr(self,class_type,name,value):
254
+ return _swig_setattr_nondynamic(self,class_type,name,value,0)
255
+
256
+def _swig_getattr(self,class_type,name):
257
+ if (name == "thisown"): return self.this.own()
258
+ method = class_type.__swig_getmethods__.get(name,None)
259
+ if method: return method(self)
260
+ raise AttributeError,name
261
+
262
+def _swig_repr(self):
263
+ try: strthis = "proxy of " + self.this.__repr__()
264
+ except: strthis = ""
265
+ return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
266
+
267
+import types
268
+try:
269
+ _object = types.ObjectType
270
+ _newclass = 1
271
+except AttributeError:
272
+ class _object : pass
273
+ _newclass = 0
274
+del types
275
+
276
+
277
+class PySwigIterator(_object):
278
+ __swig_setmethods__ = {}
279
+ __setattr__ = lambda self, name, value: _swig_setattr(self, PySwigIterator, name, value)
280
+ __swig_getmethods__ = {}
281
+ __getattr__ = lambda self, name: _swig_getattr(self, PySwigIterator, name)
282
+ def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
283
+ __repr__ = _swig_repr
284
+ __swig_destroy__ = _grass6_wxnviz.delete_PySwigIterator
285
+ __del__ = lambda self : None;
286
+ def value(*args): return _grass6_wxnviz.PySwigIterator_value(*args)
287
+ def incr(*args): return _grass6_wxnviz.PySwigIterator_incr(*args)
288
+ def decr(*args): return _grass6_wxnviz.PySwigIterator_decr(*args)
289
+ def distance(*args): return _grass6_wxnviz.PySwigIterator_distance(*args)
290
+ def equal(*args): return _grass6_wxnviz.PySwigIterator_equal(*args)
291
+ def copy(*args): return _grass6_wxnviz.PySwigIterator_copy(*args)
292
+ def next(*args): return _grass6_wxnviz.PySwigIterator_next(*args)
293
+ def previous(*args): return _grass6_wxnviz.PySwigIterator_previous(*args)
294
+ def advance(*args): return _grass6_wxnviz.PySwigIterator_advance(*args)
295
+ def __eq__(*args): return _grass6_wxnviz.PySwigIterator___eq__(*args)
296
+ def __ne__(*args): return _grass6_wxnviz.PySwigIterator___ne__(*args)
297
+ def __iadd__(*args): return _grass6_wxnviz.PySwigIterator___iadd__(*args)
298
+ def __isub__(*args): return _grass6_wxnviz.PySwigIterator___isub__(*args)
299
+ def __add__(*args): return _grass6_wxnviz.PySwigIterator___add__(*args)
300
+ def __sub__(*args): return _grass6_wxnviz.PySwigIterator___sub__(*args)
301
+ def __iter__(self): return self
302
+PySwigIterator_swigregister = _grass6_wxnviz.PySwigIterator_swigregister
303
+PySwigIterator_swigregister(PySwigIterator)
304
+
305
+class IntVector(_object):
306
+ __swig_setmethods__ = {}
307
+ __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
308
+ __swig_getmethods__ = {}
309
+ __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
310
+ __repr__ = _swig_repr
311
+ def iterator(*args): return _grass6_wxnviz.IntVector_iterator(*args)
312
+ def __iter__(self): return self.iterator()
313
+ def __nonzero__(*args): return _grass6_wxnviz.IntVector___nonzero__(*args)
314
+ def __len__(*args): return _grass6_wxnviz.IntVector___len__(*args)
315
+ def pop(*args): return _grass6_wxnviz.IntVector_pop(*args)
316
+ def __getslice__(*args): return _grass6_wxnviz.IntVector___getslice__(*args)
317
+ def __setslice__(*args): return _grass6_wxnviz.IntVector___setslice__(*args)
318
+ def __delslice__(*args): return _grass6_wxnviz.IntVector___delslice__(*args)
319
+ def __delitem__(*args): return _grass6_wxnviz.IntVector___delitem__(*args)
320
+ def __getitem__(*args): return _grass6_wxnviz.IntVector___getitem__(*args)
321
+ def __setitem__(*args): return _grass6_wxnviz.IntVector___setitem__(*args)
322
+ def append(*args): return _grass6_wxnviz.IntVector_append(*args)
323
+ def empty(*args): return _grass6_wxnviz.IntVector_empty(*args)
324
+ def size(*args): return _grass6_wxnviz.IntVector_size(*args)
325
+ def clear(*args): return _grass6_wxnviz.IntVector_clear(*args)
326
+ def swap(*args): return _grass6_wxnviz.IntVector_swap(*args)
327
+ def get_allocator(*args): return _grass6_wxnviz.IntVector_get_allocator(*args)
328
+ def begin(*args): return _grass6_wxnviz.IntVector_begin(*args)
329
+ def end(*args): return _grass6_wxnviz.IntVector_end(*args)
330
+ def rbegin(*args): return _grass6_wxnviz.IntVector_rbegin(*args)
331
+ def rend(*args): return _grass6_wxnviz.IntVector_rend(*args)
332
+ def pop_back(*args): return _grass6_wxnviz.IntVector_pop_back(*args)
333
+ def erase(*args): return _grass6_wxnviz.IntVector_erase(*args)
334
+ def __init__(self, *args):
335
+ this = _grass6_wxnviz.new_IntVector(*args)
336
+ try: self.this.append(this)
337
+ except: self.this = this
338
+ def push_back(*args): return _grass6_wxnviz.IntVector_push_back(*args)
339
+ def front(*args): return _grass6_wxnviz.IntVector_front(*args)
340
+ def back(*args): return _grass6_wxnviz.IntVector_back(*args)
341
+ def assign(*args): return _grass6_wxnviz.IntVector_assign(*args)
342
+ def resize(*args): return _grass6_wxnviz.IntVector_resize(*args)
343
+ def insert(*args): return _grass6_wxnviz.IntVector_insert(*args)
344
+ def reserve(*args): return _grass6_wxnviz.IntVector_reserve(*args)
345
+ def capacity(*args): return _grass6_wxnviz.IntVector_capacity(*args)
346
+ __swig_destroy__ = _grass6_wxnviz.delete_IntVector
347
+ __del__ = lambda self : None;
348
+IntVector_swigregister = _grass6_wxnviz.IntVector_swigregister
349
+IntVector_swigregister(IntVector)
350
+
351
+class DoubleVector(_object):
352
+ __swig_setmethods__ = {}
353
+ __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
354
+ __swig_getmethods__ = {}
355
+ __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
356
+ __repr__ = _swig_repr
357
+ def iterator(*args): return _grass6_wxnviz.DoubleVector_iterator(*args)
358
+ def __iter__(self): return self.iterator()
359
+ def __nonzero__(*args): return _grass6_wxnviz.DoubleVector___nonzero__(*args)
360
+ def __len__(*args): return _grass6_wxnviz.DoubleVector___len__(*args)
361
+ def pop(*args): return _grass6_wxnviz.DoubleVector_pop(*args)
362
+ def __getslice__(*args): return _grass6_wxnviz.DoubleVector___getslice__(*args)
363
+ def __setslice__(*args): return _grass6_wxnviz.DoubleVector___setslice__(*args)
364
+ def __delslice__(*args): return _grass6_wxnviz.DoubleVector___delslice__(*args)
365
+ def __delitem__(*args): return _grass6_wxnviz.DoubleVector___delitem__(*args)
366
+ def __getitem__(*args): return _grass6_wxnviz.DoubleVector___getitem__(*args)
367
+ def __setitem__(*args): return _grass6_wxnviz.DoubleVector___setitem__(*args)
368
+ def append(*args): return _grass6_wxnviz.DoubleVector_append(*args)
369
+ def empty(*args): return _grass6_wxnviz.DoubleVector_empty(*args)
370
+ def size(*args): return _grass6_wxnviz.DoubleVector_size(*args)
371
+ def clear(*args): return _grass6_wxnviz.DoubleVector_clear(*args)
372
+ def swap(*args): return _grass6_wxnviz.DoubleVector_swap(*args)
373
+ def get_allocator(*args): return _grass6_wxnviz.DoubleVector_get_allocator(*args)
374
+ def begin(*args): return _grass6_wxnviz.DoubleVector_begin(*args)
375
+ def end(*args): return _grass6_wxnviz.DoubleVector_end(*args)
376
+ def rbegin(*args): return _grass6_wxnviz.DoubleVector_rbegin(*args)
377
+ def rend(*args): return _grass6_wxnviz.DoubleVector_rend(*args)
378
+ def pop_back(*args): return _grass6_wxnviz.DoubleVector_pop_back(*args)
379
+ def erase(*args): return _grass6_wxnviz.DoubleVector_erase(*args)
380
+ def __init__(self, *args):
381
+ this = _grass6_wxnviz.new_DoubleVector(*args)
382
+ try: self.this.append(this)
383
+ except: self.this = this
384
+ def push_back(*args): return _grass6_wxnviz.DoubleVector_push_back(*args)
385
+ def front(*args): return _grass6_wxnviz.DoubleVector_front(*args)
386
+ def back(*args): return _grass6_wxnviz.DoubleVector_back(*args)
387
+ def assign(*args): return _grass6_wxnviz.DoubleVector_assign(*args)
388
+ def resize(*args): return _grass6_wxnviz.DoubleVector_resize(*args)
389
+ def insert(*args): return _grass6_wxnviz.DoubleVector_insert(*args)
390
+ def reserve(*args): return _grass6_wxnviz.DoubleVector_reserve(*args)
391
+ def capacity(*args): return _grass6_wxnviz.DoubleVector_capacity(*args)
392
+ __swig_destroy__ = _grass6_wxnviz.delete_DoubleVector
393
+ __del__ = lambda self : None;
394
+DoubleVector_swigregister = _grass6_wxnviz.DoubleVector_swigregister
395
+DoubleVector_swigregister(DoubleVector)
396
+
397
+class IntVecIntMap(_object):
398
+ __swig_setmethods__ = {}
399
+ __setattr__ = lambda self, name, value: _swig_setattr(self, IntVecIntMap, name, value)
400
+ __swig_getmethods__ = {}
401
+ __getattr__ = lambda self, name: _swig_getattr(self, IntVecIntMap, name)
402
+ __repr__ = _swig_repr
403
+ def iterator(*args): return _grass6_wxnviz.IntVecIntMap_iterator(*args)
404
+ def __iter__(self): return self.iterator()
405
+ def __nonzero__(*args): return _grass6_wxnviz.IntVecIntMap___nonzero__(*args)
406
+ def __len__(*args): return _grass6_wxnviz.IntVecIntMap___len__(*args)
407
+ def __getitem__(*args): return _grass6_wxnviz.IntVecIntMap___getitem__(*args)
408
+ def __delitem__(*args): return _grass6_wxnviz.IntVecIntMap___delitem__(*args)
409
+ def has_key(*args): return _grass6_wxnviz.IntVecIntMap_has_key(*args)
410
+ def keys(*args): return _grass6_wxnviz.IntVecIntMap_keys(*args)
411
+ def values(*args): return _grass6_wxnviz.IntVecIntMap_values(*args)
412
+ def items(*args): return _grass6_wxnviz.IntVecIntMap_items(*args)
413
+ def __contains__(*args): return _grass6_wxnviz.IntVecIntMap___contains__(*args)
414
+ def key_iterator(*args): return _grass6_wxnviz.IntVecIntMap_key_iterator(*args)
415
+ def value_iterator(*args): return _grass6_wxnviz.IntVecIntMap_value_iterator(*args)
416
+ def __iter__(self): return self.key_iterator()
417
+ def iterkeys(self): return self.key_iterator()
418
+ def itervalues(self): return self.value_iterator()
419
+ def iteritems(self): return self.iterator()
420
+ def __setitem__(*args): return _grass6_wxnviz.IntVecIntMap___setitem__(*args)
421
+ def __init__(self, *args):
422
+ this = _grass6_wxnviz.new_IntVecIntMap(*args)
423
+ try: self.this.append(this)
424
+ except: self.this = this
425
+ def empty(*args): return _grass6_wxnviz.IntVecIntMap_empty(*args)
426
+ def size(*args): return _grass6_wxnviz.IntVecIntMap_size(*args)
427
+ def clear(*args): return _grass6_wxnviz.IntVecIntMap_clear(*args)
428
+ def swap(*args): return _grass6_wxnviz.IntVecIntMap_swap(*args)
429
+ def get_allocator(*args): return _grass6_wxnviz.IntVecIntMap_get_allocator(*args)
430
+ def begin(*args): return _grass6_wxnviz.IntVecIntMap_begin(*args)
431
+ def end(*args): return _grass6_wxnviz.IntVecIntMap_end(*args)
432
+ def rbegin(*args): return _grass6_wxnviz.IntVecIntMap_rbegin(*args)
433
+ def rend(*args): return _grass6_wxnviz.IntVecIntMap_rend(*args)
434
+ def count(*args): return _grass6_wxnviz.IntVecIntMap_count(*args)
435
+ def erase(*args): return _grass6_wxnviz.IntVecIntMap_erase(*args)
436
+ def find(*args): return _grass6_wxnviz.IntVecIntMap_find(*args)
437
+ def lower_bound(*args): return _grass6_wxnviz.IntVecIntMap_lower_bound(*args)
438
+ def upper_bound(*args): return _grass6_wxnviz.IntVecIntMap_upper_bound(*args)
439
+ __swig_destroy__ = _grass6_wxnviz.delete_IntVecIntMap
440
+ __del__ = lambda self : None;
441
+IntVecIntMap_swigregister = _grass6_wxnviz.IntVecIntMap_swigregister
442
+IntVecIntMap_swigregister(IntVecIntMap)
443
+
444
+class Nviz(_object):
445
+ __swig_setmethods__ = {}
446
+ __setattr__ = lambda self, name, value: _swig_setattr(self, Nviz, name, value)
447
+ __swig_getmethods__ = {}
448
+ __getattr__ = lambda self, name: _swig_getattr(self, Nviz, name)
449
+ __repr__ = _swig_repr
450
+ def __init__(self, *args):
451
+ this = _grass6_wxnviz.new_Nviz(*args)
452
+ try: self.this.append(this)
453
+ except: self.this = this
454
+ __swig_destroy__ = _grass6_wxnviz.delete_Nviz
455
+ __del__ = lambda self : None;
456
+ def ResizeWindow(*args): return _grass6_wxnviz.Nviz_ResizeWindow(*args)
457
+ def SetViewDefault(*args): return _grass6_wxnviz.Nviz_SetViewDefault(*args)
458
+ def SetView(*args): return _grass6_wxnviz.Nviz_SetView(*args)
459
+ def SetZExag(*args): return _grass6_wxnviz.Nviz_SetZExag(*args)
460
+ def SetDisplay(*args): return _grass6_wxnviz.Nviz_SetDisplay(*args)
461
+ def InitView(*args): return _grass6_wxnviz.Nviz_InitView(*args)
462
+ def SetBgColor(*args): return _grass6_wxnviz.Nviz_SetBgColor(*args)
463
+ def SetLightsDefault(*args): return _grass6_wxnviz.Nviz_SetLightsDefault(*args)
464
+ def LoadSurface(*args): return _grass6_wxnviz.Nviz_LoadSurface(*args)
465
+ def UnloadSurface(*args): return _grass6_wxnviz.Nviz_UnloadSurface(*args)
466
+ def LoadVector(*args): return _grass6_wxnviz.Nviz_LoadVector(*args)
467
+ def UnloadVector(*args): return _grass6_wxnviz.Nviz_UnloadVector(*args)
468
+ def LoadVolume(*args): return _grass6_wxnviz.Nviz_LoadVolume(*args)
469
+ def UnloadVolume(*args): return _grass6_wxnviz.Nviz_UnloadVolume(*args)
470
+ def Draw(*args): return _grass6_wxnviz.Nviz_Draw(*args)
471
+ def EraseMap(*args): return _grass6_wxnviz.Nviz_EraseMap(*args)
472
+ def SetSurfaceTopo(*args): return _grass6_wxnviz.Nviz_SetSurfaceTopo(*args)
473
+ def SetSurfaceColor(*args): return _grass6_wxnviz.Nviz_SetSurfaceColor(*args)
474
+ def SetSurfaceMask(*args): return _grass6_wxnviz.Nviz_SetSurfaceMask(*args)
475
+ def SetSurfaceTransp(*args): return _grass6_wxnviz.Nviz_SetSurfaceTransp(*args)
476
+ def SetSurfaceShine(*args): return _grass6_wxnviz.Nviz_SetSurfaceShine(*args)
477
+ def SetSurfaceEmit(*args): return _grass6_wxnviz.Nviz_SetSurfaceEmit(*args)
478
+ def UnsetSurfaceMask(*args): return _grass6_wxnviz.Nviz_UnsetSurfaceMask(*args)
479
+ def UnsetSurfaceTransp(*args): return _grass6_wxnviz.Nviz_UnsetSurfaceTransp(*args)
480
+ def UnsetSurfaceEmit(*args): return _grass6_wxnviz.Nviz_UnsetSurfaceEmit(*args)
481
+ def SetSurfaceRes(*args): return _grass6_wxnviz.Nviz_SetSurfaceRes(*args)
482
+ def SetSurfaceStyle(*args): return _grass6_wxnviz.Nviz_SetSurfaceStyle(*args)
483
+ def SetWireColor(*args): return _grass6_wxnviz.Nviz_SetWireColor(*args)
484
+ def GetSurfacePosition(*args): return _grass6_wxnviz.Nviz_GetSurfacePosition(*args)
485
+ def SetSurfacePosition(*args): return _grass6_wxnviz.Nviz_SetSurfacePosition(*args)
486
+ def SetVectorLineMode(*args): return _grass6_wxnviz.Nviz_SetVectorLineMode(*args)
487
+ def SetVectorLineHeight(*args): return _grass6_wxnviz.Nviz_SetVectorLineHeight(*args)
488
+ def SetVectorLineSurface(*args): return _grass6_wxnviz.Nviz_SetVectorLineSurface(*args)
489
+ def SetVectorPointMode(*args): return _grass6_wxnviz.Nviz_SetVectorPointMode(*args)
490
+ def SetVectorPointHeight(*args): return _grass6_wxnviz.Nviz_SetVectorPointHeight(*args)
491
+ def SetVectorPointSurface(*args): return _grass6_wxnviz.Nviz_SetVectorPointSurface(*args)
492
+ def AddIsosurface(*args): return _grass6_wxnviz.Nviz_AddIsosurface(*args)
493
+ def DeleteIsosurface(*args): return _grass6_wxnviz.Nviz_DeleteIsosurface(*args)
494
+ def MoveIsosurface(*args): return _grass6_wxnviz.Nviz_MoveIsosurface(*args)
495
+ def SetIsosurfaceColor(*args): return _grass6_wxnviz.Nviz_SetIsosurfaceColor(*args)
496
+ def SetIsosurfaceMask(*args): return _grass6_wxnviz.Nviz_SetIsosurfaceMask(*args)
497
+ def SetIsosurfaceTransp(*args): return _grass6_wxnviz.Nviz_SetIsosurfaceTransp(*args)
498
+ def SetIsosurfaceShine(*args): return _grass6_wxnviz.Nviz_SetIsosurfaceShine(*args)
499
+ def SetIsosurfaceEmit(*args): return _grass6_wxnviz.Nviz_SetIsosurfaceEmit(*args)
500
+ def UnsetIsosurfaceMask(*args): return _grass6_wxnviz.Nviz_UnsetIsosurfaceMask(*args)
501
+ def UnsetIsosurfaceTransp(*args): return _grass6_wxnviz.Nviz_UnsetIsosurfaceTransp(*args)
502
+ def UnsetIsosurfaceEmit(*args): return _grass6_wxnviz.Nviz_UnsetIsosurfaceEmit(*args)
503
+ def SetIsosurfaceMode(*args): return _grass6_wxnviz.Nviz_SetIsosurfaceMode(*args)
504
+ def SetIsosurfaceRes(*args): return _grass6_wxnviz.Nviz_SetIsosurfaceRes(*args)
505
+Nviz_swigregister = _grass6_wxnviz.Nviz_swigregister
506
+Nviz_swigregister(Nviz)
507
+
508
+GV_POINT = _grass6_wxnviz.GV_POINT
509
+GV_LINE = _grass6_wxnviz.GV_LINE
510
+GV_BOUNDARY = _grass6_wxnviz.GV_BOUNDARY
511
+GV_CENTROID = _grass6_wxnviz.GV_CENTROID
512
+GV_FACE = _grass6_wxnviz.GV_FACE
513
+GV_KERNEL = _grass6_wxnviz.GV_KERNEL
514
+GV_AREA = _grass6_wxnviz.GV_AREA
515
+GV_VOLUME = _grass6_wxnviz.GV_VOLUME
516
+GV_POINTS = _grass6_wxnviz.GV_POINTS
517
+GV_LINES = _grass6_wxnviz.GV_LINES
518
+PORT_DOUBLE_MAX = _grass6_wxnviz.PORT_DOUBLE_MAX
519
+VIEW_DEFAULT_POS_X = _grass6_wxnviz.VIEW_DEFAULT_POS_X
520
+VIEW_DEFAULT_POS_Y = _grass6_wxnviz.VIEW_DEFAULT_POS_Y
521
+VIEW_DEFAULT_PERSP = _grass6_wxnviz.VIEW_DEFAULT_PERSP
522
+VIEW_DEFAULT_TWIST = _grass6_wxnviz.VIEW_DEFAULT_TWIST
523
+VIEW_DEFAULT_ZEXAG = _grass6_wxnviz.VIEW_DEFAULT_ZEXAG
524
+DM_GOURAUD = _grass6_wxnviz.DM_GOURAUD
525
+DM_FLAT = _grass6_wxnviz.DM_FLAT
526
+DM_FRINGE = _grass6_wxnviz.DM_FRINGE
527
+DM_WIRE = _grass6_wxnviz.DM_WIRE
528
+DM_COL_WIRE = _grass6_wxnviz.DM_COL_WIRE
529
+DM_POLY = _grass6_wxnviz.DM_POLY
530
+DM_WIRE_POLY = _grass6_wxnviz.DM_WIRE_POLY
531
+DM_GRID_WIRE = _grass6_wxnviz.DM_GRID_WIRE
532
+DM_GRID_SURF = _grass6_wxnviz.DM_GRID_SURF
533
+ST_X = _grass6_wxnviz.ST_X
534
+ST_BOX = _grass6_wxnviz.ST_BOX
535
+ST_SPHERE = _grass6_wxnviz.ST_SPHERE
536
+ST_CUBE = _grass6_wxnviz.ST_CUBE
537
+ST_DIAMOND = _grass6_wxnviz.ST_DIAMOND
538
+ST_DEC_TREE = _grass6_wxnviz.ST_DEC_TREE
539
+ST_CON_TREE = _grass6_wxnviz.ST_CON_TREE
540
+ST_ASTER = _grass6_wxnviz.ST_ASTER
541
+ST_GYRO = _grass6_wxnviz.ST_GYRO
542
+ST_HISTOGRAM = _grass6_wxnviz.ST_HISTOGRAM
543
+MAX_ISOSURFS = _grass6_wxnviz.MAX_ISOSURFS
544
+MAX_SLICES = _grass6_wxnviz.MAX_SLICES
545
+DRAW_QUICK_SURFACE = _grass6_wxnviz.DRAW_QUICK_SURFACE
546
+DRAW_QUICK_VLINES = _grass6_wxnviz.DRAW_QUICK_VLINES
547
+DRAW_QUICK_VPOINTS = _grass6_wxnviz.DRAW_QUICK_VPOINTS
548
+DRAW_QUICK_VOLUME = _grass6_wxnviz.DRAW_QUICK_VOLUME
549
+
550
+
551
diff -urNad grass-6.4.0~rc5+39426~/gui/wxpython/nviz/grass6_wxnviz_wrap.cpp grass-6.4.0~rc5+39426/gui/wxpython/nviz/grass6_wxnviz_wrap.cpp
552
--- grass-6.4.0~rc5+39426~/gui/wxpython/nviz/grass6_wxnviz_wrap.cpp 1970-01-01 01:00:00.000000000 +0100
553
+++ grass-6.4.0~rc5+39426/gui/wxpython/nviz/grass6_wxnviz_wrap.cpp 2009-10-08 00:01:13.000000000 +0200
554
@@ -0,0 +1,12315 @@
555
+/* ----------------------------------------------------------------------------
556
+ * This file was automatically generated by SWIG (http://www.swig.org).
557
+ * Version 1.3.36
558
+ *
559
+ * This file is not intended to be easily readable and contains a number of
560
+ * coding conventions designed to improve portability and efficiency. Do not make
561
+ * changes to this file unless you know what you are doing--modify the SWIG
562
+ * interface file instead.
563
+ * ----------------------------------------------------------------------------- */
564
+
565
+#define SWIGPYTHON
566
+#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
567
+
568
+#ifdef __cplusplus
569
+template<typename T> class SwigValueWrapper {
570
+ T *tt;
571
+public:
572
+ SwigValueWrapper() : tt(0) { }
573
+ SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
574
+ SwigValueWrapper(const T& t) : tt(new T(t)) { }
575
+ ~SwigValueWrapper() { delete tt; }
576
+ SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
577
+ operator T&() const { return *tt; }
578
+ T *operator&() { return tt; }
579
+private:
580
+ SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
581
+};
582
+
583
+template <typename T> T SwigValueInit() {
584
+ return T();
585
+}
586
+#endif
587
+
588
+/* -----------------------------------------------------------------------------
589
+ * This section contains generic SWIG labels for method/variable
590
+ * declarations/attributes, and other compiler dependent labels.
591
+ * ----------------------------------------------------------------------------- */
592
+
593
+/* template workaround for compilers that cannot correctly implement the C++ standard */
594
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
595
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
596
+# define SWIGTEMPLATEDISAMBIGUATOR template
597
+# elif defined(__HP_aCC)
598
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
599
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
600
+# define SWIGTEMPLATEDISAMBIGUATOR template
601
+# else
602
+# define SWIGTEMPLATEDISAMBIGUATOR
603
+# endif
604
+#endif
605
+
606
+/* inline attribute */
607
+#ifndef SWIGINLINE
608
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
609
+# define SWIGINLINE inline
610
+# else
611
+# define SWIGINLINE
612
+# endif
613
+#endif
614
+
615
+/* attribute recognised by some compilers to avoid 'unused' warnings */
616
+#ifndef SWIGUNUSED
617
+# if defined(__GNUC__)
618
+# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
619
+# define SWIGUNUSED __attribute__ ((__unused__))
620
+# else
621
+# define SWIGUNUSED
622
+# endif
623
+# elif defined(__ICC)
624
+# define SWIGUNUSED __attribute__ ((__unused__))
625
+# else
626
+# define SWIGUNUSED
627
+# endif
628
+#endif
629
+
630
+#ifndef SWIG_MSC_UNSUPPRESS_4505
631
+# if defined(_MSC_VER)
632
+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
633
+# endif
634
+#endif
635
+
636
+#ifndef SWIGUNUSEDPARM
637
+# ifdef __cplusplus
638
+# define SWIGUNUSEDPARM(p)
639
+# else
640
+# define SWIGUNUSEDPARM(p) p SWIGUNUSED
641
+# endif
642
+#endif
643
+
644
+/* internal SWIG method */
645
+#ifndef SWIGINTERN
646
+# define SWIGINTERN static SWIGUNUSED
647
+#endif
648
+
649
+/* internal inline SWIG method */
650
+#ifndef SWIGINTERNINLINE
651
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
652
+#endif
653
+
654
+/* exporting methods */
655
+#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
656
+# ifndef GCC_HASCLASSVISIBILITY
657
+# define GCC_HASCLASSVISIBILITY
658
+# endif
659
+#endif
660
+
661
+#ifndef SWIGEXPORT
662
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
663
+# if defined(STATIC_LINKED)
664
+# define SWIGEXPORT
665
+# else
666
+# define SWIGEXPORT __declspec(dllexport)
667
+# endif
668
+# else
669
+# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
670
+# define SWIGEXPORT __attribute__ ((visibility("default")))
671
+# else
672
+# define SWIGEXPORT
673
+# endif
674
+# endif
675
+#endif
676
+
677
+/* calling conventions for Windows */
678
+#ifndef SWIGSTDCALL
679
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
680
+# define SWIGSTDCALL __stdcall
681
+# else
682
+# define SWIGSTDCALL
683
+# endif
684
+#endif
685
+
686
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
687
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
688
+# define _CRT_SECURE_NO_DEPRECATE
689
+#endif
690
+
691
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
692
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
693
+# define _SCL_SECURE_NO_DEPRECATE
694
+#endif
695
+
696
+
697
+
698
+/* Python.h has to appear first */
699
+#include <Python.h>
700
+
701
+/* -----------------------------------------------------------------------------
702
+ * swigrun.swg
703
+ *
704
+ * This file contains generic CAPI SWIG runtime support for pointer
705
+ * type checking.
706
+ * ----------------------------------------------------------------------------- */
707
+
708
+/* This should only be incremented when either the layout of swig_type_info changes,
709
+ or for whatever reason, the runtime changes incompatibly */
710
+#define SWIG_RUNTIME_VERSION "4"
711
+
712
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
713
+#ifdef SWIG_TYPE_TABLE
714
+# define SWIG_QUOTE_STRING(x) #x
715
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
716
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
717
+#else
718
+# define SWIG_TYPE_TABLE_NAME
719
+#endif
720
+
721
+/*
722
+ You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
723
+ creating a static or dynamic library from the swig runtime code.
724
+ In 99.9% of the cases, swig just needs to declare them as 'static'.
725
+
726
+ But only do this if is strictly necessary, ie, if you have problems
727
+ with your compiler or so.
728
+*/
729
+
730
+#ifndef SWIGRUNTIME
731
+# define SWIGRUNTIME SWIGINTERN
732
+#endif
733
+
734
+#ifndef SWIGRUNTIMEINLINE
735
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
736
+#endif
737
+
738
+/* Generic buffer size */
739
+#ifndef SWIG_BUFFER_SIZE
740
+# define SWIG_BUFFER_SIZE 1024
741
+#endif
742
+
743
+/* Flags for pointer conversions */
744
+#define SWIG_POINTER_DISOWN 0x1
745
+#define SWIG_CAST_NEW_MEMORY 0x2
746
+
747
+/* Flags for new pointer objects */
748
+#define SWIG_POINTER_OWN 0x1
749
+
750
+
751
+/*
752
+ Flags/methods for returning states.
753
+
754
+ The swig conversion methods, as ConvertPtr, return and integer
755
+ that tells if the conversion was successful or not. And if not,
756
+ an error code can be returned (see swigerrors.swg for the codes).
757
+
758
+ Use the following macros/flags to set or process the returning
759
+ states.
760
+
761
+ In old swig versions, you usually write code as:
762
+
763
+ if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
764
+ // success code
765
+ } else {
766
+ //fail code
767
+ }
768
+
769
+ Now you can be more explicit as:
770
+
771
+ int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
772
+ if (SWIG_IsOK(res)) {
773
+ // success code
774
+ } else {
775
+ // fail code
776
+ }
777
+
778
+ that seems to be the same, but now you can also do
779
+
780
+ Type *ptr;
781
+ int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
782
+ if (SWIG_IsOK(res)) {
783
+ // success code
784
+ if (SWIG_IsNewObj(res) {
785
+ ...
786
+ delete *ptr;
787
+ } else {
788
+ ...
789
+ }
790
+ } else {
791
+ // fail code
792
+ }
793
+
794
+ I.e., now SWIG_ConvertPtr can return new objects and you can
795
+ identify the case and take care of the deallocation. Of course that
796
+ requires also to SWIG_ConvertPtr to return new result values, as
797
+
798
+ int SWIG_ConvertPtr(obj, ptr,...) {
799
+ if (<obj is ok>) {
800
+ if (<need new object>) {
801
+ *ptr = <ptr to new allocated object>;
802
+ return SWIG_NEWOBJ;
803
+ } else {
804
+ *ptr = <ptr to old object>;
805
+ return SWIG_OLDOBJ;
806
+ }
807
+ } else {
808
+ return SWIG_BADOBJ;
809
+ }
810
+ }
811
+
812
+ Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
813
+ more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
814
+ swig errors code.
815
+
816
+ Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
817
+ allows to return the 'cast rank', for example, if you have this
818
+
819
+ int food(double)
820
+ int fooi(int);
821
+
822
+ and you call
823
+
824
+ food(1) // cast rank '1' (1 -> 1.0)
825
+ fooi(1) // cast rank '0'
826
+
827
+ just use the SWIG_AddCast()/SWIG_CheckState()
828
+
829
+
830
+ */
831
+#define SWIG_OK (0)
832
+#define SWIG_ERROR (-1)
833
+#define SWIG_IsOK(r) (r >= 0)
834
+#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
835
+
836
+/* The CastRankLimit says how many bits are used for the cast rank */
837
+#define SWIG_CASTRANKLIMIT (1 << 8)
838
+/* The NewMask denotes the object was created (using new/malloc) */
839
+#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
840
+/* The TmpMask is for in/out typemaps that use temporal objects */
841
+#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
842
+/* Simple returning values */
843
+#define SWIG_BADOBJ (SWIG_ERROR)
844
+#define SWIG_OLDOBJ (SWIG_OK)
845
+#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
846
+#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
847
+/* Check, add and del mask methods */
848
+#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
849
+#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
850
+#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
851
+#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
852
+#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
853
+#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
854
+
855
+
856
+/* Cast-Rank Mode */
857
+#if defined(SWIG_CASTRANK_MODE)
858
+# ifndef SWIG_TypeRank
859
+# define SWIG_TypeRank unsigned long
860
+# endif
861
+# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
862
+# define SWIG_MAXCASTRANK (2)
863
+# endif
864
+# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
865
+# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
866
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
867
+ return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
868
+}
869
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
870
+ return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
871
+}
872
+#else /* no cast-rank mode */
873
+# define SWIG_AddCast
874
+# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
875
+#endif
876
+
877
+
878
+
879
+
880
+#include <string.h>
881
+
882
+#ifdef __cplusplus
883
+extern "C" {
884
+#endif
885
+
886
+typedef void *(*swig_converter_func)(void *, int *);
887
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
888
+
889
+/* Structure to store information on one type */
890
+typedef struct swig_type_info {
891
+ const char *name; /* mangled name of this type */
892
+ const char *str; /* human readable name of this type */
893
+ swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
894
+ struct swig_cast_info *cast; /* linked list of types that can cast into this type */
895
+ void *clientdata; /* language specific type data */
896
+ int owndata; /* flag if the structure owns the clientdata */
897
+} swig_type_info;
898
+
899
+/* Structure to store a type and conversion function used for casting */
900
+typedef struct swig_cast_info {
901
+ swig_type_info *type; /* pointer to type that is equivalent to this type */
902
+ swig_converter_func converter; /* function to cast the void pointers */
903
+ struct swig_cast_info *next; /* pointer to next cast in linked list */
904
+ struct swig_cast_info *prev; /* pointer to the previous cast */
905
+} swig_cast_info;
906
+
907
+/* Structure used to store module information
908
+ * Each module generates one structure like this, and the runtime collects
909
+ * all of these structures and stores them in a circularly linked list.*/
910
+typedef struct swig_module_info {
911
+ swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
912
+ size_t size; /* Number of types in this module */
913
+ struct swig_module_info *next; /* Pointer to next element in circularly linked list */
914
+ swig_type_info **type_initial; /* Array of initially generated type structures */
915
+ swig_cast_info **cast_initial; /* Array of initially generated casting structures */
916
+ void *clientdata; /* Language specific module data */
917
+} swig_module_info;
918
+
919
+/*
920
+ Compare two type names skipping the space characters, therefore
921
+ "char*" == "char *" and "Class<int>" == "Class<int >", etc.
922
+
923
+ Return 0 when the two name types are equivalent, as in
924
+ strncmp, but skipping ' '.
925
+*/
926
+SWIGRUNTIME int
927
+SWIG_TypeNameComp(const char *f1, const char *l1,
928
+ const char *f2, const char *l2) {
929
+ for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
930
+ while ((*f1 == ' ') && (f1 != l1)) ++f1;
931
+ while ((*f2 == ' ') && (f2 != l2)) ++f2;
932
+ if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
933
+ }
934
+ return (int)((l1 - f1) - (l2 - f2));
935
+}
936
+
937
+/*
938
+ Check type equivalence in a name list like <name1>|<name2>|...
939
+ Return 0 if not equal, 1 if equal
940
+*/
941
+SWIGRUNTIME int
942
+SWIG_TypeEquiv(const char *nb, const char *tb) {
943
+ int equiv = 0;
944
+ const char* te = tb + strlen(tb);
945
+ const char* ne = nb;
946
+ while (!equiv && *ne) {
947
+ for (nb = ne; *ne; ++ne) {
948
+ if (*ne == '|') break;
949
+ }
950
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
951
+ if (*ne) ++ne;
952
+ }
953
+ return equiv;
954
+}
955
+
956
+/*
957
+ Check type equivalence in a name list like <name1>|<name2>|...
958
+ Return 0 if equal, -1 if nb < tb, 1 if nb > tb
959
+*/
960
+SWIGRUNTIME int
961
+SWIG_TypeCompare(const char *nb, const char *tb) {
962
+ int equiv = 0;
963
+ const char* te = tb + strlen(tb);
964
+ const char* ne = nb;
965
+ while (!equiv && *ne) {
966
+ for (nb = ne; *ne; ++ne) {
967
+ if (*ne == '|') break;
968
+ }
969
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
970
+ if (*ne) ++ne;
971
+ }
972
+ return equiv;
973
+}
974
+
975
+
976
+/* think of this as a c++ template<> or a scheme macro */
977
+#define SWIG_TypeCheck_Template(comparison, ty) \
978
+ if (ty) { \
979
+ swig_cast_info *iter = ty->cast; \
980
+ while (iter) { \
981
+ if (comparison) { \
982
+ if (iter == ty->cast) return iter; \
983
+ /* Move iter to the top of the linked list */ \
984
+ iter->prev->next = iter->next; \
985
+ if (iter->next) \
986
+ iter->next->prev = iter->prev; \
987
+ iter->next = ty->cast; \
988
+ iter->prev = 0; \
989
+ if (ty->cast) ty->cast->prev = iter; \
990
+ ty->cast = iter; \
991
+ return iter; \
992
+ } \
993
+ iter = iter->next; \
994
+ } \
995
+ } \
996
+ return 0
997
+
998
+/*
999
+ Check the typename
1000
+*/
1001
+SWIGRUNTIME swig_cast_info *
1002
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
1003
+ SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
1004
+}
1005
+
1006
+/* Same as previous function, except strcmp is replaced with a pointer comparison */
1007
+SWIGRUNTIME swig_cast_info *
1008
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
1009
+ SWIG_TypeCheck_Template(iter->type == from, into);
1010
+}
1011
+
1012
+/*
1013
+ Cast a pointer up an inheritance hierarchy
1014
+*/
1015
+SWIGRUNTIMEINLINE void *
1016
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
1017
+ return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
1018
+}
1019
+
1020
+/*
1021
+ Dynamic pointer casting. Down an inheritance hierarchy
1022
+*/
1023
+SWIGRUNTIME swig_type_info *
1024
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
1025
+ swig_type_info *lastty = ty;
1026
+ if (!ty || !ty->dcast) return ty;
1027
+ while (ty && (ty->dcast)) {
1028
+ ty = (*ty->dcast)(ptr);
1029
+ if (ty) lastty = ty;
1030
+ }
1031
+ return lastty;
1032
+}
1033
+
1034
+/*
1035
+ Return the name associated with this type
1036
+*/
1037
+SWIGRUNTIMEINLINE const char *
1038
+SWIG_TypeName(const swig_type_info *ty) {
1039
+ return ty->name;
1040
+}
1041
+
1042
+/*
1043
+ Return the pretty name associated with this type,
1044
+ that is an unmangled type name in a form presentable to the user.
1045
+*/
1046
+SWIGRUNTIME const char *
1047
+SWIG_TypePrettyName(const swig_type_info *type) {
1048
+ /* The "str" field contains the equivalent pretty names of the
1049
+ type, separated by vertical-bar characters. We choose
1050
+ to print the last name, as it is often (?) the most
1051
+ specific. */
1052
+ if (!type) return NULL;
1053
+ if (type->str != NULL) {
1054
+ const char *last_name = type->str;
1055
+ const char *s;
1056
+ for (s = type->str; *s; s++)
1057
+ if (*s == '|') last_name = s+1;
1058
+ return last_name;
1059
+ }
1060
+ else
1061
+ return type->name;
1062
+}
1063
+
1064
+/*
1065
+ Set the clientdata field for a type
1066
+*/
1067
+SWIGRUNTIME void
1068
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
1069
+ swig_cast_info *cast = ti->cast;
1070
+ /* if (ti->clientdata == clientdata) return; */
1071
+ ti->clientdata = clientdata;
1072
+
1073
+ while (cast) {
1074
+ if (!cast->converter) {
1075
+ swig_type_info *tc = cast->type;
1076
+ if (!tc->clientdata) {
1077
+ SWIG_TypeClientData(tc, clientdata);
1078
+ }
1079
+ }
1080
+ cast = cast->next;
1081
+ }
1082
+}
1083
+SWIGRUNTIME void
1084
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
1085
+ SWIG_TypeClientData(ti, clientdata);
1086
+ ti->owndata = 1;
1087
+}
1088
+
1089
+/*
1090
+ Search for a swig_type_info structure only by mangled name
1091
+ Search is a O(log #types)
1092
+
1093
+ We start searching at module start, and finish searching when start == end.
1094
+ Note: if start == end at the beginning of the function, we go all the way around
1095
+ the circular list.
1096
+*/
1097
+SWIGRUNTIME swig_type_info *
1098
+SWIG_MangledTypeQueryModule(swig_module_info *start,
1099
+ swig_module_info *end,
1100
+ const char *name) {
1101
+ swig_module_info *iter = start;
1102
+ do {
1103
+ if (iter->size) {
1104
+ register size_t l = 0;
1105
+ register size_t r = iter->size - 1;
1106
+ do {
1107
+ /* since l+r >= 0, we can (>> 1) instead (/ 2) */
1108
+ register size_t i = (l + r) >> 1;
1109
+ const char *iname = iter->types[i]->name;
1110
+ if (iname) {
1111
+ register int compare = strcmp(name, iname);
1112
+ if (compare == 0) {
1113
+ return iter->types[i];
1114
+ } else if (compare < 0) {
1115
+ if (i) {
1116
+ r = i - 1;
1117
+ } else {
1118
+ break;
1119
+ }
1120
+ } else if (compare > 0) {
1121
+ l = i + 1;
1122
+ }
1123
+ } else {
1124
+ break; /* should never happen */
1125
+ }
1126
+ } while (l <= r);
1127
+ }
1128
+ iter = iter->next;
1129
+ } while (iter != end);
1130
+ return 0;
1131
+}
1132
+
1133
+/*
1134
+ Search for a swig_type_info structure for either a mangled name or a human readable name.
1135
+ It first searches the mangled names of the types, which is a O(log #types)
1136
+ If a type is not found it then searches the human readable names, which is O(#types).
1137
+
1138
+ We start searching at module start, and finish searching when start == end.
1139
+ Note: if start == end at the beginning of the function, we go all the way around
1140
+ the circular list.
1141
+*/
1142
+SWIGRUNTIME swig_type_info *
1143
+SWIG_TypeQueryModule(swig_module_info *start,
1144
+ swig_module_info *end,
1145
+ const char *name) {
1146
+ /* STEP 1: Search the name field using binary search */
1147
+ swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
1148
+ if (ret) {
1149
+ return ret;
1150
+ } else {
1151
+ /* STEP 2: If the type hasn't been found, do a complete search
1152
+ of the str field (the human readable name) */
1153
+ swig_module_info *iter = start;
1154
+ do {
1155
+ register size_t i = 0;
1156
+ for (; i < iter->size; ++i) {
1157
+ if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
1158
+ return iter->types[i];
1159
+ }
1160
+ iter = iter->next;
1161
+ } while (iter != end);
1162
+ }
1163
+
1164
+ /* neither found a match */
1165
+ return 0;
1166
+}
1167
+
1168
+/*
1169
+ Pack binary data into a string
1170
+*/
1171
+SWIGRUNTIME char *
1172
+SWIG_PackData(char *c, void *ptr, size_t sz) {
1173
+ static const char hex[17] = "0123456789abcdef";
1174
+ register const unsigned char *u = (unsigned char *) ptr;
1175
+ register const unsigned char *eu = u + sz;
1176
+ for (; u != eu; ++u) {
1177
+ register unsigned char uu = *u;
1178
+ *(c++) = hex[(uu & 0xf0) >> 4];
1179
+ *(c++) = hex[uu & 0xf];
1180
+ }
1181
+ return c;
1182
+}
1183
+
1184
+/*
1185
+ Unpack binary data from a string
1186
+*/
1187
+SWIGRUNTIME const char *
1188
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
1189
+ register unsigned char *u = (unsigned char *) ptr;
1190
+ register const unsigned char *eu = u + sz;
1191
+ for (; u != eu; ++u) {
1192
+ register char d = *(c++);
1193
+ register unsigned char uu;
1194
+ if ((d >= '0') && (d <= '9'))
1195
+ uu = ((d - '0') << 4);
1196
+ else if ((d >= 'a') && (d <= 'f'))
1197
+ uu = ((d - ('a'-10)) << 4);
1198
+ else
1199
+ return (char *) 0;
1200
+ d = *(c++);
1201
+ if ((d >= '0') && (d <= '9'))
1202
+ uu |= (d - '0');
1203
+ else if ((d >= 'a') && (d <= 'f'))
1204
+ uu |= (d - ('a'-10));
1205
+ else
1206
+ return (char *) 0;
1207
+ *u = uu;
1208
+ }
1209
+ return c;
1210
+}
1211
+
1212
+/*
1213
+ Pack 'void *' into a string buffer.
1214
+*/
1215
+SWIGRUNTIME char *
1216
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
1217
+ char *r = buff;
1218
+ if ((2*sizeof(void *) + 2) > bsz) return 0;
1219
+ *(r++) = '_';
1220
+ r = SWIG_PackData(r,&ptr,sizeof(void *));
1221
+ if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
1222
+ strcpy(r,name);
1223
+ return buff;
1224
+}
1225
+
1226
+SWIGRUNTIME const char *
1227
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
1228
+ if (*c != '_') {
1229
+ if (strcmp(c,"NULL") == 0) {
1230
+ *ptr = (void *) 0;
1231
+ return name;
1232
+ } else {
1233
+ return 0;
1234
+ }
1235
+ }
1236
+ return SWIG_UnpackData(++c,ptr,sizeof(void *));
1237
+}
1238
+
1239
+SWIGRUNTIME char *
1240
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
1241
+ char *r = buff;
1242
+ size_t lname = (name ? strlen(name) : 0);
1243
+ if ((2*sz + 2 + lname) > bsz) return 0;
1244
+ *(r++) = '_';
1245
+ r = SWIG_PackData(r,ptr,sz);
1246
+ if (lname) {
1247
+ strncpy(r,name,lname+1);
1248
+ } else {
1249
+ *r = 0;
1250
+ }
1251
+ return buff;
1252
+}
1253
+
1254
+SWIGRUNTIME const char *
1255
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
1256
+ if (*c != '_') {
1257
+ if (strcmp(c,"NULL") == 0) {
1258
+ memset(ptr,0,sz);
1259
+ return name;
1260
+ } else {
1261
+ return 0;
1262
+ }
1263
+ }
1264
+ return SWIG_UnpackData(++c,ptr,sz);
1265
+}
1266
+
1267
+#ifdef __cplusplus
1268
+}
1269
+#endif
1270
+
1271
+/* Errors in SWIG */
1272
+#define SWIG_UnknownError -1
1273
+#define SWIG_IOError -2
1274
+#define SWIG_RuntimeError -3
1275
+#define SWIG_IndexError -4
1276
+#define SWIG_TypeError -5
1277
+#define SWIG_DivisionByZero -6
1278
+#define SWIG_OverflowError -7
1279
+#define SWIG_SyntaxError -8
1280
+#define SWIG_ValueError -9
1281
+#define SWIG_SystemError -10
1282
+#define SWIG_AttributeError -11
1283
+#define SWIG_MemoryError -12
1284
+#define SWIG_NullReferenceError -13
1285
+
1286
+
1287
+
1288
+
1289
+/* Add PyOS_snprintf for old Pythons */
1290
+#if PY_VERSION_HEX < 0x02020000
1291
+# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
1292
+# define PyOS_snprintf _snprintf
1293
+# else
1294
+# define PyOS_snprintf snprintf
1295
+# endif
1296
+#endif
1297
+
1298
+/* A crude PyString_FromFormat implementation for old Pythons */
1299
+#if PY_VERSION_HEX < 0x02020000
1300
+
1301
+#ifndef SWIG_PYBUFFER_SIZE
1302
+# define SWIG_PYBUFFER_SIZE 1024
1303
+#endif
1304
+
1305
+static PyObject *
1306
+PyString_FromFormat(const char *fmt, ...) {
1307
+ va_list ap;
1308
+ char buf[SWIG_PYBUFFER_SIZE * 2];
1309
+ int res;
1310
+ va_start(ap, fmt);
1311
+ res = vsnprintf(buf, sizeof(buf), fmt, ap);
1312
+ va_end(ap);
1313
+ return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
1314
+}
1315
+#endif
1316
+
1317
+/* Add PyObject_Del for old Pythons */
1318
+#if PY_VERSION_HEX < 0x01060000
1319
+# define PyObject_Del(op) PyMem_DEL((op))
1320
+#endif
1321
+#ifndef PyObject_DEL
1322
+# define PyObject_DEL PyObject_Del
1323
+#endif
1324
+
1325
+/* A crude PyExc_StopIteration exception for old Pythons */
1326
+#if PY_VERSION_HEX < 0x02020000
1327
+# ifndef PyExc_StopIteration
1328
+# define PyExc_StopIteration PyExc_RuntimeError
1329
+# endif
1330
+# ifndef PyObject_GenericGetAttr
1331
+# define PyObject_GenericGetAttr 0
1332
+# endif
1333
+#endif
1334
+/* Py_NotImplemented is defined in 2.1 and up. */
1335
+#if PY_VERSION_HEX < 0x02010000
1336
+# ifndef Py_NotImplemented
1337
+# define Py_NotImplemented PyExc_RuntimeError
1338
+# endif
1339
+#endif
1340
+
1341
+
1342
+/* A crude PyString_AsStringAndSize implementation for old Pythons */
1343
+#if PY_VERSION_HEX < 0x02010000
1344
+# ifndef PyString_AsStringAndSize
1345
+# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
1346
+# endif
1347
+#endif
1348
+
1349
+/* PySequence_Size for old Pythons */
1350
+#if PY_VERSION_HEX < 0x02000000
1351
+# ifndef PySequence_Size
1352
+# define PySequence_Size PySequence_Length
1353
+# endif
1354
+#endif
1355
+
1356
+
1357
+/* PyBool_FromLong for old Pythons */
1358
+#if PY_VERSION_HEX < 0x02030000
1359
+static
1360
+PyObject *PyBool_FromLong(long ok)
1361
+{
1362
+ PyObject *result = ok ? Py_True : Py_False;
1363
+ Py_INCREF(result);
1364
+ return result;
1365
+}
1366
+#endif
1367
+
1368
+/* Py_ssize_t for old Pythons */
1369
+/* This code is as recommended by: */
1370
+/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
1371
+#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
1372
+typedef int Py_ssize_t;
1373
+# define PY_SSIZE_T_MAX INT_MAX
1374
+# define PY_SSIZE_T_MIN INT_MIN
1375
+#endif
1376
+
1377
+/* -----------------------------------------------------------------------------
1378
+ * error manipulation
1379
+ * ----------------------------------------------------------------------------- */
1380
+
1381
+SWIGRUNTIME PyObject*
1382
+SWIG_Python_ErrorType(int code) {
1383
+ PyObject* type = 0;
1384
+ switch(code) {
1385
+ case SWIG_MemoryError:
1386
+ type = PyExc_MemoryError;
1387
+ break;
1388
+ case SWIG_IOError:
1389
+ type = PyExc_IOError;
1390
+ break;
1391
+ case SWIG_RuntimeError:
1392
+ type = PyExc_RuntimeError;
1393
+ break;
1394
+ case SWIG_IndexError:
1395
+ type = PyExc_IndexError;
1396
+ break;
1397
+ case SWIG_TypeError:
1398
+ type = PyExc_TypeError;
1399
+ break;
1400
+ case SWIG_DivisionByZero:
1401
+ type = PyExc_ZeroDivisionError;
1402
+ break;
1403
+ case SWIG_OverflowError:
1404
+ type = PyExc_OverflowError;
1405
+ break;
1406
+ case SWIG_SyntaxError:
1407
+ type = PyExc_SyntaxError;
1408
+ break;
1409
+ case SWIG_ValueError:
1410
+ type = PyExc_ValueError;
1411
+ break;
1412
+ case SWIG_SystemError:
1413
+ type = PyExc_SystemError;
1414
+ break;
1415
+ case SWIG_AttributeError:
1416
+ type = PyExc_AttributeError;
1417
+ break;
1418
+ default:
1419
+ type = PyExc_RuntimeError;
1420
+ }
1421
+ return type;
1422
+}
1423
+
1424
+
1425
+SWIGRUNTIME void
1426
+SWIG_Python_AddErrorMsg(const char* mesg)
1427
+{
1428
+ PyObject *type = 0;
1429
+ PyObject *value = 0;
1430
+ PyObject *traceback = 0;
1431
+
1432
+ if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1433
+ if (value) {
1434
+ PyObject *old_str = PyObject_Str(value);
1435
+ PyErr_Clear();
1436
+ Py_XINCREF(type);
1437
+ PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1438
+ Py_DECREF(old_str);
1439
+ Py_DECREF(value);
1440
+ } else {
1441
+ PyErr_SetString(PyExc_RuntimeError, mesg);
1442
+ }
1443
+}
1444
+
1445
+
1446
+
1447
+#if defined(SWIG_PYTHON_NO_THREADS)
1448
+# if defined(SWIG_PYTHON_THREADS)
1449
+# undef SWIG_PYTHON_THREADS
1450
+# endif
1451
+#endif
1452
+#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1453
+# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1454
+# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1455
+# define SWIG_PYTHON_USE_GIL
1456
+# endif
1457
+# endif
1458
+# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1459
+# ifndef SWIG_PYTHON_INITIALIZE_THREADS
1460
+# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1461
+# endif
1462
+# ifdef __cplusplus /* C++ code */
1463
+ class SWIG_Python_Thread_Block {
1464
+ bool status;
1465
+ PyGILState_STATE state;
1466
+ public:
1467
+ void end() { if (status) { PyGILState_Release(state); status = false;} }
1468
+ SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1469
+ ~SWIG_Python_Thread_Block() { end(); }
1470
+ };
1471
+ class SWIG_Python_Thread_Allow {
1472
+ bool status;
1473
+ PyThreadState *save;
1474
+ public:
1475
+ void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1476
+ SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1477
+ ~SWIG_Python_Thread_Allow() { end(); }
1478
+ };
1479
+# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1480
+# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1481
+# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1482
+# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1483
+# else /* C code */
1484
+# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1485
+# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1486
+# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1487
+# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1488
+# endif
1489
+# else /* Old thread way, not implemented, user must provide it */
1490
+# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1491
+# define SWIG_PYTHON_INITIALIZE_THREADS
1492
+# endif
1493
+# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1494
+# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1495
+# endif
1496
+# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1497
+# define SWIG_PYTHON_THREAD_END_BLOCK
1498
+# endif
1499
+# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1500
+# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1501
+# endif
1502
+# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1503
+# define SWIG_PYTHON_THREAD_END_ALLOW
1504
+# endif
1505
+# endif
1506
+#else /* No thread support */
1507
+# define SWIG_PYTHON_INITIALIZE_THREADS
1508
+# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1509
+# define SWIG_PYTHON_THREAD_END_BLOCK
1510
+# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1511
+# define SWIG_PYTHON_THREAD_END_ALLOW
1512
+#endif
1513
+
1514
+/* -----------------------------------------------------------------------------
1515
+ * Python API portion that goes into the runtime
1516
+ * ----------------------------------------------------------------------------- */
1517
+
1518
+#ifdef __cplusplus
1519
+extern "C" {
1520
+#if 0
1521
+} /* cc-mode */
1522
+#endif
1523
+#endif
1524
+
1525
+/* -----------------------------------------------------------------------------
1526
+ * Constant declarations
1527
+ * ----------------------------------------------------------------------------- */
1528
+
1529
+/* Constant Types */
1530
+#define SWIG_PY_POINTER 4
1531
+#define SWIG_PY_BINARY 5
1532
+
1533
+/* Constant information structure */
1534
+typedef struct swig_const_info {
1535
+ int type;
1536
+ char *name;
1537
+ long lvalue;
1538
+ double dvalue;
1539
+ void *pvalue;
1540
+ swig_type_info **ptype;
1541
+} swig_const_info;
1542
+
1543
+#ifdef __cplusplus
1544
+#if 0
1545
+{ /* cc-mode */
1546
+#endif
1547
+}
1548
+#endif
1549
+
1550
+
1551
+/* -----------------------------------------------------------------------------
1552
+ * See the LICENSE file for information on copyright, usage and redistribution
1553
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
1554
+ *
1555
+ * pyrun.swg
1556
+ *
1557
+ * This file contains the runtime support for Python modules
1558
+ * and includes code for managing global variables and pointer
1559
+ * type checking.
1560
+ *
1561
+ * ----------------------------------------------------------------------------- */
1562
+
1563
+/* Common SWIG API */
1564
+
1565
+/* for raw pointers */
1566
+#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1567
+#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1568
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1569
+#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
1570
+#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1571
+#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1572
+#define swig_owntype int
1573
+
1574
+/* for raw packed data */
1575
+#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1576
+#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1577
+
1578
+/* for class or struct pointers */
1579
+#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1580
+#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1581
+
1582
+/* for C or C++ function pointers */
1583
+#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1584
+#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1585
+
1586
+/* for C++ member pointers, ie, member methods */
1587
+#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1588
+#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1589
+
1590
+
1591
+/* Runtime API */
1592
+
1593
+#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1594
+#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1595
+#define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1596
+
1597
+#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1598
+#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1599
+#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1600
+#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1601
+#define SWIG_fail goto fail
1602
+
1603
+
1604
+/* Runtime API implementation */
1605
+
1606
+/* Error manipulation */
1607
+
1608
+SWIGINTERN void
1609
+SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1610
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1611
+ PyErr_SetObject(errtype, obj);
1612
+ Py_DECREF(obj);
1613
+ SWIG_PYTHON_THREAD_END_BLOCK;
1614
+}
1615
+
1616
+SWIGINTERN void
1617
+SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1618
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1619
+ PyErr_SetString(errtype, (char *) msg);
1620
+ SWIG_PYTHON_THREAD_END_BLOCK;
1621
+}
1622
+
1623
+#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1624
+
1625
+/* Set a constant value */
1626
+
1627
+SWIGINTERN void
1628
+SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1629
+ PyDict_SetItemString(d, (char*) name, obj);
1630
+ Py_DECREF(obj);
1631
+}
1632
+
1633
+/* Append a value to the result obj */
1634
+
1635
+SWIGINTERN PyObject*
1636
+SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1637
+#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1638
+ if (!result) {
1639
+ result = obj;
1640
+ } else if (result == Py_None) {
1641
+ Py_DECREF(result);
1642
+ result = obj;
1643
+ } else {
1644
+ if (!PyList_Check(result)) {
1645
+ PyObject *o2 = result;
1646
+ result = PyList_New(1);
1647
+ PyList_SetItem(result, 0, o2);
1648
+ }
1649
+ PyList_Append(result,obj);
1650
+ Py_DECREF(obj);
1651
+ }
1652
+ return result;
1653
+#else
1654
+ PyObject* o2;
1655
+ PyObject* o3;
1656
+ if (!result) {
1657
+ result = obj;
1658
+ } else if (result == Py_None) {
1659
+ Py_DECREF(result);
1660
+ result = obj;
1661
+ } else {
1662
+ if (!PyTuple_Check(result)) {
1663
+ o2 = result;
1664
+ result = PyTuple_New(1);
1665
+ PyTuple_SET_ITEM(result, 0, o2);
1666
+ }
1667
+ o3 = PyTuple_New(1);
1668
+ PyTuple_SET_ITEM(o3, 0, obj);
1669
+ o2 = result;
1670
+ result = PySequence_Concat(o2, o3);
1671
+ Py_DECREF(o2);
1672
+ Py_DECREF(o3);
1673
+ }
1674
+ return result;
1675
+#endif
1676
+}
1677
+
1678
+/* Unpack the argument tuple */
1679
+
1680
+SWIGINTERN int
1681
+SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1682
+{
1683
+ if (!args) {
1684
+ if (!min && !max) {
1685
+ return 1;
1686
+ } else {
1687
+ PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1688
+ name, (min == max ? "" : "at least "), (int)min);
1689
+ return 0;
1690
+ }
1691
+ }
1692
+ if (!PyTuple_Check(args)) {
1693
+ PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1694
+ return 0;
1695
+ } else {
1696
+ register Py_ssize_t l = PyTuple_GET_SIZE(args);
1697
+ if (l < min) {
1698
+ PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1699
+ name, (min == max ? "" : "at least "), (int)min, (int)l);
1700
+ return 0;
1701
+ } else if (l > max) {
1702
+ PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1703
+ name, (min == max ? "" : "at most "), (int)max, (int)l);
1704
+ return 0;
1705
+ } else {
1706
+ register int i;
1707
+ for (i = 0; i < l; ++i) {
1708
+ objs[i] = PyTuple_GET_ITEM(args, i);
1709
+ }
1710
+ for (; l < max; ++l) {
1711
+ objs[l] = 0;
1712
+ }
1713
+ return i + 1;
1714
+ }
1715
+ }
1716
+}
1717
+
1718
+/* A functor is a function object with one single object argument */
1719
+#if PY_VERSION_HEX >= 0x02020000
1720
+#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1721
+#else
1722
+#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1723
+#endif
1724
+
1725
+/*
1726
+ Helper for static pointer initialization for both C and C++ code, for example
1727
+ static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1728
+*/
1729
+#ifdef __cplusplus
1730
+#define SWIG_STATIC_POINTER(var) var
1731
+#else
1732
+#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1733
+#endif
1734
+
1735
+/* -----------------------------------------------------------------------------
1736
+ * Pointer declarations
1737
+ * ----------------------------------------------------------------------------- */
1738
+
1739
+/* Flags for new pointer objects */
1740
+#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1741
+#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1742
+
1743
+#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1744
+
1745
+#ifdef __cplusplus
1746
+extern "C" {
1747
+#if 0
1748
+} /* cc-mode */
1749
+#endif
1750
+#endif
1751
+
1752
+/* How to access Py_None */
1753
+#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1754
+# ifndef SWIG_PYTHON_NO_BUILD_NONE
1755
+# ifndef SWIG_PYTHON_BUILD_NONE
1756
+# define SWIG_PYTHON_BUILD_NONE
1757
+# endif
1758
+# endif
1759
+#endif
1760
+
1761
+#ifdef SWIG_PYTHON_BUILD_NONE
1762
+# ifdef Py_None
1763
+# undef Py_None
1764
+# define Py_None SWIG_Py_None()
1765
+# endif
1766
+SWIGRUNTIMEINLINE PyObject *
1767
+_SWIG_Py_None(void)
1768
+{
1769
+ PyObject *none = Py_BuildValue((char*)"");
1770
+ Py_DECREF(none);
1771
+ return none;
1772
+}
1773
+SWIGRUNTIME PyObject *
1774
+SWIG_Py_None(void)
1775
+{
1776
+ static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1777
+ return none;
1778
+}
1779
+#endif
1780
+
1781
+/* The python void return value */
1782
+
1783
+SWIGRUNTIMEINLINE PyObject *
1784
+SWIG_Py_Void(void)
1785
+{
1786
+ PyObject *none = Py_None;
1787
+ Py_INCREF(none);
1788
+ return none;
1789
+}
1790
+
1791
+/* PySwigClientData */
1792
+
1793
+typedef struct {
1794
+ PyObject *klass;
1795
+ PyObject *newraw;
1796
+ PyObject *newargs;
1797
+ PyObject *destroy;
1798
+ int delargs;
1799
+ int implicitconv;
1800
+} PySwigClientData;
1801
+
1802
+SWIGRUNTIMEINLINE int
1803
+SWIG_Python_CheckImplicit(swig_type_info *ty)
1804
+{
1805
+ PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1806
+ return data ? data->implicitconv : 0;
1807
+}
1808
+
1809
+SWIGRUNTIMEINLINE PyObject *
1810
+SWIG_Python_ExceptionType(swig_type_info *desc) {
1811
+ PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1812
+ PyObject *klass = data ? data->klass : 0;
1813
+ return (klass ? klass : PyExc_RuntimeError);
1814
+}
1815
+
1816
+
1817
+SWIGRUNTIME PySwigClientData *
1818
+PySwigClientData_New(PyObject* obj)
1819
+{
1820
+ if (!obj) {
1821
+ return 0;
1822
+ } else {
1823
+ PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1824
+ /* the klass element */
1825
+ data->klass = obj;
1826
+ Py_INCREF(data->klass);
1827
+ /* the newraw method and newargs arguments used to create a new raw instance */
1828
+ if (PyClass_Check(obj)) {
1829
+ data->newraw = 0;
1830
+ data->newargs = obj;
1831
+ Py_INCREF(obj);
1832
+ } else {
1833
+#if (PY_VERSION_HEX < 0x02020000)
1834
+ data->newraw = 0;
1835
+#else
1836
+ data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1837
+#endif
1838
+ if (data->newraw) {
1839
+ Py_INCREF(data->newraw);
1840
+ data->newargs = PyTuple_New(1);
1841
+ PyTuple_SetItem(data->newargs, 0, obj);
1842
+ } else {
1843
+ data->newargs = obj;
1844
+ }
1845
+ Py_INCREF(data->newargs);
1846
+ }
1847
+ /* the destroy method, aka as the C++ delete method */
1848
+ data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1849
+ if (PyErr_Occurred()) {
1850
+ PyErr_Clear();
1851
+ data->destroy = 0;
1852
+ }
1853
+ if (data->destroy) {
1854
+ int flags;
1855
+ Py_INCREF(data->destroy);
1856
+ flags = PyCFunction_GET_FLAGS(data->destroy);
1857
+#ifdef METH_O
1858
+ data->delargs = !(flags & (METH_O));
1859
+#else
1860
+ data->delargs = 0;
1861
+#endif
1862
+ } else {
1863
+ data->delargs = 0;
1864
+ }
1865
+ data->implicitconv = 0;
1866
+ return data;
1867
+ }
1868
+}
1869
+
1870
+SWIGRUNTIME void
1871
+PySwigClientData_Del(PySwigClientData* data)
1872
+{
1873
+ Py_XDECREF(data->newraw);
1874
+ Py_XDECREF(data->newargs);
1875
+ Py_XDECREF(data->destroy);
1876
+}
1877
+
1878
+/* =============== PySwigObject =====================*/
1879
+
1880
+typedef struct {
1881
+ PyObject_HEAD
1882
+ void *ptr;
1883
+ swig_type_info *ty;
1884
+ int own;
1885
+ PyObject *next;
1886
+} PySwigObject;
1887
+
1888
+SWIGRUNTIME PyObject *
1889
+PySwigObject_long(PySwigObject *v)
1890
+{
1891
+ return PyLong_FromVoidPtr(v->ptr);
1892
+}
1893
+
1894
+SWIGRUNTIME PyObject *
1895
+PySwigObject_format(const char* fmt, PySwigObject *v)
1896
+{
1897
+ PyObject *res = NULL;
1898
+ PyObject *args = PyTuple_New(1);
1899
+ if (args) {
1900
+ if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1901
+ PyObject *ofmt = PyString_FromString(fmt);
1902
+ if (ofmt) {
1903
+ res = PyString_Format(ofmt,args);
1904
+ Py_DECREF(ofmt);
1905
+ }
1906
+ Py_DECREF(args);
1907
+ }
1908
+ }
1909
+ return res;
1910
+}
1911
+
1912
+SWIGRUNTIME PyObject *
1913
+PySwigObject_oct(PySwigObject *v)
1914
+{
1915
+ return PySwigObject_format("%o",v);
1916
+}
1917
+
1918
+SWIGRUNTIME PyObject *
1919
+PySwigObject_hex(PySwigObject *v)
1920
+{
1921
+ return PySwigObject_format("%x",v);
1922
+}
1923
+
1924
+SWIGRUNTIME PyObject *
1925
+#ifdef METH_NOARGS
1926
+PySwigObject_repr(PySwigObject *v)
1927
+#else
1928
+PySwigObject_repr(PySwigObject *v, PyObject *args)
1929
+#endif
1930
+{
1931
+ const char *name = SWIG_TypePrettyName(v->ty);
1932
+ PyObject *hex = PySwigObject_hex(v);
1933
+ PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1934
+ Py_DECREF(hex);
1935
+ if (v->next) {
1936
+#ifdef METH_NOARGS
1937
+ PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1938
+#else
1939
+ PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1940
+#endif
1941
+ PyString_ConcatAndDel(&repr,nrep);
1942
+ }
1943
+ return repr;
1944
+}
1945
+
1946
+SWIGRUNTIME int
1947
+PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1948
+{
1949
+#ifdef METH_NOARGS
1950
+ PyObject *repr = PySwigObject_repr(v);
1951
+#else
1952
+ PyObject *repr = PySwigObject_repr(v, NULL);
1953
+#endif
1954
+ if (repr) {
1955
+ fputs(PyString_AsString(repr), fp);
1956
+ Py_DECREF(repr);
1957
+ return 0;
1958
+ } else {
1959
+ return 1;
1960
+ }
1961
+}
1962
+
1963
+SWIGRUNTIME PyObject *
1964
+PySwigObject_str(PySwigObject *v)
1965
+{
1966
+ char result[SWIG_BUFFER_SIZE];
1967
+ return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1968
+ PyString_FromString(result) : 0;
1969
+}
1970
+
1971
+SWIGRUNTIME int
1972
+PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1973
+{
1974
+ void *i = v->ptr;
1975
+ void *j = w->ptr;
1976
+ return (i < j) ? -1 : ((i > j) ? 1 : 0);
1977
+}
1978
+
1979
+SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1980
+
1981
+SWIGRUNTIME PyTypeObject*
1982
+PySwigObject_type(void) {
1983
+ static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1984
+ return type;
1985
+}
1986
+
1987
+SWIGRUNTIMEINLINE int
1988
+PySwigObject_Check(PyObject *op) {
1989
+ return ((op)->ob_type == PySwigObject_type())
1990
+ || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1991
+}
1992
+
1993
+SWIGRUNTIME PyObject *
1994
+PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1995
+
1996
+SWIGRUNTIME void
1997
+PySwigObject_dealloc(PyObject *v)
1998
+{
1999
+ PySwigObject *sobj = (PySwigObject *) v;
2000
+ PyObject *next = sobj->next;
2001
+ if (sobj->own == SWIG_POINTER_OWN) {
2002
+ swig_type_info *ty = sobj->ty;
2003
+ PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2004
+ PyObject *destroy = data ? data->destroy : 0;
2005
+ if (destroy) {
2006
+ /* destroy is always a VARARGS method */
2007
+ PyObject *res;
2008
+ if (data->delargs) {
2009
+ /* we need to create a temporal object to carry the destroy operation */
2010
+ PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
2011
+ res = SWIG_Python_CallFunctor(destroy, tmp);
2012
+ Py_DECREF(tmp);
2013
+ } else {
2014
+ PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
2015
+ PyObject *mself = PyCFunction_GET_SELF(destroy);
2016
+ res = ((*meth)(mself, v));
2017
+ }
2018
+ Py_XDECREF(res);
2019
+ }
2020
+#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
2021
+ else {
2022
+ const char *name = SWIG_TypePrettyName(ty);
2023
+ printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
2024
+ }
2025
+#endif
2026
+ }
2027
+ Py_XDECREF(next);
2028
+ PyObject_DEL(v);
2029
+}
2030
+
2031
+SWIGRUNTIME PyObject*
2032
+PySwigObject_append(PyObject* v, PyObject* next)
2033
+{
2034
+ PySwigObject *sobj = (PySwigObject *) v;
2035
+#ifndef METH_O
2036
+ PyObject *tmp = 0;
2037
+ if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
2038
+ next = tmp;
2039
+#endif
2040
+ if (!PySwigObject_Check(next)) {
2041
+ return NULL;
2042
+ }
2043
+ sobj->next = next;
2044
+ Py_INCREF(next);
2045
+ return SWIG_Py_Void();
2046
+}
2047
+
2048
+SWIGRUNTIME PyObject*
2049
+#ifdef METH_NOARGS
2050
+PySwigObject_next(PyObject* v)
2051
+#else
2052
+PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
2053
+#endif
2054
+{
2055
+ PySwigObject *sobj = (PySwigObject *) v;
2056
+ if (sobj->next) {
2057
+ Py_INCREF(sobj->next);
2058
+ return sobj->next;
2059
+ } else {
2060
+ return SWIG_Py_Void();
2061
+ }
2062
+}
2063
+
2064
+SWIGINTERN PyObject*
2065
+#ifdef METH_NOARGS
2066
+PySwigObject_disown(PyObject *v)
2067
+#else
2068
+PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
2069
+#endif
2070
+{
2071
+ PySwigObject *sobj = (PySwigObject *)v;
2072
+ sobj->own = 0;
2073
+ return SWIG_Py_Void();
2074
+}
2075
+
2076
+SWIGINTERN PyObject*
2077
+#ifdef METH_NOARGS
2078
+PySwigObject_acquire(PyObject *v)
2079
+#else
2080
+PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
2081
+#endif
2082
+{
2083
+ PySwigObject *sobj = (PySwigObject *)v;
2084
+ sobj->own = SWIG_POINTER_OWN;
2085
+ return SWIG_Py_Void();
2086
+}
2087
+
2088
+SWIGINTERN PyObject*
2089
+PySwigObject_own(PyObject *v, PyObject *args)
2090
+{
2091
+ PyObject *val = 0;
2092
+#if (PY_VERSION_HEX < 0x02020000)
2093
+ if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
2094
+#else
2095
+ if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
2096
+#endif
2097
+ {
2098
+ return NULL;
2099
+ }
2100
+ else
2101
+ {
2102
+ PySwigObject *sobj = (PySwigObject *)v;
2103
+ PyObject *obj = PyBool_FromLong(sobj->own);
2104
+ if (val) {
2105
+#ifdef METH_NOARGS
2106
+ if (PyObject_IsTrue(val)) {
2107
+ PySwigObject_acquire(v);
2108
+ } else {
2109
+ PySwigObject_disown(v);
2110
+ }
2111
+#else
2112
+ if (PyObject_IsTrue(val)) {
2113
+ PySwigObject_acquire(v,args);
2114
+ } else {
2115
+ PySwigObject_disown(v,args);
2116
+ }
2117
+#endif
2118
+ }
2119
+ return obj;
2120
+ }
2121
+}
2122
+
2123
+#ifdef METH_O
2124
+static PyMethodDef
2125
+swigobject_methods[] = {
2126
+ {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
2127
+ {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
2128
+ {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
2129
+ {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
2130
+ {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
2131
+ {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
2132
+ {0, 0, 0, 0}
2133
+};
2134
+#else
2135
+static PyMethodDef
2136
+swigobject_methods[] = {
2137
+ {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
2138
+ {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
2139
+ {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
2140
+ {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
2141
+ {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
2142
+ {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
2143
+ {0, 0, 0, 0}
2144
+};
2145
+#endif
2146
+
2147
+#if PY_VERSION_HEX < 0x02020000
2148
+SWIGINTERN PyObject *
2149
+PySwigObject_getattr(PySwigObject *sobj,char *name)
2150
+{
2151
+ return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
2152
+}
2153
+#endif
2154
+
2155
+SWIGRUNTIME PyTypeObject*
2156
+_PySwigObject_type(void) {
2157
+ static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
2158
+
2159
+ static PyNumberMethods PySwigObject_as_number = {
2160
+ (binaryfunc)0, /*nb_add*/
2161
+ (binaryfunc)0, /*nb_subtract*/
2162
+ (binaryfunc)0, /*nb_multiply*/
2163
+ (binaryfunc)0, /*nb_divide*/
2164
+ (binaryfunc)0, /*nb_remainder*/
2165
+ (binaryfunc)0, /*nb_divmod*/
2166
+ (ternaryfunc)0,/*nb_power*/
2167
+ (unaryfunc)0, /*nb_negative*/
2168
+ (unaryfunc)0, /*nb_positive*/
2169
+ (unaryfunc)0, /*nb_absolute*/
2170
+ (inquiry)0, /*nb_nonzero*/
2171
+ 0, /*nb_invert*/
2172
+ 0, /*nb_lshift*/
2173
+ 0, /*nb_rshift*/
2174
+ 0, /*nb_and*/
2175
+ 0, /*nb_xor*/
2176
+ 0, /*nb_or*/
2177
+ (coercion)0, /*nb_coerce*/
2178
+ (unaryfunc)PySwigObject_long, /*nb_int*/
2179
+ (unaryfunc)PySwigObject_long, /*nb_long*/
2180
+ (unaryfunc)0, /*nb_float*/
2181
+ (unaryfunc)PySwigObject_oct, /*nb_oct*/
2182
+ (unaryfunc)PySwigObject_hex, /*nb_hex*/
2183
+#if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
2184
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
2185
+#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
2186
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
2187
+#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
2188
+ 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
2189
+#endif
2190
+ };
2191
+
2192
+ static PyTypeObject pyswigobject_type;
2193
+ static int type_init = 0;
2194
+ if (!type_init) {
2195
+ const PyTypeObject tmp
2196
+ = {
2197
+ PyObject_HEAD_INIT(NULL)
2198
+ 0, /* ob_size */
2199
+ (char *)"PySwigObject", /* tp_name */
2200
+ sizeof(PySwigObject), /* tp_basicsize */
2201
+ 0, /* tp_itemsize */
2202
+ (destructor)PySwigObject_dealloc, /* tp_dealloc */
2203
+ (printfunc)PySwigObject_print, /* tp_print */
2204
+#if PY_VERSION_HEX < 0x02020000
2205
+ (getattrfunc)PySwigObject_getattr, /* tp_getattr */
2206
+#else
2207
+ (getattrfunc)0, /* tp_getattr */
2208
+#endif
2209
+ (setattrfunc)0, /* tp_setattr */
2210
+ (cmpfunc)PySwigObject_compare, /* tp_compare */
2211
+ (reprfunc)PySwigObject_repr, /* tp_repr */
2212
+ &PySwigObject_as_number, /* tp_as_number */
2213
+ 0, /* tp_as_sequence */
2214
+ 0, /* tp_as_mapping */
2215
+ (hashfunc)0, /* tp_hash */
2216
+ (ternaryfunc)0, /* tp_call */
2217
+ (reprfunc)PySwigObject_str, /* tp_str */
2218
+ PyObject_GenericGetAttr, /* tp_getattro */
2219
+ 0, /* tp_setattro */
2220
+ 0, /* tp_as_buffer */
2221
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
2222
+ swigobject_doc, /* tp_doc */
2223
+ 0, /* tp_traverse */
2224
+ 0, /* tp_clear */
2225
+ 0, /* tp_richcompare */
2226
+ 0, /* tp_weaklistoffset */
2227
+#if PY_VERSION_HEX >= 0x02020000
2228
+ 0, /* tp_iter */
2229
+ 0, /* tp_iternext */
2230
+ swigobject_methods, /* tp_methods */
2231
+ 0, /* tp_members */
2232
+ 0, /* tp_getset */
2233
+ 0, /* tp_base */
2234
+ 0, /* tp_dict */
2235
+ 0, /* tp_descr_get */
2236
+ 0, /* tp_descr_set */
2237
+ 0, /* tp_dictoffset */
2238
+ 0, /* tp_init */
2239
+ 0, /* tp_alloc */
2240
+ 0, /* tp_new */
2241
+ 0, /* tp_free */
2242
+ 0, /* tp_is_gc */
2243
+ 0, /* tp_bases */
2244
+ 0, /* tp_mro */
2245
+ 0, /* tp_cache */
2246
+ 0, /* tp_subclasses */
2247
+ 0, /* tp_weaklist */
2248
+#endif
2249
+#if PY_VERSION_HEX >= 0x02030000
2250
+ 0, /* tp_del */
2251
+#endif
2252
+#ifdef COUNT_ALLOCS
2253
+ 0,0,0,0 /* tp_alloc -> tp_next */
2254
+#endif
2255
+ };
2256
+ pyswigobject_type = tmp;
2257
+ pyswigobject_type.ob_type = &PyType_Type;
2258
+ type_init = 1;
2259
+ }
2260
+ return &pyswigobject_type;
2261
+}
2262
+
2263
+SWIGRUNTIME PyObject *
2264
+PySwigObject_New(void *ptr, swig_type_info *ty, int own)
2265
+{
2266
+ PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
2267
+ if (sobj) {
2268
+ sobj->ptr = ptr;
2269
+ sobj->ty = ty;
2270
+ sobj->own = own;
2271
+ sobj->next = 0;
2272
+ }
2273
+ return (PyObject *)sobj;
2274
+}
2275
+
2276
+/* -----------------------------------------------------------------------------
2277
+ * Implements a simple Swig Packed type, and use it instead of string
2278
+ * ----------------------------------------------------------------------------- */
2279
+
2280
+typedef struct {
2281
+ PyObject_HEAD
2282
+ void *pack;
2283
+ swig_type_info *ty;
2284
+ size_t size;
2285
+} PySwigPacked;
2286
+
2287
+SWIGRUNTIME int
2288
+PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
2289
+{
2290
+ char result[SWIG_BUFFER_SIZE];
2291
+ fputs("<Swig Packed ", fp);
2292
+ if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2293
+ fputs("at ", fp);
2294
+ fputs(result, fp);
2295
+ }
2296
+ fputs(v->ty->name,fp);
2297
+ fputs(">", fp);
2298
+ return 0;
2299
+}
2300
+
2301
+SWIGRUNTIME PyObject *
2302
+PySwigPacked_repr(PySwigPacked *v)
2303
+{
2304
+ char result[SWIG_BUFFER_SIZE];
2305
+ if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2306
+ return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2307
+ } else {
2308
+ return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
2309
+ }
2310
+}
2311
+
2312
+SWIGRUNTIME PyObject *
2313
+PySwigPacked_str(PySwigPacked *v)
2314
+{
2315
+ char result[SWIG_BUFFER_SIZE];
2316
+ if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2317
+ return PyString_FromFormat("%s%s", result, v->ty->name);
2318
+ } else {
2319
+ return PyString_FromString(v->ty->name);
2320
+ }
2321
+}
2322
+
2323
+SWIGRUNTIME int
2324
+PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
2325
+{
2326
+ size_t i = v->size;
2327
+ size_t j = w->size;
2328
+ int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2329
+ return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2330
+}
2331
+
2332
+SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
2333
+
2334
+SWIGRUNTIME PyTypeObject*
2335
+PySwigPacked_type(void) {
2336
+ static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
2337
+ return type;
2338
+}
2339
+
2340
+SWIGRUNTIMEINLINE int
2341
+PySwigPacked_Check(PyObject *op) {
2342
+ return ((op)->ob_type == _PySwigPacked_type())
2343
+ || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
2344
+}
2345
+
2346
+SWIGRUNTIME void
2347
+PySwigPacked_dealloc(PyObject *v)
2348
+{
2349
+ if (PySwigPacked_Check(v)) {
2350
+ PySwigPacked *sobj = (PySwigPacked *) v;
2351
+ free(sobj->pack);
2352
+ }
2353
+ PyObject_DEL(v);
2354
+}
2355
+
2356
+SWIGRUNTIME PyTypeObject*
2357
+_PySwigPacked_type(void) {
2358
+ static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2359
+ static PyTypeObject pyswigpacked_type;
2360
+ static int type_init = 0;
2361
+ if (!type_init) {
2362
+ const PyTypeObject tmp
2363
+ = {
2364
+ PyObject_HEAD_INIT(NULL)
2365
+ 0, /* ob_size */
2366
+ (char *)"PySwigPacked", /* tp_name */
2367
+ sizeof(PySwigPacked), /* tp_basicsize */
2368
+ 0, /* tp_itemsize */
2369
+ (destructor)PySwigPacked_dealloc, /* tp_dealloc */
2370
+ (printfunc)PySwigPacked_print, /* tp_print */
2371
+ (getattrfunc)0, /* tp_getattr */
2372
+ (setattrfunc)0, /* tp_setattr */
2373
+ (cmpfunc)PySwigPacked_compare, /* tp_compare */
2374
+ (reprfunc)PySwigPacked_repr, /* tp_repr */
2375
+ 0, /* tp_as_number */
2376
+ 0, /* tp_as_sequence */
2377
+ 0, /* tp_as_mapping */
2378
+ (hashfunc)0, /* tp_hash */
2379
+ (ternaryfunc)0, /* tp_call */
2380
+ (reprfunc)PySwigPacked_str, /* tp_str */
2381
+ PyObject_GenericGetAttr, /* tp_getattro */
2382
+ 0, /* tp_setattro */
2383
+ 0, /* tp_as_buffer */
2384
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
2385
+ swigpacked_doc, /* tp_doc */
2386
+ 0, /* tp_traverse */
2387
+ 0, /* tp_clear */
2388
+ 0, /* tp_richcompare */
2389
+ 0, /* tp_weaklistoffset */
2390
+#if PY_VERSION_HEX >= 0x02020000
2391
+ 0, /* tp_iter */
2392
+ 0, /* tp_iternext */
2393
+ 0, /* tp_methods */
2394
+ 0, /* tp_members */
2395
+ 0, /* tp_getset */
2396
+ 0, /* tp_base */
2397
+ 0, /* tp_dict */
2398
+ 0, /* tp_descr_get */
2399
+ 0, /* tp_descr_set */
2400
+ 0, /* tp_dictoffset */
2401
+ 0, /* tp_init */
2402
+ 0, /* tp_alloc */
2403
+ 0, /* tp_new */
2404
+ 0, /* tp_free */
2405
+ 0, /* tp_is_gc */
2406
+ 0, /* tp_bases */
2407
+ 0, /* tp_mro */
2408
+ 0, /* tp_cache */
2409
+ 0, /* tp_subclasses */
2410
+ 0, /* tp_weaklist */
2411
+#endif
2412
+#if PY_VERSION_HEX >= 0x02030000
2413
+ 0, /* tp_del */
2414
+#endif
2415
+#ifdef COUNT_ALLOCS
2416
+ 0,0,0,0 /* tp_alloc -> tp_next */
2417
+#endif
2418
+ };
2419
+ pyswigpacked_type = tmp;
2420
+ pyswigpacked_type.ob_type = &PyType_Type;
2421
+ type_init = 1;
2422
+ }
2423
+ return &pyswigpacked_type;
2424
+}
2425
+
2426
+SWIGRUNTIME PyObject *
2427
+PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
2428
+{
2429
+ PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
2430
+ if (sobj) {
2431
+ void *pack = malloc(size);
2432
+ if (pack) {
2433
+ memcpy(pack, ptr, size);
2434
+ sobj->pack = pack;
2435
+ sobj->ty = ty;
2436
+ sobj->size = size;
2437
+ } else {
2438
+ PyObject_DEL((PyObject *) sobj);
2439
+ sobj = 0;
2440
+ }
2441
+ }
2442
+ return (PyObject *) sobj;
2443
+}
2444
+
2445
+SWIGRUNTIME swig_type_info *
2446
+PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2447
+{
2448
+ if (PySwigPacked_Check(obj)) {
2449
+ PySwigPacked *sobj = (PySwigPacked *)obj;
2450
+ if (sobj->size != size) return 0;
2451
+ memcpy(ptr, sobj->pack, size);
2452
+ return sobj->ty;
2453
+ } else {
2454
+ return 0;
2455
+ }
2456
+}
2457
+
2458
+/* -----------------------------------------------------------------------------
2459
+ * pointers/data manipulation
2460
+ * ----------------------------------------------------------------------------- */
2461
+
2462
+SWIGRUNTIMEINLINE PyObject *
2463
+_SWIG_This(void)
2464
+{
2465
+ return PyString_FromString("this");
2466
+}
2467
+
2468
+SWIGRUNTIME PyObject *
2469
+SWIG_This(void)
2470
+{
2471
+ static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
2472
+ return swig_this;
2473
+}
2474
+
2475
+/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2476
+
2477
+SWIGRUNTIME PySwigObject *
2478
+SWIG_Python_GetSwigThis(PyObject *pyobj)
2479
+{
2480
+ if (PySwigObject_Check(pyobj)) {
2481
+ return (PySwigObject *) pyobj;
2482
+ } else {
2483
+ PyObject *obj = 0;
2484
+#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2485
+ if (PyInstance_Check(pyobj)) {
2486
+ obj = _PyInstance_Lookup(pyobj, SWIG_This());
2487
+ } else {
2488
+ PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2489
+ if (dictptr != NULL) {
2490
+ PyObject *dict = *dictptr;
2491
+ obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2492
+ } else {
2493
+#ifdef PyWeakref_CheckProxy
2494
+ if (PyWeakref_CheckProxy(pyobj)) {
2495
+ PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2496
+ return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2497
+ }
2498
+#endif
2499
+ obj = PyObject_GetAttr(pyobj,SWIG_This());
2500
+ if (obj) {
2501
+ Py_DECREF(obj);
2502
+ } else {
2503
+ if (PyErr_Occurred()) PyErr_Clear();
2504
+ return 0;
2505
+ }
2506
+ }
2507
+ }
2508
+#else
2509
+ obj = PyObject_GetAttr(pyobj,SWIG_This());
2510
+ if (obj) {
2511
+ Py_DECREF(obj);
2512
+ } else {
2513
+ if (PyErr_Occurred()) PyErr_Clear();
2514
+ return 0;
2515
+ }
2516
+#endif
2517
+ if (obj && !PySwigObject_Check(obj)) {
2518
+ /* a PyObject is called 'this', try to get the 'real this'
2519
+ PySwigObject from it */
2520
+ return SWIG_Python_GetSwigThis(obj);
2521
+ }
2522
+ return (PySwigObject *)obj;
2523
+ }
2524
+}
2525
+
2526
+/* Acquire a pointer value */
2527
+
2528
+SWIGRUNTIME int
2529
+SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2530
+ if (own == SWIG_POINTER_OWN) {
2531
+ PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
2532
+ if (sobj) {
2533
+ int oldown = sobj->own;
2534
+ sobj->own = own;
2535
+ return oldown;
2536
+ }
2537
+ }
2538
+ return 0;
2539
+}
2540
+
2541
+/* Convert a pointer value */
2542
+
2543
+SWIGRUNTIME int
2544
+SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2545
+ if (!obj) return SWIG_ERROR;
2546
+ if (obj == Py_None) {
2547
+ if (ptr) *ptr = 0;
2548
+ return SWIG_OK;
2549
+ } else {
2550
+ PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
2551
+ if (own)
2552
+ *own = 0;
2553
+ while (sobj) {
2554
+ void *vptr = sobj->ptr;
2555
+ if (ty) {
2556
+ swig_type_info *to = sobj->ty;
2557
+ if (to == ty) {
2558
+ /* no type cast needed */
2559
+ if (ptr) *ptr = vptr;
2560
+ break;
2561
+ } else {
2562
+ swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2563
+ if (!tc) {
2564
+ sobj = (PySwigObject *)sobj->next;
2565
+ } else {
2566
+ if (ptr) {
2567
+ int newmemory = 0;
2568
+ *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2569
+ if (newmemory == SWIG_CAST_NEW_MEMORY) {
2570
+ assert(own);
2571
+ if (own)
2572
+ *own = *own | SWIG_CAST_NEW_MEMORY;
2573
+ }
2574
+ }
2575
+ break;
2576
+ }
2577
+ }
2578
+ } else {
2579
+ if (ptr) *ptr = vptr;
2580
+ break;
2581
+ }
2582
+ }
2583
+ if (sobj) {
2584
+ if (own)
2585
+ *own = *own | sobj->own;
2586
+ if (flags & SWIG_POINTER_DISOWN) {
2587
+ sobj->own = 0;
2588
+ }
2589
+ return SWIG_OK;
2590
+ } else {
2591
+ int res = SWIG_ERROR;
2592
+ if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2593
+ PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2594
+ if (data && !data->implicitconv) {
2595
+ PyObject *klass = data->klass;
2596
+ if (klass) {
2597
+ PyObject *impconv;
2598
+ data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2599
+ impconv = SWIG_Python_CallFunctor(klass, obj);
2600
+ data->implicitconv = 0;
2601
+ if (PyErr_Occurred()) {
2602
+ PyErr_Clear();
2603
+ impconv = 0;
2604
+ }
2605
+ if (impconv) {
2606
+ PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2607
+ if (iobj) {
2608
+ void *vptr;
2609
+ res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2610
+ if (SWIG_IsOK(res)) {
2611
+ if (ptr) {
2612
+ *ptr = vptr;
2613
+ /* transfer the ownership to 'ptr' */
2614
+ iobj->own = 0;
2615
+ res = SWIG_AddCast(res);
2616
+ res = SWIG_AddNewMask(res);
2617
+ } else {
2618
+ res = SWIG_AddCast(res);
2619
+ }
2620
+ }
2621
+ }
2622
+ Py_DECREF(impconv);
2623
+ }
2624
+ }
2625
+ }
2626
+ }
2627
+ return res;
2628
+ }
2629
+ }
2630
+}
2631
+
2632
+/* Convert a function ptr value */
2633
+
2634
+SWIGRUNTIME int
2635
+SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2636
+ if (!PyCFunction_Check(obj)) {
2637
+ return SWIG_ConvertPtr(obj, ptr, ty, 0);
2638
+ } else {
2639
+ void *vptr = 0;
2640
+
2641
+ /* here we get the method pointer for callbacks */
2642
+ const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2643
+ const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2644
+ if (desc) {
2645
+ desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2646
+ if (!desc) return SWIG_ERROR;
2647
+ }
2648
+ if (ty) {
2649
+ swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2650
+ if (tc) {
2651
+ int newmemory = 0;
2652
+ *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2653
+ assert(!newmemory); /* newmemory handling not yet implemented */
2654
+ } else {
2655
+ return SWIG_ERROR;
2656
+ }
2657
+ } else {
2658
+ *ptr = vptr;
2659
+ }
2660
+ return SWIG_OK;
2661
+ }
2662
+}
2663
+
2664
+/* Convert a packed value value */
2665
+
2666
+SWIGRUNTIME int
2667
+SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2668
+ swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2669
+ if (!to) return SWIG_ERROR;
2670
+ if (ty) {
2671
+ if (to != ty) {
2672
+ /* check type cast? */
2673
+ swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2674
+ if (!tc) return SWIG_ERROR;
2675
+ }
2676
+ }
2677
+ return SWIG_OK;
2678
+}
2679
+
2680
+/* -----------------------------------------------------------------------------
2681
+ * Create a new pointer object
2682
+ * ----------------------------------------------------------------------------- */
2683
+
2684
+/*
2685
+ Create a new instance object, whitout calling __init__, and set the
2686
+ 'this' attribute.
2687
+*/
2688
+
2689
+SWIGRUNTIME PyObject*
2690
+SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2691
+{
2692
+#if (PY_VERSION_HEX >= 0x02020000)
2693
+ PyObject *inst = 0;
2694
+ PyObject *newraw = data->newraw;
2695
+ if (newraw) {
2696
+ inst = PyObject_Call(newraw, data->newargs, NULL);
2697
+ if (inst) {
2698
+#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2699
+ PyObject **dictptr = _PyObject_GetDictPtr(inst);
2700
+ if (dictptr != NULL) {
2701
+ PyObject *dict = *dictptr;
2702
+ if (dict == NULL) {
2703
+ dict = PyDict_New();
2704
+ *dictptr = dict;
2705
+ PyDict_SetItem(dict, SWIG_This(), swig_this);
2706
+ }
2707
+ }
2708
+#else
2709
+ PyObject *key = SWIG_This();
2710
+ PyObject_SetAttr(inst, key, swig_this);
2711
+#endif
2712
+ }
2713
+ } else {
2714
+ PyObject *dict = PyDict_New();
2715
+ PyDict_SetItem(dict, SWIG_This(), swig_this);
2716
+ inst = PyInstance_NewRaw(data->newargs, dict);
2717
+ Py_DECREF(dict);
2718
+ }
2719
+ return inst;
2720
+#else
2721
+#if (PY_VERSION_HEX >= 0x02010000)
2722
+ PyObject *inst;
2723
+ PyObject *dict = PyDict_New();
2724
+ PyDict_SetItem(dict, SWIG_This(), swig_this);
2725
+ inst = PyInstance_NewRaw(data->newargs, dict);
2726
+ Py_DECREF(dict);
2727
+ return (PyObject *) inst;
2728
+#else
2729
+ PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2730
+ if (inst == NULL) {
2731
+ return NULL;
2732
+ }
2733
+ inst->in_class = (PyClassObject *)data->newargs;
2734
+ Py_INCREF(inst->in_class);
2735
+ inst->in_dict = PyDict_New();
2736
+ if (inst->in_dict == NULL) {
2737
+ Py_DECREF(inst);
2738
+ return NULL;
2739
+ }
2740
+#ifdef Py_TPFLAGS_HAVE_WEAKREFS
2741
+ inst->in_weakreflist = NULL;
2742
+#endif
2743
+#ifdef Py_TPFLAGS_GC
2744
+ PyObject_GC_Init(inst);
2745
+#endif
2746
+ PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2747
+ return (PyObject *) inst;
2748
+#endif
2749
+#endif
2750
+}
2751
+
2752
+SWIGRUNTIME void
2753
+SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2754
+{
2755
+ PyObject *dict;
2756
+#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2757
+ PyObject **dictptr = _PyObject_GetDictPtr(inst);
2758
+ if (dictptr != NULL) {
2759
+ dict = *dictptr;
2760
+ if (dict == NULL) {
2761
+ dict = PyDict_New();
2762
+ *dictptr = dict;
2763
+ }
2764
+ PyDict_SetItem(dict, SWIG_This(), swig_this);
2765
+ return;
2766
+ }
2767
+#endif
2768
+ dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2769
+ PyDict_SetItem(dict, SWIG_This(), swig_this);
2770
+ Py_DECREF(dict);
2771
+}
2772
+
2773
+
2774
+SWIGINTERN PyObject *
2775
+SWIG_Python_InitShadowInstance(PyObject *args) {
2776
+ PyObject *obj[2];
2777
+ if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2778
+ return NULL;
2779
+ } else {
2780
+ PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2781
+ if (sthis) {
2782
+ PySwigObject_append((PyObject*) sthis, obj[1]);
2783
+ } else {
2784
+ SWIG_Python_SetSwigThis(obj[0], obj[1]);
2785
+ }
2786
+ return SWIG_Py_Void();
2787
+ }
2788
+}
2789
+
2790
+/* Create a new pointer object */
2791
+
2792
+SWIGRUNTIME PyObject *
2793
+SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2794
+ if (!ptr) {
2795
+ return SWIG_Py_Void();
2796
+ } else {
2797
+ int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2798
+ PyObject *robj = PySwigObject_New(ptr, type, own);
2799
+ PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2800
+ if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2801
+ PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2802
+ if (inst) {
2803
+ Py_DECREF(robj);
2804
+ robj = inst;
2805
+ }
2806
+ }
2807
+ return robj;
2808
+ }
2809
+}
2810
+
2811
+/* Create a new packed object */
2812
+
2813
+SWIGRUNTIMEINLINE PyObject *
2814
+SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2815
+ return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2816
+}
2817
+
2818
+/* -----------------------------------------------------------------------------*
2819
+ * Get type list
2820
+ * -----------------------------------------------------------------------------*/
2821
+
2822
+#ifdef SWIG_LINK_RUNTIME
2823
+void *SWIG_ReturnGlobalTypeList(void *);
2824
+#endif
2825
+
2826
+SWIGRUNTIME swig_module_info *
2827
+SWIG_Python_GetModule(void) {
2828
+ static void *type_pointer = (void *)0;
2829
+ /* first check if module already created */
2830
+ if (!type_pointer) {
2831
+#ifdef SWIG_LINK_RUNTIME
2832
+ type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2833
+#else
2834
+ type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2835
+ (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2836
+ if (PyErr_Occurred()) {
2837
+ PyErr_Clear();
2838
+ type_pointer = (void *)0;
2839
+ }
2840
+#endif
2841
+ }
2842
+ return (swig_module_info *) type_pointer;
2843
+}
2844
+
2845
+#if PY_MAJOR_VERSION < 2
2846
+/* PyModule_AddObject function was introduced in Python 2.0. The following function
2847
+ is copied out of Python/modsupport.c in python version 2.3.4 */
2848
+SWIGINTERN int
2849
+PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2850
+{
2851
+ PyObject *dict;
2852
+ if (!PyModule_Check(m)) {
2853
+ PyErr_SetString(PyExc_TypeError,
2854
+ "PyModule_AddObject() needs module as first arg");
2855
+ return SWIG_ERROR;
2856
+ }
2857
+ if (!o) {
2858
+ PyErr_SetString(PyExc_TypeError,
2859
+ "PyModule_AddObject() needs non-NULL value");
2860
+ return SWIG_ERROR;
2861
+ }
2862
+
2863
+ dict = PyModule_GetDict(m);
2864
+ if (dict == NULL) {
2865
+ /* Internal error -- modules must have a dict! */
2866
+ PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2867
+ PyModule_GetName(m));
2868
+ return SWIG_ERROR;
2869
+ }
2870
+ if (PyDict_SetItemString(dict, name, o))
2871
+ return SWIG_ERROR;
2872
+ Py_DECREF(o);
2873
+ return SWIG_OK;
2874
+}
2875
+#endif
2876
+
2877
+SWIGRUNTIME void
2878
+SWIG_Python_DestroyModule(void *vptr)
2879
+{
2880
+ swig_module_info *swig_module = (swig_module_info *) vptr;
2881
+ swig_type_info **types = swig_module->types;
2882
+ size_t i;
2883
+ for (i =0; i < swig_module->size; ++i) {
2884
+ swig_type_info *ty = types[i];
2885
+ if (ty->owndata) {
2886
+ PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2887
+ if (data) PySwigClientData_Del(data);
2888
+ }
2889
+ }
2890
+ Py_DECREF(SWIG_This());
2891
+}
2892
+
2893
+SWIGRUNTIME void
2894
+SWIG_Python_SetModule(swig_module_info *swig_module) {
2895
+ static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2896
+
2897
+ PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2898
+ swig_empty_runtime_method_table);
2899
+ PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2900
+ if (pointer && module) {
2901
+ PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2902
+ } else {
2903
+ Py_XDECREF(pointer);
2904
+ }
2905
+}
2906
+
2907
+/* The python cached type query */
2908
+SWIGRUNTIME PyObject *
2909
+SWIG_Python_TypeCache(void) {
2910
+ static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2911
+ return cache;
2912
+}
2913
+
2914
+SWIGRUNTIME swig_type_info *
2915
+SWIG_Python_TypeQuery(const char *type)
2916
+{
2917
+ PyObject *cache = SWIG_Python_TypeCache();
2918
+ PyObject *key = PyString_FromString(type);
2919
+ PyObject *obj = PyDict_GetItem(cache, key);
2920
+ swig_type_info *descriptor;
2921
+ if (obj) {
2922
+ descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2923
+ } else {
2924
+ swig_module_info *swig_module = SWIG_Python_GetModule();
2925
+ descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2926
+ if (descriptor) {
2927
+ obj = PyCObject_FromVoidPtr(descriptor, NULL);
2928
+ PyDict_SetItem(cache, key, obj);
2929
+ Py_DECREF(obj);
2930
+ }
2931
+ }
2932
+ Py_DECREF(key);
2933
+ return descriptor;
2934
+}
2935
+
2936
+/*
2937
+ For backward compatibility only
2938
+*/
2939
+#define SWIG_POINTER_EXCEPTION 0
2940
+#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2941
+#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2942
+
2943
+SWIGRUNTIME int
2944
+SWIG_Python_AddErrMesg(const char* mesg, int infront)
2945
+{
2946
+ if (PyErr_Occurred()) {
2947
+ PyObject *type = 0;
2948
+ PyObject *value = 0;
2949
+ PyObject *traceback = 0;
2950
+ PyErr_Fetch(&type, &value, &traceback);
2951
+ if (value) {
2952
+ PyObject *old_str = PyObject_Str(value);
2953
+ Py_XINCREF(type);
2954
+ PyErr_Clear();
2955
+ if (infront) {
2956
+ PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2957
+ } else {
2958
+ PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2959
+ }
2960
+ Py_DECREF(old_str);
2961
+ }
2962
+ return 1;
2963
+ } else {
2964
+ return 0;
2965
+ }
2966
+}
2967
+
2968
+SWIGRUNTIME int
2969
+SWIG_Python_ArgFail(int argnum)
2970
+{
2971
+ if (PyErr_Occurred()) {
2972
+ /* add information about failing argument */
2973
+ char mesg[256];
2974
+ PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2975
+ return SWIG_Python_AddErrMesg(mesg, 1);
2976
+ } else {
2977
+ return 0;
2978
+ }
2979
+}
2980
+
2981
+SWIGRUNTIMEINLINE const char *
2982
+PySwigObject_GetDesc(PyObject *self)
2983
+{
2984
+ PySwigObject *v = (PySwigObject *)self;
2985
+ swig_type_info *ty = v ? v->ty : 0;
2986
+ return ty ? ty->str : (char*)"";
2987
+}
2988
+
2989
+SWIGRUNTIME void
2990
+SWIG_Python_TypeError(const char *type, PyObject *obj)
2991
+{
2992
+ if (type) {
2993
+#if defined(SWIG_COBJECT_TYPES)
2994
+ if (obj && PySwigObject_Check(obj)) {
2995
+ const char *otype = (const char *) PySwigObject_GetDesc(obj);
2996
+ if (otype) {
2997
+ PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2998
+ type, otype);
2999
+ return;
3000
+ }
3001
+ } else
3002
+#endif
3003
+ {
3004
+ const char *otype = (obj ? obj->ob_type->tp_name : 0);
3005
+ if (otype) {
3006
+ PyObject *str = PyObject_Str(obj);
3007
+ const char *cstr = str ? PyString_AsString(str) : 0;
3008
+ if (cstr) {
3009
+ PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
3010
+ type, otype, cstr);
3011
+ } else {
3012
+ PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
3013
+ type, otype);
3014
+ }
3015
+ Py_XDECREF(str);
3016
+ return;
3017
+ }
3018
+ }
3019
+ PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
3020
+ } else {
3021
+ PyErr_Format(PyExc_TypeError, "unexpected type is received");
3022
+ }
3023
+}
3024
+
3025
+
3026
+/* Convert a pointer value, signal an exception on a type mismatch */
3027
+SWIGRUNTIME void *
3028
+SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
3029
+ void *result;
3030
+ if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
3031
+ PyErr_Clear();
3032
+ if (flags & SWIG_POINTER_EXCEPTION) {
3033
+ SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
3034
+ SWIG_Python_ArgFail(argnum);
3035
+ }
3036
+ }
3037
+ return result;
3038
+}
3039
+
3040
+
3041
+#ifdef __cplusplus
3042
+#if 0
3043
+{ /* cc-mode */
3044
+#endif
3045
+}
3046
+#endif
3047
+
3048
+
3049
+
3050
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3051
+
3052
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
3053
+
3054
+
3055
+
3056
+ #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
3057
+
3058
+
3059
+/* -------- TYPES TABLE (BEGIN) -------- */
3060
+
3061
+#define SWIGTYPE_p_Nviz swig_types[0]
3062
+#define SWIGTYPE_p_allocator_type swig_types[1]
3063
+#define SWIGTYPE_p_char swig_types[2]
3064
+#define SWIGTYPE_p_difference_type swig_types[3]
3065
+#define SWIGTYPE_p_key_type swig_types[4]
3066
+#define SWIGTYPE_p_mapped_type swig_types[5]
3067
+#define SWIGTYPE_p_p_PyObject swig_types[6]
3068
+#define SWIGTYPE_p_size_type swig_types[7]
3069
+#define SWIGTYPE_p_std__invalid_argument swig_types[8]
3070
+#define SWIGTYPE_p_std__lessT_int_t swig_types[9]
3071
+#define SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t swig_types[10]
3072
+#define SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type swig_types[11]
3073
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[12]
3074
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type swig_types[13]
3075
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[14]
3076
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type swig_types[15]
3077
+#define SWIGTYPE_p_swig__PySwigIterator swig_types[16]
3078
+#define SWIGTYPE_p_value_type swig_types[17]
3079
+static swig_type_info *swig_types[19];
3080
+static swig_module_info swig_module = {swig_types, 18, 0, 0, 0, 0};
3081
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3082
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3083
+
3084
+/* -------- TYPES TABLE (END) -------- */
3085
+
3086
+#if (PY_VERSION_HEX <= 0x02000000)
3087
+# if !defined(SWIG_PYTHON_CLASSIC)
3088
+# error "This python version requires swig to be run with the '-classic' option"
3089
+# endif
3090
+#endif
3091
+
3092
+/*-----------------------------------------------
3093
+ @(target):= _grass6_wxnviz.so
3094
+ ------------------------------------------------*/
3095
+#define SWIG_init init_grass6_wxnviz
3096
+
3097
+#define SWIG_name "_grass6_wxnviz"
3098
+
3099
+#define SWIGVERSION 0x010336
3100
+#define SWIG_VERSION SWIGVERSION
3101
+
3102
+
3103
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
3104
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
3105
+
3106
+
3107
+#include <stdexcept>
3108
+
3109
+
3110
+namespace swig {
3111
+ class PyObject_ptr {
3112
+ protected:
3113
+ PyObject *_obj;
3114
+
3115
+ public:
3116
+ PyObject_ptr() :_obj(0)
3117
+ {
3118
+ }
3119
+
3120
+ PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
3121
+ {
3122
+ Py_XINCREF(_obj);
3123
+ }
3124
+
3125
+ PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
3126
+ {
3127
+ if (initial_ref) {
3128
+ Py_XINCREF(_obj);
3129
+ }
3130
+ }
3131
+
3132
+ PyObject_ptr & operator=(const PyObject_ptr& item)
3133
+ {
3134
+ Py_XINCREF(item._obj);
3135
+ Py_XDECREF(_obj);
3136
+ _obj = item._obj;
3137
+ return *this;
3138
+ }
3139
+
3140
+ ~PyObject_ptr()
3141
+ {
3142
+ Py_XDECREF(_obj);
3143
+ }
3144
+
3145
+ operator PyObject *() const
3146
+ {
3147
+ return _obj;
3148
+ }
3149
+
3150
+ PyObject *operator->() const
3151
+ {
3152
+ return _obj;
3153
+ }
3154
+ };
3155
+}
3156
+
3157
+
3158
+namespace swig {
3159
+ struct PyObject_var : PyObject_ptr {
3160
+ PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
3161
+
3162
+ PyObject_var & operator = (PyObject* obj)
3163
+ {
3164
+ Py_XDECREF(_obj);
3165
+ _obj = obj;
3166
+ return *this;
3167
+ }
3168
+ };
3169
+}
3170
+
3171
+
3172
+#include "nviz.h"
3173
+#include <grass/gsurf.h>
3174
+#include <grass/gstypes.h>
3175
+#undef check
3176
+
3177
+
3178
+#include <iostream>
3179
+
3180
+
3181
+#include <stdexcept>
3182
+
3183
+
3184
+#if defined(__GNUC__)
3185
+# if __GNUC__ == 2 && __GNUC_MINOR <= 96
3186
+# define SWIG_STD_NOMODERN_STL
3187
+# endif
3188
+#endif
3189
+
3190
+
3191
+#include <string>
3192
+#include <stdexcept>
3193
+
3194
+
3195
+namespace swig {
3196
+ struct stop_iteration {
3197
+ };
3198
+
3199
+ struct PySwigIterator {
3200
+ private:
3201
+ PyObject_ptr _seq;
3202
+
3203
+ protected:
3204
+ PySwigIterator(PyObject *seq) : _seq(seq)
3205
+ {
3206
+ }
3207
+
3208
+ public:
3209
+ virtual ~PySwigIterator() {}
3210
+
3211
+ // Access iterator method, required by Python
3212
+ virtual PyObject *value() const = 0;
3213
+
3214
+ // Forward iterator method, required by Python
3215
+ virtual PySwigIterator *incr(size_t n = 1) = 0;
3216
+
3217
+ // Backward iterator method, very common in C++, but not required in Python
3218
+ virtual PySwigIterator *decr(size_t /*n*/ = 1)
3219
+ {
3220
+ throw stop_iteration();
3221
+ }
3222
+
3223
+ // Random access iterator methods, but not required in Python
3224
+ virtual ptrdiff_t distance(const PySwigIterator &/*x*/) const
3225
+ {
3226
+ throw std::invalid_argument("operation not supported");
3227
+ }
3228
+
3229
+ virtual bool equal (const PySwigIterator &/*x*/) const
3230
+ {
3231
+ throw std::invalid_argument("operation not supported");
3232
+ }
3233
+
3234
+ // C++ common/needed methods
3235
+ virtual PySwigIterator *copy() const = 0;
3236
+
3237
+ PyObject *next()
3238
+ {
3239
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
3240
+ PyObject *obj = value();
3241
+ incr();
3242
+ SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
3243
+ return obj;
3244
+ }
3245
+
3246
+ PyObject *previous()
3247
+ {
3248
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
3249
+ decr();
3250
+ PyObject *obj = value();
3251
+ SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
3252
+ return obj;
3253
+ }
3254
+
3255
+ PySwigIterator *advance(ptrdiff_t n)
3256
+ {
3257
+ return (n > 0) ? incr(n) : decr(-n);
3258
+ }
3259
+
3260
+ bool operator == (const PySwigIterator& x) const
3261
+ {
3262
+ return equal(x);
3263
+ }
3264
+
3265
+ bool operator != (const PySwigIterator& x) const
3266
+ {
3267
+ return ! operator==(x);
3268
+ }
3269
+
3270
+ PySwigIterator& operator += (ptrdiff_t n)
3271
+ {
3272
+ return *advance(n);
3273
+ }
3274
+
3275
+ PySwigIterator& operator -= (ptrdiff_t n)
3276
+ {
3277
+ return *advance(-n);
3278
+ }
3279
+
3280
+ PySwigIterator* operator + (ptrdiff_t n) const
3281
+ {
3282
+ return copy()->advance(n);
3283
+ }
3284
+
3285
+ PySwigIterator* operator - (ptrdiff_t n) const
3286
+ {
3287
+ return copy()->advance(-n);
3288
+ }
3289
+
3290
+ ptrdiff_t operator - (const PySwigIterator& x) const
3291
+ {
3292
+ return x.distance(*this);
3293
+ }
3294
+
3295
+ static swig_type_info* descriptor() {
3296
+ static int init = 0;
3297
+ static swig_type_info* desc = 0;
3298
+ if (!init) {
3299
+ desc = SWIG_TypeQuery("swig::PySwigIterator *");
3300
+ init = 1;
3301
+ }
3302
+ return desc;
3303
+ }
3304
+ };
3305
+}
3306
+
3307
+
3308
+SWIGINTERN int
3309
+SWIG_AsVal_double (PyObject *obj, double *val)
3310
+{
3311
+ int res = SWIG_TypeError;
3312
+ if (PyFloat_Check(obj)) {
3313
+ if (val) *val = PyFloat_AsDouble(obj);
3314
+ return SWIG_OK;
3315
+ } else if (PyInt_Check(obj)) {
3316
+ if (val) *val = PyInt_AsLong(obj);
3317
+ return SWIG_OK;
3318
+ } else if (PyLong_Check(obj)) {
3319
+ double v = PyLong_AsDouble(obj);
3320
+ if (!PyErr_Occurred()) {
3321
+ if (val) *val = v;
3322
+ return SWIG_OK;
3323
+ } else {
3324
+ PyErr_Clear();
3325
+ }
3326
+ }
3327
+#ifdef SWIG_PYTHON_CAST_MODE
3328
+ {
3329
+ int dispatch = 0;
3330
+ double d = PyFloat_AsDouble(obj);
3331
+ if (!PyErr_Occurred()) {
3332
+ if (val) *val = d;
3333
+ return SWIG_AddCast(SWIG_OK);
3334
+ } else {
3335
+ PyErr_Clear();
3336
+ }
3337
+ if (!dispatch) {
3338
+ long v = PyLong_AsLong(obj);
3339
+ if (!PyErr_Occurred()) {
3340
+ if (val) *val = v;
3341
+ return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3342
+ } else {
3343
+ PyErr_Clear();
3344
+ }
3345
+ }
3346
+ }
3347
+#endif
3348
+ return res;
3349
+}
3350
+
3351
+
3352
+#include <float.h>
3353
+
3354
+
3355
+#include <math.h>
3356
+
3357
+
3358
+SWIGINTERNINLINE int
3359
+SWIG_CanCastAsInteger(double *d, double min, double max) {
3360
+ double x = *d;
3361
+ if ((min <= x && x <= max)) {
3362
+ double fx = floor(x);
3363
+ double cx = ceil(x);
3364
+ double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3365
+ if ((errno == EDOM) || (errno == ERANGE)) {
3366
+ errno = 0;
3367
+ } else {
3368
+ double summ, reps, diff;
3369
+ if (rd < x) {
3370
+ diff = x - rd;
3371
+ } else if (rd > x) {
3372
+ diff = rd - x;
3373
+ } else {
3374
+ return 1;
3375
+ }
3376
+ summ = rd + x;
3377
+ reps = diff/summ;
3378
+ if (reps < 8*DBL_EPSILON) {
3379
+ *d = rd;
3380
+ return 1;
3381
+ }
3382
+ }
3383
+ }
3384
+ return 0;
3385
+}
3386
+
3387
+
3388
+SWIGINTERN int
3389
+SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3390
+{
3391
+ if (PyInt_Check(obj)) {
3392
+ long v = PyInt_AsLong(obj);
3393
+ if (v >= 0) {
3394
+ if (val) *val = v;
3395
+ return SWIG_OK;
3396
+ } else {
3397
+ return SWIG_OverflowError;
3398
+ }
3399
+ } else if (PyLong_Check(obj)) {
3400
+ unsigned long v = PyLong_AsUnsignedLong(obj);
3401
+ if (!PyErr_Occurred()) {
3402
+ if (val) *val = v;
3403
+ return SWIG_OK;
3404
+ } else {
3405
+ PyErr_Clear();
3406
+ }
3407
+ }
3408
+#ifdef SWIG_PYTHON_CAST_MODE
3409
+ {
3410
+ int dispatch = 0;
3411
+ unsigned long v = PyLong_AsUnsignedLong(obj);
3412
+ if (!PyErr_Occurred()) {
3413
+ if (val) *val = v;
3414
+ return SWIG_AddCast(SWIG_OK);
3415
+ } else {
3416
+ PyErr_Clear();
3417
+ }
3418
+ if (!dispatch) {
3419
+ double d;
3420
+ int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3421
+ if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3422
+ if (val) *val = (unsigned long)(d);
3423
+ return res;
3424
+ }
3425
+ }
3426
+ }
3427
+#endif
3428
+ return SWIG_TypeError;
3429
+}
3430
+
3431
+
3432
+SWIGINTERNINLINE int
3433
+SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3434
+{
3435
+ unsigned long v;
3436
+ int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3437
+ if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3438
+ return res;
3439
+}
3440
+
3441
+
3442
+ #define SWIG_From_long PyInt_FromLong
3443
+
3444
+
3445
+SWIGINTERNINLINE PyObject *
3446
+SWIG_From_ptrdiff_t (ptrdiff_t value)
3447
+{
3448
+ return SWIG_From_long (static_cast< long >(value));
3449
+}
3450
+
3451
+
3452
+SWIGINTERNINLINE PyObject*
3453
+ SWIG_From_bool (bool value)
3454
+{
3455
+ return PyBool_FromLong(value ? 1 : 0);
3456
+}
3457
+
3458
+
3459
+SWIGINTERN int
3460
+SWIG_AsVal_long (PyObject *obj, long* val)
3461
+{
3462
+ if (PyInt_Check(obj)) {
3463
+ if (val) *val = PyInt_AsLong(obj);
3464
+ return SWIG_OK;
3465
+ } else if (PyLong_Check(obj)) {
3466
+ long v = PyLong_AsLong(obj);
3467
+ if (!PyErr_Occurred()) {
3468
+ if (val) *val = v;
3469
+ return SWIG_OK;
3470
+ } else {
3471
+ PyErr_Clear();
3472
+ }
3473
+ }
3474
+#ifdef SWIG_PYTHON_CAST_MODE
3475
+ {
3476
+ int dispatch = 0;
3477
+ long v = PyInt_AsLong(obj);
3478
+ if (!PyErr_Occurred()) {
3479
+ if (val) *val = v;
3480
+ return SWIG_AddCast(SWIG_OK);
3481
+ } else {
3482
+ PyErr_Clear();
3483
+ }
3484
+ if (!dispatch) {
3485
+ double d;
3486
+ int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3487
+ if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3488
+ if (val) *val = (long)(d);
3489
+ return res;
3490
+ }
3491
+ }
3492
+ }
3493
+#endif
3494
+ return SWIG_TypeError;
3495
+}
3496
+
3497
+
3498
+SWIGINTERNINLINE int
3499
+SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
3500
+{
3501
+ long v;
3502
+ int res = SWIG_AsVal_long (obj, val ? &v : 0);
3503
+ if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
3504
+ return res;
3505
+}
3506
+
3507
+
3508
+#include <stdexcept>
3509
+
3510
+
3511
+#include <algorithm>
3512
+
3513
+
3514
+#include <vector>
3515
+
3516
+
3517
+namespace swig {
3518
+ template <class Type>
3519
+ struct noconst_traits {
3520
+ typedef Type noconst_type;
3521
+ };
3522
+
3523
+ template <class Type>
3524
+ struct noconst_traits<const Type> {
3525
+ typedef Type noconst_type;
3526
+ };
3527
+
3528
+ /*
3529
+ type categories
3530
+ */
3531
+ struct pointer_category { };
3532
+ struct value_category { };
3533
+
3534
+ /*
3535
+ General traits that provides type_name and type_info
3536
+ */
3537
+ template <class Type> struct traits { };
3538
+
3539
+ template <class Type>
3540
+ inline const char* type_name() {
3541
+ return traits<typename noconst_traits<Type >::noconst_type >::type_name();
3542
+ }
3543
+
3544
+ template <class Type>
3545
+ struct traits_info {
3546
+ static swig_type_info *type_query(std::string name) {
3547
+ name += " *";
3548
+ return SWIG_TypeQuery(name.c_str());
3549
+ }
3550
+ static swig_type_info *type_info() {
3551
+ static swig_type_info *info = type_query(type_name<Type>());
3552
+ return info;
3553
+ }
3554
+ };
3555
+
3556
+ template <class Type>
3557
+ inline swig_type_info *type_info() {
3558
+ return traits_info<Type>::type_info();
3559
+ }
3560
+
3561
+ /*
3562
+ Partial specialization for pointers
3563
+ */
3564
+ template <class Type> struct traits <Type *> {
3565
+ typedef pointer_category category;
3566
+ static std::string make_ptr_name(const char* name) {
3567
+ std::string ptrname = name;
3568
+ ptrname += " *";
3569
+ return ptrname;
3570
+ }
3571
+ static const char* type_name() {
3572
+ static std::string name = make_ptr_name(swig::type_name<Type>());
3573
+ return name.c_str();
3574
+ }
3575
+ };
3576
+
3577
+ template <class Type, class Category>
3578
+ struct traits_as { };
3579
+
3580
+ template <class Type, class Category>
3581
+ struct traits_check { };
3582
+
3583
+}
3584
+
3585
+
3586
+namespace swig {
3587
+ /*
3588
+ Traits that provides the from method
3589
+ */
3590
+ template <class Type> struct traits_from_ptr {
3591
+ static PyObject *from(Type *val, int owner = 0) {
3592
+ return SWIG_NewPointerObj(val, type_info<Type>(), owner);
3593
+ }
3594
+ };
3595
+
3596
+ template <class Type> struct traits_from {
3597
+ static PyObject *from(const Type& val) {
3598
+ return traits_from_ptr<Type>::from(new Type(val), 1);
3599
+ }
3600
+ };
3601
+
3602
+ template <class Type> struct traits_from<Type *> {
3603
+ static PyObject *from(Type* val) {
3604
+ return traits_from_ptr<Type>::from(val, 0);
3605
+ }
3606
+ };
3607
+
3608
+ template <class Type> struct traits_from<const Type *> {
3609
+ static PyObject *from(const Type* val) {
3610
+ return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
3611
+ }
3612
+ };
3613
+
3614
+
3615
+ template <class Type>
3616
+ inline PyObject *from(const Type& val) {
3617
+ return traits_from<Type>::from(val);
3618
+ }
3619
+
3620
+ template <class Type>
3621
+ inline PyObject *from_ptr(Type* val, int owner) {
3622
+ return traits_from_ptr<Type>::from(val, owner);
3623
+ }
3624
+
3625
+ /*
3626
+ Traits that provides the asval/as/check method
3627
+ */
3628
+ template <class Type>
3629
+ struct traits_asptr {
3630
+ static int asptr(PyObject *obj, Type **val) {
3631
+ Type *p;
3632
+ int res = (SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0) == SWIG_OK) ? SWIG_OLDOBJ : 0;
3633
+ if (SWIG_IsOK(res)) {
3634
+ if (val) *val = p;
3635
+ }
3636
+ return res;
3637
+ }
3638
+ };
3639
+
3640
+ template <class Type>
3641
+ inline int asptr(PyObject *obj, Type **vptr) {
3642
+ return traits_asptr<Type>::asptr(obj, vptr);
3643
+ }
3644
+
3645
+ template <class Type>
3646
+ struct traits_asval {
3647
+ static int asval(PyObject *obj, Type *val) {
3648
+ if (val) {
3649
+ Type *p = 0;
3650
+ int res = traits_asptr<Type>::asptr(obj, &p);
3651
+ if (!SWIG_IsOK(res)) return res;
3652
+ if (p) {
3653
+ typedef typename noconst_traits<Type>::noconst_type noconst_type;
3654
+ *(const_cast<noconst_type*>(val)) = *p;
3655
+ if (SWIG_IsNewObj(res)){
3656
+ delete p;
3657
+ res = SWIG_DelNewMask(res);
3658
+ }
3659
+ return res;
3660
+ } else {
3661
+ return SWIG_ERROR;
3662
+ }
3663
+ } else {
3664
+ return traits_asptr<Type>::asptr(obj, (Type **)(0));
3665
+ }
3666
+ }
3667
+ };
3668
+
3669
+ template <class Type> struct traits_asval<Type*> {
3670
+ static int asval(PyObject *obj, Type **val) {
3671
+ if (val) {
3672
+ typedef typename noconst_traits<Type>::noconst_type noconst_type;
3673
+ noconst_type *p = 0;
3674
+ int res = traits_asptr<noconst_type>::asptr(obj, &p);
3675
+ if (SWIG_IsOK(res)) {
3676
+ *(const_cast<noconst_type**>(val)) = p;
3677
+ }
3678
+ return res;
3679
+ } else {
3680
+ return traits_asptr<Type>::asptr(obj, (Type **)(0));
3681
+ }
3682
+ }
3683
+ };
3684
+
3685
+ template <class Type>
3686
+ inline int asval(PyObject *obj, Type *val) {
3687
+ return traits_asval<Type>::asval(obj, val);
3688
+ }
3689
+
3690
+ template <class Type>
3691
+ struct traits_as<Type, value_category> {
3692
+ static Type as(PyObject *obj, bool throw_error) {
3693
+ Type v;
3694
+ int res = asval(obj, &v);
3695
+ if (!obj || !SWIG_IsOK(res)) {
3696
+ if (!PyErr_Occurred()) {
3697
+ ::SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3698
+ }
3699
+ if (throw_error) throw std::invalid_argument("bad type");
3700
+ }
3701
+ return v;
3702
+ }
3703
+ };
3704
+
3705
+ template <class Type>
3706
+ struct traits_as<Type, pointer_category> {
3707
+ static Type as(PyObject *obj, bool throw_error) {
3708
+ Type *v = 0;
3709
+ int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3710
+ if (SWIG_IsOK(res) && v) {
3711
+ if (SWIG_IsNewObj(res)) {
3712
+ Type r(*v);
3713
+ delete v;
3714
+ return r;
3715
+ } else {
3716
+ return *v;
3717
+ }
3718
+ } else {
3719
+ // Uninitialized return value, no Type() constructor required.
3720
+ static Type *v_def = (Type*) malloc(sizeof(Type));
3721
+ if (!PyErr_Occurred()) {
3722
+ SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3723
+ }
3724
+ if (throw_error) throw std::invalid_argument("bad type");
3725
+ memset(v_def,0,sizeof(Type));
3726
+ return *v_def;
3727
+ }
3728
+ }
3729
+ };
3730
+
3731
+ template <class Type>
3732
+ struct traits_as<Type*, pointer_category> {
3733
+ static Type* as(PyObject *obj, bool throw_error) {
3734
+ Type *v = 0;
3735
+ int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3736
+ if (SWIG_IsOK(res)) {
3737
+ return v;
3738
+ } else {
3739
+ if (!PyErr_Occurred()) {
3740
+ SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3741
+ }
3742
+ if (throw_error) throw std::invalid_argument("bad type");
3743
+ return 0;
3744
+ }
3745
+ }
3746
+ };
3747
+
3748
+ template <class Type>
3749
+ inline Type as(PyObject *obj, bool te = false) {
3750
+ return traits_as<Type, typename traits<Type>::category>::as(obj, te);
3751
+ }
3752
+
3753
+ template <class Type>
3754
+ struct traits_check<Type, value_category> {
3755
+ static bool check(PyObject *obj) {
3756
+ int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
3757
+ return SWIG_IsOK(res) ? true : false;
3758
+ }
3759
+ };
3760
+
3761
+ template <class Type>
3762
+ struct traits_check<Type, pointer_category> {
3763
+ static bool check(PyObject *obj) {
3764
+ int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
3765
+ return SWIG_IsOK(res) ? true : false;
3766
+ }
3767
+ };
3768
+
3769
+ template <class Type>
3770
+ inline bool check(PyObject *obj) {
3771
+ return traits_check<Type, typename traits<Type>::category>::check(obj);
3772
+ }
3773
+}
3774
+
3775
+
3776
+#include <functional>
3777
+
3778
+namespace std {
3779
+ template <>
3780
+ struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
3781
+ {
3782
+ bool
3783
+ operator()(PyObject * v, PyObject *w) const
3784
+ {
3785
+ bool res;
3786
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3787
+ res = PyObject_Compare(v, w) < 0;
3788
+ SWIG_PYTHON_THREAD_END_BLOCK;
3789
+ return res;
3790
+ }
3791
+ };
3792
+
3793
+ template <>
3794
+ struct less <swig::PyObject_ptr>: public binary_function<swig::PyObject_ptr, swig::PyObject_ptr, bool>
3795
+ {
3796
+ bool
3797
+ operator()(const swig::PyObject_ptr& v, const swig::PyObject_ptr& w) const
3798
+ {
3799
+ return std::less<PyObject *>()(v, w);
3800
+ }
3801
+ };
3802
+
3803
+ template <>
3804
+ struct less <swig::PyObject_var>: public binary_function<swig::PyObject_var, swig::PyObject_var, bool>
3805
+ {
3806
+ bool
3807
+ operator()(const swig::PyObject_var& v, const swig::PyObject_var& w) const
3808
+ {
3809
+ return std::less<PyObject *>()(v, w);
3810
+ }
3811
+ };
3812
+
3813
+}
3814
+
3815
+namespace swig {
3816
+ template <> struct traits<PyObject *> {
3817
+ typedef value_category category;
3818
+ static const char* type_name() { return "PyObject *"; }
3819
+ };
3820
+
3821
+ template <> struct traits_asval<PyObject * > {
3822
+ typedef PyObject * value_type;
3823
+ static int asval(PyObject *obj, value_type *val) {
3824
+ if (val) *val = obj;
3825
+ return SWIG_OK;
3826
+ }
3827
+ };
3828
+
3829
+ template <>
3830
+ struct traits_check<PyObject *, value_category> {
3831
+ static bool check(PyObject *) {
3832
+ return true;
3833
+ }
3834
+ };
3835
+
3836
+ template <> struct traits_from<PyObject *> {
3837
+ typedef PyObject * value_type;
3838
+ static PyObject *from(const value_type& val) {
3839
+ Py_XINCREF(val);
3840
+ return val;
3841
+ }
3842
+ };
3843
+
3844
+}
3845
+
3846
+namespace swig {
3847
+ inline size_t
3848
+ check_index(ptrdiff_t i, size_t size, bool insert = false) {
3849
+ if ( i < 0 ) {
3850
+ if ((size_t) (-i) <= size)
3851
+ return (size_t) (i + size);
3852
+ } else if ( (size_t) i < size ) {
3853
+ return (size_t) i;
3854
+ } else if (insert && ((size_t) i == size)) {
3855
+ return size;
3856
+ }
3857
+
3858
+ throw std::out_of_range("index out of range");
3859
+ }
3860
+
3861
+ inline size_t
3862
+ slice_index(ptrdiff_t i, size_t size) {
3863
+ if ( i < 0 ) {
3864
+ if ((size_t) (-i) <= size) {
3865
+ return (size_t) (i + size);
3866
+ } else {
3867
+ throw std::out_of_range("index out of range");
3868
+ }
3869
+ } else {
3870
+ return ( (size_t) i < size ) ? ((size_t) i) : size;
3871
+ }
3872
+ }
3873
+
3874
+ template <class Sequence, class Difference>
3875
+ inline typename Sequence::iterator
3876
+ getpos(Sequence* self, Difference i) {
3877
+ typename Sequence::iterator pos = self->begin();
3878
+ std::advance(pos, check_index(i,self->size()));
3879
+ return pos;
3880
+ }
3881
+
3882
+ template <class Sequence, class Difference>
3883
+ inline typename Sequence::const_iterator
3884
+ cgetpos(const Sequence* self, Difference i) {
3885
+ typename Sequence::const_iterator pos = self->begin();
3886
+ std::advance(pos, check_index(i,self->size()));
3887
+ return pos;
3888
+ }
3889
+
3890
+ template <class Sequence, class Difference>
3891
+ inline Sequence*
3892
+ getslice(const Sequence* self, Difference i, Difference j) {
3893
+ typename Sequence::size_type size = self->size();
3894
+ typename Sequence::size_type ii = swig::check_index(i, size);
3895
+ typename Sequence::size_type jj = swig::slice_index(j, size);
3896
+
3897
+ if (jj > ii) {
3898
+ typename Sequence::const_iterator vb = self->begin();
3899
+ typename Sequence::const_iterator ve = self->begin();
3900
+ std::advance(vb,ii);
3901
+ std::advance(ve,jj);
3902
+ return new Sequence(vb, ve);
3903
+ } else {
3904
+ return new Sequence();
3905
+ }
3906
+ }
3907
+
3908
+ template <class Sequence, class Difference, class InputSeq>
3909
+ inline void
3910
+ setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
3911
+ typename Sequence::size_type size = self->size();
3912
+ typename Sequence::size_type ii = swig::check_index(i, size, true);
3913
+ typename Sequence::size_type jj = swig::slice_index(j, size);
3914
+ if (jj < ii) jj = ii;
3915
+ size_t ssize = jj - ii;
3916
+ if (ssize <= v.size()) {
3917
+ typename Sequence::iterator sb = self->begin();
3918
+ typename InputSeq::const_iterator vmid = v.begin();
3919
+ std::advance(sb,ii);
3920
+ std::advance(vmid, jj - ii);
3921
+ self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
3922
+ } else {
3923
+ typename Sequence::iterator sb = self->begin();
3924
+ typename Sequence::iterator se = self->begin();
3925
+ std::advance(sb,ii);
3926
+ std::advance(se,jj);
3927
+ self->erase(sb,se);
3928
+ self->insert(sb, v.begin(), v.end());
3929
+ }
3930
+ }
3931
+
3932
+ template <class Sequence, class Difference>
3933
+ inline void
3934
+ delslice(Sequence* self, Difference i, Difference j) {
3935
+ typename Sequence::size_type size = self->size();
3936
+ typename Sequence::size_type ii = swig::check_index(i, size, true);
3937
+ typename Sequence::size_type jj = swig::slice_index(j, size);
3938
+ if (jj > ii) {
3939
+ typename Sequence::iterator sb = self->begin();
3940
+ typename Sequence::iterator se = self->begin();
3941
+ std::advance(sb,ii);
3942
+ std::advance(se,jj);
3943
+ self->erase(sb,se);
3944
+ }
3945
+ }
3946
+}
3947
+
3948
+
3949
+#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
3950
+# if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
3951
+# define SWIG_STD_NOITERATOR_TRAITS_STL
3952
+# endif
3953
+#endif
3954
+
3955
+#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
3956
+#include <iterator>
3957
+#else
3958
+namespace std {
3959
+ template <class Iterator>
3960
+ struct iterator_traits {
3961
+ typedef ptrdiff_t difference_type;
3962
+ typedef typename Iterator::value_type value_type;
3963
+ };
3964
+
3965
+ template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
3966
+ struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
3967
+ typedef Distance difference_type;
3968
+ typedef T value_type;
3969
+ };
3970
+
3971
+ template <class T>
3972
+ struct iterator_traits<T*> {
3973
+ typedef T value_type;
3974
+ typedef ptrdiff_t difference_type;
3975
+ };
3976
+
3977
+ template<typename _InputIterator>
3978
+ inline typename iterator_traits<_InputIterator>::difference_type
3979
+ distance(_InputIterator __first, _InputIterator __last)
3980
+ {
3981
+ typename iterator_traits<_InputIterator>::difference_type __n = 0;
3982
+ while (__first != __last) {
3983
+ ++__first; ++__n;
3984
+ }
3985
+ return __n;
3986
+ }
3987
+}
3988
+#endif
3989
+
3990
+
3991
+namespace swig {
3992
+ template<typename OutIterator>
3993
+ class PySwigIterator_T : public PySwigIterator
3994
+ {
3995
+ public:
3996
+ typedef OutIterator out_iterator;
3997
+ typedef typename std::iterator_traits<out_iterator>::value_type value_type;
3998
+ typedef PySwigIterator_T<out_iterator> self_type;
3999
+
4000
+ PySwigIterator_T(out_iterator curr, PyObject *seq)
4001
+ : PySwigIterator(seq), current(curr)
4002
+ {
4003
+ }
4004
+
4005
+ const out_iterator& get_current() const
4006
+ {
4007
+ return current;
4008
+ }
4009
+
4010
+
4011
+ bool equal (const PySwigIterator &iter) const
4012
+ {
4013
+ const self_type *iters = dynamic_cast<const self_type *>(&iter);
4014
+ if (iters) {
4015
+ return (current == iters->get_current());
4016
+ } else {
4017
+ throw std::invalid_argument("bad iterator type");
4018
+ }
4019
+ }
4020
+
4021
+ ptrdiff_t distance(const PySwigIterator &iter) const
4022
+ {
4023
+ const self_type *iters = dynamic_cast<const self_type *>(&iter);
4024
+ if (iters) {
4025
+ return std::distance(current, iters->get_current());
4026
+ } else {
4027
+ throw std::invalid_argument("bad iterator type");
4028
+ }
4029
+ }
4030
+
4031
+ protected:
4032
+ out_iterator current;
4033
+ };
4034
+
4035
+ template <class ValueType>
4036
+ struct from_oper
4037
+ {
4038
+ typedef const ValueType& argument_type;
4039
+ typedef PyObject *result_type;
4040
+ result_type operator()(argument_type v) const
4041
+ {
4042
+ return swig::from(v);
4043
+ }
4044
+ };
4045
+
4046
+ template<typename OutIterator,
4047
+ typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
4048
+ typename FromOper = from_oper<ValueType> >
4049
+ class PySwigIteratorOpen_T : public PySwigIterator_T<OutIterator>
4050
+ {
4051
+ public:
4052
+ FromOper from;
4053
+ typedef OutIterator out_iterator;
4054
+ typedef ValueType value_type;
4055
+ typedef PySwigIterator_T<out_iterator> base;
4056
+ typedef PySwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
4057
+
4058
+ PySwigIteratorOpen_T(out_iterator curr, PyObject *seq)
4059
+ : PySwigIterator_T<OutIterator>(curr, seq)
4060
+ {
4061
+ }
4062
+
4063
+ PyObject *value() const {
4064
+ return from(static_cast<const value_type&>(*(base::current)));
4065
+ }
4066
+
4067
+ PySwigIterator *copy() const
4068
+ {
4069
+ return new self_type(*this);
4070
+ }
4071
+
4072
+ PySwigIterator *incr(size_t n = 1)
4073
+ {
4074
+ while (n--) {
4075
+ ++base::current;
4076
+ }
4077
+ return this;
4078
+ }
4079
+
4080
+ PySwigIterator *decr(size_t n = 1)
4081
+ {
4082
+ while (n--) {
4083
+ --base::current;
4084
+ }
4085
+ return this;
4086
+ }
4087
+ };
4088
+
4089
+ template<typename OutIterator,
4090
+ typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
4091
+ typename FromOper = from_oper<ValueType> >
4092
+ class PySwigIteratorClosed_T : public PySwigIterator_T<OutIterator>
4093
+ {
4094
+ public:
4095
+ FromOper from;
4096
+ typedef OutIterator out_iterator;
4097
+ typedef ValueType value_type;
4098
+ typedef PySwigIterator_T<out_iterator> base;
4099
+ typedef PySwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
4100
+
4101
+ PySwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
4102
+ : PySwigIterator_T<OutIterator>(curr, seq), begin(first), end(last)
4103
+ {
4104
+ }
4105
+
4106
+ PyObject *value() const {
4107
+ if (base::current == end) {
4108
+ throw stop_iteration();
4109
+ } else {
4110
+ return from(static_cast<const value_type&>(*(base::current)));
4111
+ }
4112
+ }
4113
+
4114
+ PySwigIterator *copy() const
4115
+ {
4116
+ return new self_type(*this);
4117
+ }
4118
+
4119
+ PySwigIterator *incr(size_t n = 1)
4120
+ {
4121
+ while (n--) {
4122
+ if (base::current == end) {
4123
+ throw stop_iteration();
4124
+ } else {
4125
+ ++base::current;
4126
+ }
4127
+ }
4128
+ return this;
4129
+ }
4130
+
4131
+ PySwigIterator *decr(size_t n = 1)
4132
+ {
4133
+ while (n--) {
4134
+ if (base::current == begin) {
4135
+ throw stop_iteration();
4136
+ } else {
4137
+ --base::current;
4138
+ }
4139
+ }
4140
+ return this;
4141
+ }
4142
+
4143
+ private:
4144
+ out_iterator begin;
4145
+ out_iterator end;
4146
+ };
4147
+
4148
+ template<typename OutIter>
4149
+ inline PySwigIterator*
4150
+ make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
4151
+ {
4152
+ return new PySwigIteratorClosed_T<OutIter>(current, begin, end, seq);
4153
+ }
4154
+
4155
+ template<typename OutIter>
4156
+ inline PySwigIterator*
4157
+ make_output_iterator(const OutIter& current, PyObject *seq = 0)
4158
+ {
4159
+ return new PySwigIteratorOpen_T<OutIter>(current, seq);
4160
+ }
4161
+}
4162
+
4163
+
4164
+namespace swig
4165
+{
4166
+ template <class T>
4167
+ struct PySequence_Ref
4168
+ {
4169
+ PySequence_Ref(PyObject* seq, int index)
4170
+ : _seq(seq), _index(index)
4171
+ {
4172
+ }
4173
+
4174
+ operator T () const
4175
+ {
4176
+ swig::PyObject_var item = PySequence_GetItem(_seq, _index);
4177
+ try {
4178
+ return swig::as<T>(item, true);
4179
+ } catch (std::exception& e) {
4180
+ char msg[1024];
4181
+ sprintf(msg, "in sequence element %d ", _index);
4182
+ if (!PyErr_Occurred()) {
4183
+ ::SWIG_Error(SWIG_TypeError, swig::type_name<T>());
4184
+ }
4185
+ SWIG_Python_AddErrorMsg(msg);
4186
+ SWIG_Python_AddErrorMsg(e.what());
4187
+ throw;
4188
+ }
4189
+ }
4190
+
4191
+ PySequence_Ref& operator=(const T& v)
4192
+ {
4193
+ PySequence_SetItem(_seq, _index, swig::from<T>(v));
4194
+ return *this;
4195
+ }
4196
+
4197
+ private:
4198
+ PyObject* _seq;
4199
+ int _index;
4200
+ };
4201
+
4202
+ template <class T>
4203
+ struct PySequence_ArrowProxy
4204
+ {
4205
+ PySequence_ArrowProxy(const T& x): m_value(x) {}
4206
+ const T* operator->() const { return &m_value; }
4207
+ operator const T*() const { return &m_value; }
4208
+ T m_value;
4209
+ };
4210
+
4211
+ template <class T, class Reference >
4212
+ struct PySequence_InputIterator
4213
+ {
4214
+ typedef PySequence_InputIterator<T, Reference > self;
4215
+
4216
+ typedef std::random_access_iterator_tag iterator_category;
4217
+ typedef Reference reference;
4218
+ typedef T value_type;
4219
+ typedef T* pointer;
4220
+ typedef int difference_type;
4221
+
4222
+ PySequence_InputIterator()
4223
+ {
4224
+ }
4225
+
4226
+ PySequence_InputIterator(PyObject* seq, int index)
4227
+ : _seq(seq), _index(index)
4228
+ {
4229
+ }
4230
+
4231
+ reference operator*() const
4232
+ {
4233
+ return reference(_seq, _index);
4234
+ }
4235
+
4236
+ PySequence_ArrowProxy<T>
4237
+ operator->() const {
4238
+ return PySequence_ArrowProxy<T>(operator*());
4239
+ }
4240
+
4241
+ bool operator==(const self& ri) const
4242
+ {
4243
+ return (_index == ri._index) && (_seq == ri._seq);
4244
+ }
4245
+
4246
+ bool operator!=(const self& ri) const
4247
+ {
4248
+ return !(operator==(ri));
4249
+ }
4250
+
4251
+ self& operator ++ ()
4252
+ {
4253
+ ++_index;
4254
+ return *this;
4255
+ }
4256
+
4257
+ self& operator -- ()
4258
+ {
4259
+ --_index;
4260
+ return *this;
4261
+ }
4262
+
4263
+ self& operator += (difference_type n)
4264
+ {
4265
+ _index += n;
4266
+ return *this;
4267
+ }
4268
+
4269
+ self operator +(difference_type n) const
4270
+ {
4271
+ return self(_seq, _index + n);
4272
+ }
4273
+
4274
+ self& operator -= (difference_type n)
4275
+ {
4276
+ _index -= n;
4277
+ return *this;
4278
+ }
4279
+
4280
+ self operator -(difference_type n) const
4281
+ {
4282
+ return self(_seq, _index - n);
4283
+ }
4284
+
4285
+ difference_type operator - (const self& ri) const
4286
+ {
4287
+ return _index - ri._index;
4288
+ }
4289
+
4290
+ bool operator < (const self& ri) const
4291
+ {
4292
+ return _index < ri._index;
4293
+ }
4294
+
4295
+ reference
4296
+ operator[](difference_type n) const
4297
+ {
4298
+ return reference(_seq, _index + n);
4299
+ }
4300
+
4301
+ private:
4302
+ PyObject* _seq;
4303
+ difference_type _index;
4304
+ };
4305
+
4306
+ template <class T>
4307
+ struct PySequence_Cont
4308
+ {
4309
+ typedef PySequence_Ref<T> reference;
4310
+ typedef const PySequence_Ref<T> const_reference;
4311
+ typedef T value_type;
4312
+ typedef T* pointer;
4313
+ typedef int difference_type;
4314
+ typedef int size_type;
4315
+ typedef const pointer const_pointer;
4316
+ typedef PySequence_InputIterator<T, reference> iterator;
4317
+ typedef PySequence_InputIterator<T, const_reference> const_iterator;
4318
+
4319
+ PySequence_Cont(PyObject* seq) : _seq(0)
4320
+ {
4321
+ if (!PySequence_Check(seq)) {
4322
+ throw std::invalid_argument("a sequence is expected");
4323
+ }
4324
+ _seq = seq;
4325
+ Py_INCREF(_seq);
4326
+ }
4327
+
4328
+ ~PySequence_Cont()
4329
+ {
4330
+ Py_XDECREF(_seq);
4331
+ }
4332
+
4333
+ size_type size() const
4334
+ {
4335
+ return static_cast<size_type>(PySequence_Size(_seq));
4336
+ }
4337
+
4338
+ bool empty() const
4339
+ {
4340
+ return size() == 0;
4341
+ }
4342
+
4343
+ iterator begin()
4344
+ {
4345
+ return iterator(_seq, 0);
4346
+ }
4347
+
4348
+ const_iterator begin() const
4349
+ {
4350
+ return const_iterator(_seq, 0);
4351
+ }
4352
+
4353
+ iterator end()
4354
+ {
4355
+ return iterator(_seq, size());
4356
+ }
4357
+
4358
+ const_iterator end() const
4359
+ {
4360
+ return const_iterator(_seq, size());
4361
+ }
4362
+
4363
+ reference operator[](difference_type n)
4364
+ {
4365
+ return reference(_seq, n);
4366
+ }
4367
+
4368
+ const_reference operator[](difference_type n) const
4369
+ {
4370
+ return const_reference(_seq, n);
4371
+ }
4372
+
4373
+ bool check(bool set_err = true) const
4374
+ {
4375
+ int s = size();
4376
+ for (int i = 0; i < s; ++i) {
4377
+ swig::PyObject_var item = PySequence_GetItem(_seq, i);
4378
+ if (!swig::check<value_type>(item)) {
4379
+ if (set_err) {
4380
+ char msg[1024];
4381
+ sprintf(msg, "in sequence element %d", i);
4382
+ SWIG_Error(SWIG_RuntimeError, msg);
4383
+ }
4384
+ return false;
4385
+ }
4386
+ }
4387
+ return true;
4388
+ }
4389
+
4390
+ private:
4391
+ PyObject* _seq;
4392
+ };
4393
+
4394
+}
4395
+
4396
+
4397
+#include <limits.h>
4398
+#if !defined(SWIG_NO_LLONG_MAX)
4399
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
4400
+# define LLONG_MAX __LONG_LONG_MAX__
4401
+# define LLONG_MIN (-LLONG_MAX - 1LL)
4402
+# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
4403
+# endif
4404
+#endif
4405
+
4406
+
4407
+SWIGINTERN int
4408
+SWIG_AsVal_int (PyObject * obj, int *val)
4409
+{
4410
+ long v;
4411
+ int res = SWIG_AsVal_long (obj, &v);
4412
+ if (SWIG_IsOK(res)) {
4413
+ if ((v < INT_MIN || v > INT_MAX)) {
4414
+ return SWIG_OverflowError;
4415
+ } else {
4416
+ if (val) *val = static_cast< int >(v);
4417
+ }
4418
+ }
4419
+ return res;
4420
+}
4421
+
4422
+
4423
+SWIGINTERNINLINE PyObject *
4424
+SWIG_From_int (int value)
4425
+{
4426
+ return SWIG_From_long (value);
4427
+}
4428
+
4429
+
4430
+namespace swig {
4431
+ template <> struct traits<int > {
4432
+ typedef value_category category;
4433
+ static const char* type_name() { return"int"; }
4434
+ };
4435
+ template <> struct traits_asval<int > {
4436
+ typedef int value_type;
4437
+ static int asval(PyObject *obj, value_type *val) {
4438
+ return SWIG_AsVal_int (obj, val);
4439
+ }
4440
+ };
4441
+ template <> struct traits_from<int > {
4442
+ typedef int value_type;
4443
+ static PyObject *from(const value_type& val) {
4444
+ return SWIG_From_int (val);
4445
+ }
4446
+ };
4447
+}
4448
+
4449
+
4450
+namespace swig {
4451
+ template <class PySeq, class Seq>
4452
+ inline void
4453
+ assign(const PySeq& pyseq, Seq* seq) {
4454
+ // seq->assign(pyseq.begin(), pyseq.end()); // not used as not always implemented
4455
+ typedef typename PySeq::value_type value_type;
4456
+ typename PySeq::const_iterator it = pyseq.begin();
4457
+ for (;it != pyseq.end(); ++it) {
4458
+ seq->insert(seq->end(),(value_type)(*it));
4459
+ }
4460
+ }
4461
+
4462
+ template <class Seq, class T = typename Seq::value_type >
4463
+ struct traits_asptr_stdseq {
4464
+ typedef Seq sequence;
4465
+ typedef T value_type;
4466
+
4467
+ static int asptr(PyObject *obj, sequence **seq) {
4468
+ if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
4469
+ sequence *p;
4470
+ if (::SWIG_ConvertPtr(obj,(void**)&p,
4471
+ swig::type_info<sequence>(),0) == SWIG_OK) {
4472
+ if (seq) *seq = p;
4473
+ return SWIG_OLDOBJ;
4474
+ }
4475
+ } else if (PySequence_Check(obj)) {
4476
+ try {
4477
+ PySequence_Cont<value_type> pyseq(obj);
4478
+ if (seq) {
4479
+ sequence *pseq = new sequence();
4480
+ assign(pyseq, pseq);
4481
+ *seq = pseq;
4482
+ return SWIG_NEWOBJ;
4483
+ } else {
4484
+ return pyseq.check() ? SWIG_OK : SWIG_ERROR;
4485
+ }
4486
+ } catch (std::exception& e) {
4487
+ if (seq) {
4488
+ if (!PyErr_Occurred()) {
4489
+ PyErr_SetString(PyExc_TypeError, e.what());
4490
+ }
4491
+ }
4492
+ return SWIG_ERROR;
4493
+ }
4494
+ }
4495
+ return SWIG_ERROR;
4496
+ }
4497
+ };
4498
+
4499
+ template <class Seq, class T = typename Seq::value_type >
4500
+ struct traits_from_stdseq {
4501
+ typedef Seq sequence;
4502
+ typedef T value_type;
4503
+ typedef typename Seq::size_type size_type;
4504
+ typedef typename sequence::const_iterator const_iterator;
4505
+
4506
+ static PyObject *from(const sequence& seq) {
4507
+#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
4508
+ swig_type_info *desc = swig::type_info<sequence>();
4509
+ if (desc && desc->clientdata) {
4510
+ return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
4511
+ }
4512
+#endif
4513
+ size_type size = seq.size();
4514
+ if (size <= (size_type)INT_MAX) {
4515
+ PyObject *obj = PyTuple_New((int)size);
4516
+ int i = 0;
4517
+ for (const_iterator it = seq.begin();
4518
+ it != seq.end(); ++it, ++i) {
4519
+ PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
4520
+ }
4521
+ return obj;
4522
+ } else {
4523
+ PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
4524
+ return NULL;
4525
+ }
4526
+ }
4527
+ };
4528
+}
4529
+
4530
+
4531
+ namespace swig {
4532
+ template <class T>
4533
+ struct traits_asptr<std::vector<T> > {
4534
+ static int asptr(PyObject *obj, std::vector<T> **vec) {
4535
+ return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
4536
+ }
4537
+ };
4538
+
4539
+ template <class T>
4540
+ struct traits_from<std::vector<T> > {
4541
+ static PyObject *from(const std::vector<T>& vec) {
4542
+ return traits_from_stdseq<std::vector<T> >::from(vec);
4543
+ }
4544
+ };
4545
+ }
4546
+
4547
+
4548
+ namespace swig {
4549
+ template <> struct traits<std::vector<int, std::allocator< int > > > {
4550
+ typedef pointer_category category;
4551
+ static const char* type_name() {
4552
+ return "std::vector<" "int" "," "std::allocator< int >" " >";
4553
+ }
4554
+ };
4555
+ }
4556
+
4557
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
4558
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4559
+ }
4560
+SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
4561
+ return !(self->empty());
4562
+ }
4563
+SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
4564
+ return self->size();
4565
+ }
4566
+
4567
+SWIGINTERNINLINE PyObject*
4568
+SWIG_From_unsigned_SS_long (unsigned long value)
4569
+{
4570
+ return (value > LONG_MAX) ?
4571
+ PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
4572
+}
4573
+
4574
+
4575
+SWIGINTERNINLINE PyObject *
4576
+SWIG_From_size_t (size_t value)
4577
+{
4578
+ return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
4579
+}
4580
+
4581
+SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
4582
+ if (self->size() == 0)
4583
+ throw std::out_of_range("pop from empty container");
4584
+ std::vector<int,std::allocator< int > >::value_type x = self->back();
4585
+ self->pop_back();
4586
+ return x;
4587
+ }
4588
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
4589
+ return swig::getslice(self, i, j);
4590
+ }
4591
+SWIGINTERN void std_vector_Sl_int_Sg____setslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
4592
+ swig::setslice(self, i, j, v);
4593
+ }
4594
+SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
4595
+ swig::delslice(self, i, j);
4596
+ }
4597
+SWIGINTERN void std_vector_Sl_int_Sg____delitem__(std::vector< int > *self,std::vector< int >::difference_type i){
4598
+ self->erase(swig::getpos(self,i));
4599
+ }
4600
+SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem__(std::vector< int > const *self,std::vector< int >::difference_type i){
4601
+ return *(swig::cgetpos(self, i));
4602
+ }
4603
+SWIGINTERN void std_vector_Sl_int_Sg____setitem__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
4604
+ *(swig::getpos(self,i)) = x;
4605
+ }
4606
+SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
4607
+ self->push_back(x);
4608
+ }
4609
+
4610
+ #define SWIG_From_double PyFloat_FromDouble
4611
+
4612
+
4613
+namespace swig {
4614
+ template <> struct traits<double > {
4615
+ typedef value_category category;
4616
+ static const char* type_name() { return"double"; }
4617
+ };
4618
+ template <> struct traits_asval<double > {
4619
+ typedef double value_type;
4620
+ static int asval(PyObject *obj, value_type *val) {
4621
+ return SWIG_AsVal_double (obj, val);
4622
+ }
4623
+ };
4624
+ template <> struct traits_from<double > {
4625
+ typedef double value_type;
4626
+ static PyObject *from(const value_type& val) {
4627
+ return SWIG_From_double (val);
4628
+ }
4629
+ };
4630
+}
4631
+
4632
+
4633
+ namespace swig {
4634
+ template <> struct traits<std::vector<double, std::allocator< double > > > {
4635
+ typedef pointer_category category;
4636
+ static const char* type_name() {
4637
+ return "std::vector<" "double" "," "std::allocator< double >" " >";
4638
+ }
4639
+ };
4640
+ }
4641
+
4642
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
4643
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4644
+ }
4645
+SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
4646
+ return !(self->empty());
4647
+ }
4648
+SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
4649
+ return self->size();
4650
+ }
4651
+SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
4652
+ if (self->size() == 0)
4653
+ throw std::out_of_range("pop from empty container");
4654
+ std::vector<double,std::allocator< double > >::value_type x = self->back();
4655
+ self->pop_back();
4656
+ return x;
4657
+ }
4658
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
4659
+ return swig::getslice(self, i, j);
4660
+ }
4661
+SWIGINTERN void std_vector_Sl_double_Sg____setslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
4662
+ swig::setslice(self, i, j, v);
4663
+ }
4664
+SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
4665
+ swig::delslice(self, i, j);
4666
+ }
4667
+SWIGINTERN void std_vector_Sl_double_Sg____delitem__(std::vector< double > *self,std::vector< double >::difference_type i){
4668
+ self->erase(swig::getpos(self,i));
4669
+ }
4670
+SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem__(std::vector< double > const *self,std::vector< double >::difference_type i){
4671
+ return *(swig::cgetpos(self, i));
4672
+ }
4673
+SWIGINTERN void std_vector_Sl_double_Sg____setitem__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
4674
+ *(swig::getpos(self,i)) = x;
4675
+ }
4676
+SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
4677
+ self->push_back(x);
4678
+ }
4679
+
4680
+#include <utility>
4681
+
4682
+
4683
+#include <map>
4684
+#include <algorithm>
4685
+#include <stdexcept>
4686
+
4687
+
4688
+ namespace swig {
4689
+
4690
+
4691
+
4692
+
4693
+
4694
+
4695
+
4696
+
4697
+
4698
+
4699
+
4700
+
4701
+
4702
+
4703
+
4704
+
4705
+
4706
+
4707
+
4708
+
4709
+
4710
+
4711
+
4712
+
4713
+
4714
+
4715
+
4716
+
4717
+
4718
+
4719
+
4720
+
4721
+
4722
+
4723
+
4724
+
4725
+
4726
+
4727
+
4728
+
4729
+
4730
+
4731
+
4732
+
4733
+
4734
+
4735
+
4736
+
4737
+
4738
+ template <class T, class U >
4739
+ struct traits_asptr<std::pair<T,U> > {
4740
+ typedef std::pair<T,U> value_type;
4741
+
4742
+ static int get_pair(PyObject* first, PyObject* second,
4743
+ std::pair<T,U> **val)
4744
+ {
4745
+ if (val) {
4746
+ value_type *vp = (new std::pair<T,U>);
4747
+ T *pfirst = &(vp->first);
4748
+ int res1 = swig::asval((PyObject*)first, pfirst);
4749
+ if (!SWIG_IsOK(res1)) return res1;
4750
+ U *psecond = &(vp->second);
4751
+ int res2 = swig::asval((PyObject*)second, psecond);
4752
+ if (!SWIG_IsOK(res2)) return res2;
4753
+ *val = vp;
4754
+ return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
4755
+ } else {
4756
+ T *pfirst = 0;
4757
+ int res1 = swig::asval((PyObject*)first, pfirst);
4758
+ if (!SWIG_IsOK(res1)) return res1;
4759
+ U *psecond = 0;
4760
+ int res2 = swig::asval((PyObject*)second, psecond);
4761
+ if (!SWIG_IsOK(res2)) return res2;
4762
+ return res1 > res2 ? res1 : res2;
4763
+ }
4764
+ }
4765
+
4766
+ static int asptr(PyObject *obj, std::pair<T,U> **val) {
4767
+ int res = SWIG_ERROR;
4768
+ if (PyTuple_Check(obj)) {
4769
+ if (PyTuple_GET_SIZE(obj) == 2) {
4770
+ res = get_pair(PyTuple_GET_ITEM(obj,0),PyTuple_GET_ITEM(obj,1), val);
4771
+ }
4772
+ } else if (PySequence_Check(obj)) {
4773
+ if (PySequence_Size(obj) == 2) {
4774
+ swig::PyObject_var first = PySequence_GetItem(obj,0);
4775
+ swig::PyObject_var second = PySequence_GetItem(obj,1);
4776
+ res = get_pair(first, second, val);
4777
+ }
4778
+ } else {
4779
+ value_type *p;
4780
+ res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
4781
+ if (SWIG_IsOK(res) && val) *val = p;
4782
+ }
4783
+ return res;
4784
+ }
4785
+ };
4786
+
4787
+
4788
+ template <class T, class U >
4789
+ struct traits_from<std::pair<T,U> > {
4790
+ static PyObject *from(const std::pair<T,U>& val) {
4791
+ PyObject* obj = PyTuple_New(2);
4792
+ PyTuple_SetItem(obj,0,swig::from(val.first));
4793
+ PyTuple_SetItem(obj,1,swig::from(val.second));
4794
+ return obj;
4795
+ }
4796
+ };
4797
+ }
4798
+
4799
+
4800
+ namespace swig {
4801
+ template <> struct traits<std::pair< int, std::vector< int,std::allocator< int > > > > {
4802
+ typedef pointer_category category;
4803
+ static const char* type_name() {
4804
+ return "std::pair<" "int" "," "std::vector< int,std::allocator< int > >" " >";
4805
+ }
4806
+ };
4807
+ }
4808
+
4809
+
4810
+ namespace swig {
4811
+ template <class PySeq, class K, class T >
4812
+ inline void
4813
+ assign(const PySeq& pyseq, std::map<K,T > *map) {
4814
+ typedef typename std::map<K,T>::value_type value_type;
4815
+ typename PySeq::const_iterator it = pyseq.begin();
4816
+ for (;it != pyseq.end(); ++it) {
4817
+ map->insert(value_type(it->first, it->second));
4818
+ }
4819
+ }
4820
+
4821
+ template <class K, class T>
4822
+ struct traits_asptr<std::map<K,T> > {
4823
+ typedef std::map<K,T> map_type;
4824
+ static int asptr(PyObject *obj, map_type **val) {
4825
+ int res = SWIG_ERROR;
4826
+ if (PyDict_Check(obj)) {
4827
+ PyObject_var items = PyObject_CallMethod(obj,(char *)"items",NULL);
4828
+ res = traits_asptr_stdseq<std::map<K,T>, std::pair<K, T> >::asptr(items, val);
4829
+ } else {
4830
+ map_type *p;
4831
+ res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
4832
+ if (SWIG_IsOK(res) && val) *val = p;
4833
+ }
4834
+ return res;
4835
+ }
4836
+ };
4837
+
4838
+ template <class K, class T >
4839
+ struct traits_from<std::map<K,T> > {
4840
+ typedef std::map<K,T> map_type;
4841
+ typedef typename map_type::const_iterator const_iterator;
4842
+ typedef typename map_type::size_type size_type;
4843
+
4844
+ static PyObject *from(const map_type& map) {
4845
+ swig_type_info *desc = swig::type_info<map_type>();
4846
+ if (desc && desc->clientdata) {
4847
+ return SWIG_NewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
4848
+ } else {
4849
+ size_type size = map.size();
4850
+ int pysize = (size <= (size_type) INT_MAX) ? (int) size : -1;
4851
+ if (pysize < 0) {
4852
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4853
+ PyErr_SetString(PyExc_OverflowError,
4854
+ "map size not valid in python");
4855
+ SWIG_PYTHON_THREAD_END_BLOCK;
4856
+ return NULL;
4857
+ }
4858
+ PyObject *obj = PyDict_New();
4859
+ for (const_iterator i= map.begin(); i!= map.end(); ++i) {
4860
+ swig::PyObject_var key = swig::from(i->first);
4861
+ swig::PyObject_var val = swig::from(i->second);
4862
+ PyDict_SetItem(obj, key, val);
4863
+ }
4864
+ return obj;
4865
+ }
4866
+ }
4867
+ };
4868
+
4869
+ template <class ValueType>
4870
+ struct from_key_oper
4871
+ {
4872
+ typedef const ValueType& argument_type;
4873
+ typedef PyObject *result_type;
4874
+ result_type operator()(argument_type v) const
4875
+ {
4876
+ return swig::from(v.first);
4877
+ }
4878
+ };
4879
+
4880
+ template <class ValueType>
4881
+ struct from_value_oper
4882
+ {
4883
+ typedef const ValueType& argument_type;
4884
+ typedef PyObject *result_type;
4885
+ result_type operator()(argument_type v) const
4886
+ {
4887
+ return swig::from(v.second);
4888
+ }
4889
+ };
4890
+
4891
+ template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
4892
+ struct PyMapIterator_T : PySwigIteratorClosed_T<OutIterator, ValueType, FromOper>
4893
+ {
4894
+ PyMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
4895
+ : PySwigIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
4896
+ {
4897
+ }
4898
+ };
4899
+
4900
+
4901
+ template<class OutIterator,
4902
+ class FromOper = from_key_oper<typename OutIterator::value_type> >
4903
+ struct PyMapKeyIterator_T : PyMapIterator_T<OutIterator, FromOper>
4904
+ {
4905
+ PyMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
4906
+ : PyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
4907
+ {
4908
+ }
4909
+ };
4910
+
4911
+ template<typename OutIter>
4912
+ inline PySwigIterator*
4913
+ make_output_key_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
4914
+ {
4915
+ return new PyMapKeyIterator_T<OutIter>(current, begin, end, seq);
4916
+ }
4917
+
4918
+ template<class OutIterator,
4919
+ class FromOper = from_value_oper<typename OutIterator::value_type> >
4920
+ struct PyMapValueIterator_T : PyMapIterator_T<OutIterator, FromOper>
4921
+ {
4922
+ PyMapValueIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
4923
+ : PyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
4924
+ {
4925
+ }
4926
+ };
4927
+
4928
+
4929
+ template<typename OutIter>
4930
+ inline PySwigIterator*
4931
+ make_output_value_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
4932
+ {
4933
+ return new PyMapValueIterator_T<OutIter>(current, begin, end, seq);
4934
+ }
4935
+ }
4936
+
4937
+
4938
+ namespace swig {
4939
+ template <> struct traits<std::map<int, std::vector< int,std::allocator< int > >, std::less< int >, std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > > > {
4940
+ typedef pointer_category category;
4941
+ static const char* type_name() {
4942
+ return "std::map<" "int" "," "std::vector< int,std::allocator< int > >" "," "std::less< int >" "," "std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > >" " >";
4943
+ }
4944
+ };
4945
+ }
4946
+
4947
+SWIGINTERN swig::PySwigIterator *std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__iterator(std::map< int,std::vector< int > > *self,PyObject **PYTHON_SELF){
4948
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4949
+ }
4950
+SWIGINTERN bool std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____nonzero__(std::map< int,std::vector< int > > const *self){
4951
+ return !(self->empty());
4952
+ }
4953
+SWIGINTERN std::map< int,std::vector< int > >::size_type std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____len__(std::map< int,std::vector< int > > const *self){
4954
+ return self->size();
4955
+ }
4956
+SWIGINTERN std::map< int,std::vector< int > >::mapped_type std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____getitem__(std::map< int,std::vector< int > > const *self,std::map< int,std::vector< int > >::key_type const &key){
4957
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::const_iterator i = self->find(key);
4958
+ if (i != self->end())
4959
+ return i->second;
4960
+ else
4961
+ throw std::out_of_range("key not found");
4962
+ }
4963
+SWIGINTERN void std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____delitem__(std::map< int,std::vector< int > > *self,std::map< int,std::vector< int > >::key_type const &key){
4964
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::iterator i = self->find(key);
4965
+ if (i != self->end())
4966
+ self->erase(i);
4967
+ else
4968
+ throw std::out_of_range("key not found");
4969
+ }
4970
+SWIGINTERN bool std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__has_key(std::map< int,std::vector< int > > const *self,std::map< int,std::vector< int > >::key_type const &key){
4971
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::const_iterator i = self->find(key);
4972
+ return i != self->end();
4973
+ }
4974
+SWIGINTERN PyObject *std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__keys(std::map< int,std::vector< int > > *self){
4975
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::size_type size = self->size();
4976
+ int pysize = (size <= (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::size_type) INT_MAX) ? (int) size : -1;
4977
+ if (pysize < 0) {
4978
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4979
+ PyErr_SetString(PyExc_OverflowError,
4980
+ "map size not valid in python");
4981
+ SWIG_PYTHON_THREAD_END_BLOCK;
4982
+ return NULL;
4983
+ }
4984
+ PyObject* keyList = PyList_New(pysize);
4985
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::const_iterator i = self->begin();
4986
+ for (int j = 0; j < pysize; ++i, ++j) {
4987
+ PyList_SET_ITEM(keyList, j, swig::from(i->first));
4988
+ }
4989
+ return keyList;
4990
+ }
4991
+SWIGINTERN PyObject *std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__values(std::map< int,std::vector< int > > *self){
4992
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::size_type size = self->size();
4993
+ int pysize = (size <= (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::size_type) INT_MAX) ? (int) size : -1;
4994
+ if (pysize < 0) {
4995
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4996
+ PyErr_SetString(PyExc_OverflowError,
4997
+ "map size not valid in python");
4998
+ SWIG_PYTHON_THREAD_END_BLOCK;
4999
+ return NULL;
5000
+ }
5001
+ PyObject* valList = PyList_New(pysize);
5002
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::const_iterator i = self->begin();
5003
+ for (int j = 0; j < pysize; ++i, ++j) {
5004
+ PyList_SET_ITEM(valList, j, swig::from(i->second));
5005
+ }
5006
+ return valList;
5007
+ }
5008
+SWIGINTERN PyObject *std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__items(std::map< int,std::vector< int > > *self){
5009
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::size_type size = self->size();
5010
+ int pysize = (size <= (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::size_type) INT_MAX) ? (int) size : -1;
5011
+ if (pysize < 0) {
5012
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
5013
+ PyErr_SetString(PyExc_OverflowError,
5014
+ "map size not valid in python");
5015
+ SWIG_PYTHON_THREAD_END_BLOCK;
5016
+ return NULL;
5017
+ }
5018
+ PyObject* itemList = PyList_New(pysize);
5019
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::const_iterator i = self->begin();
5020
+ for (int j = 0; j < pysize; ++i, ++j) {
5021
+ PyList_SET_ITEM(itemList, j, swig::from(*i));
5022
+ }
5023
+ return itemList;
5024
+ }
5025
+SWIGINTERN bool std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____contains__(std::map< int,std::vector< int > > *self,std::map< int,std::vector< int > >::key_type const &key){
5026
+ return self->find(key) != self->end();
5027
+ }
5028
+SWIGINTERN swig::PySwigIterator *std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__key_iterator(std::map< int,std::vector< int > > *self,PyObject **PYTHON_SELF){
5029
+ return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
5030
+ }
5031
+SWIGINTERN swig::PySwigIterator *std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__value_iterator(std::map< int,std::vector< int > > *self,PyObject **PYTHON_SELF){
5032
+ return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
5033
+ }
5034
+SWIGINTERN void std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____setitem__(std::map< int,std::vector< int > > *self,std::map< int,std::vector< int > >::key_type const &key,std::map< int,std::vector< int > >::mapped_type const &x){
5035
+ (*self)[key] = x;
5036
+ }
5037
+
5038
+SWIGINTERN int
5039
+SWIG_AsVal_float (PyObject * obj, float *val)
5040
+{
5041
+ double v;
5042
+ int res = SWIG_AsVal_double (obj, &v);
5043
+ if (SWIG_IsOK(res)) {
5044
+ if ((v < -FLT_MAX || v > FLT_MAX)) {
5045
+ return SWIG_OverflowError;
5046
+ } else {
5047
+ if (val) *val = static_cast< float >(v);
5048
+ }
5049
+ }
5050
+ return res;
5051
+}
5052
+
5053
+
5054
+SWIGINTERN swig_type_info*
5055
+SWIG_pchar_descriptor(void)
5056
+{
5057
+ static int init = 0;
5058
+ static swig_type_info* info = 0;
5059
+ if (!init) {
5060
+ info = SWIG_TypeQuery("_p_char");
5061
+ init = 1;
5062
+ }
5063
+ return info;
5064
+}
5065
+
5066
+
5067
+SWIGINTERN int
5068
+SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
5069
+{
5070
+ if (PyString_Check(obj)) {
5071
+ char *cstr; Py_ssize_t len;
5072
+ PyString_AsStringAndSize(obj, &cstr, &len);
5073
+ if (cptr) {
5074
+ if (alloc) {
5075
+ /*
5076
+ In python the user should not be able to modify the inner
5077
+ string representation. To warranty that, if you define
5078
+ SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
5079
+ buffer is always returned.
5080
+
5081
+ The default behavior is just to return the pointer value,
5082
+ so, be careful.
5083
+ */
5084
+#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
5085
+ if (*alloc != SWIG_OLDOBJ)
5086
+#else
5087
+ if (*alloc == SWIG_NEWOBJ)
5088
+#endif
5089
+ {
5090
+ *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
5091
+ *alloc = SWIG_NEWOBJ;
5092
+ }
5093
+ else {
5094
+ *cptr = cstr;
5095
+ *alloc = SWIG_OLDOBJ;
5096
+ }
5097
+ } else {
5098
+ *cptr = PyString_AsString(obj);
5099
+ }
5100
+ }
5101
+ if (psize) *psize = len + 1;
5102
+ return SWIG_OK;
5103
+ } else {
5104
+ swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
5105
+ if (pchar_descriptor) {
5106
+ void* vptr = 0;
5107
+ if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
5108
+ if (cptr) *cptr = (char *) vptr;
5109
+ if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
5110
+ if (alloc) *alloc = SWIG_OLDOBJ;
5111
+ return SWIG_OK;
5112
+ }
5113
+ }
5114
+ }
5115
+ return SWIG_TypeError;
5116
+}
5117
+
5118
+
5119
+
5120
+
5121
+
5122
+SWIGINTERN int
5123
+SWIG_AsVal_bool (PyObject *obj, bool *val)
5124
+{
5125
+ int r = PyObject_IsTrue(obj);
5126
+ if (r == -1)
5127
+ return SWIG_ERROR;
5128
+ if (val) *val = r ? true : false;
5129
+ return SWIG_OK;
5130
+}
5131
+
5132
+#ifdef __cplusplus
5133
+extern "C" {
5134
+#endif
5135
+SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5136
+ PyObject *resultobj = 0;
5137
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5138
+ void *argp1 = 0 ;
5139
+ int res1 = 0 ;
5140
+ PyObject * obj0 = 0 ;
5141
+
5142
+ if (!PyArg_ParseTuple(args,(char *)"O:delete_PySwigIterator",&obj0)) SWIG_fail;
5143
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
5144
+ if (!SWIG_IsOK(res1)) {
5145
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySwigIterator" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5146
+ }
5147
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5148
+ delete arg1;
5149
+ resultobj = SWIG_Py_Void();
5150
+ return resultobj;
5151
+fail:
5152
+ return NULL;
5153
+}
5154
+
5155
+
5156
+SWIGINTERN PyObject *_wrap_PySwigIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5157
+ PyObject *resultobj = 0;
5158
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5159
+ void *argp1 = 0 ;
5160
+ int res1 = 0 ;
5161
+ PyObject * obj0 = 0 ;
5162
+ PyObject *result = 0 ;
5163
+
5164
+ if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_value",&obj0)) SWIG_fail;
5165
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5166
+ if (!SWIG_IsOK(res1)) {
5167
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_value" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5168
+ }
5169
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5170
+ try {
5171
+ result = (PyObject *)((swig::PySwigIterator const *)arg1)->value();
5172
+ }
5173
+ catch(swig::stop_iteration &_e) {
5174
+ {
5175
+ (void)_e;
5176
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5177
+ SWIG_fail;
5178
+ }
5179
+ }
5180
+
5181
+ resultobj = result;
5182
+ return resultobj;
5183
+fail:
5184
+ return NULL;
5185
+}
5186
+
5187
+
5188
+SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5189
+ PyObject *resultobj = 0;
5190
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5191
+ size_t arg2 ;
5192
+ void *argp1 = 0 ;
5193
+ int res1 = 0 ;
5194
+ size_t val2 ;
5195
+ int ecode2 = 0 ;
5196
+ PyObject * obj0 = 0 ;
5197
+ PyObject * obj1 = 0 ;
5198
+ swig::PySwigIterator *result = 0 ;
5199
+
5200
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_incr",&obj0,&obj1)) SWIG_fail;
5201
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5202
+ if (!SWIG_IsOK(res1)) {
5203
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5204
+ }
5205
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5206
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
5207
+ if (!SWIG_IsOK(ecode2)) {
5208
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
5209
+ }
5210
+ arg2 = static_cast< size_t >(val2);
5211
+ try {
5212
+ result = (swig::PySwigIterator *)(arg1)->incr(arg2);
5213
+ }
5214
+ catch(swig::stop_iteration &_e) {
5215
+ {
5216
+ (void)_e;
5217
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5218
+ SWIG_fail;
5219
+ }
5220
+ }
5221
+
5222
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5223
+ return resultobj;
5224
+fail:
5225
+ return NULL;
5226
+}
5227
+
5228
+
5229
+SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5230
+ PyObject *resultobj = 0;
5231
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5232
+ void *argp1 = 0 ;
5233
+ int res1 = 0 ;
5234
+ PyObject * obj0 = 0 ;
5235
+ swig::PySwigIterator *result = 0 ;
5236
+
5237
+ if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_incr",&obj0)) SWIG_fail;
5238
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5239
+ if (!SWIG_IsOK(res1)) {
5240
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5241
+ }
5242
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5243
+ try {
5244
+ result = (swig::PySwigIterator *)(arg1)->incr();
5245
+ }
5246
+ catch(swig::stop_iteration &_e) {
5247
+ {
5248
+ (void)_e;
5249
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5250
+ SWIG_fail;
5251
+ }
5252
+ }
5253
+
5254
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5255
+ return resultobj;
5256
+fail:
5257
+ return NULL;
5258
+}
5259
+
5260
+
5261
+SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
5262
+ int argc;
5263
+ PyObject *argv[3];
5264
+ int ii;
5265
+
5266
+ if (!PyTuple_Check(args)) SWIG_fail;
5267
+ argc = (int)PyObject_Length(args);
5268
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5269
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
5270
+ }
5271
+ if (argc == 1) {
5272
+ int _v;
5273
+ void *vptr = 0;
5274
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5275
+ _v = SWIG_CheckState(res);
5276
+ if (_v) {
5277
+ return _wrap_PySwigIterator_incr__SWIG_1(self, args);
5278
+ }
5279
+ }
5280
+ if (argc == 2) {
5281
+ int _v;
5282
+ void *vptr = 0;
5283
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5284
+ _v = SWIG_CheckState(res);
5285
+ if (_v) {
5286
+ {
5287
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
5288
+ _v = SWIG_CheckState(res);
5289
+ }
5290
+ if (_v) {
5291
+ return _wrap_PySwigIterator_incr__SWIG_0(self, args);
5292
+ }
5293
+ }
5294
+ }
5295
+
5296
+fail:
5297
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_incr'.\n"
5298
+ " Possible C/C++ prototypes are:\n"
5299
+ " incr(swig::PySwigIterator *,size_t)\n"
5300
+ " incr(swig::PySwigIterator *)\n");
5301
+ return NULL;
5302
+}
5303
+
5304
+
5305
+SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5306
+ PyObject *resultobj = 0;
5307
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5308
+ size_t arg2 ;
5309
+ void *argp1 = 0 ;
5310
+ int res1 = 0 ;
5311
+ size_t val2 ;
5312
+ int ecode2 = 0 ;
5313
+ PyObject * obj0 = 0 ;
5314
+ PyObject * obj1 = 0 ;
5315
+ swig::PySwigIterator *result = 0 ;
5316
+
5317
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_decr",&obj0,&obj1)) SWIG_fail;
5318
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5319
+ if (!SWIG_IsOK(res1)) {
5320
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5321
+ }
5322
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5323
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
5324
+ if (!SWIG_IsOK(ecode2)) {
5325
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_decr" "', argument " "2"" of type '" "size_t""'");
5326
+ }
5327
+ arg2 = static_cast< size_t >(val2);
5328
+ try {
5329
+ result = (swig::PySwigIterator *)(arg1)->decr(arg2);
5330
+ }
5331
+ catch(swig::stop_iteration &_e) {
5332
+ {
5333
+ (void)_e;
5334
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5335
+ SWIG_fail;
5336
+ }
5337
+ }
5338
+
5339
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5340
+ return resultobj;
5341
+fail:
5342
+ return NULL;
5343
+}
5344
+
5345
+
5346
+SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5347
+ PyObject *resultobj = 0;
5348
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5349
+ void *argp1 = 0 ;
5350
+ int res1 = 0 ;
5351
+ PyObject * obj0 = 0 ;
5352
+ swig::PySwigIterator *result = 0 ;
5353
+
5354
+ if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_decr",&obj0)) SWIG_fail;
5355
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5356
+ if (!SWIG_IsOK(res1)) {
5357
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5358
+ }
5359
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5360
+ try {
5361
+ result = (swig::PySwigIterator *)(arg1)->decr();
5362
+ }
5363
+ catch(swig::stop_iteration &_e) {
5364
+ {
5365
+ (void)_e;
5366
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5367
+ SWIG_fail;
5368
+ }
5369
+ }
5370
+
5371
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5372
+ return resultobj;
5373
+fail:
5374
+ return NULL;
5375
+}
5376
+
5377
+
5378
+SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *self, PyObject *args) {
5379
+ int argc;
5380
+ PyObject *argv[3];
5381
+ int ii;
5382
+
5383
+ if (!PyTuple_Check(args)) SWIG_fail;
5384
+ argc = (int)PyObject_Length(args);
5385
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5386
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
5387
+ }
5388
+ if (argc == 1) {
5389
+ int _v;
5390
+ void *vptr = 0;
5391
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5392
+ _v = SWIG_CheckState(res);
5393
+ if (_v) {
5394
+ return _wrap_PySwigIterator_decr__SWIG_1(self, args);
5395
+ }
5396
+ }
5397
+ if (argc == 2) {
5398
+ int _v;
5399
+ void *vptr = 0;
5400
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5401
+ _v = SWIG_CheckState(res);
5402
+ if (_v) {
5403
+ {
5404
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
5405
+ _v = SWIG_CheckState(res);
5406
+ }
5407
+ if (_v) {
5408
+ return _wrap_PySwigIterator_decr__SWIG_0(self, args);
5409
+ }
5410
+ }
5411
+ }
5412
+
5413
+fail:
5414
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_decr'.\n"
5415
+ " Possible C/C++ prototypes are:\n"
5416
+ " decr(swig::PySwigIterator *,size_t)\n"
5417
+ " decr(swig::PySwigIterator *)\n");
5418
+ return NULL;
5419
+}
5420
+
5421
+
5422
+SWIGINTERN PyObject *_wrap_PySwigIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5423
+ PyObject *resultobj = 0;
5424
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5425
+ swig::PySwigIterator *arg2 = 0 ;
5426
+ void *argp1 = 0 ;
5427
+ int res1 = 0 ;
5428
+ void *argp2 = 0 ;
5429
+ int res2 = 0 ;
5430
+ PyObject * obj0 = 0 ;
5431
+ PyObject * obj1 = 0 ;
5432
+ ptrdiff_t result;
5433
+
5434
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_distance",&obj0,&obj1)) SWIG_fail;
5435
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5436
+ if (!SWIG_IsOK(res1)) {
5437
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_distance" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5438
+ }
5439
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5440
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
5441
+ if (!SWIG_IsOK(res2)) {
5442
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5443
+ }
5444
+ if (!argp2) {
5445
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5446
+ }
5447
+ arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5448
+ try {
5449
+ result = ((swig::PySwigIterator const *)arg1)->distance((swig::PySwigIterator const &)*arg2);
5450
+ }
5451
+ catch(std::invalid_argument &_e) {
5452
+ SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
5453
+ }
5454
+
5455
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
5456
+ return resultobj;
5457
+fail:
5458
+ return NULL;
5459
+}
5460
+
5461
+
5462
+SWIGINTERN PyObject *_wrap_PySwigIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5463
+ PyObject *resultobj = 0;
5464
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5465
+ swig::PySwigIterator *arg2 = 0 ;
5466
+ void *argp1 = 0 ;
5467
+ int res1 = 0 ;
5468
+ void *argp2 = 0 ;
5469
+ int res2 = 0 ;
5470
+ PyObject * obj0 = 0 ;
5471
+ PyObject * obj1 = 0 ;
5472
+ bool result;
5473
+
5474
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_equal",&obj0,&obj1)) SWIG_fail;
5475
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5476
+ if (!SWIG_IsOK(res1)) {
5477
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_equal" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5478
+ }
5479
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5480
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
5481
+ if (!SWIG_IsOK(res2)) {
5482
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5483
+ }
5484
+ if (!argp2) {
5485
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5486
+ }
5487
+ arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5488
+ try {
5489
+ result = (bool)((swig::PySwigIterator const *)arg1)->equal((swig::PySwigIterator const &)*arg2);
5490
+ }
5491
+ catch(std::invalid_argument &_e) {
5492
+ SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
5493
+ }
5494
+
5495
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
5496
+ return resultobj;
5497
+fail:
5498
+ return NULL;
5499
+}
5500
+
5501
+
5502
+SWIGINTERN PyObject *_wrap_PySwigIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5503
+ PyObject *resultobj = 0;
5504
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5505
+ void *argp1 = 0 ;
5506
+ int res1 = 0 ;
5507
+ PyObject * obj0 = 0 ;
5508
+ swig::PySwigIterator *result = 0 ;
5509
+
5510
+ if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_copy",&obj0)) SWIG_fail;
5511
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5512
+ if (!SWIG_IsOK(res1)) {
5513
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_copy" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5514
+ }
5515
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5516
+ result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->copy();
5517
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5518
+ return resultobj;
5519
+fail:
5520
+ return NULL;
5521
+}
5522
+
5523
+
5524
+SWIGINTERN PyObject *_wrap_PySwigIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5525
+ PyObject *resultobj = 0;
5526
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5527
+ void *argp1 = 0 ;
5528
+ int res1 = 0 ;
5529
+ PyObject * obj0 = 0 ;
5530
+ PyObject *result = 0 ;
5531
+
5532
+ if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_next",&obj0)) SWIG_fail;
5533
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5534
+ if (!SWIG_IsOK(res1)) {
5535
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_next" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5536
+ }
5537
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5538
+ try {
5539
+ result = (PyObject *)(arg1)->next();
5540
+ }
5541
+ catch(swig::stop_iteration &_e) {
5542
+ {
5543
+ (void)_e;
5544
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5545
+ SWIG_fail;
5546
+ }
5547
+ }
5548
+
5549
+ resultobj = result;
5550
+ return resultobj;
5551
+fail:
5552
+ return NULL;
5553
+}
5554
+
5555
+
5556
+SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5557
+ PyObject *resultobj = 0;
5558
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5559
+ void *argp1 = 0 ;
5560
+ int res1 = 0 ;
5561
+ PyObject * obj0 = 0 ;
5562
+ PyObject *result = 0 ;
5563
+
5564
+ if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_previous",&obj0)) SWIG_fail;
5565
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5566
+ if (!SWIG_IsOK(res1)) {
5567
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5568
+ }
5569
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5570
+ try {
5571
+ result = (PyObject *)(arg1)->previous();
5572
+ }
5573
+ catch(swig::stop_iteration &_e) {
5574
+ {
5575
+ (void)_e;
5576
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5577
+ SWIG_fail;
5578
+ }
5579
+ }
5580
+
5581
+ resultobj = result;
5582
+ return resultobj;
5583
+fail:
5584
+ return NULL;
5585
+}
5586
+
5587
+
5588
+SWIGINTERN PyObject *_wrap_PySwigIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5589
+ PyObject *resultobj = 0;
5590
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5591
+ ptrdiff_t arg2 ;
5592
+ void *argp1 = 0 ;
5593
+ int res1 = 0 ;
5594
+ ptrdiff_t val2 ;
5595
+ int ecode2 = 0 ;
5596
+ PyObject * obj0 = 0 ;
5597
+ PyObject * obj1 = 0 ;
5598
+ swig::PySwigIterator *result = 0 ;
5599
+
5600
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_advance",&obj0,&obj1)) SWIG_fail;
5601
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5602
+ if (!SWIG_IsOK(res1)) {
5603
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_advance" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5604
+ }
5605
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5606
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5607
+ if (!SWIG_IsOK(ecode2)) {
5608
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
5609
+ }
5610
+ arg2 = static_cast< ptrdiff_t >(val2);
5611
+ try {
5612
+ result = (swig::PySwigIterator *)(arg1)->advance(arg2);
5613
+ }
5614
+ catch(swig::stop_iteration &_e) {
5615
+ {
5616
+ (void)_e;
5617
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5618
+ SWIG_fail;
5619
+ }
5620
+ }
5621
+
5622
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5623
+ return resultobj;
5624
+fail:
5625
+ return NULL;
5626
+}
5627
+
5628
+
5629
+SWIGINTERN PyObject *_wrap_PySwigIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5630
+ PyObject *resultobj = 0;
5631
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5632
+ swig::PySwigIterator *arg2 = 0 ;
5633
+ void *argp1 = 0 ;
5634
+ int res1 = 0 ;
5635
+ void *argp2 = 0 ;
5636
+ int res2 = 0 ;
5637
+ PyObject * obj0 = 0 ;
5638
+ PyObject * obj1 = 0 ;
5639
+ bool result;
5640
+
5641
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___eq__",&obj0,&obj1)) SWIG_fail;
5642
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5643
+ if (!SWIG_IsOK(res1)) {
5644
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___eq__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5645
+ }
5646
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5647
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
5648
+ if (!SWIG_IsOK(res2)) {
5649
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5650
+ }
5651
+ if (!argp2) {
5652
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5653
+ }
5654
+ arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5655
+ result = (bool)((swig::PySwigIterator const *)arg1)->operator ==((swig::PySwigIterator const &)*arg2);
5656
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
5657
+ return resultobj;
5658
+fail:
5659
+ return NULL;
5660
+}
5661
+
5662
+
5663
+SWIGINTERN PyObject *_wrap_PySwigIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5664
+ PyObject *resultobj = 0;
5665
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5666
+ swig::PySwigIterator *arg2 = 0 ;
5667
+ void *argp1 = 0 ;
5668
+ int res1 = 0 ;
5669
+ void *argp2 = 0 ;
5670
+ int res2 = 0 ;
5671
+ PyObject * obj0 = 0 ;
5672
+ PyObject * obj1 = 0 ;
5673
+ bool result;
5674
+
5675
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___ne__",&obj0,&obj1)) SWIG_fail;
5676
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5677
+ if (!SWIG_IsOK(res1)) {
5678
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___ne__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5679
+ }
5680
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5681
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
5682
+ if (!SWIG_IsOK(res2)) {
5683
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5684
+ }
5685
+ if (!argp2) {
5686
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5687
+ }
5688
+ arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5689
+ result = (bool)((swig::PySwigIterator const *)arg1)->operator !=((swig::PySwigIterator const &)*arg2);
5690
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
5691
+ return resultobj;
5692
+fail:
5693
+ return NULL;
5694
+}
5695
+
5696
+
5697
+SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5698
+ PyObject *resultobj = 0;
5699
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5700
+ ptrdiff_t arg2 ;
5701
+ void *argp1 = 0 ;
5702
+ int res1 = 0 ;
5703
+ ptrdiff_t val2 ;
5704
+ int ecode2 = 0 ;
5705
+ PyObject * obj0 = 0 ;
5706
+ PyObject * obj1 = 0 ;
5707
+ swig::PySwigIterator *result = 0 ;
5708
+
5709
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___iadd__",&obj0,&obj1)) SWIG_fail;
5710
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
5711
+ if (!SWIG_IsOK(res1)) {
5712
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___iadd__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5713
+ }
5714
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5715
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5716
+ if (!SWIG_IsOK(ecode2)) {
5717
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
5718
+ }
5719
+ arg2 = static_cast< ptrdiff_t >(val2);
5720
+ try {
5721
+ {
5722
+ swig::PySwigIterator &_result_ref = (arg1)->operator +=(arg2);
5723
+ result = (swig::PySwigIterator *) &_result_ref;
5724
+ }
5725
+ }
5726
+ catch(swig::stop_iteration &_e) {
5727
+ {
5728
+ (void)_e;
5729
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5730
+ SWIG_fail;
5731
+ }
5732
+ }
5733
+
5734
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5735
+ return resultobj;
5736
+fail:
5737
+ return NULL;
5738
+}
5739
+
5740
+
5741
+SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5742
+ PyObject *resultobj = 0;
5743
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5744
+ ptrdiff_t arg2 ;
5745
+ void *argp1 = 0 ;
5746
+ int res1 = 0 ;
5747
+ ptrdiff_t val2 ;
5748
+ int ecode2 = 0 ;
5749
+ PyObject * obj0 = 0 ;
5750
+ PyObject * obj1 = 0 ;
5751
+ swig::PySwigIterator *result = 0 ;
5752
+
5753
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___isub__",&obj0,&obj1)) SWIG_fail;
5754
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
5755
+ if (!SWIG_IsOK(res1)) {
5756
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___isub__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5757
+ }
5758
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5759
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5760
+ if (!SWIG_IsOK(ecode2)) {
5761
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
5762
+ }
5763
+ arg2 = static_cast< ptrdiff_t >(val2);
5764
+ try {
5765
+ {
5766
+ swig::PySwigIterator &_result_ref = (arg1)->operator -=(arg2);
5767
+ result = (swig::PySwigIterator *) &_result_ref;
5768
+ }
5769
+ }
5770
+ catch(swig::stop_iteration &_e) {
5771
+ {
5772
+ (void)_e;
5773
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5774
+ SWIG_fail;
5775
+ }
5776
+ }
5777
+
5778
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5779
+ return resultobj;
5780
+fail:
5781
+ return NULL;
5782
+}
5783
+
5784
+
5785
+SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5786
+ PyObject *resultobj = 0;
5787
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5788
+ ptrdiff_t arg2 ;
5789
+ void *argp1 = 0 ;
5790
+ int res1 = 0 ;
5791
+ ptrdiff_t val2 ;
5792
+ int ecode2 = 0 ;
5793
+ PyObject * obj0 = 0 ;
5794
+ PyObject * obj1 = 0 ;
5795
+ swig::PySwigIterator *result = 0 ;
5796
+
5797
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___add__",&obj0,&obj1)) SWIG_fail;
5798
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5799
+ if (!SWIG_IsOK(res1)) {
5800
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___add__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5801
+ }
5802
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5803
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5804
+ if (!SWIG_IsOK(ecode2)) {
5805
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
5806
+ }
5807
+ arg2 = static_cast< ptrdiff_t >(val2);
5808
+ try {
5809
+ result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator +(arg2);
5810
+ }
5811
+ catch(swig::stop_iteration &_e) {
5812
+ {
5813
+ (void)_e;
5814
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5815
+ SWIG_fail;
5816
+ }
5817
+ }
5818
+
5819
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5820
+ return resultobj;
5821
+fail:
5822
+ return NULL;
5823
+}
5824
+
5825
+
5826
+SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5827
+ PyObject *resultobj = 0;
5828
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5829
+ ptrdiff_t arg2 ;
5830
+ void *argp1 = 0 ;
5831
+ int res1 = 0 ;
5832
+ ptrdiff_t val2 ;
5833
+ int ecode2 = 0 ;
5834
+ PyObject * obj0 = 0 ;
5835
+ PyObject * obj1 = 0 ;
5836
+ swig::PySwigIterator *result = 0 ;
5837
+
5838
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
5839
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5840
+ if (!SWIG_IsOK(res1)) {
5841
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5842
+ }
5843
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5844
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5845
+ if (!SWIG_IsOK(ecode2)) {
5846
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
5847
+ }
5848
+ arg2 = static_cast< ptrdiff_t >(val2);
5849
+ try {
5850
+ result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator -(arg2);
5851
+ }
5852
+ catch(swig::stop_iteration &_e) {
5853
+ {
5854
+ (void)_e;
5855
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5856
+ SWIG_fail;
5857
+ }
5858
+ }
5859
+
5860
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5861
+ return resultobj;
5862
+fail:
5863
+ return NULL;
5864
+}
5865
+
5866
+
5867
+SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5868
+ PyObject *resultobj = 0;
5869
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5870
+ swig::PySwigIterator *arg2 = 0 ;
5871
+ void *argp1 = 0 ;
5872
+ int res1 = 0 ;
5873
+ void *argp2 = 0 ;
5874
+ int res2 = 0 ;
5875
+ PyObject * obj0 = 0 ;
5876
+ PyObject * obj1 = 0 ;
5877
+ ptrdiff_t result;
5878
+
5879
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
5880
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5881
+ if (!SWIG_IsOK(res1)) {
5882
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5883
+ }
5884
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5885
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
5886
+ if (!SWIG_IsOK(res2)) {
5887
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5888
+ }
5889
+ if (!argp2) {
5890
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5891
+ }
5892
+ arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5893
+ result = ((swig::PySwigIterator const *)arg1)->operator -((swig::PySwigIterator const &)*arg2);
5894
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
5895
+ return resultobj;
5896
+fail:
5897
+ return NULL;
5898
+}
5899
+
5900
+
5901
+SWIGINTERN PyObject *_wrap_PySwigIterator___sub__(PyObject *self, PyObject *args) {
5902
+ int argc;
5903
+ PyObject *argv[3];
5904
+ int ii;
5905
+
5906
+ if (!PyTuple_Check(args)) SWIG_fail;
5907
+ argc = (int)PyObject_Length(args);
5908
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5909
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
5910
+ }
5911
+ if (argc == 2) {
5912
+ int _v;
5913
+ void *vptr = 0;
5914
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5915
+ _v = SWIG_CheckState(res);
5916
+ if (_v) {
5917
+ int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__PySwigIterator, 0);
5918
+ _v = SWIG_CheckState(res);
5919
+ if (_v) {
5920
+ return _wrap_PySwigIterator___sub____SWIG_1(self, args);
5921
+ }
5922
+ }
5923
+ }
5924
+ if (argc == 2) {
5925
+ int _v;
5926
+ void *vptr = 0;
5927
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5928
+ _v = SWIG_CheckState(res);
5929
+ if (_v) {
5930
+ {
5931
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
5932
+ _v = SWIG_CheckState(res);
5933
+ }
5934
+ if (_v) {
5935
+ return _wrap_PySwigIterator___sub____SWIG_0(self, args);
5936
+ }
5937
+ }
5938
+ }
5939
+
5940
+fail:
5941
+ Py_INCREF(Py_NotImplemented);
5942
+ return Py_NotImplemented;
5943
+}
5944
+
5945
+
5946
+SWIGINTERN PyObject *PySwigIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5947
+ PyObject *obj;
5948
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5949
+ SWIG_TypeNewClientData(SWIGTYPE_p_swig__PySwigIterator, SWIG_NewClientData(obj));
5950
+ return SWIG_Py_Void();
5951
+}
5952
+
5953
+SWIGINTERN PyObject *_wrap_IntVector_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5954
+ PyObject *resultobj = 0;
5955
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
5956
+ PyObject **arg2 = (PyObject **) 0 ;
5957
+ void *argp1 = 0 ;
5958
+ int res1 = 0 ;
5959
+ PyObject * obj0 = 0 ;
5960
+ swig::PySwigIterator *result = 0 ;
5961
+
5962
+ arg2 = &obj0;
5963
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_iterator",&obj0)) SWIG_fail;
5964
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
5965
+ if (!SWIG_IsOK(res1)) {
5966
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_iterator" "', argument " "1"" of type '" "std::vector< int > *""'");
5967
+ }
5968
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
5969
+ result = (swig::PySwigIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
5970
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5971
+ return resultobj;
5972
+fail:
5973
+ return NULL;
5974
+}
5975
+
5976
+
5977
+SWIGINTERN PyObject *_wrap_IntVector___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5978
+ PyObject *resultobj = 0;
5979
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
5980
+ void *argp1 = 0 ;
5981
+ int res1 = 0 ;
5982
+ PyObject * obj0 = 0 ;
5983
+ bool result;
5984
+
5985
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector___nonzero__",&obj0)) SWIG_fail;
5986
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
5987
+ if (!SWIG_IsOK(res1)) {
5988
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'");
5989
+ }
5990
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
5991
+ result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< int > const *)arg1);
5992
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
5993
+ return resultobj;
5994
+fail:
5995
+ return NULL;
5996
+}
5997
+
5998
+
5999
+SWIGINTERN PyObject *_wrap_IntVector___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6000
+ PyObject *resultobj = 0;
6001
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6002
+ void *argp1 = 0 ;
6003
+ int res1 = 0 ;
6004
+ PyObject * obj0 = 0 ;
6005
+ std::vector< int >::size_type result;
6006
+
6007
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector___len__",&obj0)) SWIG_fail;
6008
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6009
+ if (!SWIG_IsOK(res1)) {
6010
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___len__" "', argument " "1"" of type '" "std::vector< int > const *""'");
6011
+ }
6012
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6013
+ result = std_vector_Sl_int_Sg____len__((std::vector< int > const *)arg1);
6014
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
6015
+ return resultobj;
6016
+fail:
6017
+ return NULL;
6018
+}
6019
+
6020
+
6021
+SWIGINTERN PyObject *_wrap_IntVector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6022
+ PyObject *resultobj = 0;
6023
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6024
+ void *argp1 = 0 ;
6025
+ int res1 = 0 ;
6026
+ PyObject * obj0 = 0 ;
6027
+ std::vector< int >::value_type result;
6028
+
6029
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_pop",&obj0)) SWIG_fail;
6030
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6031
+ if (!SWIG_IsOK(res1)) {
6032
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_pop" "', argument " "1"" of type '" "std::vector< int > *""'");
6033
+ }
6034
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6035
+ try {
6036
+ result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
6037
+ }
6038
+ catch(std::out_of_range &_e) {
6039
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6040
+ }
6041
+
6042
+ resultobj = SWIG_From_int(static_cast< int >(result));
6043
+ return resultobj;
6044
+fail:
6045
+ return NULL;
6046
+}
6047
+
6048
+
6049
+SWIGINTERN PyObject *_wrap_IntVector___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6050
+ PyObject *resultobj = 0;
6051
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6052
+ std::vector< int >::difference_type arg2 ;
6053
+ std::vector< int >::difference_type arg3 ;
6054
+ void *argp1 = 0 ;
6055
+ int res1 = 0 ;
6056
+ ptrdiff_t val2 ;
6057
+ int ecode2 = 0 ;
6058
+ ptrdiff_t val3 ;
6059
+ int ecode3 = 0 ;
6060
+ PyObject * obj0 = 0 ;
6061
+ PyObject * obj1 = 0 ;
6062
+ PyObject * obj2 = 0 ;
6063
+ std::vector< int,std::allocator< int > > *result = 0 ;
6064
+
6065
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
6066
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6067
+ if (!SWIG_IsOK(res1)) {
6068
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
6069
+ }
6070
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6071
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6072
+ if (!SWIG_IsOK(ecode2)) {
6073
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___getslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
6074
+ }
6075
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
6076
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6077
+ if (!SWIG_IsOK(ecode3)) {
6078
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___getslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
6079
+ }
6080
+ arg3 = static_cast< std::vector< int >::difference_type >(val3);
6081
+ try {
6082
+ result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3);
6083
+ }
6084
+ catch(std::out_of_range &_e) {
6085
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6086
+ }
6087
+
6088
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN | 0 );
6089
+ return resultobj;
6090
+fail:
6091
+ return NULL;
6092
+}
6093
+
6094
+
6095
+SWIGINTERN PyObject *_wrap_IntVector___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6096
+ PyObject *resultobj = 0;
6097
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6098
+ std::vector< int >::difference_type arg2 ;
6099
+ std::vector< int >::difference_type arg3 ;
6100
+ std::vector< int,std::allocator< int > > *arg4 = 0 ;
6101
+ void *argp1 = 0 ;
6102
+ int res1 = 0 ;
6103
+ ptrdiff_t val2 ;
6104
+ int ecode2 = 0 ;
6105
+ ptrdiff_t val3 ;
6106
+ int ecode3 = 0 ;
6107
+ int res4 = SWIG_OLDOBJ ;
6108
+ PyObject * obj0 = 0 ;
6109
+ PyObject * obj1 = 0 ;
6110
+ PyObject * obj2 = 0 ;
6111
+ PyObject * obj3 = 0 ;
6112
+
6113
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:IntVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6114
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6115
+ if (!SWIG_IsOK(res1)) {
6116
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
6117
+ }
6118
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6119
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6120
+ if (!SWIG_IsOK(ecode2)) {
6121
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
6122
+ }
6123
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
6124
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6125
+ if (!SWIG_IsOK(ecode3)) {
6126
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
6127
+ }
6128
+ arg3 = static_cast< std::vector< int >::difference_type >(val3);
6129
+ {
6130
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
6131
+ res4 = swig::asptr(obj3, &ptr);
6132
+ if (!SWIG_IsOK(res4)) {
6133
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntVector___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'");
6134
+ }
6135
+ if (!ptr) {
6136
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVector___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'");
6137
+ }
6138
+ arg4 = ptr;
6139
+ }
6140
+ try {
6141
+ std_vector_Sl_int_Sg____setslice__(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
6142
+ }
6143
+ catch(std::out_of_range &_e) {
6144
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6145
+ }
6146
+ catch(std::invalid_argument &_e) {
6147
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6148
+ }
6149
+
6150
+ resultobj = SWIG_Py_Void();
6151
+ if (SWIG_IsNewObj(res4)) delete arg4;
6152
+ return resultobj;
6153
+fail:
6154
+ if (SWIG_IsNewObj(res4)) delete arg4;
6155
+ return NULL;
6156
+}
6157
+
6158
+
6159
+SWIGINTERN PyObject *_wrap_IntVector___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6160
+ PyObject *resultobj = 0;
6161
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6162
+ std::vector< int >::difference_type arg2 ;
6163
+ std::vector< int >::difference_type arg3 ;
6164
+ void *argp1 = 0 ;
6165
+ int res1 = 0 ;
6166
+ ptrdiff_t val2 ;
6167
+ int ecode2 = 0 ;
6168
+ ptrdiff_t val3 ;
6169
+ int ecode3 = 0 ;
6170
+ PyObject * obj0 = 0 ;
6171
+ PyObject * obj1 = 0 ;
6172
+ PyObject * obj2 = 0 ;
6173
+
6174
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
6175
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6176
+ if (!SWIG_IsOK(res1)) {
6177
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
6178
+ }
6179
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6180
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6181
+ if (!SWIG_IsOK(ecode2)) {
6182
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___delslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
6183
+ }
6184
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
6185
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6186
+ if (!SWIG_IsOK(ecode3)) {
6187
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___delslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
6188
+ }
6189
+ arg3 = static_cast< std::vector< int >::difference_type >(val3);
6190
+ try {
6191
+ std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3);
6192
+ }
6193
+ catch(std::out_of_range &_e) {
6194
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6195
+ }
6196
+
6197
+ resultobj = SWIG_Py_Void();
6198
+ return resultobj;
6199
+fail:
6200
+ return NULL;
6201
+}
6202
+
6203
+
6204
+SWIGINTERN PyObject *_wrap_IntVector___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6205
+ PyObject *resultobj = 0;
6206
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6207
+ std::vector< int >::difference_type arg2 ;
6208
+ void *argp1 = 0 ;
6209
+ int res1 = 0 ;
6210
+ ptrdiff_t val2 ;
6211
+ int ecode2 = 0 ;
6212
+ PyObject * obj0 = 0 ;
6213
+ PyObject * obj1 = 0 ;
6214
+
6215
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector___delitem__",&obj0,&obj1)) SWIG_fail;
6216
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6217
+ if (!SWIG_IsOK(res1)) {
6218
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
6219
+ }
6220
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6221
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6222
+ if (!SWIG_IsOK(ecode2)) {
6223
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___delitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
6224
+ }
6225
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
6226
+ try {
6227
+ std_vector_Sl_int_Sg____delitem__(arg1,arg2);
6228
+ }
6229
+ catch(std::out_of_range &_e) {
6230
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6231
+ }
6232
+
6233
+ resultobj = SWIG_Py_Void();
6234
+ return resultobj;
6235
+fail:
6236
+ return NULL;
6237
+}
6238
+
6239
+
6240
+SWIGINTERN PyObject *_wrap_IntVector___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6241
+ PyObject *resultobj = 0;
6242
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6243
+ std::vector< int >::difference_type arg2 ;
6244
+ void *argp1 = 0 ;
6245
+ int res1 = 0 ;
6246
+ ptrdiff_t val2 ;
6247
+ int ecode2 = 0 ;
6248
+ PyObject * obj0 = 0 ;
6249
+ PyObject * obj1 = 0 ;
6250
+ std::vector< int >::value_type *result = 0 ;
6251
+
6252
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector___getitem__",&obj0,&obj1)) SWIG_fail;
6253
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6254
+ if (!SWIG_IsOK(res1)) {
6255
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'");
6256
+ }
6257
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6258
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6259
+ if (!SWIG_IsOK(ecode2)) {
6260
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___getitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
6261
+ }
6262
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
6263
+ try {
6264
+ {
6265
+ std::vector< int >::value_type const &_result_ref = std_vector_Sl_int_Sg____getitem__((std::vector< int > const *)arg1,arg2);
6266
+ result = (std::vector< int >::value_type *) &_result_ref;
6267
+ }
6268
+ }
6269
+ catch(std::out_of_range &_e) {
6270
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6271
+ }
6272
+
6273
+ resultobj = SWIG_From_int(static_cast< int >(*result));
6274
+ return resultobj;
6275
+fail:
6276
+ return NULL;
6277
+}
6278
+
6279
+
6280
+SWIGINTERN PyObject *_wrap_IntVector___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6281
+ PyObject *resultobj = 0;
6282
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6283
+ std::vector< int >::difference_type arg2 ;
6284
+ std::vector< int >::value_type *arg3 = 0 ;
6285
+ void *argp1 = 0 ;
6286
+ int res1 = 0 ;
6287
+ ptrdiff_t val2 ;
6288
+ int ecode2 = 0 ;
6289
+ std::vector< int >::value_type temp3 ;
6290
+ int val3 ;
6291
+ int ecode3 = 0 ;
6292
+ PyObject * obj0 = 0 ;
6293
+ PyObject * obj1 = 0 ;
6294
+ PyObject * obj2 = 0 ;
6295
+
6296
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
6297
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6298
+ if (!SWIG_IsOK(res1)) {
6299
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
6300
+ }
6301
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6302
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6303
+ if (!SWIG_IsOK(ecode2)) {
6304
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___setitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
6305
+ }
6306
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
6307
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
6308
+ if (!SWIG_IsOK(ecode3)) {
6309
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___setitem__" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
6310
+ }
6311
+ temp3 = static_cast< std::vector< int >::value_type >(val3);
6312
+ arg3 = &temp3;
6313
+ try {
6314
+ std_vector_Sl_int_Sg____setitem__(arg1,arg2,(int const &)*arg3);
6315
+ }
6316
+ catch(std::out_of_range &_e) {
6317
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6318
+ }
6319
+
6320
+ resultobj = SWIG_Py_Void();
6321
+ return resultobj;
6322
+fail:
6323
+ return NULL;
6324
+}
6325
+
6326
+
6327
+SWIGINTERN PyObject *_wrap_IntVector_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6328
+ PyObject *resultobj = 0;
6329
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6330
+ std::vector< int >::value_type *arg2 = 0 ;
6331
+ void *argp1 = 0 ;
6332
+ int res1 = 0 ;
6333
+ std::vector< int >::value_type temp2 ;
6334
+ int val2 ;
6335
+ int ecode2 = 0 ;
6336
+ PyObject * obj0 = 0 ;
6337
+ PyObject * obj1 = 0 ;
6338
+
6339
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_append",&obj0,&obj1)) SWIG_fail;
6340
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6341
+ if (!SWIG_IsOK(res1)) {
6342
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_append" "', argument " "1"" of type '" "std::vector< int > *""'");
6343
+ }
6344
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6345
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
6346
+ if (!SWIG_IsOK(ecode2)) {
6347
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
6348
+ }
6349
+ temp2 = static_cast< std::vector< int >::value_type >(val2);
6350
+ arg2 = &temp2;
6351
+ std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2);
6352
+ resultobj = SWIG_Py_Void();
6353
+ return resultobj;
6354
+fail:
6355
+ return NULL;
6356
+}
6357
+
6358
+
6359
+SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6360
+ PyObject *resultobj = 0;
6361
+ std::vector< int > *result = 0 ;
6362
+
6363
+ if (!PyArg_ParseTuple(args,(char *)":new_IntVector")) SWIG_fail;
6364
+ result = (std::vector< int > *)new std::vector< int >();
6365
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
6366
+ return resultobj;
6367
+fail:
6368
+ return NULL;
6369
+}
6370
+
6371
+
6372
+SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6373
+ PyObject *resultobj = 0;
6374
+ std::vector< int > *arg1 = 0 ;
6375
+ int res1 = SWIG_OLDOBJ ;
6376
+ PyObject * obj0 = 0 ;
6377
+ std::vector< int > *result = 0 ;
6378
+
6379
+ if (!PyArg_ParseTuple(args,(char *)"O:new_IntVector",&obj0)) SWIG_fail;
6380
+ {
6381
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
6382
+ res1 = swig::asptr(obj0, &ptr);
6383
+ if (!SWIG_IsOK(res1)) {
6384
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int > const &""'");
6385
+ }
6386
+ if (!ptr) {
6387
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int > const &""'");
6388
+ }
6389
+ arg1 = ptr;
6390
+ }
6391
+ result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
6392
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
6393
+ if (SWIG_IsNewObj(res1)) delete arg1;
6394
+ return resultobj;
6395
+fail:
6396
+ if (SWIG_IsNewObj(res1)) delete arg1;
6397
+ return NULL;
6398
+}
6399
+
6400
+
6401
+SWIGINTERN PyObject *_wrap_IntVector_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6402
+ PyObject *resultobj = 0;
6403
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6404
+ void *argp1 = 0 ;
6405
+ int res1 = 0 ;
6406
+ PyObject * obj0 = 0 ;
6407
+ bool result;
6408
+
6409
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_empty",&obj0)) SWIG_fail;
6410
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6411
+ if (!SWIG_IsOK(res1)) {
6412
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_empty" "', argument " "1"" of type '" "std::vector< int > const *""'");
6413
+ }
6414
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6415
+ result = (bool)((std::vector< int > const *)arg1)->empty();
6416
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
6417
+ return resultobj;
6418
+fail:
6419
+ return NULL;
6420
+}
6421
+
6422
+
6423
+SWIGINTERN PyObject *_wrap_IntVector_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6424
+ PyObject *resultobj = 0;
6425
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6426
+ void *argp1 = 0 ;
6427
+ int res1 = 0 ;
6428
+ PyObject * obj0 = 0 ;
6429
+ std::vector< int >::size_type result;
6430
+
6431
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_size",&obj0)) SWIG_fail;
6432
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6433
+ if (!SWIG_IsOK(res1)) {
6434
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_size" "', argument " "1"" of type '" "std::vector< int > const *""'");
6435
+ }
6436
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6437
+ result = ((std::vector< int > const *)arg1)->size();
6438
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
6439
+ return resultobj;
6440
+fail:
6441
+ return NULL;
6442
+}
6443
+
6444
+
6445
+SWIGINTERN PyObject *_wrap_IntVector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6446
+ PyObject *resultobj = 0;
6447
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6448
+ void *argp1 = 0 ;
6449
+ int res1 = 0 ;
6450
+ PyObject * obj0 = 0 ;
6451
+
6452
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_clear",&obj0)) SWIG_fail;
6453
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6454
+ if (!SWIG_IsOK(res1)) {
6455
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_clear" "', argument " "1"" of type '" "std::vector< int > *""'");
6456
+ }
6457
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6458
+ (arg1)->clear();
6459
+ resultobj = SWIG_Py_Void();
6460
+ return resultobj;
6461
+fail:
6462
+ return NULL;
6463
+}
6464
+
6465
+
6466
+SWIGINTERN PyObject *_wrap_IntVector_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6467
+ PyObject *resultobj = 0;
6468
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6469
+ std::vector< int > *arg2 = 0 ;
6470
+ void *argp1 = 0 ;
6471
+ int res1 = 0 ;
6472
+ void *argp2 = 0 ;
6473
+ int res2 = 0 ;
6474
+ PyObject * obj0 = 0 ;
6475
+ PyObject * obj1 = 0 ;
6476
+
6477
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_swap",&obj0,&obj1)) SWIG_fail;
6478
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6479
+ if (!SWIG_IsOK(res1)) {
6480
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_swap" "', argument " "1"" of type '" "std::vector< int > *""'");
6481
+ }
6482
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6483
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 );
6484
+ if (!SWIG_IsOK(res2)) {
6485
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntVector_swap" "', argument " "2"" of type '" "std::vector< int > &""'");
6486
+ }
6487
+ if (!argp2) {
6488
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVector_swap" "', argument " "2"" of type '" "std::vector< int > &""'");
6489
+ }
6490
+ arg2 = reinterpret_cast< std::vector< int > * >(argp2);
6491
+ (arg1)->swap(*arg2);
6492
+ resultobj = SWIG_Py_Void();
6493
+ return resultobj;
6494
+fail:
6495
+ return NULL;
6496
+}
6497
+
6498
+
6499
+SWIGINTERN PyObject *_wrap_IntVector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6500
+ PyObject *resultobj = 0;
6501
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6502
+ void *argp1 = 0 ;
6503
+ int res1 = 0 ;
6504
+ PyObject * obj0 = 0 ;
6505
+ SwigValueWrapper< std::allocator< int > > result;
6506
+
6507
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_get_allocator",&obj0)) SWIG_fail;
6508
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6509
+ if (!SWIG_IsOK(res1)) {
6510
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'");
6511
+ }
6512
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6513
+ result = ((std::vector< int > const *)arg1)->get_allocator();
6514
+ resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
6515
+ return resultobj;
6516
+fail:
6517
+ return NULL;
6518
+}
6519
+
6520
+
6521
+SWIGINTERN PyObject *_wrap_IntVector_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6522
+ PyObject *resultobj = 0;
6523
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6524
+ void *argp1 = 0 ;
6525
+ int res1 = 0 ;
6526
+ PyObject * obj0 = 0 ;
6527
+ std::vector< int >::const_iterator result;
6528
+
6529
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_begin",&obj0)) SWIG_fail;
6530
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6531
+ if (!SWIG_IsOK(res1)) {
6532
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_begin" "', argument " "1"" of type '" "std::vector< int > const *""'");
6533
+ }
6534
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6535
+ result = ((std::vector< int > const *)arg1)->begin();
6536
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_iterator & >(result)),
6537
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6538
+ return resultobj;
6539
+fail:
6540
+ return NULL;
6541
+}
6542
+
6543
+
6544
+SWIGINTERN PyObject *_wrap_IntVector_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6545
+ PyObject *resultobj = 0;
6546
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6547
+ void *argp1 = 0 ;
6548
+ int res1 = 0 ;
6549
+ PyObject * obj0 = 0 ;
6550
+ std::vector< int >::const_iterator result;
6551
+
6552
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_end",&obj0)) SWIG_fail;
6553
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6554
+ if (!SWIG_IsOK(res1)) {
6555
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_end" "', argument " "1"" of type '" "std::vector< int > const *""'");
6556
+ }
6557
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6558
+ result = ((std::vector< int > const *)arg1)->end();
6559
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_iterator & >(result)),
6560
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6561
+ return resultobj;
6562
+fail:
6563
+ return NULL;
6564
+}
6565
+
6566
+
6567
+SWIGINTERN PyObject *_wrap_IntVector_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6568
+ PyObject *resultobj = 0;
6569
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6570
+ void *argp1 = 0 ;
6571
+ int res1 = 0 ;
6572
+ PyObject * obj0 = 0 ;
6573
+ std::vector< int >::const_reverse_iterator result;
6574
+
6575
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_rbegin",&obj0)) SWIG_fail;
6576
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6577
+ if (!SWIG_IsOK(res1)) {
6578
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_rbegin" "', argument " "1"" of type '" "std::vector< int > const *""'");
6579
+ }
6580
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6581
+ result = ((std::vector< int > const *)arg1)->rbegin();
6582
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_reverse_iterator & >(result)),
6583
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6584
+ return resultobj;
6585
+fail:
6586
+ return NULL;
6587
+}
6588
+
6589
+
6590
+SWIGINTERN PyObject *_wrap_IntVector_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6591
+ PyObject *resultobj = 0;
6592
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6593
+ void *argp1 = 0 ;
6594
+ int res1 = 0 ;
6595
+ PyObject * obj0 = 0 ;
6596
+ std::vector< int >::const_reverse_iterator result;
6597
+
6598
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_rend",&obj0)) SWIG_fail;
6599
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6600
+ if (!SWIG_IsOK(res1)) {
6601
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_rend" "', argument " "1"" of type '" "std::vector< int > const *""'");
6602
+ }
6603
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6604
+ result = ((std::vector< int > const *)arg1)->rend();
6605
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_reverse_iterator & >(result)),
6606
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6607
+ return resultobj;
6608
+fail:
6609
+ return NULL;
6610
+}
6611
+
6612
+
6613
+SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6614
+ PyObject *resultobj = 0;
6615
+ std::vector< int >::size_type arg1 ;
6616
+ size_t val1 ;
6617
+ int ecode1 = 0 ;
6618
+ PyObject * obj0 = 0 ;
6619
+ std::vector< int > *result = 0 ;
6620
+
6621
+ if (!PyArg_ParseTuple(args,(char *)"O:new_IntVector",&obj0)) SWIG_fail;
6622
+ ecode1 = SWIG_AsVal_size_t(obj0, &val1);
6623
+ if (!SWIG_IsOK(ecode1)) {
6624
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
6625
+ }
6626
+ arg1 = static_cast< std::vector< int >::size_type >(val1);
6627
+ result = (std::vector< int > *)new std::vector< int >(arg1);
6628
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
6629
+ return resultobj;
6630
+fail:
6631
+ return NULL;
6632
+}
6633
+
6634
+
6635
+SWIGINTERN PyObject *_wrap_IntVector_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6636
+ PyObject *resultobj = 0;
6637
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6638
+ void *argp1 = 0 ;
6639
+ int res1 = 0 ;
6640
+ PyObject * obj0 = 0 ;
6641
+
6642
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_pop_back",&obj0)) SWIG_fail;
6643
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6644
+ if (!SWIG_IsOK(res1)) {
6645
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'");
6646
+ }
6647
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6648
+ (arg1)->pop_back();
6649
+ resultobj = SWIG_Py_Void();
6650
+ return resultobj;
6651
+fail:
6652
+ return NULL;
6653
+}
6654
+
6655
+
6656
+SWIGINTERN PyObject *_wrap_IntVector_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6657
+ PyObject *resultobj = 0;
6658
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6659
+ std::vector< int >::size_type arg2 ;
6660
+ void *argp1 = 0 ;
6661
+ int res1 = 0 ;
6662
+ size_t val2 ;
6663
+ int ecode2 = 0 ;
6664
+ PyObject * obj0 = 0 ;
6665
+ PyObject * obj1 = 0 ;
6666
+
6667
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_resize",&obj0,&obj1)) SWIG_fail;
6668
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6669
+ if (!SWIG_IsOK(res1)) {
6670
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_resize" "', argument " "1"" of type '" "std::vector< int > *""'");
6671
+ }
6672
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6673
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
6674
+ if (!SWIG_IsOK(ecode2)) {
6675
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
6676
+ }
6677
+ arg2 = static_cast< std::vector< int >::size_type >(val2);
6678
+ (arg1)->resize(arg2);
6679
+ resultobj = SWIG_Py_Void();
6680
+ return resultobj;
6681
+fail:
6682
+ return NULL;
6683
+}
6684
+
6685
+
6686
+SWIGINTERN PyObject *_wrap_IntVector_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6687
+ PyObject *resultobj = 0;
6688
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6689
+ std::vector< int >::iterator arg2 ;
6690
+ void *argp1 = 0 ;
6691
+ int res1 = 0 ;
6692
+ swig::PySwigIterator *iter2 = 0 ;
6693
+ int res2 ;
6694
+ PyObject * obj0 = 0 ;
6695
+ PyObject * obj1 = 0 ;
6696
+ std::vector< int >::iterator result;
6697
+
6698
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_erase",&obj0,&obj1)) SWIG_fail;
6699
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6700
+ if (!SWIG_IsOK(res1)) {
6701
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_erase" "', argument " "1"" of type '" "std::vector< int > *""'");
6702
+ }
6703
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6704
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
6705
+ if (!SWIG_IsOK(res2) || !iter2) {
6706
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
6707
+ } else {
6708
+ swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter2);
6709
+ if (iter_t) {
6710
+ arg2 = iter_t->get_current();
6711
+ } else {
6712
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
6713
+ }
6714
+ }
6715
+ result = (arg1)->erase(arg2);
6716
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
6717
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6718
+ return resultobj;
6719
+fail:
6720
+ return NULL;
6721
+}
6722
+
6723
+
6724
+SWIGINTERN PyObject *_wrap_IntVector_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6725
+ PyObject *resultobj = 0;
6726
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6727
+ std::vector< int >::iterator arg2 ;
6728
+ std::vector< int >::iterator arg3 ;
6729
+ void *argp1 = 0 ;
6730
+ int res1 = 0 ;
6731
+ swig::PySwigIterator *iter2 = 0 ;
6732
+ int res2 ;
6733
+ swig::PySwigIterator *iter3 = 0 ;
6734
+ int res3 ;
6735
+ PyObject * obj0 = 0 ;
6736
+ PyObject * obj1 = 0 ;
6737
+ PyObject * obj2 = 0 ;
6738
+ std::vector< int >::iterator result;
6739
+
6740
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector_erase",&obj0,&obj1,&obj2)) SWIG_fail;
6741
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6742
+ if (!SWIG_IsOK(res1)) {
6743
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_erase" "', argument " "1"" of type '" "std::vector< int > *""'");
6744
+ }
6745
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6746
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
6747
+ if (!SWIG_IsOK(res2) || !iter2) {
6748
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
6749
+ } else {
6750
+ swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter2);
6751
+ if (iter_t) {
6752
+ arg2 = iter_t->get_current();
6753
+ } else {
6754
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
6755
+ }
6756
+ }
6757
+ res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
6758
+ if (!SWIG_IsOK(res3) || !iter3) {
6759
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
6760
+ } else {
6761
+ swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter3);
6762
+ if (iter_t) {
6763
+ arg3 = iter_t->get_current();
6764
+ } else {
6765
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
6766
+ }
6767
+ }
6768
+ result = (arg1)->erase(arg2,arg3);
6769
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
6770
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6771
+ return resultobj;
6772
+fail:
6773
+ return NULL;
6774
+}
6775
+
6776
+
6777
+SWIGINTERN PyObject *_wrap_IntVector_erase(PyObject *self, PyObject *args) {
6778
+ int argc;
6779
+ PyObject *argv[4];
6780
+ int ii;
6781
+
6782
+ if (!PyTuple_Check(args)) SWIG_fail;
6783
+ argc = (int)PyObject_Length(args);
6784
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
6785
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
6786
+ }
6787
+ if (argc == 2) {
6788
+ int _v;
6789
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
6790
+ _v = SWIG_CheckState(res);
6791
+ if (_v) {
6792
+ swig::PySwigIterator *iter = 0;
6793
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6794
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
6795
+ if (_v) {
6796
+ return _wrap_IntVector_erase__SWIG_0(self, args);
6797
+ }
6798
+ }
6799
+ }
6800
+ if (argc == 3) {
6801
+ int _v;
6802
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
6803
+ _v = SWIG_CheckState(res);
6804
+ if (_v) {
6805
+ swig::PySwigIterator *iter = 0;
6806
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6807
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
6808
+ if (_v) {
6809
+ swig::PySwigIterator *iter = 0;
6810
+ int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6811
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
6812
+ if (_v) {
6813
+ return _wrap_IntVector_erase__SWIG_1(self, args);
6814
+ }
6815
+ }
6816
+ }
6817
+ }
6818
+
6819
+fail:
6820
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IntVector_erase'.\n"
6821
+ " Possible C/C++ prototypes are:\n"
6822
+ " erase(std::vector< int > *,std::vector< int >::iterator)\n"
6823
+ " erase(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::iterator)\n");
6824
+ return NULL;
6825
+}
6826
+
6827
+
6828
+SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6829
+ PyObject *resultobj = 0;
6830
+ std::vector< int >::size_type arg1 ;
6831
+ std::vector< int >::value_type *arg2 = 0 ;
6832
+ size_t val1 ;
6833
+ int ecode1 = 0 ;
6834
+ std::vector< int >::value_type temp2 ;
6835
+ int val2 ;
6836
+ int ecode2 = 0 ;
6837
+ PyObject * obj0 = 0 ;
6838
+ PyObject * obj1 = 0 ;
6839
+ std::vector< int > *result = 0 ;
6840
+
6841
+ if (!PyArg_ParseTuple(args,(char *)"OO:new_IntVector",&obj0,&obj1)) SWIG_fail;
6842
+ ecode1 = SWIG_AsVal_size_t(obj0, &val1);
6843
+ if (!SWIG_IsOK(ecode1)) {
6844
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
6845
+ }
6846
+ arg1 = static_cast< std::vector< int >::size_type >(val1);
6847
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
6848
+ if (!SWIG_IsOK(ecode2)) {
6849
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IntVector" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
6850
+ }
6851
+ temp2 = static_cast< std::vector< int >::value_type >(val2);
6852
+ arg2 = &temp2;
6853
+ result = (std::vector< int > *)new std::vector< int >(arg1,(std::vector< int >::value_type const &)*arg2);
6854
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
6855
+ return resultobj;
6856
+fail:
6857
+ return NULL;
6858
+}
6859
+
6860
+
6861
+SWIGINTERN PyObject *_wrap_new_IntVector(PyObject *self, PyObject *args) {
6862
+ int argc;
6863
+ PyObject *argv[3];
6864
+ int ii;
6865
+
6866
+ if (!PyTuple_Check(args)) SWIG_fail;
6867
+ argc = (int)PyObject_Length(args);
6868
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
6869
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
6870
+ }
6871
+ if (argc == 0) {
6872
+ return _wrap_new_IntVector__SWIG_0(self, args);
6873
+ }
6874
+ if (argc == 1) {
6875
+ int _v;
6876
+ {
6877
+ int res = SWIG_AsVal_size_t(argv[0], NULL);
6878
+ _v = SWIG_CheckState(res);
6879
+ }
6880
+ if (_v) {
6881
+ return _wrap_new_IntVector__SWIG_2(self, args);
6882
+ }
6883
+ }
6884
+ if (argc == 1) {
6885
+ int _v;
6886
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
6887
+ _v = SWIG_CheckState(res);
6888
+ if (_v) {
6889
+ return _wrap_new_IntVector__SWIG_1(self, args);
6890
+ }
6891
+ }
6892
+ if (argc == 2) {
6893
+ int _v;
6894
+ {
6895
+ int res = SWIG_AsVal_size_t(argv[0], NULL);
6896
+ _v = SWIG_CheckState(res);
6897
+ }
6898
+ if (_v) {
6899
+ {
6900
+ int res = SWIG_AsVal_int(argv[1], NULL);
6901
+ _v = SWIG_CheckState(res);
6902
+ }
6903
+ if (_v) {
6904
+ return _wrap_new_IntVector__SWIG_3(self, args);
6905
+ }
6906
+ }
6907
+ }
6908
+
6909
+fail:
6910
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IntVector'.\n"
6911
+ " Possible C/C++ prototypes are:\n"
6912
+ " std::vector< int >()\n"
6913
+ " std::vector< int >(std::vector< int > const &)\n"
6914
+ " std::vector< int >(std::vector< int >::size_type)\n"
6915
+ " std::vector< int >(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
6916
+ return NULL;
6917
+}
6918
+
6919
+
6920
+SWIGINTERN PyObject *_wrap_IntVector_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6921
+ PyObject *resultobj = 0;
6922
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6923
+ std::vector< int >::value_type *arg2 = 0 ;
6924
+ void *argp1 = 0 ;
6925
+ int res1 = 0 ;
6926
+ std::vector< int >::value_type temp2 ;
6927
+ int val2 ;
6928
+ int ecode2 = 0 ;
6929
+ PyObject * obj0 = 0 ;
6930
+ PyObject * obj1 = 0 ;
6931
+
6932
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_push_back",&obj0,&obj1)) SWIG_fail;
6933
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6934
+ if (!SWIG_IsOK(res1)) {
6935
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_push_back" "', argument " "1"" of type '" "std::vector< int > *""'");
6936
+ }
6937
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6938
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
6939
+ if (!SWIG_IsOK(ecode2)) {
6940
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
6941
+ }
6942
+ temp2 = static_cast< std::vector< int >::value_type >(val2);
6943
+ arg2 = &temp2;
6944
+ (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
6945
+ resultobj = SWIG_Py_Void();
6946
+ return resultobj;
6947
+fail:
6948
+ return NULL;
6949
+}
6950
+
6951
+
6952
+SWIGINTERN PyObject *_wrap_IntVector_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6953
+ PyObject *resultobj = 0;
6954
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6955
+ void *argp1 = 0 ;
6956
+ int res1 = 0 ;
6957
+ PyObject * obj0 = 0 ;
6958
+ std::vector< int >::value_type *result = 0 ;
6959
+
6960
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_front",&obj0)) SWIG_fail;
6961
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6962
+ if (!SWIG_IsOK(res1)) {
6963
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_front" "', argument " "1"" of type '" "std::vector< int > const *""'");
6964
+ }
6965
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6966
+ {
6967
+ std::vector< int >::value_type const &_result_ref = ((std::vector< int > const *)arg1)->front();
6968
+ result = (std::vector< int >::value_type *) &_result_ref;
6969
+ }
6970
+ resultobj = SWIG_From_int(static_cast< int >(*result));
6971
+ return resultobj;
6972
+fail:
6973
+ return NULL;
6974
+}
6975
+
6976
+
6977
+SWIGINTERN PyObject *_wrap_IntVector_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6978
+ PyObject *resultobj = 0;
6979
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
6980
+ void *argp1 = 0 ;
6981
+ int res1 = 0 ;
6982
+ PyObject * obj0 = 0 ;
6983
+ std::vector< int >::value_type *result = 0 ;
6984
+
6985
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_back",&obj0)) SWIG_fail;
6986
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
6987
+ if (!SWIG_IsOK(res1)) {
6988
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_back" "', argument " "1"" of type '" "std::vector< int > const *""'");
6989
+ }
6990
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
6991
+ {
6992
+ std::vector< int >::value_type const &_result_ref = ((std::vector< int > const *)arg1)->back();
6993
+ result = (std::vector< int >::value_type *) &_result_ref;
6994
+ }
6995
+ resultobj = SWIG_From_int(static_cast< int >(*result));
6996
+ return resultobj;
6997
+fail:
6998
+ return NULL;
6999
+}
7000
+
7001
+
7002
+SWIGINTERN PyObject *_wrap_IntVector_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7003
+ PyObject *resultobj = 0;
7004
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
7005
+ std::vector< int >::size_type arg2 ;
7006
+ std::vector< int >::value_type *arg3 = 0 ;
7007
+ void *argp1 = 0 ;
7008
+ int res1 = 0 ;
7009
+ size_t val2 ;
7010
+ int ecode2 = 0 ;
7011
+ std::vector< int >::value_type temp3 ;
7012
+ int val3 ;
7013
+ int ecode3 = 0 ;
7014
+ PyObject * obj0 = 0 ;
7015
+ PyObject * obj1 = 0 ;
7016
+ PyObject * obj2 = 0 ;
7017
+
7018
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector_assign",&obj0,&obj1,&obj2)) SWIG_fail;
7019
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
7020
+ if (!SWIG_IsOK(res1)) {
7021
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_assign" "', argument " "1"" of type '" "std::vector< int > *""'");
7022
+ }
7023
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
7024
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7025
+ if (!SWIG_IsOK(ecode2)) {
7026
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
7027
+ }
7028
+ arg2 = static_cast< std::vector< int >::size_type >(val2);
7029
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
7030
+ if (!SWIG_IsOK(ecode3)) {
7031
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
7032
+ }
7033
+ temp3 = static_cast< std::vector< int >::value_type >(val3);
7034
+ arg3 = &temp3;
7035
+ (arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3);
7036
+ resultobj = SWIG_Py_Void();
7037
+ return resultobj;
7038
+fail:
7039
+ return NULL;
7040
+}
7041
+
7042
+
7043
+SWIGINTERN PyObject *_wrap_IntVector_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7044
+ PyObject *resultobj = 0;
7045
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
7046
+ std::vector< int >::size_type arg2 ;
7047
+ std::vector< int >::value_type *arg3 = 0 ;
7048
+ void *argp1 = 0 ;
7049
+ int res1 = 0 ;
7050
+ size_t val2 ;
7051
+ int ecode2 = 0 ;
7052
+ std::vector< int >::value_type temp3 ;
7053
+ int val3 ;
7054
+ int ecode3 = 0 ;
7055
+ PyObject * obj0 = 0 ;
7056
+ PyObject * obj1 = 0 ;
7057
+ PyObject * obj2 = 0 ;
7058
+
7059
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector_resize",&obj0,&obj1,&obj2)) SWIG_fail;
7060
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
7061
+ if (!SWIG_IsOK(res1)) {
7062
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_resize" "', argument " "1"" of type '" "std::vector< int > *""'");
7063
+ }
7064
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
7065
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7066
+ if (!SWIG_IsOK(ecode2)) {
7067
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
7068
+ }
7069
+ arg2 = static_cast< std::vector< int >::size_type >(val2);
7070
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
7071
+ if (!SWIG_IsOK(ecode3)) {
7072
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
7073
+ }
7074
+ temp3 = static_cast< std::vector< int >::value_type >(val3);
7075
+ arg3 = &temp3;
7076
+ (arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3);
7077
+ resultobj = SWIG_Py_Void();
7078
+ return resultobj;
7079
+fail:
7080
+ return NULL;
7081
+}
7082
+
7083
+
7084
+SWIGINTERN PyObject *_wrap_IntVector_resize(PyObject *self, PyObject *args) {
7085
+ int argc;
7086
+ PyObject *argv[4];
7087
+ int ii;
7088
+
7089
+ if (!PyTuple_Check(args)) SWIG_fail;
7090
+ argc = (int)PyObject_Length(args);
7091
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
7092
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
7093
+ }
7094
+ if (argc == 2) {
7095
+ int _v;
7096
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
7097
+ _v = SWIG_CheckState(res);
7098
+ if (_v) {
7099
+ {
7100
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
7101
+ _v = SWIG_CheckState(res);
7102
+ }
7103
+ if (_v) {
7104
+ return _wrap_IntVector_resize__SWIG_0(self, args);
7105
+ }
7106
+ }
7107
+ }
7108
+ if (argc == 3) {
7109
+ int _v;
7110
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
7111
+ _v = SWIG_CheckState(res);
7112
+ if (_v) {
7113
+ {
7114
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
7115
+ _v = SWIG_CheckState(res);
7116
+ }
7117
+ if (_v) {
7118
+ {
7119
+ int res = SWIG_AsVal_int(argv[2], NULL);
7120
+ _v = SWIG_CheckState(res);
7121
+ }
7122
+ if (_v) {
7123
+ return _wrap_IntVector_resize__SWIG_1(self, args);
7124
+ }
7125
+ }
7126
+ }
7127
+ }
7128
+
7129
+fail:
7130
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IntVector_resize'.\n"
7131
+ " Possible C/C++ prototypes are:\n"
7132
+ " resize(std::vector< int > *,std::vector< int >::size_type)\n"
7133
+ " resize(std::vector< int > *,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
7134
+ return NULL;
7135
+}
7136
+
7137
+
7138
+SWIGINTERN PyObject *_wrap_IntVector_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7139
+ PyObject *resultobj = 0;
7140
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
7141
+ std::vector< int >::iterator arg2 ;
7142
+ std::vector< int >::value_type *arg3 = 0 ;
7143
+ void *argp1 = 0 ;
7144
+ int res1 = 0 ;
7145
+ swig::PySwigIterator *iter2 = 0 ;
7146
+ int res2 ;
7147
+ std::vector< int >::value_type temp3 ;
7148
+ int val3 ;
7149
+ int ecode3 = 0 ;
7150
+ PyObject * obj0 = 0 ;
7151
+ PyObject * obj1 = 0 ;
7152
+ PyObject * obj2 = 0 ;
7153
+ std::vector< int >::iterator result;
7154
+
7155
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector_insert",&obj0,&obj1,&obj2)) SWIG_fail;
7156
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
7157
+ if (!SWIG_IsOK(res1)) {
7158
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_insert" "', argument " "1"" of type '" "std::vector< int > *""'");
7159
+ }
7160
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
7161
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
7162
+ if (!SWIG_IsOK(res2) || !iter2) {
7163
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
7164
+ } else {
7165
+ swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter2);
7166
+ if (iter_t) {
7167
+ arg2 = iter_t->get_current();
7168
+ } else {
7169
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
7170
+ }
7171
+ }
7172
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
7173
+ if (!SWIG_IsOK(ecode3)) {
7174
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
7175
+ }
7176
+ temp3 = static_cast< std::vector< int >::value_type >(val3);
7177
+ arg3 = &temp3;
7178
+ result = (arg1)->insert(arg2,(std::vector< int >::value_type const &)*arg3);
7179
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
7180
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7181
+ return resultobj;
7182
+fail:
7183
+ return NULL;
7184
+}
7185
+
7186
+
7187
+SWIGINTERN PyObject *_wrap_IntVector_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7188
+ PyObject *resultobj = 0;
7189
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
7190
+ std::vector< int >::iterator arg2 ;
7191
+ std::vector< int >::size_type arg3 ;
7192
+ std::vector< int >::value_type *arg4 = 0 ;
7193
+ void *argp1 = 0 ;
7194
+ int res1 = 0 ;
7195
+ swig::PySwigIterator *iter2 = 0 ;
7196
+ int res2 ;
7197
+ size_t val3 ;
7198
+ int ecode3 = 0 ;
7199
+ std::vector< int >::value_type temp4 ;
7200
+ int val4 ;
7201
+ int ecode4 = 0 ;
7202
+ PyObject * obj0 = 0 ;
7203
+ PyObject * obj1 = 0 ;
7204
+ PyObject * obj2 = 0 ;
7205
+ PyObject * obj3 = 0 ;
7206
+
7207
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:IntVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7208
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
7209
+ if (!SWIG_IsOK(res1)) {
7210
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_insert" "', argument " "1"" of type '" "std::vector< int > *""'");
7211
+ }
7212
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
7213
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
7214
+ if (!SWIG_IsOK(res2) || !iter2) {
7215
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
7216
+ } else {
7217
+ swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter2);
7218
+ if (iter_t) {
7219
+ arg2 = iter_t->get_current();
7220
+ } else {
7221
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
7222
+ }
7223
+ }
7224
+ ecode3 = SWIG_AsVal_size_t(obj2, &val3);
7225
+ if (!SWIG_IsOK(ecode3)) {
7226
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'");
7227
+ }
7228
+ arg3 = static_cast< std::vector< int >::size_type >(val3);
7229
+ ecode4 = SWIG_AsVal_int(obj3, &val4);
7230
+ if (!SWIG_IsOK(ecode4)) {
7231
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IntVector_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'");
7232
+ }
7233
+ temp4 = static_cast< std::vector< int >::value_type >(val4);
7234
+ arg4 = &temp4;
7235
+ (arg1)->insert(arg2,arg3,(std::vector< int >::value_type const &)*arg4);
7236
+ resultobj = SWIG_Py_Void();
7237
+ return resultobj;
7238
+fail:
7239
+ return NULL;
7240
+}
7241
+
7242
+
7243
+SWIGINTERN PyObject *_wrap_IntVector_insert(PyObject *self, PyObject *args) {
7244
+ int argc;
7245
+ PyObject *argv[5];
7246
+ int ii;
7247
+
7248
+ if (!PyTuple_Check(args)) SWIG_fail;
7249
+ argc = (int)PyObject_Length(args);
7250
+ for (ii = 0; (ii < argc) && (ii < 4); ii++) {
7251
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
7252
+ }
7253
+ if (argc == 3) {
7254
+ int _v;
7255
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
7256
+ _v = SWIG_CheckState(res);
7257
+ if (_v) {
7258
+ swig::PySwigIterator *iter = 0;
7259
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
7260
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
7261
+ if (_v) {
7262
+ {
7263
+ int res = SWIG_AsVal_int(argv[2], NULL);
7264
+ _v = SWIG_CheckState(res);
7265
+ }
7266
+ if (_v) {
7267
+ return _wrap_IntVector_insert__SWIG_0(self, args);
7268
+ }
7269
+ }
7270
+ }
7271
+ }
7272
+ if (argc == 4) {
7273
+ int _v;
7274
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
7275
+ _v = SWIG_CheckState(res);
7276
+ if (_v) {
7277
+ swig::PySwigIterator *iter = 0;
7278
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
7279
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
7280
+ if (_v) {
7281
+ {
7282
+ int res = SWIG_AsVal_size_t(argv[2], NULL);
7283
+ _v = SWIG_CheckState(res);
7284
+ }
7285
+ if (_v) {
7286
+ {
7287
+ int res = SWIG_AsVal_int(argv[3], NULL);
7288
+ _v = SWIG_CheckState(res);
7289
+ }
7290
+ if (_v) {
7291
+ return _wrap_IntVector_insert__SWIG_1(self, args);
7292
+ }
7293
+ }
7294
+ }
7295
+ }
7296
+ }
7297
+
7298
+fail:
7299
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IntVector_insert'.\n"
7300
+ " Possible C/C++ prototypes are:\n"
7301
+ " insert(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::value_type const &)\n"
7302
+ " insert(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
7303
+ return NULL;
7304
+}
7305
+
7306
+
7307
+SWIGINTERN PyObject *_wrap_IntVector_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7308
+ PyObject *resultobj = 0;
7309
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
7310
+ std::vector< int >::size_type arg2 ;
7311
+ void *argp1 = 0 ;
7312
+ int res1 = 0 ;
7313
+ size_t val2 ;
7314
+ int ecode2 = 0 ;
7315
+ PyObject * obj0 = 0 ;
7316
+ PyObject * obj1 = 0 ;
7317
+
7318
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_reserve",&obj0,&obj1)) SWIG_fail;
7319
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
7320
+ if (!SWIG_IsOK(res1)) {
7321
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_reserve" "', argument " "1"" of type '" "std::vector< int > *""'");
7322
+ }
7323
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
7324
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7325
+ if (!SWIG_IsOK(ecode2)) {
7326
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
7327
+ }
7328
+ arg2 = static_cast< std::vector< int >::size_type >(val2);
7329
+ (arg1)->reserve(arg2);
7330
+ resultobj = SWIG_Py_Void();
7331
+ return resultobj;
7332
+fail:
7333
+ return NULL;
7334
+}
7335
+
7336
+
7337
+SWIGINTERN PyObject *_wrap_IntVector_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7338
+ PyObject *resultobj = 0;
7339
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
7340
+ void *argp1 = 0 ;
7341
+ int res1 = 0 ;
7342
+ PyObject * obj0 = 0 ;
7343
+ std::vector< int >::size_type result;
7344
+
7345
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_capacity",&obj0)) SWIG_fail;
7346
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
7347
+ if (!SWIG_IsOK(res1)) {
7348
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'");
7349
+ }
7350
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
7351
+ result = ((std::vector< int > const *)arg1)->capacity();
7352
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7353
+ return resultobj;
7354
+fail:
7355
+ return NULL;
7356
+}
7357
+
7358
+
7359
+SWIGINTERN PyObject *_wrap_delete_IntVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7360
+ PyObject *resultobj = 0;
7361
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
7362
+ void *argp1 = 0 ;
7363
+ int res1 = 0 ;
7364
+ PyObject * obj0 = 0 ;
7365
+
7366
+ if (!PyArg_ParseTuple(args,(char *)"O:delete_IntVector",&obj0)) SWIG_fail;
7367
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_DISOWN | 0 );
7368
+ if (!SWIG_IsOK(res1)) {
7369
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntVector" "', argument " "1"" of type '" "std::vector< int > *""'");
7370
+ }
7371
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
7372
+ delete arg1;
7373
+ resultobj = SWIG_Py_Void();
7374
+ return resultobj;
7375
+fail:
7376
+ return NULL;
7377
+}
7378
+
7379
+
7380
+SWIGINTERN PyObject *IntVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7381
+ PyObject *obj;
7382
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
7383
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_NewClientData(obj));
7384
+ return SWIG_Py_Void();
7385
+}
7386
+
7387
+SWIGINTERN PyObject *_wrap_DoubleVector_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7388
+ PyObject *resultobj = 0;
7389
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7390
+ PyObject **arg2 = (PyObject **) 0 ;
7391
+ void *argp1 = 0 ;
7392
+ int res1 = 0 ;
7393
+ PyObject * obj0 = 0 ;
7394
+ swig::PySwigIterator *result = 0 ;
7395
+
7396
+ arg2 = &obj0;
7397
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_iterator",&obj0)) SWIG_fail;
7398
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7399
+ if (!SWIG_IsOK(res1)) {
7400
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_iterator" "', argument " "1"" of type '" "std::vector< double > *""'");
7401
+ }
7402
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7403
+ result = (swig::PySwigIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
7404
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
7405
+ return resultobj;
7406
+fail:
7407
+ return NULL;
7408
+}
7409
+
7410
+
7411
+SWIGINTERN PyObject *_wrap_DoubleVector___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7412
+ PyObject *resultobj = 0;
7413
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7414
+ void *argp1 = 0 ;
7415
+ int res1 = 0 ;
7416
+ PyObject * obj0 = 0 ;
7417
+ bool result;
7418
+
7419
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector___nonzero__",&obj0)) SWIG_fail;
7420
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7421
+ if (!SWIG_IsOK(res1)) {
7422
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___nonzero__" "', argument " "1"" of type '" "std::vector< double > const *""'");
7423
+ }
7424
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7425
+ result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector< double > const *)arg1);
7426
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
7427
+ return resultobj;
7428
+fail:
7429
+ return NULL;
7430
+}
7431
+
7432
+
7433
+SWIGINTERN PyObject *_wrap_DoubleVector___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7434
+ PyObject *resultobj = 0;
7435
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7436
+ void *argp1 = 0 ;
7437
+ int res1 = 0 ;
7438
+ PyObject * obj0 = 0 ;
7439
+ std::vector< double >::size_type result;
7440
+
7441
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector___len__",&obj0)) SWIG_fail;
7442
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7443
+ if (!SWIG_IsOK(res1)) {
7444
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___len__" "', argument " "1"" of type '" "std::vector< double > const *""'");
7445
+ }
7446
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7447
+ result = std_vector_Sl_double_Sg____len__((std::vector< double > const *)arg1);
7448
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7449
+ return resultobj;
7450
+fail:
7451
+ return NULL;
7452
+}
7453
+
7454
+
7455
+SWIGINTERN PyObject *_wrap_DoubleVector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7456
+ PyObject *resultobj = 0;
7457
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7458
+ void *argp1 = 0 ;
7459
+ int res1 = 0 ;
7460
+ PyObject * obj0 = 0 ;
7461
+ std::vector< double >::value_type result;
7462
+
7463
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_pop",&obj0)) SWIG_fail;
7464
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7465
+ if (!SWIG_IsOK(res1)) {
7466
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_pop" "', argument " "1"" of type '" "std::vector< double > *""'");
7467
+ }
7468
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7469
+ try {
7470
+ result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
7471
+ }
7472
+ catch(std::out_of_range &_e) {
7473
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7474
+ }
7475
+
7476
+ resultobj = SWIG_From_double(static_cast< double >(result));
7477
+ return resultobj;
7478
+fail:
7479
+ return NULL;
7480
+}
7481
+
7482
+
7483
+SWIGINTERN PyObject *_wrap_DoubleVector___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7484
+ PyObject *resultobj = 0;
7485
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7486
+ std::vector< double >::difference_type arg2 ;
7487
+ std::vector< double >::difference_type arg3 ;
7488
+ void *argp1 = 0 ;
7489
+ int res1 = 0 ;
7490
+ ptrdiff_t val2 ;
7491
+ int ecode2 = 0 ;
7492
+ ptrdiff_t val3 ;
7493
+ int ecode3 = 0 ;
7494
+ PyObject * obj0 = 0 ;
7495
+ PyObject * obj1 = 0 ;
7496
+ PyObject * obj2 = 0 ;
7497
+ std::vector< double,std::allocator< double > > *result = 0 ;
7498
+
7499
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
7500
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7501
+ if (!SWIG_IsOK(res1)) {
7502
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
7503
+ }
7504
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7505
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7506
+ if (!SWIG_IsOK(ecode2)) {
7507
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
7508
+ }
7509
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
7510
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7511
+ if (!SWIG_IsOK(ecode3)) {
7512
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
7513
+ }
7514
+ arg3 = static_cast< std::vector< double >::difference_type >(val3);
7515
+ try {
7516
+ result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getslice__(arg1,arg2,arg3);
7517
+ }
7518
+ catch(std::out_of_range &_e) {
7519
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7520
+ }
7521
+
7522
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN | 0 );
7523
+ return resultobj;
7524
+fail:
7525
+ return NULL;
7526
+}
7527
+
7528
+
7529
+SWIGINTERN PyObject *_wrap_DoubleVector___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7530
+ PyObject *resultobj = 0;
7531
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7532
+ std::vector< double >::difference_type arg2 ;
7533
+ std::vector< double >::difference_type arg3 ;
7534
+ std::vector< double,std::allocator< double > > *arg4 = 0 ;
7535
+ void *argp1 = 0 ;
7536
+ int res1 = 0 ;
7537
+ ptrdiff_t val2 ;
7538
+ int ecode2 = 0 ;
7539
+ ptrdiff_t val3 ;
7540
+ int ecode3 = 0 ;
7541
+ int res4 = SWIG_OLDOBJ ;
7542
+ PyObject * obj0 = 0 ;
7543
+ PyObject * obj1 = 0 ;
7544
+ PyObject * obj2 = 0 ;
7545
+ PyObject * obj3 = 0 ;
7546
+
7547
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:DoubleVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7548
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7549
+ if (!SWIG_IsOK(res1)) {
7550
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
7551
+ }
7552
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7553
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7554
+ if (!SWIG_IsOK(ecode2)) {
7555
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
7556
+ }
7557
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
7558
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7559
+ if (!SWIG_IsOK(ecode3)) {
7560
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
7561
+ }
7562
+ arg3 = static_cast< std::vector< double >::difference_type >(val3);
7563
+ {
7564
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
7565
+ res4 = swig::asptr(obj3, &ptr);
7566
+ if (!SWIG_IsOK(res4)) {
7567
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoubleVector___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
7568
+ }
7569
+ if (!ptr) {
7570
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVector___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
7571
+ }
7572
+ arg4 = ptr;
7573
+ }
7574
+ try {
7575
+ std_vector_Sl_double_Sg____setslice__(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
7576
+ }
7577
+ catch(std::out_of_range &_e) {
7578
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7579
+ }
7580
+ catch(std::invalid_argument &_e) {
7581
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7582
+ }
7583
+
7584
+ resultobj = SWIG_Py_Void();
7585
+ if (SWIG_IsNewObj(res4)) delete arg4;
7586
+ return resultobj;
7587
+fail:
7588
+ if (SWIG_IsNewObj(res4)) delete arg4;
7589
+ return NULL;
7590
+}
7591
+
7592
+
7593
+SWIGINTERN PyObject *_wrap_DoubleVector___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7594
+ PyObject *resultobj = 0;
7595
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7596
+ std::vector< double >::difference_type arg2 ;
7597
+ std::vector< double >::difference_type arg3 ;
7598
+ void *argp1 = 0 ;
7599
+ int res1 = 0 ;
7600
+ ptrdiff_t val2 ;
7601
+ int ecode2 = 0 ;
7602
+ ptrdiff_t val3 ;
7603
+ int ecode3 = 0 ;
7604
+ PyObject * obj0 = 0 ;
7605
+ PyObject * obj1 = 0 ;
7606
+ PyObject * obj2 = 0 ;
7607
+
7608
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
7609
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7610
+ if (!SWIG_IsOK(res1)) {
7611
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___delslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
7612
+ }
7613
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7614
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7615
+ if (!SWIG_IsOK(ecode2)) {
7616
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___delslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
7617
+ }
7618
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
7619
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7620
+ if (!SWIG_IsOK(ecode3)) {
7621
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___delslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
7622
+ }
7623
+ arg3 = static_cast< std::vector< double >::difference_type >(val3);
7624
+ try {
7625
+ std_vector_Sl_double_Sg____delslice__(arg1,arg2,arg3);
7626
+ }
7627
+ catch(std::out_of_range &_e) {
7628
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7629
+ }
7630
+
7631
+ resultobj = SWIG_Py_Void();
7632
+ return resultobj;
7633
+fail:
7634
+ return NULL;
7635
+}
7636
+
7637
+
7638
+SWIGINTERN PyObject *_wrap_DoubleVector___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7639
+ PyObject *resultobj = 0;
7640
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7641
+ std::vector< double >::difference_type arg2 ;
7642
+ void *argp1 = 0 ;
7643
+ int res1 = 0 ;
7644
+ ptrdiff_t val2 ;
7645
+ int ecode2 = 0 ;
7646
+ PyObject * obj0 = 0 ;
7647
+ PyObject * obj1 = 0 ;
7648
+
7649
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector___delitem__",&obj0,&obj1)) SWIG_fail;
7650
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7651
+ if (!SWIG_IsOK(res1)) {
7652
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
7653
+ }
7654
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7655
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7656
+ if (!SWIG_IsOK(ecode2)) {
7657
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___delitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
7658
+ }
7659
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
7660
+ try {
7661
+ std_vector_Sl_double_Sg____delitem__(arg1,arg2);
7662
+ }
7663
+ catch(std::out_of_range &_e) {
7664
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7665
+ }
7666
+
7667
+ resultobj = SWIG_Py_Void();
7668
+ return resultobj;
7669
+fail:
7670
+ return NULL;
7671
+}
7672
+
7673
+
7674
+SWIGINTERN PyObject *_wrap_DoubleVector___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7675
+ PyObject *resultobj = 0;
7676
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7677
+ std::vector< double >::difference_type arg2 ;
7678
+ void *argp1 = 0 ;
7679
+ int res1 = 0 ;
7680
+ ptrdiff_t val2 ;
7681
+ int ecode2 = 0 ;
7682
+ PyObject * obj0 = 0 ;
7683
+ PyObject * obj1 = 0 ;
7684
+ std::vector< double >::value_type *result = 0 ;
7685
+
7686
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector___getitem__",&obj0,&obj1)) SWIG_fail;
7687
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7688
+ if (!SWIG_IsOK(res1)) {
7689
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___getitem__" "', argument " "1"" of type '" "std::vector< double > const *""'");
7690
+ }
7691
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7692
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7693
+ if (!SWIG_IsOK(ecode2)) {
7694
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___getitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
7695
+ }
7696
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
7697
+ try {
7698
+ {
7699
+ std::vector< double >::value_type const &_result_ref = std_vector_Sl_double_Sg____getitem__((std::vector< double > const *)arg1,arg2);
7700
+ result = (std::vector< double >::value_type *) &_result_ref;
7701
+ }
7702
+ }
7703
+ catch(std::out_of_range &_e) {
7704
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7705
+ }
7706
+
7707
+ resultobj = SWIG_From_double(static_cast< double >(*result));
7708
+ return resultobj;
7709
+fail:
7710
+ return NULL;
7711
+}
7712
+
7713
+
7714
+SWIGINTERN PyObject *_wrap_DoubleVector___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7715
+ PyObject *resultobj = 0;
7716
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7717
+ std::vector< double >::difference_type arg2 ;
7718
+ std::vector< double >::value_type *arg3 = 0 ;
7719
+ void *argp1 = 0 ;
7720
+ int res1 = 0 ;
7721
+ ptrdiff_t val2 ;
7722
+ int ecode2 = 0 ;
7723
+ std::vector< double >::value_type temp3 ;
7724
+ double val3 ;
7725
+ int ecode3 = 0 ;
7726
+ PyObject * obj0 = 0 ;
7727
+ PyObject * obj1 = 0 ;
7728
+ PyObject * obj2 = 0 ;
7729
+
7730
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
7731
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7732
+ if (!SWIG_IsOK(res1)) {
7733
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
7734
+ }
7735
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7736
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7737
+ if (!SWIG_IsOK(ecode2)) {
7738
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___setitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
7739
+ }
7740
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
7741
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
7742
+ if (!SWIG_IsOK(ecode3)) {
7743
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___setitem__" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
7744
+ }
7745
+ temp3 = static_cast< std::vector< double >::value_type >(val3);
7746
+ arg3 = &temp3;
7747
+ try {
7748
+ std_vector_Sl_double_Sg____setitem__(arg1,arg2,(double const &)*arg3);
7749
+ }
7750
+ catch(std::out_of_range &_e) {
7751
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7752
+ }
7753
+
7754
+ resultobj = SWIG_Py_Void();
7755
+ return resultobj;
7756
+fail:
7757
+ return NULL;
7758
+}
7759
+
7760
+
7761
+SWIGINTERN PyObject *_wrap_DoubleVector_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7762
+ PyObject *resultobj = 0;
7763
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7764
+ std::vector< double >::value_type *arg2 = 0 ;
7765
+ void *argp1 = 0 ;
7766
+ int res1 = 0 ;
7767
+ std::vector< double >::value_type temp2 ;
7768
+ double val2 ;
7769
+ int ecode2 = 0 ;
7770
+ PyObject * obj0 = 0 ;
7771
+ PyObject * obj1 = 0 ;
7772
+
7773
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector_append",&obj0,&obj1)) SWIG_fail;
7774
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7775
+ if (!SWIG_IsOK(res1)) {
7776
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_append" "', argument " "1"" of type '" "std::vector< double > *""'");
7777
+ }
7778
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7779
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
7780
+ if (!SWIG_IsOK(ecode2)) {
7781
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_append" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
7782
+ }
7783
+ temp2 = static_cast< std::vector< double >::value_type >(val2);
7784
+ arg2 = &temp2;
7785
+ std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2);
7786
+ resultobj = SWIG_Py_Void();
7787
+ return resultobj;
7788
+fail:
7789
+ return NULL;
7790
+}
7791
+
7792
+
7793
+SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7794
+ PyObject *resultobj = 0;
7795
+ std::vector< double > *result = 0 ;
7796
+
7797
+ if (!PyArg_ParseTuple(args,(char *)":new_DoubleVector")) SWIG_fail;
7798
+ result = (std::vector< double > *)new std::vector< double >();
7799
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
7800
+ return resultobj;
7801
+fail:
7802
+ return NULL;
7803
+}
7804
+
7805
+
7806
+SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7807
+ PyObject *resultobj = 0;
7808
+ std::vector< double > *arg1 = 0 ;
7809
+ int res1 = SWIG_OLDOBJ ;
7810
+ PyObject * obj0 = 0 ;
7811
+ std::vector< double > *result = 0 ;
7812
+
7813
+ if (!PyArg_ParseTuple(args,(char *)"O:new_DoubleVector",&obj0)) SWIG_fail;
7814
+ {
7815
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
7816
+ res1 = swig::asptr(obj0, &ptr);
7817
+ if (!SWIG_IsOK(res1)) {
7818
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double > const &""'");
7819
+ }
7820
+ if (!ptr) {
7821
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double > const &""'");
7822
+ }
7823
+ arg1 = ptr;
7824
+ }
7825
+ result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
7826
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
7827
+ if (SWIG_IsNewObj(res1)) delete arg1;
7828
+ return resultobj;
7829
+fail:
7830
+ if (SWIG_IsNewObj(res1)) delete arg1;
7831
+ return NULL;
7832
+}
7833
+
7834
+
7835
+SWIGINTERN PyObject *_wrap_DoubleVector_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7836
+ PyObject *resultobj = 0;
7837
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7838
+ void *argp1 = 0 ;
7839
+ int res1 = 0 ;
7840
+ PyObject * obj0 = 0 ;
7841
+ bool result;
7842
+
7843
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_empty",&obj0)) SWIG_fail;
7844
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7845
+ if (!SWIG_IsOK(res1)) {
7846
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_empty" "', argument " "1"" of type '" "std::vector< double > const *""'");
7847
+ }
7848
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7849
+ result = (bool)((std::vector< double > const *)arg1)->empty();
7850
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
7851
+ return resultobj;
7852
+fail:
7853
+ return NULL;
7854
+}
7855
+
7856
+
7857
+SWIGINTERN PyObject *_wrap_DoubleVector_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7858
+ PyObject *resultobj = 0;
7859
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7860
+ void *argp1 = 0 ;
7861
+ int res1 = 0 ;
7862
+ PyObject * obj0 = 0 ;
7863
+ std::vector< double >::size_type result;
7864
+
7865
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_size",&obj0)) SWIG_fail;
7866
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7867
+ if (!SWIG_IsOK(res1)) {
7868
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_size" "', argument " "1"" of type '" "std::vector< double > const *""'");
7869
+ }
7870
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7871
+ result = ((std::vector< double > const *)arg1)->size();
7872
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7873
+ return resultobj;
7874
+fail:
7875
+ return NULL;
7876
+}
7877
+
7878
+
7879
+SWIGINTERN PyObject *_wrap_DoubleVector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7880
+ PyObject *resultobj = 0;
7881
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7882
+ void *argp1 = 0 ;
7883
+ int res1 = 0 ;
7884
+ PyObject * obj0 = 0 ;
7885
+
7886
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_clear",&obj0)) SWIG_fail;
7887
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7888
+ if (!SWIG_IsOK(res1)) {
7889
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_clear" "', argument " "1"" of type '" "std::vector< double > *""'");
7890
+ }
7891
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7892
+ (arg1)->clear();
7893
+ resultobj = SWIG_Py_Void();
7894
+ return resultobj;
7895
+fail:
7896
+ return NULL;
7897
+}
7898
+
7899
+
7900
+SWIGINTERN PyObject *_wrap_DoubleVector_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7901
+ PyObject *resultobj = 0;
7902
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7903
+ std::vector< double > *arg2 = 0 ;
7904
+ void *argp1 = 0 ;
7905
+ int res1 = 0 ;
7906
+ void *argp2 = 0 ;
7907
+ int res2 = 0 ;
7908
+ PyObject * obj0 = 0 ;
7909
+ PyObject * obj1 = 0 ;
7910
+
7911
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector_swap",&obj0,&obj1)) SWIG_fail;
7912
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7913
+ if (!SWIG_IsOK(res1)) {
7914
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_swap" "', argument " "1"" of type '" "std::vector< double > *""'");
7915
+ }
7916
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7917
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 );
7918
+ if (!SWIG_IsOK(res2)) {
7919
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleVector_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
7920
+ }
7921
+ if (!argp2) {
7922
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVector_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
7923
+ }
7924
+ arg2 = reinterpret_cast< std::vector< double > * >(argp2);
7925
+ (arg1)->swap(*arg2);
7926
+ resultobj = SWIG_Py_Void();
7927
+ return resultobj;
7928
+fail:
7929
+ return NULL;
7930
+}
7931
+
7932
+
7933
+SWIGINTERN PyObject *_wrap_DoubleVector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7934
+ PyObject *resultobj = 0;
7935
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7936
+ void *argp1 = 0 ;
7937
+ int res1 = 0 ;
7938
+ PyObject * obj0 = 0 ;
7939
+ SwigValueWrapper< std::allocator< double > > result;
7940
+
7941
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_get_allocator",&obj0)) SWIG_fail;
7942
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7943
+ if (!SWIG_IsOK(res1)) {
7944
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'");
7945
+ }
7946
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7947
+ result = ((std::vector< double > const *)arg1)->get_allocator();
7948
+ resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
7949
+ return resultobj;
7950
+fail:
7951
+ return NULL;
7952
+}
7953
+
7954
+
7955
+SWIGINTERN PyObject *_wrap_DoubleVector_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7956
+ PyObject *resultobj = 0;
7957
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7958
+ void *argp1 = 0 ;
7959
+ int res1 = 0 ;
7960
+ PyObject * obj0 = 0 ;
7961
+ std::vector< double >::const_iterator result;
7962
+
7963
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_begin",&obj0)) SWIG_fail;
7964
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7965
+ if (!SWIG_IsOK(res1)) {
7966
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_begin" "', argument " "1"" of type '" "std::vector< double > const *""'");
7967
+ }
7968
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7969
+ result = ((std::vector< double > const *)arg1)->begin();
7970
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_iterator & >(result)),
7971
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7972
+ return resultobj;
7973
+fail:
7974
+ return NULL;
7975
+}
7976
+
7977
+
7978
+SWIGINTERN PyObject *_wrap_DoubleVector_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7979
+ PyObject *resultobj = 0;
7980
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
7981
+ void *argp1 = 0 ;
7982
+ int res1 = 0 ;
7983
+ PyObject * obj0 = 0 ;
7984
+ std::vector< double >::const_iterator result;
7985
+
7986
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_end",&obj0)) SWIG_fail;
7987
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
7988
+ if (!SWIG_IsOK(res1)) {
7989
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_end" "', argument " "1"" of type '" "std::vector< double > const *""'");
7990
+ }
7991
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
7992
+ result = ((std::vector< double > const *)arg1)->end();
7993
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_iterator & >(result)),
7994
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7995
+ return resultobj;
7996
+fail:
7997
+ return NULL;
7998
+}
7999
+
8000
+
8001
+SWIGINTERN PyObject *_wrap_DoubleVector_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8002
+ PyObject *resultobj = 0;
8003
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8004
+ void *argp1 = 0 ;
8005
+ int res1 = 0 ;
8006
+ PyObject * obj0 = 0 ;
8007
+ std::vector< double >::const_reverse_iterator result;
8008
+
8009
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_rbegin",&obj0)) SWIG_fail;
8010
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8011
+ if (!SWIG_IsOK(res1)) {
8012
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_rbegin" "', argument " "1"" of type '" "std::vector< double > const *""'");
8013
+ }
8014
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8015
+ result = ((std::vector< double > const *)arg1)->rbegin();
8016
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_reverse_iterator & >(result)),
8017
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8018
+ return resultobj;
8019
+fail:
8020
+ return NULL;
8021
+}
8022
+
8023
+
8024
+SWIGINTERN PyObject *_wrap_DoubleVector_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8025
+ PyObject *resultobj = 0;
8026
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8027
+ void *argp1 = 0 ;
8028
+ int res1 = 0 ;
8029
+ PyObject * obj0 = 0 ;
8030
+ std::vector< double >::const_reverse_iterator result;
8031
+
8032
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_rend",&obj0)) SWIG_fail;
8033
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8034
+ if (!SWIG_IsOK(res1)) {
8035
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_rend" "', argument " "1"" of type '" "std::vector< double > const *""'");
8036
+ }
8037
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8038
+ result = ((std::vector< double > const *)arg1)->rend();
8039
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_reverse_iterator & >(result)),
8040
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8041
+ return resultobj;
8042
+fail:
8043
+ return NULL;
8044
+}
8045
+
8046
+
8047
+SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8048
+ PyObject *resultobj = 0;
8049
+ std::vector< double >::size_type arg1 ;
8050
+ size_t val1 ;
8051
+ int ecode1 = 0 ;
8052
+ PyObject * obj0 = 0 ;
8053
+ std::vector< double > *result = 0 ;
8054
+
8055
+ if (!PyArg_ParseTuple(args,(char *)"O:new_DoubleVector",&obj0)) SWIG_fail;
8056
+ ecode1 = SWIG_AsVal_size_t(obj0, &val1);
8057
+ if (!SWIG_IsOK(ecode1)) {
8058
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
8059
+ }
8060
+ arg1 = static_cast< std::vector< double >::size_type >(val1);
8061
+ result = (std::vector< double > *)new std::vector< double >(arg1);
8062
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
8063
+ return resultobj;
8064
+fail:
8065
+ return NULL;
8066
+}
8067
+
8068
+
8069
+SWIGINTERN PyObject *_wrap_DoubleVector_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8070
+ PyObject *resultobj = 0;
8071
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8072
+ void *argp1 = 0 ;
8073
+ int res1 = 0 ;
8074
+ PyObject * obj0 = 0 ;
8075
+
8076
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_pop_back",&obj0)) SWIG_fail;
8077
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8078
+ if (!SWIG_IsOK(res1)) {
8079
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_pop_back" "', argument " "1"" of type '" "std::vector< double > *""'");
8080
+ }
8081
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8082
+ (arg1)->pop_back();
8083
+ resultobj = SWIG_Py_Void();
8084
+ return resultobj;
8085
+fail:
8086
+ return NULL;
8087
+}
8088
+
8089
+
8090
+SWIGINTERN PyObject *_wrap_DoubleVector_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8091
+ PyObject *resultobj = 0;
8092
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8093
+ std::vector< double >::size_type arg2 ;
8094
+ void *argp1 = 0 ;
8095
+ int res1 = 0 ;
8096
+ size_t val2 ;
8097
+ int ecode2 = 0 ;
8098
+ PyObject * obj0 = 0 ;
8099
+ PyObject * obj1 = 0 ;
8100
+
8101
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector_resize",&obj0,&obj1)) SWIG_fail;
8102
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8103
+ if (!SWIG_IsOK(res1)) {
8104
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
8105
+ }
8106
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8107
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8108
+ if (!SWIG_IsOK(ecode2)) {
8109
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
8110
+ }
8111
+ arg2 = static_cast< std::vector< double >::size_type >(val2);
8112
+ (arg1)->resize(arg2);
8113
+ resultobj = SWIG_Py_Void();
8114
+ return resultobj;
8115
+fail:
8116
+ return NULL;
8117
+}
8118
+
8119
+
8120
+SWIGINTERN PyObject *_wrap_DoubleVector_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8121
+ PyObject *resultobj = 0;
8122
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8123
+ std::vector< double >::iterator arg2 ;
8124
+ void *argp1 = 0 ;
8125
+ int res1 = 0 ;
8126
+ swig::PySwigIterator *iter2 = 0 ;
8127
+ int res2 ;
8128
+ PyObject * obj0 = 0 ;
8129
+ PyObject * obj1 = 0 ;
8130
+ std::vector< double >::iterator result;
8131
+
8132
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector_erase",&obj0,&obj1)) SWIG_fail;
8133
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8134
+ if (!SWIG_IsOK(res1)) {
8135
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
8136
+ }
8137
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8138
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
8139
+ if (!SWIG_IsOK(res2) || !iter2) {
8140
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
8141
+ } else {
8142
+ swig::PySwigIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter2);
8143
+ if (iter_t) {
8144
+ arg2 = iter_t->get_current();
8145
+ } else {
8146
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
8147
+ }
8148
+ }
8149
+ result = (arg1)->erase(arg2);
8150
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
8151
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8152
+ return resultobj;
8153
+fail:
8154
+ return NULL;
8155
+}
8156
+
8157
+
8158
+SWIGINTERN PyObject *_wrap_DoubleVector_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8159
+ PyObject *resultobj = 0;
8160
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8161
+ std::vector< double >::iterator arg2 ;
8162
+ std::vector< double >::iterator arg3 ;
8163
+ void *argp1 = 0 ;
8164
+ int res1 = 0 ;
8165
+ swig::PySwigIterator *iter2 = 0 ;
8166
+ int res2 ;
8167
+ swig::PySwigIterator *iter3 = 0 ;
8168
+ int res3 ;
8169
+ PyObject * obj0 = 0 ;
8170
+ PyObject * obj1 = 0 ;
8171
+ PyObject * obj2 = 0 ;
8172
+ std::vector< double >::iterator result;
8173
+
8174
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVector_erase",&obj0,&obj1,&obj2)) SWIG_fail;
8175
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8176
+ if (!SWIG_IsOK(res1)) {
8177
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
8178
+ }
8179
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8180
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
8181
+ if (!SWIG_IsOK(res2) || !iter2) {
8182
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
8183
+ } else {
8184
+ swig::PySwigIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter2);
8185
+ if (iter_t) {
8186
+ arg2 = iter_t->get_current();
8187
+ } else {
8188
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
8189
+ }
8190
+ }
8191
+ res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
8192
+ if (!SWIG_IsOK(res3) || !iter3) {
8193
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
8194
+ } else {
8195
+ swig::PySwigIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter3);
8196
+ if (iter_t) {
8197
+ arg3 = iter_t->get_current();
8198
+ } else {
8199
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
8200
+ }
8201
+ }
8202
+ result = (arg1)->erase(arg2,arg3);
8203
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
8204
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8205
+ return resultobj;
8206
+fail:
8207
+ return NULL;
8208
+}
8209
+
8210
+
8211
+SWIGINTERN PyObject *_wrap_DoubleVector_erase(PyObject *self, PyObject *args) {
8212
+ int argc;
8213
+ PyObject *argv[4];
8214
+ int ii;
8215
+
8216
+ if (!PyTuple_Check(args)) SWIG_fail;
8217
+ argc = (int)PyObject_Length(args);
8218
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8219
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
8220
+ }
8221
+ if (argc == 2) {
8222
+ int _v;
8223
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
8224
+ _v = SWIG_CheckState(res);
8225
+ if (_v) {
8226
+ swig::PySwigIterator *iter = 0;
8227
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8228
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter) != 0));
8229
+ if (_v) {
8230
+ return _wrap_DoubleVector_erase__SWIG_0(self, args);
8231
+ }
8232
+ }
8233
+ }
8234
+ if (argc == 3) {
8235
+ int _v;
8236
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
8237
+ _v = SWIG_CheckState(res);
8238
+ if (_v) {
8239
+ swig::PySwigIterator *iter = 0;
8240
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8241
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter) != 0));
8242
+ if (_v) {
8243
+ swig::PySwigIterator *iter = 0;
8244
+ int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8245
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter) != 0));
8246
+ if (_v) {
8247
+ return _wrap_DoubleVector_erase__SWIG_1(self, args);
8248
+ }
8249
+ }
8250
+ }
8251
+ }
8252
+
8253
+fail:
8254
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'DoubleVector_erase'.\n"
8255
+ " Possible C/C++ prototypes are:\n"
8256
+ " erase(std::vector< double > *,std::vector< double >::iterator)\n"
8257
+ " erase(std::vector< double > *,std::vector< double >::iterator,std::vector< double >::iterator)\n");
8258
+ return NULL;
8259
+}
8260
+
8261
+
8262
+SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8263
+ PyObject *resultobj = 0;
8264
+ std::vector< double >::size_type arg1 ;
8265
+ std::vector< double >::value_type *arg2 = 0 ;
8266
+ size_t val1 ;
8267
+ int ecode1 = 0 ;
8268
+ std::vector< double >::value_type temp2 ;
8269
+ double val2 ;
8270
+ int ecode2 = 0 ;
8271
+ PyObject * obj0 = 0 ;
8272
+ PyObject * obj1 = 0 ;
8273
+ std::vector< double > *result = 0 ;
8274
+
8275
+ if (!PyArg_ParseTuple(args,(char *)"OO:new_DoubleVector",&obj0,&obj1)) SWIG_fail;
8276
+ ecode1 = SWIG_AsVal_size_t(obj0, &val1);
8277
+ if (!SWIG_IsOK(ecode1)) {
8278
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
8279
+ }
8280
+ arg1 = static_cast< std::vector< double >::size_type >(val1);
8281
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
8282
+ if (!SWIG_IsOK(ecode2)) {
8283
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleVector" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
8284
+ }
8285
+ temp2 = static_cast< std::vector< double >::value_type >(val2);
8286
+ arg2 = &temp2;
8287
+ result = (std::vector< double > *)new std::vector< double >(arg1,(std::vector< double >::value_type const &)*arg2);
8288
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
8289
+ return resultobj;
8290
+fail:
8291
+ return NULL;
8292
+}
8293
+
8294
+
8295
+SWIGINTERN PyObject *_wrap_new_DoubleVector(PyObject *self, PyObject *args) {
8296
+ int argc;
8297
+ PyObject *argv[3];
8298
+ int ii;
8299
+
8300
+ if (!PyTuple_Check(args)) SWIG_fail;
8301
+ argc = (int)PyObject_Length(args);
8302
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
8303
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
8304
+ }
8305
+ if (argc == 0) {
8306
+ return _wrap_new_DoubleVector__SWIG_0(self, args);
8307
+ }
8308
+ if (argc == 1) {
8309
+ int _v;
8310
+ {
8311
+ int res = SWIG_AsVal_size_t(argv[0], NULL);
8312
+ _v = SWIG_CheckState(res);
8313
+ }
8314
+ if (_v) {
8315
+ return _wrap_new_DoubleVector__SWIG_2(self, args);
8316
+ }
8317
+ }
8318
+ if (argc == 1) {
8319
+ int _v;
8320
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
8321
+ _v = SWIG_CheckState(res);
8322
+ if (_v) {
8323
+ return _wrap_new_DoubleVector__SWIG_1(self, args);
8324
+ }
8325
+ }
8326
+ if (argc == 2) {
8327
+ int _v;
8328
+ {
8329
+ int res = SWIG_AsVal_size_t(argv[0], NULL);
8330
+ _v = SWIG_CheckState(res);
8331
+ }
8332
+ if (_v) {
8333
+ {
8334
+ int res = SWIG_AsVal_double(argv[1], NULL);
8335
+ _v = SWIG_CheckState(res);
8336
+ }
8337
+ if (_v) {
8338
+ return _wrap_new_DoubleVector__SWIG_3(self, args);
8339
+ }
8340
+ }
8341
+ }
8342
+
8343
+fail:
8344
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DoubleVector'.\n"
8345
+ " Possible C/C++ prototypes are:\n"
8346
+ " std::vector< double >()\n"
8347
+ " std::vector< double >(std::vector< double > const &)\n"
8348
+ " std::vector< double >(std::vector< double >::size_type)\n"
8349
+ " std::vector< double >(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
8350
+ return NULL;
8351
+}
8352
+
8353
+
8354
+SWIGINTERN PyObject *_wrap_DoubleVector_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8355
+ PyObject *resultobj = 0;
8356
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8357
+ std::vector< double >::value_type *arg2 = 0 ;
8358
+ void *argp1 = 0 ;
8359
+ int res1 = 0 ;
8360
+ std::vector< double >::value_type temp2 ;
8361
+ double val2 ;
8362
+ int ecode2 = 0 ;
8363
+ PyObject * obj0 = 0 ;
8364
+ PyObject * obj1 = 0 ;
8365
+
8366
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector_push_back",&obj0,&obj1)) SWIG_fail;
8367
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8368
+ if (!SWIG_IsOK(res1)) {
8369
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_push_back" "', argument " "1"" of type '" "std::vector< double > *""'");
8370
+ }
8371
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8372
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
8373
+ if (!SWIG_IsOK(ecode2)) {
8374
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_push_back" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
8375
+ }
8376
+ temp2 = static_cast< std::vector< double >::value_type >(val2);
8377
+ arg2 = &temp2;
8378
+ (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
8379
+ resultobj = SWIG_Py_Void();
8380
+ return resultobj;
8381
+fail:
8382
+ return NULL;
8383
+}
8384
+
8385
+
8386
+SWIGINTERN PyObject *_wrap_DoubleVector_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8387
+ PyObject *resultobj = 0;
8388
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8389
+ void *argp1 = 0 ;
8390
+ int res1 = 0 ;
8391
+ PyObject * obj0 = 0 ;
8392
+ std::vector< double >::value_type *result = 0 ;
8393
+
8394
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_front",&obj0)) SWIG_fail;
8395
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8396
+ if (!SWIG_IsOK(res1)) {
8397
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_front" "', argument " "1"" of type '" "std::vector< double > const *""'");
8398
+ }
8399
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8400
+ {
8401
+ std::vector< double >::value_type const &_result_ref = ((std::vector< double > const *)arg1)->front();
8402
+ result = (std::vector< double >::value_type *) &_result_ref;
8403
+ }
8404
+ resultobj = SWIG_From_double(static_cast< double >(*result));
8405
+ return resultobj;
8406
+fail:
8407
+ return NULL;
8408
+}
8409
+
8410
+
8411
+SWIGINTERN PyObject *_wrap_DoubleVector_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8412
+ PyObject *resultobj = 0;
8413
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8414
+ void *argp1 = 0 ;
8415
+ int res1 = 0 ;
8416
+ PyObject * obj0 = 0 ;
8417
+ std::vector< double >::value_type *result = 0 ;
8418
+
8419
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_back",&obj0)) SWIG_fail;
8420
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8421
+ if (!SWIG_IsOK(res1)) {
8422
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_back" "', argument " "1"" of type '" "std::vector< double > const *""'");
8423
+ }
8424
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8425
+ {
8426
+ std::vector< double >::value_type const &_result_ref = ((std::vector< double > const *)arg1)->back();
8427
+ result = (std::vector< double >::value_type *) &_result_ref;
8428
+ }
8429
+ resultobj = SWIG_From_double(static_cast< double >(*result));
8430
+ return resultobj;
8431
+fail:
8432
+ return NULL;
8433
+}
8434
+
8435
+
8436
+SWIGINTERN PyObject *_wrap_DoubleVector_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8437
+ PyObject *resultobj = 0;
8438
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8439
+ std::vector< double >::size_type arg2 ;
8440
+ std::vector< double >::value_type *arg3 = 0 ;
8441
+ void *argp1 = 0 ;
8442
+ int res1 = 0 ;
8443
+ size_t val2 ;
8444
+ int ecode2 = 0 ;
8445
+ std::vector< double >::value_type temp3 ;
8446
+ double val3 ;
8447
+ int ecode3 = 0 ;
8448
+ PyObject * obj0 = 0 ;
8449
+ PyObject * obj1 = 0 ;
8450
+ PyObject * obj2 = 0 ;
8451
+
8452
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVector_assign",&obj0,&obj1,&obj2)) SWIG_fail;
8453
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8454
+ if (!SWIG_IsOK(res1)) {
8455
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_assign" "', argument " "1"" of type '" "std::vector< double > *""'");
8456
+ }
8457
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8458
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8459
+ if (!SWIG_IsOK(ecode2)) {
8460
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_assign" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
8461
+ }
8462
+ arg2 = static_cast< std::vector< double >::size_type >(val2);
8463
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
8464
+ if (!SWIG_IsOK(ecode3)) {
8465
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_assign" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
8466
+ }
8467
+ temp3 = static_cast< std::vector< double >::value_type >(val3);
8468
+ arg3 = &temp3;
8469
+ (arg1)->assign(arg2,(std::vector< double >::value_type const &)*arg3);
8470
+ resultobj = SWIG_Py_Void();
8471
+ return resultobj;
8472
+fail:
8473
+ return NULL;
8474
+}
8475
+
8476
+
8477
+SWIGINTERN PyObject *_wrap_DoubleVector_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8478
+ PyObject *resultobj = 0;
8479
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8480
+ std::vector< double >::size_type arg2 ;
8481
+ std::vector< double >::value_type *arg3 = 0 ;
8482
+ void *argp1 = 0 ;
8483
+ int res1 = 0 ;
8484
+ size_t val2 ;
8485
+ int ecode2 = 0 ;
8486
+ std::vector< double >::value_type temp3 ;
8487
+ double val3 ;
8488
+ int ecode3 = 0 ;
8489
+ PyObject * obj0 = 0 ;
8490
+ PyObject * obj1 = 0 ;
8491
+ PyObject * obj2 = 0 ;
8492
+
8493
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVector_resize",&obj0,&obj1,&obj2)) SWIG_fail;
8494
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8495
+ if (!SWIG_IsOK(res1)) {
8496
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
8497
+ }
8498
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8499
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8500
+ if (!SWIG_IsOK(ecode2)) {
8501
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
8502
+ }
8503
+ arg2 = static_cast< std::vector< double >::size_type >(val2);
8504
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
8505
+ if (!SWIG_IsOK(ecode3)) {
8506
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_resize" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
8507
+ }
8508
+ temp3 = static_cast< std::vector< double >::value_type >(val3);
8509
+ arg3 = &temp3;
8510
+ (arg1)->resize(arg2,(std::vector< double >::value_type const &)*arg3);
8511
+ resultobj = SWIG_Py_Void();
8512
+ return resultobj;
8513
+fail:
8514
+ return NULL;
8515
+}
8516
+
8517
+
8518
+SWIGINTERN PyObject *_wrap_DoubleVector_resize(PyObject *self, PyObject *args) {
8519
+ int argc;
8520
+ PyObject *argv[4];
8521
+ int ii;
8522
+
8523
+ if (!PyTuple_Check(args)) SWIG_fail;
8524
+ argc = (int)PyObject_Length(args);
8525
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8526
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
8527
+ }
8528
+ if (argc == 2) {
8529
+ int _v;
8530
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
8531
+ _v = SWIG_CheckState(res);
8532
+ if (_v) {
8533
+ {
8534
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
8535
+ _v = SWIG_CheckState(res);
8536
+ }
8537
+ if (_v) {
8538
+ return _wrap_DoubleVector_resize__SWIG_0(self, args);
8539
+ }
8540
+ }
8541
+ }
8542
+ if (argc == 3) {
8543
+ int _v;
8544
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
8545
+ _v = SWIG_CheckState(res);
8546
+ if (_v) {
8547
+ {
8548
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
8549
+ _v = SWIG_CheckState(res);
8550
+ }
8551
+ if (_v) {
8552
+ {
8553
+ int res = SWIG_AsVal_double(argv[2], NULL);
8554
+ _v = SWIG_CheckState(res);
8555
+ }
8556
+ if (_v) {
8557
+ return _wrap_DoubleVector_resize__SWIG_1(self, args);
8558
+ }
8559
+ }
8560
+ }
8561
+ }
8562
+
8563
+fail:
8564
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'DoubleVector_resize'.\n"
8565
+ " Possible C/C++ prototypes are:\n"
8566
+ " resize(std::vector< double > *,std::vector< double >::size_type)\n"
8567
+ " resize(std::vector< double > *,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
8568
+ return NULL;
8569
+}
8570
+
8571
+
8572
+SWIGINTERN PyObject *_wrap_DoubleVector_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8573
+ PyObject *resultobj = 0;
8574
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8575
+ std::vector< double >::iterator arg2 ;
8576
+ std::vector< double >::value_type *arg3 = 0 ;
8577
+ void *argp1 = 0 ;
8578
+ int res1 = 0 ;
8579
+ swig::PySwigIterator *iter2 = 0 ;
8580
+ int res2 ;
8581
+ std::vector< double >::value_type temp3 ;
8582
+ double val3 ;
8583
+ int ecode3 = 0 ;
8584
+ PyObject * obj0 = 0 ;
8585
+ PyObject * obj1 = 0 ;
8586
+ PyObject * obj2 = 0 ;
8587
+ std::vector< double >::iterator result;
8588
+
8589
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVector_insert",&obj0,&obj1,&obj2)) SWIG_fail;
8590
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8591
+ if (!SWIG_IsOK(res1)) {
8592
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
8593
+ }
8594
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8595
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
8596
+ if (!SWIG_IsOK(res2) || !iter2) {
8597
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
8598
+ } else {
8599
+ swig::PySwigIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter2);
8600
+ if (iter_t) {
8601
+ arg2 = iter_t->get_current();
8602
+ } else {
8603
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
8604
+ }
8605
+ }
8606
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
8607
+ if (!SWIG_IsOK(ecode3)) {
8608
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_insert" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
8609
+ }
8610
+ temp3 = static_cast< std::vector< double >::value_type >(val3);
8611
+ arg3 = &temp3;
8612
+ result = (arg1)->insert(arg2,(std::vector< double >::value_type const &)*arg3);
8613
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
8614
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8615
+ return resultobj;
8616
+fail:
8617
+ return NULL;
8618
+}
8619
+
8620
+
8621
+SWIGINTERN PyObject *_wrap_DoubleVector_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8622
+ PyObject *resultobj = 0;
8623
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8624
+ std::vector< double >::iterator arg2 ;
8625
+ std::vector< double >::size_type arg3 ;
8626
+ std::vector< double >::value_type *arg4 = 0 ;
8627
+ void *argp1 = 0 ;
8628
+ int res1 = 0 ;
8629
+ swig::PySwigIterator *iter2 = 0 ;
8630
+ int res2 ;
8631
+ size_t val3 ;
8632
+ int ecode3 = 0 ;
8633
+ std::vector< double >::value_type temp4 ;
8634
+ double val4 ;
8635
+ int ecode4 = 0 ;
8636
+ PyObject * obj0 = 0 ;
8637
+ PyObject * obj1 = 0 ;
8638
+ PyObject * obj2 = 0 ;
8639
+ PyObject * obj3 = 0 ;
8640
+
8641
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:DoubleVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8642
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8643
+ if (!SWIG_IsOK(res1)) {
8644
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
8645
+ }
8646
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8647
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
8648
+ if (!SWIG_IsOK(res2) || !iter2) {
8649
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
8650
+ } else {
8651
+ swig::PySwigIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter2);
8652
+ if (iter_t) {
8653
+ arg2 = iter_t->get_current();
8654
+ } else {
8655
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
8656
+ }
8657
+ }
8658
+ ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8659
+ if (!SWIG_IsOK(ecode3)) {
8660
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_insert" "', argument " "3"" of type '" "std::vector< double >::size_type""'");
8661
+ }
8662
+ arg3 = static_cast< std::vector< double >::size_type >(val3);
8663
+ ecode4 = SWIG_AsVal_double(obj3, &val4);
8664
+ if (!SWIG_IsOK(ecode4)) {
8665
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleVector_insert" "', argument " "4"" of type '" "std::vector< double >::value_type""'");
8666
+ }
8667
+ temp4 = static_cast< std::vector< double >::value_type >(val4);
8668
+ arg4 = &temp4;
8669
+ (arg1)->insert(arg2,arg3,(std::vector< double >::value_type const &)*arg4);
8670
+ resultobj = SWIG_Py_Void();
8671
+ return resultobj;
8672
+fail:
8673
+ return NULL;
8674
+}
8675
+
8676
+
8677
+SWIGINTERN PyObject *_wrap_DoubleVector_insert(PyObject *self, PyObject *args) {
8678
+ int argc;
8679
+ PyObject *argv[5];
8680
+ int ii;
8681
+
8682
+ if (!PyTuple_Check(args)) SWIG_fail;
8683
+ argc = (int)PyObject_Length(args);
8684
+ for (ii = 0; (ii < argc) && (ii < 4); ii++) {
8685
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
8686
+ }
8687
+ if (argc == 3) {
8688
+ int _v;
8689
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
8690
+ _v = SWIG_CheckState(res);
8691
+ if (_v) {
8692
+ swig::PySwigIterator *iter = 0;
8693
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8694
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter) != 0));
8695
+ if (_v) {
8696
+ {
8697
+ int res = SWIG_AsVal_double(argv[2], NULL);
8698
+ _v = SWIG_CheckState(res);
8699
+ }
8700
+ if (_v) {
8701
+ return _wrap_DoubleVector_insert__SWIG_0(self, args);
8702
+ }
8703
+ }
8704
+ }
8705
+ }
8706
+ if (argc == 4) {
8707
+ int _v;
8708
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
8709
+ _v = SWIG_CheckState(res);
8710
+ if (_v) {
8711
+ swig::PySwigIterator *iter = 0;
8712
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8713
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter) != 0));
8714
+ if (_v) {
8715
+ {
8716
+ int res = SWIG_AsVal_size_t(argv[2], NULL);
8717
+ _v = SWIG_CheckState(res);
8718
+ }
8719
+ if (_v) {
8720
+ {
8721
+ int res = SWIG_AsVal_double(argv[3], NULL);
8722
+ _v = SWIG_CheckState(res);
8723
+ }
8724
+ if (_v) {
8725
+ return _wrap_DoubleVector_insert__SWIG_1(self, args);
8726
+ }
8727
+ }
8728
+ }
8729
+ }
8730
+ }
8731
+
8732
+fail:
8733
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'DoubleVector_insert'.\n"
8734
+ " Possible C/C++ prototypes are:\n"
8735
+ " insert(std::vector< double > *,std::vector< double >::iterator,std::vector< double >::value_type const &)\n"
8736
+ " insert(std::vector< double > *,std::vector< double >::iterator,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
8737
+ return NULL;
8738
+}
8739
+
8740
+
8741
+SWIGINTERN PyObject *_wrap_DoubleVector_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8742
+ PyObject *resultobj = 0;
8743
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8744
+ std::vector< double >::size_type arg2 ;
8745
+ void *argp1 = 0 ;
8746
+ int res1 = 0 ;
8747
+ size_t val2 ;
8748
+ int ecode2 = 0 ;
8749
+ PyObject * obj0 = 0 ;
8750
+ PyObject * obj1 = 0 ;
8751
+
8752
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector_reserve",&obj0,&obj1)) SWIG_fail;
8753
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8754
+ if (!SWIG_IsOK(res1)) {
8755
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_reserve" "', argument " "1"" of type '" "std::vector< double > *""'");
8756
+ }
8757
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8758
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8759
+ if (!SWIG_IsOK(ecode2)) {
8760
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_reserve" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
8761
+ }
8762
+ arg2 = static_cast< std::vector< double >::size_type >(val2);
8763
+ (arg1)->reserve(arg2);
8764
+ resultobj = SWIG_Py_Void();
8765
+ return resultobj;
8766
+fail:
8767
+ return NULL;
8768
+}
8769
+
8770
+
8771
+SWIGINTERN PyObject *_wrap_DoubleVector_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8772
+ PyObject *resultobj = 0;
8773
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8774
+ void *argp1 = 0 ;
8775
+ int res1 = 0 ;
8776
+ PyObject * obj0 = 0 ;
8777
+ std::vector< double >::size_type result;
8778
+
8779
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_capacity",&obj0)) SWIG_fail;
8780
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8781
+ if (!SWIG_IsOK(res1)) {
8782
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_capacity" "', argument " "1"" of type '" "std::vector< double > const *""'");
8783
+ }
8784
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8785
+ result = ((std::vector< double > const *)arg1)->capacity();
8786
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
8787
+ return resultobj;
8788
+fail:
8789
+ return NULL;
8790
+}
8791
+
8792
+
8793
+SWIGINTERN PyObject *_wrap_delete_DoubleVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8794
+ PyObject *resultobj = 0;
8795
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8796
+ void *argp1 = 0 ;
8797
+ int res1 = 0 ;
8798
+ PyObject * obj0 = 0 ;
8799
+
8800
+ if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleVector",&obj0)) SWIG_fail;
8801
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_DISOWN | 0 );
8802
+ if (!SWIG_IsOK(res1)) {
8803
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleVector" "', argument " "1"" of type '" "std::vector< double > *""'");
8804
+ }
8805
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8806
+ delete arg1;
8807
+ resultobj = SWIG_Py_Void();
8808
+ return resultobj;
8809
+fail:
8810
+ return NULL;
8811
+}
8812
+
8813
+
8814
+SWIGINTERN PyObject *DoubleVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8815
+ PyObject *obj;
8816
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
8817
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_NewClientData(obj));
8818
+ return SWIG_Py_Void();
8819
+}
8820
+
8821
+SWIGINTERN PyObject *_wrap_new_IntVecIntMap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8822
+ PyObject *resultobj = 0;
8823
+ std::less< int > *arg1 = 0 ;
8824
+ void *argp1 = 0 ;
8825
+ int res1 = 0 ;
8826
+ PyObject * obj0 = 0 ;
8827
+ std::map< int,std::vector< int > > *result = 0 ;
8828
+
8829
+ if (!PyArg_ParseTuple(args,(char *)"O:new_IntVecIntMap",&obj0)) SWIG_fail;
8830
+ res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_int_t, 0 | 0);
8831
+ if (!SWIG_IsOK(res1)) {
8832
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntVecIntMap" "', argument " "1"" of type '" "std::less< int > const &""'");
8833
+ }
8834
+ if (!argp1) {
8835
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntVecIntMap" "', argument " "1"" of type '" "std::less< int > const &""'");
8836
+ }
8837
+ arg1 = reinterpret_cast< std::less< int > * >(argp1);
8838
+ result = (std::map< int,std::vector< int > > *)new std::map< int,std::vector< int > >((std::less< int > const &)*arg1);
8839
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, SWIG_POINTER_NEW | 0 );
8840
+ return resultobj;
8841
+fail:
8842
+ return NULL;
8843
+}
8844
+
8845
+
8846
+SWIGINTERN PyObject *_wrap_IntVecIntMap_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8847
+ PyObject *resultobj = 0;
8848
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
8849
+ PyObject **arg2 = (PyObject **) 0 ;
8850
+ void *argp1 = 0 ;
8851
+ int res1 = 0 ;
8852
+ PyObject * obj0 = 0 ;
8853
+ swig::PySwigIterator *result = 0 ;
8854
+
8855
+ arg2 = &obj0;
8856
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_iterator",&obj0)) SWIG_fail;
8857
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
8858
+ if (!SWIG_IsOK(res1)) {
8859
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_iterator" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
8860
+ }
8861
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
8862
+ result = (swig::PySwigIterator *)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__iterator(arg1,arg2);
8863
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
8864
+ return resultobj;
8865
+fail:
8866
+ return NULL;
8867
+}
8868
+
8869
+
8870
+SWIGINTERN PyObject *_wrap_IntVecIntMap___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8871
+ PyObject *resultobj = 0;
8872
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
8873
+ void *argp1 = 0 ;
8874
+ int res1 = 0 ;
8875
+ PyObject * obj0 = 0 ;
8876
+ bool result;
8877
+
8878
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap___nonzero__",&obj0)) SWIG_fail;
8879
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
8880
+ if (!SWIG_IsOK(res1)) {
8881
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap___nonzero__" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
8882
+ }
8883
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
8884
+ result = (bool)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____nonzero__((std::map< int,std::vector< int > > const *)arg1);
8885
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
8886
+ return resultobj;
8887
+fail:
8888
+ return NULL;
8889
+}
8890
+
8891
+
8892
+SWIGINTERN PyObject *_wrap_IntVecIntMap___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8893
+ PyObject *resultobj = 0;
8894
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
8895
+ void *argp1 = 0 ;
8896
+ int res1 = 0 ;
8897
+ PyObject * obj0 = 0 ;
8898
+ std::map< int,std::vector< int > >::size_type result;
8899
+
8900
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap___len__",&obj0)) SWIG_fail;
8901
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
8902
+ if (!SWIG_IsOK(res1)) {
8903
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap___len__" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
8904
+ }
8905
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
8906
+ result = std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____len__((std::map< int,std::vector< int > > const *)arg1);
8907
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
8908
+ return resultobj;
8909
+fail:
8910
+ return NULL;
8911
+}
8912
+
8913
+
8914
+SWIGINTERN PyObject *_wrap_IntVecIntMap___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8915
+ PyObject *resultobj = 0;
8916
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
8917
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
8918
+ void *argp1 = 0 ;
8919
+ int res1 = 0 ;
8920
+ std::map< int,std::vector< int > >::key_type temp2 ;
8921
+ int val2 ;
8922
+ int ecode2 = 0 ;
8923
+ PyObject * obj0 = 0 ;
8924
+ PyObject * obj1 = 0 ;
8925
+ std::map< int,std::vector< int > >::mapped_type result;
8926
+
8927
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap___getitem__",&obj0,&obj1)) SWIG_fail;
8928
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
8929
+ if (!SWIG_IsOK(res1)) {
8930
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap___getitem__" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
8931
+ }
8932
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
8933
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
8934
+ if (!SWIG_IsOK(ecode2)) {
8935
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap___getitem__" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
8936
+ }
8937
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
8938
+ arg2 = &temp2;
8939
+ try {
8940
+ result = std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____getitem__((std::map< int,std::vector< int > > const *)arg1,(int const &)*arg2);
8941
+ }
8942
+ catch(std::out_of_range &_e) {
8943
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8944
+ }
8945
+
8946
+ resultobj = swig::from(static_cast< std::vector<int,std::allocator< int > > >(result));
8947
+ return resultobj;
8948
+fail:
8949
+ return NULL;
8950
+}
8951
+
8952
+
8953
+SWIGINTERN PyObject *_wrap_IntVecIntMap___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8954
+ PyObject *resultobj = 0;
8955
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
8956
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
8957
+ void *argp1 = 0 ;
8958
+ int res1 = 0 ;
8959
+ std::map< int,std::vector< int > >::key_type temp2 ;
8960
+ int val2 ;
8961
+ int ecode2 = 0 ;
8962
+ PyObject * obj0 = 0 ;
8963
+ PyObject * obj1 = 0 ;
8964
+
8965
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap___delitem__",&obj0,&obj1)) SWIG_fail;
8966
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
8967
+ if (!SWIG_IsOK(res1)) {
8968
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap___delitem__" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
8969
+ }
8970
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
8971
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
8972
+ if (!SWIG_IsOK(ecode2)) {
8973
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap___delitem__" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
8974
+ }
8975
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
8976
+ arg2 = &temp2;
8977
+ try {
8978
+ std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____delitem__(arg1,(int const &)*arg2);
8979
+ }
8980
+ catch(std::out_of_range &_e) {
8981
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8982
+ }
8983
+
8984
+ resultobj = SWIG_Py_Void();
8985
+ return resultobj;
8986
+fail:
8987
+ return NULL;
8988
+}
8989
+
8990
+
8991
+SWIGINTERN PyObject *_wrap_IntVecIntMap_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8992
+ PyObject *resultobj = 0;
8993
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
8994
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
8995
+ void *argp1 = 0 ;
8996
+ int res1 = 0 ;
8997
+ std::map< int,std::vector< int > >::key_type temp2 ;
8998
+ int val2 ;
8999
+ int ecode2 = 0 ;
9000
+ PyObject * obj0 = 0 ;
9001
+ PyObject * obj1 = 0 ;
9002
+ bool result;
9003
+
9004
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_has_key",&obj0,&obj1)) SWIG_fail;
9005
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9006
+ if (!SWIG_IsOK(res1)) {
9007
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_has_key" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
9008
+ }
9009
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9010
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
9011
+ if (!SWIG_IsOK(ecode2)) {
9012
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap_has_key" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
9013
+ }
9014
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
9015
+ arg2 = &temp2;
9016
+ result = (bool)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__has_key((std::map< int,std::vector< int > > const *)arg1,(int const &)*arg2);
9017
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
9018
+ return resultobj;
9019
+fail:
9020
+ return NULL;
9021
+}
9022
+
9023
+
9024
+SWIGINTERN PyObject *_wrap_IntVecIntMap_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9025
+ PyObject *resultobj = 0;
9026
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9027
+ void *argp1 = 0 ;
9028
+ int res1 = 0 ;
9029
+ PyObject * obj0 = 0 ;
9030
+ PyObject *result = 0 ;
9031
+
9032
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_keys",&obj0)) SWIG_fail;
9033
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9034
+ if (!SWIG_IsOK(res1)) {
9035
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_keys" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9036
+ }
9037
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9038
+ result = (PyObject *)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__keys(arg1);
9039
+ resultobj = result;
9040
+ return resultobj;
9041
+fail:
9042
+ return NULL;
9043
+}
9044
+
9045
+
9046
+SWIGINTERN PyObject *_wrap_IntVecIntMap_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9047
+ PyObject *resultobj = 0;
9048
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9049
+ void *argp1 = 0 ;
9050
+ int res1 = 0 ;
9051
+ PyObject * obj0 = 0 ;
9052
+ PyObject *result = 0 ;
9053
+
9054
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_values",&obj0)) SWIG_fail;
9055
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9056
+ if (!SWIG_IsOK(res1)) {
9057
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_values" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9058
+ }
9059
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9060
+ result = (PyObject *)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__values(arg1);
9061
+ resultobj = result;
9062
+ return resultobj;
9063
+fail:
9064
+ return NULL;
9065
+}
9066
+
9067
+
9068
+SWIGINTERN PyObject *_wrap_IntVecIntMap_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9069
+ PyObject *resultobj = 0;
9070
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9071
+ void *argp1 = 0 ;
9072
+ int res1 = 0 ;
9073
+ PyObject * obj0 = 0 ;
9074
+ PyObject *result = 0 ;
9075
+
9076
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_items",&obj0)) SWIG_fail;
9077
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9078
+ if (!SWIG_IsOK(res1)) {
9079
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_items" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9080
+ }
9081
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9082
+ result = (PyObject *)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__items(arg1);
9083
+ resultobj = result;
9084
+ return resultobj;
9085
+fail:
9086
+ return NULL;
9087
+}
9088
+
9089
+
9090
+SWIGINTERN PyObject *_wrap_IntVecIntMap___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9091
+ PyObject *resultobj = 0;
9092
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9093
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
9094
+ void *argp1 = 0 ;
9095
+ int res1 = 0 ;
9096
+ std::map< int,std::vector< int > >::key_type temp2 ;
9097
+ int val2 ;
9098
+ int ecode2 = 0 ;
9099
+ PyObject * obj0 = 0 ;
9100
+ PyObject * obj1 = 0 ;
9101
+ bool result;
9102
+
9103
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap___contains__",&obj0,&obj1)) SWIG_fail;
9104
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9105
+ if (!SWIG_IsOK(res1)) {
9106
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap___contains__" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9107
+ }
9108
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9109
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
9110
+ if (!SWIG_IsOK(ecode2)) {
9111
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap___contains__" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
9112
+ }
9113
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
9114
+ arg2 = &temp2;
9115
+ result = (bool)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____contains__(arg1,(int const &)*arg2);
9116
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
9117
+ return resultobj;
9118
+fail:
9119
+ return NULL;
9120
+}
9121
+
9122
+
9123
+SWIGINTERN PyObject *_wrap_IntVecIntMap_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9124
+ PyObject *resultobj = 0;
9125
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9126
+ PyObject **arg2 = (PyObject **) 0 ;
9127
+ void *argp1 = 0 ;
9128
+ int res1 = 0 ;
9129
+ PyObject * obj0 = 0 ;
9130
+ swig::PySwigIterator *result = 0 ;
9131
+
9132
+ arg2 = &obj0;
9133
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_key_iterator",&obj0)) SWIG_fail;
9134
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9135
+ if (!SWIG_IsOK(res1)) {
9136
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_key_iterator" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9137
+ }
9138
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9139
+ result = (swig::PySwigIterator *)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__key_iterator(arg1,arg2);
9140
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
9141
+ return resultobj;
9142
+fail:
9143
+ return NULL;
9144
+}
9145
+
9146
+
9147
+SWIGINTERN PyObject *_wrap_IntVecIntMap_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9148
+ PyObject *resultobj = 0;
9149
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9150
+ PyObject **arg2 = (PyObject **) 0 ;
9151
+ void *argp1 = 0 ;
9152
+ int res1 = 0 ;
9153
+ PyObject * obj0 = 0 ;
9154
+ swig::PySwigIterator *result = 0 ;
9155
+
9156
+ arg2 = &obj0;
9157
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_value_iterator",&obj0)) SWIG_fail;
9158
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9159
+ if (!SWIG_IsOK(res1)) {
9160
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_value_iterator" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9161
+ }
9162
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9163
+ result = (swig::PySwigIterator *)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__value_iterator(arg1,arg2);
9164
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
9165
+ return resultobj;
9166
+fail:
9167
+ return NULL;
9168
+}
9169
+
9170
+
9171
+SWIGINTERN PyObject *_wrap_IntVecIntMap___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9172
+ PyObject *resultobj = 0;
9173
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9174
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
9175
+ std::map< int,std::vector< int > >::mapped_type *arg3 = 0 ;
9176
+ void *argp1 = 0 ;
9177
+ int res1 = 0 ;
9178
+ std::map< int,std::vector< int > >::key_type temp2 ;
9179
+ int val2 ;
9180
+ int ecode2 = 0 ;
9181
+ int res3 = SWIG_OLDOBJ ;
9182
+ PyObject * obj0 = 0 ;
9183
+ PyObject * obj1 = 0 ;
9184
+ PyObject * obj2 = 0 ;
9185
+
9186
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVecIntMap___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
9187
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9188
+ if (!SWIG_IsOK(res1)) {
9189
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap___setitem__" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9190
+ }
9191
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9192
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
9193
+ if (!SWIG_IsOK(ecode2)) {
9194
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap___setitem__" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
9195
+ }
9196
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
9197
+ arg2 = &temp2;
9198
+ {
9199
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
9200
+ res3 = swig::asptr(obj2, &ptr);
9201
+ if (!SWIG_IsOK(res3)) {
9202
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntVecIntMap___setitem__" "', argument " "3"" of type '" "std::map< int,std::vector< int > >::mapped_type const &""'");
9203
+ }
9204
+ if (!ptr) {
9205
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVecIntMap___setitem__" "', argument " "3"" of type '" "std::map< int,std::vector< int > >::mapped_type const &""'");
9206
+ }
9207
+ arg3 = ptr;
9208
+ }
9209
+ try {
9210
+ std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____setitem__(arg1,(int const &)*arg2,(std::vector< int,std::allocator< int > > const &)*arg3);
9211
+ }
9212
+ catch(std::out_of_range &_e) {
9213
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9214
+ }
9215
+
9216
+ resultobj = SWIG_Py_Void();
9217
+ if (SWIG_IsNewObj(res3)) delete arg3;
9218
+ return resultobj;
9219
+fail:
9220
+ if (SWIG_IsNewObj(res3)) delete arg3;
9221
+ return NULL;
9222
+}
9223
+
9224
+
9225
+SWIGINTERN PyObject *_wrap_new_IntVecIntMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9226
+ PyObject *resultobj = 0;
9227
+ std::map< int,std::vector< int > > *result = 0 ;
9228
+
9229
+ if (!PyArg_ParseTuple(args,(char *)":new_IntVecIntMap")) SWIG_fail;
9230
+ result = (std::map< int,std::vector< int > > *)new std::map< int,std::vector< int > >();
9231
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, SWIG_POINTER_NEW | 0 );
9232
+ return resultobj;
9233
+fail:
9234
+ return NULL;
9235
+}
9236
+
9237
+
9238
+SWIGINTERN PyObject *_wrap_new_IntVecIntMap__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9239
+ PyObject *resultobj = 0;
9240
+ std::map< int,std::vector< int,std::allocator< int > > > *arg1 = 0 ;
9241
+ int res1 = SWIG_OLDOBJ ;
9242
+ PyObject * obj0 = 0 ;
9243
+ std::map< int,std::vector< int > > *result = 0 ;
9244
+
9245
+ if (!PyArg_ParseTuple(args,(char *)"O:new_IntVecIntMap",&obj0)) SWIG_fail;
9246
+ {
9247
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > > *ptr = (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > > *)0;
9248
+ res1 = swig::asptr(obj0, &ptr);
9249
+ if (!SWIG_IsOK(res1)) {
9250
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntVecIntMap" "', argument " "1"" of type '" "std::map< int,std::vector< int,std::allocator< int > > > const &""'");
9251
+ }
9252
+ if (!ptr) {
9253
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntVecIntMap" "', argument " "1"" of type '" "std::map< int,std::vector< int,std::allocator< int > > > const &""'");
9254
+ }
9255
+ arg1 = ptr;
9256
+ }
9257
+ result = (std::map< int,std::vector< int > > *)new std::map< int,std::vector< int > >((std::map< int,std::vector< int,std::allocator< int > > > const &)*arg1);
9258
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, SWIG_POINTER_NEW | 0 );
9259
+ if (SWIG_IsNewObj(res1)) delete arg1;
9260
+ return resultobj;
9261
+fail:
9262
+ if (SWIG_IsNewObj(res1)) delete arg1;
9263
+ return NULL;
9264
+}
9265
+
9266
+
9267
+SWIGINTERN PyObject *_wrap_new_IntVecIntMap(PyObject *self, PyObject *args) {
9268
+ int argc;
9269
+ PyObject *argv[2];
9270
+ int ii;
9271
+
9272
+ if (!PyTuple_Check(args)) SWIG_fail;
9273
+ argc = (int)PyObject_Length(args);
9274
+ for (ii = 0; (ii < argc) && (ii < 1); ii++) {
9275
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
9276
+ }
9277
+ if (argc == 0) {
9278
+ return _wrap_new_IntVecIntMap__SWIG_1(self, args);
9279
+ }
9280
+ if (argc == 1) {
9281
+ int _v;
9282
+ int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_int_t, 0);
9283
+ _v = SWIG_CheckState(res);
9284
+ if (_v) {
9285
+ return _wrap_new_IntVecIntMap__SWIG_0(self, args);
9286
+ }
9287
+ }
9288
+ if (argc == 1) {
9289
+ int _v;
9290
+ int res = swig::asptr(argv[0], (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >**)(0));
9291
+ _v = SWIG_CheckState(res);
9292
+ if (_v) {
9293
+ return _wrap_new_IntVecIntMap__SWIG_2(self, args);
9294
+ }
9295
+ }
9296
+
9297
+fail:
9298
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IntVecIntMap'.\n"
9299
+ " Possible C/C++ prototypes are:\n"
9300
+ " std::map< int,std::vector< int > >(std::less< int > const &)\n"
9301
+ " std::map< int,std::vector< int > >()\n"
9302
+ " std::map< int,std::vector< int > >(std::map< int,std::vector< int,std::allocator< int > > > const &)\n");
9303
+ return NULL;
9304
+}
9305
+
9306
+
9307
+SWIGINTERN PyObject *_wrap_IntVecIntMap_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9308
+ PyObject *resultobj = 0;
9309
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9310
+ void *argp1 = 0 ;
9311
+ int res1 = 0 ;
9312
+ PyObject * obj0 = 0 ;
9313
+ bool result;
9314
+
9315
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_empty",&obj0)) SWIG_fail;
9316
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9317
+ if (!SWIG_IsOK(res1)) {
9318
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_empty" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
9319
+ }
9320
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9321
+ result = (bool)((std::map< int,std::vector< int > > const *)arg1)->empty();
9322
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
9323
+ return resultobj;
9324
+fail:
9325
+ return NULL;
9326
+}
9327
+
9328
+
9329
+SWIGINTERN PyObject *_wrap_IntVecIntMap_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9330
+ PyObject *resultobj = 0;
9331
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9332
+ void *argp1 = 0 ;
9333
+ int res1 = 0 ;
9334
+ PyObject * obj0 = 0 ;
9335
+ std::map< int,std::vector< int > >::size_type result;
9336
+
9337
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_size",&obj0)) SWIG_fail;
9338
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9339
+ if (!SWIG_IsOK(res1)) {
9340
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_size" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
9341
+ }
9342
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9343
+ result = ((std::map< int,std::vector< int > > const *)arg1)->size();
9344
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9345
+ return resultobj;
9346
+fail:
9347
+ return NULL;
9348
+}
9349
+
9350
+
9351
+SWIGINTERN PyObject *_wrap_IntVecIntMap_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9352
+ PyObject *resultobj = 0;
9353
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9354
+ void *argp1 = 0 ;
9355
+ int res1 = 0 ;
9356
+ PyObject * obj0 = 0 ;
9357
+
9358
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_clear",&obj0)) SWIG_fail;
9359
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9360
+ if (!SWIG_IsOK(res1)) {
9361
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_clear" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9362
+ }
9363
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9364
+ (arg1)->clear();
9365
+ resultobj = SWIG_Py_Void();
9366
+ return resultobj;
9367
+fail:
9368
+ return NULL;
9369
+}
9370
+
9371
+
9372
+SWIGINTERN PyObject *_wrap_IntVecIntMap_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9373
+ PyObject *resultobj = 0;
9374
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9375
+ std::map< int,std::vector< int,std::allocator< int > > > *arg2 = 0 ;
9376
+ void *argp1 = 0 ;
9377
+ int res1 = 0 ;
9378
+ void *argp2 = 0 ;
9379
+ int res2 = 0 ;
9380
+ PyObject * obj0 = 0 ;
9381
+ PyObject * obj1 = 0 ;
9382
+
9383
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_swap",&obj0,&obj1)) SWIG_fail;
9384
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9385
+ if (!SWIG_IsOK(res1)) {
9386
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_swap" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9387
+ }
9388
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9389
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 );
9390
+ if (!SWIG_IsOK(res2)) {
9391
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntVecIntMap_swap" "', argument " "2"" of type '" "std::map< int,std::vector< int,std::allocator< int > > > &""'");
9392
+ }
9393
+ if (!argp2) {
9394
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVecIntMap_swap" "', argument " "2"" of type '" "std::map< int,std::vector< int,std::allocator< int > > > &""'");
9395
+ }
9396
+ arg2 = reinterpret_cast< std::map< int,std::vector< int,std::allocator< int > > > * >(argp2);
9397
+ (arg1)->swap(*arg2);
9398
+ resultobj = SWIG_Py_Void();
9399
+ return resultobj;
9400
+fail:
9401
+ return NULL;
9402
+}
9403
+
9404
+
9405
+SWIGINTERN PyObject *_wrap_IntVecIntMap_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9406
+ PyObject *resultobj = 0;
9407
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9408
+ void *argp1 = 0 ;
9409
+ int res1 = 0 ;
9410
+ PyObject * obj0 = 0 ;
9411
+ SwigValueWrapper< std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > > result;
9412
+
9413
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_get_allocator",&obj0)) SWIG_fail;
9414
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9415
+ if (!SWIG_IsOK(res1)) {
9416
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_get_allocator" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
9417
+ }
9418
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9419
+ result = ((std::map< int,std::vector< int > > const *)arg1)->get_allocator();
9420
+ resultobj = SWIG_NewPointerObj((new std::map< int,std::vector< int > >::allocator_type(static_cast< const std::map< int,std::vector< int > >::allocator_type& >(result))), SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
9421
+ return resultobj;
9422
+fail:
9423
+ return NULL;
9424
+}
9425
+
9426
+
9427
+SWIGINTERN PyObject *_wrap_IntVecIntMap_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9428
+ PyObject *resultobj = 0;
9429
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9430
+ void *argp1 = 0 ;
9431
+ int res1 = 0 ;
9432
+ PyObject * obj0 = 0 ;
9433
+ std::map< int,std::vector< int > >::const_iterator result;
9434
+
9435
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_begin",&obj0)) SWIG_fail;
9436
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9437
+ if (!SWIG_IsOK(res1)) {
9438
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_begin" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
9439
+ }
9440
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9441
+ result = ((std::map< int,std::vector< int > > const *)arg1)->begin();
9442
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< int > >::const_iterator & >(result)),
9443
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9444
+ return resultobj;
9445
+fail:
9446
+ return NULL;
9447
+}
9448
+
9449
+
9450
+SWIGINTERN PyObject *_wrap_IntVecIntMap_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9451
+ PyObject *resultobj = 0;
9452
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9453
+ void *argp1 = 0 ;
9454
+ int res1 = 0 ;
9455
+ PyObject * obj0 = 0 ;
9456
+ std::map< int,std::vector< int > >::const_iterator result;
9457
+
9458
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_end",&obj0)) SWIG_fail;
9459
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9460
+ if (!SWIG_IsOK(res1)) {
9461
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_end" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
9462
+ }
9463
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9464
+ result = ((std::map< int,std::vector< int > > const *)arg1)->end();
9465
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< int > >::const_iterator & >(result)),
9466
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9467
+ return resultobj;
9468
+fail:
9469
+ return NULL;
9470
+}
9471
+
9472
+
9473
+SWIGINTERN PyObject *_wrap_IntVecIntMap_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9474
+ PyObject *resultobj = 0;
9475
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9476
+ void *argp1 = 0 ;
9477
+ int res1 = 0 ;
9478
+ PyObject * obj0 = 0 ;
9479
+ std::map< int,std::vector< int > >::const_reverse_iterator result;
9480
+
9481
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_rbegin",&obj0)) SWIG_fail;
9482
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9483
+ if (!SWIG_IsOK(res1)) {
9484
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_rbegin" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
9485
+ }
9486
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9487
+ result = ((std::map< int,std::vector< int > > const *)arg1)->rbegin();
9488
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< int > >::const_reverse_iterator & >(result)),
9489
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9490
+ return resultobj;
9491
+fail:
9492
+ return NULL;
9493
+}
9494
+
9495
+
9496
+SWIGINTERN PyObject *_wrap_IntVecIntMap_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9497
+ PyObject *resultobj = 0;
9498
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9499
+ void *argp1 = 0 ;
9500
+ int res1 = 0 ;
9501
+ PyObject * obj0 = 0 ;
9502
+ std::map< int,std::vector< int > >::const_reverse_iterator result;
9503
+
9504
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_rend",&obj0)) SWIG_fail;
9505
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9506
+ if (!SWIG_IsOK(res1)) {
9507
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_rend" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
9508
+ }
9509
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9510
+ result = ((std::map< int,std::vector< int > > const *)arg1)->rend();
9511
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< int > >::const_reverse_iterator & >(result)),
9512
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9513
+ return resultobj;
9514
+fail:
9515
+ return NULL;
9516
+}
9517
+
9518
+
9519
+SWIGINTERN PyObject *_wrap_IntVecIntMap_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9520
+ PyObject *resultobj = 0;
9521
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9522
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
9523
+ void *argp1 = 0 ;
9524
+ int res1 = 0 ;
9525
+ std::map< int,std::vector< int > >::key_type temp2 ;
9526
+ int val2 ;
9527
+ int ecode2 = 0 ;
9528
+ PyObject * obj0 = 0 ;
9529
+ PyObject * obj1 = 0 ;
9530
+ std::map< int,std::vector< int > >::size_type result;
9531
+
9532
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_erase",&obj0,&obj1)) SWIG_fail;
9533
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9534
+ if (!SWIG_IsOK(res1)) {
9535
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_erase" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9536
+ }
9537
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9538
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
9539
+ if (!SWIG_IsOK(ecode2)) {
9540
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
9541
+ }
9542
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
9543
+ arg2 = &temp2;
9544
+ result = (arg1)->erase((std::map< int,std::vector< int > >::key_type const &)*arg2);
9545
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9546
+ return resultobj;
9547
+fail:
9548
+ return NULL;
9549
+}
9550
+
9551
+
9552
+SWIGINTERN PyObject *_wrap_IntVecIntMap_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9553
+ PyObject *resultobj = 0;
9554
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9555
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
9556
+ void *argp1 = 0 ;
9557
+ int res1 = 0 ;
9558
+ std::map< int,std::vector< int > >::key_type temp2 ;
9559
+ int val2 ;
9560
+ int ecode2 = 0 ;
9561
+ PyObject * obj0 = 0 ;
9562
+ PyObject * obj1 = 0 ;
9563
+ std::map< int,std::vector< int > >::size_type result;
9564
+
9565
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_count",&obj0,&obj1)) SWIG_fail;
9566
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9567
+ if (!SWIG_IsOK(res1)) {
9568
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_count" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
9569
+ }
9570
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9571
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
9572
+ if (!SWIG_IsOK(ecode2)) {
9573
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap_count" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
9574
+ }
9575
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
9576
+ arg2 = &temp2;
9577
+ result = ((std::map< int,std::vector< int > > const *)arg1)->count((std::map< int,std::vector< int > >::key_type const &)*arg2);
9578
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9579
+ return resultobj;
9580
+fail:
9581
+ return NULL;
9582
+}
9583
+
9584
+
9585
+SWIGINTERN PyObject *_wrap_IntVecIntMap_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9586
+ PyObject *resultobj = 0;
9587
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9588
+ std::map< int,std::vector< int > >::iterator arg2 ;
9589
+ void *argp1 = 0 ;
9590
+ int res1 = 0 ;
9591
+ swig::PySwigIterator *iter2 = 0 ;
9592
+ int res2 ;
9593
+ PyObject * obj0 = 0 ;
9594
+ PyObject * obj1 = 0 ;
9595
+
9596
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_erase",&obj0,&obj1)) SWIG_fail;
9597
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9598
+ if (!SWIG_IsOK(res1)) {
9599
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_erase" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9600
+ }
9601
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9602
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
9603
+ if (!SWIG_IsOK(res2) || !iter2) {
9604
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::iterator""'");
9605
+ } else {
9606
+ swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *>(iter2);
9607
+ if (iter_t) {
9608
+ arg2 = iter_t->get_current();
9609
+ } else {
9610
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::iterator""'");
9611
+ }
9612
+ }
9613
+ (arg1)->erase(arg2);
9614
+ resultobj = SWIG_Py_Void();
9615
+ return resultobj;
9616
+fail:
9617
+ return NULL;
9618
+}
9619
+
9620
+
9621
+SWIGINTERN PyObject *_wrap_IntVecIntMap_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9622
+ PyObject *resultobj = 0;
9623
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9624
+ std::map< int,std::vector< int > >::iterator arg2 ;
9625
+ std::map< int,std::vector< int > >::iterator arg3 ;
9626
+ void *argp1 = 0 ;
9627
+ int res1 = 0 ;
9628
+ swig::PySwigIterator *iter2 = 0 ;
9629
+ int res2 ;
9630
+ swig::PySwigIterator *iter3 = 0 ;
9631
+ int res3 ;
9632
+ PyObject * obj0 = 0 ;
9633
+ PyObject * obj1 = 0 ;
9634
+ PyObject * obj2 = 0 ;
9635
+
9636
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVecIntMap_erase",&obj0,&obj1,&obj2)) SWIG_fail;
9637
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9638
+ if (!SWIG_IsOK(res1)) {
9639
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_erase" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9640
+ }
9641
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9642
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
9643
+ if (!SWIG_IsOK(res2) || !iter2) {
9644
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::iterator""'");
9645
+ } else {
9646
+ swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *>(iter2);
9647
+ if (iter_t) {
9648
+ arg2 = iter_t->get_current();
9649
+ } else {
9650
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::iterator""'");
9651
+ }
9652
+ }
9653
+ res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
9654
+ if (!SWIG_IsOK(res3) || !iter3) {
9655
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVecIntMap_erase" "', argument " "3"" of type '" "std::map< int,std::vector< int > >::iterator""'");
9656
+ } else {
9657
+ swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *>(iter3);
9658
+ if (iter_t) {
9659
+ arg3 = iter_t->get_current();
9660
+ } else {
9661
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVecIntMap_erase" "', argument " "3"" of type '" "std::map< int,std::vector< int > >::iterator""'");
9662
+ }
9663
+ }
9664
+ (arg1)->erase(arg2,arg3);
9665
+ resultobj = SWIG_Py_Void();
9666
+ return resultobj;
9667
+fail:
9668
+ return NULL;
9669
+}
9670
+
9671
+
9672
+SWIGINTERN PyObject *_wrap_IntVecIntMap_erase(PyObject *self, PyObject *args) {
9673
+ int argc;
9674
+ PyObject *argv[4];
9675
+ int ii;
9676
+
9677
+ if (!PyTuple_Check(args)) SWIG_fail;
9678
+ argc = (int)PyObject_Length(args);
9679
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
9680
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
9681
+ }
9682
+ if (argc == 2) {
9683
+ int _v;
9684
+ int res = swig::asptr(argv[0], (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >**)(0));
9685
+ _v = SWIG_CheckState(res);
9686
+ if (_v) {
9687
+ swig::PySwigIterator *iter = 0;
9688
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
9689
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *>(iter) != 0));
9690
+ if (_v) {
9691
+ return _wrap_IntVecIntMap_erase__SWIG_1(self, args);
9692
+ }
9693
+ }
9694
+ }
9695
+ if (argc == 2) {
9696
+ int _v;
9697
+ int res = swig::asptr(argv[0], (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >**)(0));
9698
+ _v = SWIG_CheckState(res);
9699
+ if (_v) {
9700
+ {
9701
+ int res = SWIG_AsVal_int(argv[1], NULL);
9702
+ _v = SWIG_CheckState(res);
9703
+ }
9704
+ if (_v) {
9705
+ return _wrap_IntVecIntMap_erase__SWIG_0(self, args);
9706
+ }
9707
+ }
9708
+ }
9709
+ if (argc == 3) {
9710
+ int _v;
9711
+ int res = swig::asptr(argv[0], (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >**)(0));
9712
+ _v = SWIG_CheckState(res);
9713
+ if (_v) {
9714
+ swig::PySwigIterator *iter = 0;
9715
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
9716
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *>(iter) != 0));
9717
+ if (_v) {
9718
+ swig::PySwigIterator *iter = 0;
9719
+ int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
9720
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *>(iter) != 0));
9721
+ if (_v) {
9722
+ return _wrap_IntVecIntMap_erase__SWIG_2(self, args);
9723
+ }
9724
+ }
9725
+ }
9726
+ }
9727
+
9728
+fail:
9729
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IntVecIntMap_erase'.\n"
9730
+ " Possible C/C++ prototypes are:\n"
9731
+ " erase(std::map< int,std::vector< int > > *,std::map< int,std::vector< int > >::key_type const &)\n"
9732
+ " erase(std::map< int,std::vector< int > > *,std::map< int,std::vector< int > >::iterator)\n"
9733
+ " erase(std::map< int,std::vector< int > > *,std::map< int,std::vector< int > >::iterator,std::map< int,std::vector< int > >::iterator)\n");
9734
+ return NULL;
9735
+}
9736
+
9737
+
9738
+SWIGINTERN PyObject *_wrap_IntVecIntMap_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9739
+ PyObject *resultobj = 0;
9740
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9741
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
9742
+ void *argp1 = 0 ;
9743
+ int res1 = 0 ;
9744
+ std::map< int,std::vector< int > >::key_type temp2 ;
9745
+ int val2 ;
9746
+ int ecode2 = 0 ;
9747
+ PyObject * obj0 = 0 ;
9748
+ PyObject * obj1 = 0 ;
9749
+ std::map< int,std::vector< int > >::iterator result;
9750
+
9751
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_find",&obj0,&obj1)) SWIG_fail;
9752
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9753
+ if (!SWIG_IsOK(res1)) {
9754
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_find" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9755
+ }
9756
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9757
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
9758
+ if (!SWIG_IsOK(ecode2)) {
9759
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap_find" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
9760
+ }
9761
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
9762
+ arg2 = &temp2;
9763
+ result = (arg1)->find((std::map< int,std::vector< int > >::key_type const &)*arg2);
9764
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< int > >::iterator & >(result)),
9765
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9766
+ return resultobj;
9767
+fail:
9768
+ return NULL;
9769
+}
9770
+
9771
+
9772
+SWIGINTERN PyObject *_wrap_IntVecIntMap_lower_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9773
+ PyObject *resultobj = 0;
9774
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9775
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
9776
+ void *argp1 = 0 ;
9777
+ int res1 = 0 ;
9778
+ std::map< int,std::vector< int > >::key_type temp2 ;
9779
+ int val2 ;
9780
+ int ecode2 = 0 ;
9781
+ PyObject * obj0 = 0 ;
9782
+ PyObject * obj1 = 0 ;
9783
+ std::map< int,std::vector< int > >::iterator result;
9784
+
9785
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_lower_bound",&obj0,&obj1)) SWIG_fail;
9786
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9787
+ if (!SWIG_IsOK(res1)) {
9788
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_lower_bound" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9789
+ }
9790
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9791
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
9792
+ if (!SWIG_IsOK(ecode2)) {
9793
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap_lower_bound" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
9794
+ }
9795
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
9796
+ arg2 = &temp2;
9797
+ result = (arg1)->lower_bound((std::map< int,std::vector< int > >::key_type const &)*arg2);
9798
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< int > >::iterator & >(result)),
9799
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9800
+ return resultobj;
9801
+fail:
9802
+ return NULL;
9803
+}
9804
+
9805
+
9806
+SWIGINTERN PyObject *_wrap_IntVecIntMap_upper_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9807
+ PyObject *resultobj = 0;
9808
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9809
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
9810
+ void *argp1 = 0 ;
9811
+ int res1 = 0 ;
9812
+ std::map< int,std::vector< int > >::key_type temp2 ;
9813
+ int val2 ;
9814
+ int ecode2 = 0 ;
9815
+ PyObject * obj0 = 0 ;
9816
+ PyObject * obj1 = 0 ;
9817
+ std::map< int,std::vector< int > >::iterator result;
9818
+
9819
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_upper_bound",&obj0,&obj1)) SWIG_fail;
9820
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
9821
+ if (!SWIG_IsOK(res1)) {
9822
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_upper_bound" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9823
+ }
9824
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9825
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
9826
+ if (!SWIG_IsOK(ecode2)) {
9827
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap_upper_bound" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
9828
+ }
9829
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
9830
+ arg2 = &temp2;
9831
+ result = (arg1)->upper_bound((std::map< int,std::vector< int > >::key_type const &)*arg2);
9832
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< int > >::iterator & >(result)),
9833
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9834
+ return resultobj;
9835
+fail:
9836
+ return NULL;
9837
+}
9838
+
9839
+
9840
+SWIGINTERN PyObject *_wrap_delete_IntVecIntMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9841
+ PyObject *resultobj = 0;
9842
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
9843
+ void *argp1 = 0 ;
9844
+ int res1 = 0 ;
9845
+ PyObject * obj0 = 0 ;
9846
+
9847
+ if (!PyArg_ParseTuple(args,(char *)"O:delete_IntVecIntMap",&obj0)) SWIG_fail;
9848
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, SWIG_POINTER_DISOWN | 0 );
9849
+ if (!SWIG_IsOK(res1)) {
9850
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntVecIntMap" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
9851
+ }
9852
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
9853
+ delete arg1;
9854
+ resultobj = SWIG_Py_Void();
9855
+ return resultobj;
9856
+fail:
9857
+ return NULL;
9858
+}
9859
+
9860
+
9861
+SWIGINTERN PyObject *IntVecIntMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9862
+ PyObject *obj;
9863
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
9864
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, SWIG_NewClientData(obj));
9865
+ return SWIG_Py_Void();
9866
+}
9867
+
9868
+SWIGINTERN PyObject *_wrap_new_Nviz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9869
+ PyObject *resultobj = 0;
9870
+ PyObject *arg1 = (PyObject *) 0 ;
9871
+ PyObject * obj0 = 0 ;
9872
+ Nviz *result = 0 ;
9873
+
9874
+ if (!PyArg_ParseTuple(args,(char *)"O:new_Nviz",&obj0)) SWIG_fail;
9875
+ arg1 = obj0;
9876
+ result = (Nviz *)new Nviz(arg1);
9877
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Nviz, SWIG_POINTER_NEW | 0 );
9878
+ return resultobj;
9879
+fail:
9880
+ return NULL;
9881
+}
9882
+
9883
+
9884
+SWIGINTERN PyObject *_wrap_delete_Nviz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9885
+ PyObject *resultobj = 0;
9886
+ Nviz *arg1 = (Nviz *) 0 ;
9887
+ void *argp1 = 0 ;
9888
+ int res1 = 0 ;
9889
+ PyObject * obj0 = 0 ;
9890
+
9891
+ if (!PyArg_ParseTuple(args,(char *)"O:delete_Nviz",&obj0)) SWIG_fail;
9892
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, SWIG_POINTER_DISOWN | 0 );
9893
+ if (!SWIG_IsOK(res1)) {
9894
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nviz" "', argument " "1"" of type '" "Nviz *""'");
9895
+ }
9896
+ arg1 = reinterpret_cast< Nviz * >(argp1);
9897
+ delete arg1;
9898
+ resultobj = SWIG_Py_Void();
9899
+ return resultobj;
9900
+fail:
9901
+ return NULL;
9902
+}
9903
+
9904
+
9905
+SWIGINTERN PyObject *_wrap_Nviz_ResizeWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9906
+ PyObject *resultobj = 0;
9907
+ Nviz *arg1 = (Nviz *) 0 ;
9908
+ int arg2 ;
9909
+ int arg3 ;
9910
+ void *argp1 = 0 ;
9911
+ int res1 = 0 ;
9912
+ int val2 ;
9913
+ int ecode2 = 0 ;
9914
+ int val3 ;
9915
+ int ecode3 = 0 ;
9916
+ PyObject * obj0 = 0 ;
9917
+ PyObject * obj1 = 0 ;
9918
+ PyObject * obj2 = 0 ;
9919
+ int result;
9920
+
9921
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_ResizeWindow",&obj0,&obj1,&obj2)) SWIG_fail;
9922
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
9923
+ if (!SWIG_IsOK(res1)) {
9924
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_ResizeWindow" "', argument " "1"" of type '" "Nviz *""'");
9925
+ }
9926
+ arg1 = reinterpret_cast< Nviz * >(argp1);
9927
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
9928
+ if (!SWIG_IsOK(ecode2)) {
9929
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_ResizeWindow" "', argument " "2"" of type '" "int""'");
9930
+ }
9931
+ arg2 = static_cast< int >(val2);
9932
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
9933
+ if (!SWIG_IsOK(ecode3)) {
9934
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_ResizeWindow" "', argument " "3"" of type '" "int""'");
9935
+ }
9936
+ arg3 = static_cast< int >(val3);
9937
+ result = (int)(arg1)->ResizeWindow(arg2,arg3);
9938
+ resultobj = SWIG_From_int(static_cast< int >(result));
9939
+ return resultobj;
9940
+fail:
9941
+ return NULL;
9942
+}
9943
+
9944
+
9945
+SWIGINTERN PyObject *_wrap_Nviz_SetViewDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9946
+ PyObject *resultobj = 0;
9947
+ Nviz *arg1 = (Nviz *) 0 ;
9948
+ void *argp1 = 0 ;
9949
+ int res1 = 0 ;
9950
+ PyObject * obj0 = 0 ;
9951
+ std::vector< double,std::allocator< double > > result;
9952
+
9953
+ if (!PyArg_ParseTuple(args,(char *)"O:Nviz_SetViewDefault",&obj0)) SWIG_fail;
9954
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
9955
+ if (!SWIG_IsOK(res1)) {
9956
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetViewDefault" "', argument " "1"" of type '" "Nviz *""'");
9957
+ }
9958
+ arg1 = reinterpret_cast< Nviz * >(argp1);
9959
+ result = (arg1)->SetViewDefault();
9960
+ resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
9961
+ return resultobj;
9962
+fail:
9963
+ return NULL;
9964
+}
9965
+
9966
+
9967
+SWIGINTERN PyObject *_wrap_Nviz_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9968
+ PyObject *resultobj = 0;
9969
+ Nviz *arg1 = (Nviz *) 0 ;
9970
+ float arg2 ;
9971
+ float arg3 ;
9972
+ float arg4 ;
9973
+ float arg5 ;
9974
+ float arg6 ;
9975
+ void *argp1 = 0 ;
9976
+ int res1 = 0 ;
9977
+ float val2 ;
9978
+ int ecode2 = 0 ;
9979
+ float val3 ;
9980
+ int ecode3 = 0 ;
9981
+ float val4 ;
9982
+ int ecode4 = 0 ;
9983
+ float val5 ;
9984
+ int ecode5 = 0 ;
9985
+ float val6 ;
9986
+ int ecode6 = 0 ;
9987
+ PyObject * obj0 = 0 ;
9988
+ PyObject * obj1 = 0 ;
9989
+ PyObject * obj2 = 0 ;
9990
+ PyObject * obj3 = 0 ;
9991
+ PyObject * obj4 = 0 ;
9992
+ PyObject * obj5 = 0 ;
9993
+ int result;
9994
+
9995
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Nviz_SetView",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
9996
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
9997
+ if (!SWIG_IsOK(res1)) {
9998
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetView" "', argument " "1"" of type '" "Nviz *""'");
9999
+ }
10000
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10001
+ ecode2 = SWIG_AsVal_float(obj1, &val2);
10002
+ if (!SWIG_IsOK(ecode2)) {
10003
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetView" "', argument " "2"" of type '" "float""'");
10004
+ }
10005
+ arg2 = static_cast< float >(val2);
10006
+ ecode3 = SWIG_AsVal_float(obj2, &val3);
10007
+ if (!SWIG_IsOK(ecode3)) {
10008
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetView" "', argument " "3"" of type '" "float""'");
10009
+ }
10010
+ arg3 = static_cast< float >(val3);
10011
+ ecode4 = SWIG_AsVal_float(obj3, &val4);
10012
+ if (!SWIG_IsOK(ecode4)) {
10013
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Nviz_SetView" "', argument " "4"" of type '" "float""'");
10014
+ }
10015
+ arg4 = static_cast< float >(val4);
10016
+ ecode5 = SWIG_AsVal_float(obj4, &val5);
10017
+ if (!SWIG_IsOK(ecode5)) {
10018
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Nviz_SetView" "', argument " "5"" of type '" "float""'");
10019
+ }
10020
+ arg5 = static_cast< float >(val5);
10021
+ ecode6 = SWIG_AsVal_float(obj5, &val6);
10022
+ if (!SWIG_IsOK(ecode6)) {
10023
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Nviz_SetView" "', argument " "6"" of type '" "float""'");
10024
+ }
10025
+ arg6 = static_cast< float >(val6);
10026
+ result = (int)(arg1)->SetView(arg2,arg3,arg4,arg5,arg6);
10027
+ resultobj = SWIG_From_int(static_cast< int >(result));
10028
+ return resultobj;
10029
+fail:
10030
+ return NULL;
10031
+}
10032
+
10033
+
10034
+SWIGINTERN PyObject *_wrap_Nviz_SetZExag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10035
+ PyObject *resultobj = 0;
10036
+ Nviz *arg1 = (Nviz *) 0 ;
10037
+ float arg2 ;
10038
+ void *argp1 = 0 ;
10039
+ int res1 = 0 ;
10040
+ float val2 ;
10041
+ int ecode2 = 0 ;
10042
+ PyObject * obj0 = 0 ;
10043
+ PyObject * obj1 = 0 ;
10044
+ int result;
10045
+
10046
+ if (!PyArg_ParseTuple(args,(char *)"OO:Nviz_SetZExag",&obj0,&obj1)) SWIG_fail;
10047
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10048
+ if (!SWIG_IsOK(res1)) {
10049
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetZExag" "', argument " "1"" of type '" "Nviz *""'");
10050
+ }
10051
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10052
+ ecode2 = SWIG_AsVal_float(obj1, &val2);
10053
+ if (!SWIG_IsOK(ecode2)) {
10054
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetZExag" "', argument " "2"" of type '" "float""'");
10055
+ }
10056
+ arg2 = static_cast< float >(val2);
10057
+ result = (int)(arg1)->SetZExag(arg2);
10058
+ resultobj = SWIG_From_int(static_cast< int >(result));
10059
+ return resultobj;
10060
+fail:
10061
+ return NULL;
10062
+}
10063
+
10064
+
10065
+SWIGINTERN PyObject *_wrap_Nviz_SetDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10066
+ PyObject *resultobj = 0;
10067
+ Nviz *arg1 = (Nviz *) 0 ;
10068
+ void *arg2 = (void *) 0 ;
10069
+ void *argp1 = 0 ;
10070
+ int res1 = 0 ;
10071
+ int res2 ;
10072
+ PyObject * obj0 = 0 ;
10073
+ PyObject * obj1 = 0 ;
10074
+ int result;
10075
+
10076
+ if (!PyArg_ParseTuple(args,(char *)"OO:Nviz_SetDisplay",&obj0,&obj1)) SWIG_fail;
10077
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10078
+ if (!SWIG_IsOK(res1)) {
10079
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetDisplay" "', argument " "1"" of type '" "Nviz *""'");
10080
+ }
10081
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10082
+ res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
10083
+ if (!SWIG_IsOK(res2)) {
10084
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nviz_SetDisplay" "', argument " "2"" of type '" "void *""'");
10085
+ }
10086
+ result = (int)(arg1)->SetDisplay(arg2);
10087
+ resultobj = SWIG_From_int(static_cast< int >(result));
10088
+ return resultobj;
10089
+fail:
10090
+ return NULL;
10091
+}
10092
+
10093
+
10094
+SWIGINTERN PyObject *_wrap_Nviz_InitView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10095
+ PyObject *resultobj = 0;
10096
+ Nviz *arg1 = (Nviz *) 0 ;
10097
+ void *argp1 = 0 ;
10098
+ int res1 = 0 ;
10099
+ PyObject * obj0 = 0 ;
10100
+
10101
+ if (!PyArg_ParseTuple(args,(char *)"O:Nviz_InitView",&obj0)) SWIG_fail;
10102
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10103
+ if (!SWIG_IsOK(res1)) {
10104
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_InitView" "', argument " "1"" of type '" "Nviz *""'");
10105
+ }
10106
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10107
+ (arg1)->InitView();
10108
+ resultobj = SWIG_Py_Void();
10109
+ return resultobj;
10110
+fail:
10111
+ return NULL;
10112
+}
10113
+
10114
+
10115
+SWIGINTERN PyObject *_wrap_Nviz_SetBgColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10116
+ PyObject *resultobj = 0;
10117
+ Nviz *arg1 = (Nviz *) 0 ;
10118
+ char *arg2 = (char *) 0 ;
10119
+ void *argp1 = 0 ;
10120
+ int res1 = 0 ;
10121
+ int res2 ;
10122
+ char *buf2 = 0 ;
10123
+ int alloc2 = 0 ;
10124
+ PyObject * obj0 = 0 ;
10125
+ PyObject * obj1 = 0 ;
10126
+
10127
+ if (!PyArg_ParseTuple(args,(char *)"OO:Nviz_SetBgColor",&obj0,&obj1)) SWIG_fail;
10128
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10129
+ if (!SWIG_IsOK(res1)) {
10130
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetBgColor" "', argument " "1"" of type '" "Nviz *""'");
10131
+ }
10132
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10133
+ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10134
+ if (!SWIG_IsOK(res2)) {
10135
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nviz_SetBgColor" "', argument " "2"" of type '" "char const *""'");
10136
+ }
10137
+ arg2 = reinterpret_cast< char * >(buf2);
10138
+ (arg1)->SetBgColor((char const *)arg2);
10139
+ resultobj = SWIG_Py_Void();
10140
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10141
+ return resultobj;
10142
+fail:
10143
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10144
+ return NULL;
10145
+}
10146
+
10147
+
10148
+SWIGINTERN PyObject *_wrap_Nviz_SetLightsDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10149
+ PyObject *resultobj = 0;
10150
+ Nviz *arg1 = (Nviz *) 0 ;
10151
+ void *argp1 = 0 ;
10152
+ int res1 = 0 ;
10153
+ PyObject * obj0 = 0 ;
10154
+
10155
+ if (!PyArg_ParseTuple(args,(char *)"O:Nviz_SetLightsDefault",&obj0)) SWIG_fail;
10156
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10157
+ if (!SWIG_IsOK(res1)) {
10158
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetLightsDefault" "', argument " "1"" of type '" "Nviz *""'");
10159
+ }
10160
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10161
+ (arg1)->SetLightsDefault();
10162
+ resultobj = SWIG_Py_Void();
10163
+ return resultobj;
10164
+fail:
10165
+ return NULL;
10166
+}
10167
+
10168
+
10169
+SWIGINTERN PyObject *_wrap_Nviz_LoadSurface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10170
+ PyObject *resultobj = 0;
10171
+ Nviz *arg1 = (Nviz *) 0 ;
10172
+ char *arg2 = (char *) 0 ;
10173
+ char *arg3 = (char *) 0 ;
10174
+ char *arg4 = (char *) 0 ;
10175
+ void *argp1 = 0 ;
10176
+ int res1 = 0 ;
10177
+ int res2 ;
10178
+ char *buf2 = 0 ;
10179
+ int alloc2 = 0 ;
10180
+ int res3 ;
10181
+ char *buf3 = 0 ;
10182
+ int alloc3 = 0 ;
10183
+ int res4 ;
10184
+ char *buf4 = 0 ;
10185
+ int alloc4 = 0 ;
10186
+ PyObject * obj0 = 0 ;
10187
+ PyObject * obj1 = 0 ;
10188
+ PyObject * obj2 = 0 ;
10189
+ PyObject * obj3 = 0 ;
10190
+ int result;
10191
+
10192
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:Nviz_LoadSurface",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10193
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10194
+ if (!SWIG_IsOK(res1)) {
10195
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_LoadSurface" "', argument " "1"" of type '" "Nviz *""'");
10196
+ }
10197
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10198
+ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10199
+ if (!SWIG_IsOK(res2)) {
10200
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nviz_LoadSurface" "', argument " "2"" of type '" "char const *""'");
10201
+ }
10202
+ arg2 = reinterpret_cast< char * >(buf2);
10203
+ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
10204
+ if (!SWIG_IsOK(res3)) {
10205
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Nviz_LoadSurface" "', argument " "3"" of type '" "char const *""'");
10206
+ }
10207
+ arg3 = reinterpret_cast< char * >(buf3);
10208
+ res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
10209
+ if (!SWIG_IsOK(res4)) {
10210
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Nviz_LoadSurface" "', argument " "4"" of type '" "char const *""'");
10211
+ }
10212
+ arg4 = reinterpret_cast< char * >(buf4);
10213
+ result = (int)(arg1)->LoadSurface((char const *)arg2,(char const *)arg3,(char const *)arg4);
10214
+ resultobj = SWIG_From_int(static_cast< int >(result));
10215
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10216
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
10217
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10218
+ return resultobj;
10219
+fail:
10220
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10221
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
10222
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10223
+ return NULL;
10224
+}
10225
+
10226
+
10227
+SWIGINTERN PyObject *_wrap_Nviz_UnloadSurface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10228
+ PyObject *resultobj = 0;
10229
+ Nviz *arg1 = (Nviz *) 0 ;
10230
+ int arg2 ;
10231
+ void *argp1 = 0 ;
10232
+ int res1 = 0 ;
10233
+ int val2 ;
10234
+ int ecode2 = 0 ;
10235
+ PyObject * obj0 = 0 ;
10236
+ PyObject * obj1 = 0 ;
10237
+ int result;
10238
+
10239
+ if (!PyArg_ParseTuple(args,(char *)"OO:Nviz_UnloadSurface",&obj0,&obj1)) SWIG_fail;
10240
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10241
+ if (!SWIG_IsOK(res1)) {
10242
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_UnloadSurface" "', argument " "1"" of type '" "Nviz *""'");
10243
+ }
10244
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10245
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
10246
+ if (!SWIG_IsOK(ecode2)) {
10247
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_UnloadSurface" "', argument " "2"" of type '" "int""'");
10248
+ }
10249
+ arg2 = static_cast< int >(val2);
10250
+ result = (int)(arg1)->UnloadSurface(arg2);
10251
+ resultobj = SWIG_From_int(static_cast< int >(result));
10252
+ return resultobj;
10253
+fail:
10254
+ return NULL;
10255
+}
10256
+
10257
+
10258
+SWIGINTERN PyObject *_wrap_Nviz_LoadVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10259
+ PyObject *resultobj = 0;
10260
+ Nviz *arg1 = (Nviz *) 0 ;
10261
+ char *arg2 = (char *) 0 ;
10262
+ bool arg3 ;
10263
+ void *argp1 = 0 ;
10264
+ int res1 = 0 ;
10265
+ int res2 ;
10266
+ char *buf2 = 0 ;
10267
+ int alloc2 = 0 ;
10268
+ bool val3 ;
10269
+ int ecode3 = 0 ;
10270
+ PyObject * obj0 = 0 ;
10271
+ PyObject * obj1 = 0 ;
10272
+ PyObject * obj2 = 0 ;
10273
+ int result;
10274
+
10275
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_LoadVector",&obj0,&obj1,&obj2)) SWIG_fail;
10276
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10277
+ if (!SWIG_IsOK(res1)) {
10278
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_LoadVector" "', argument " "1"" of type '" "Nviz *""'");
10279
+ }
10280
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10281
+ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10282
+ if (!SWIG_IsOK(res2)) {
10283
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nviz_LoadVector" "', argument " "2"" of type '" "char const *""'");
10284
+ }
10285
+ arg2 = reinterpret_cast< char * >(buf2);
10286
+ ecode3 = SWIG_AsVal_bool(obj2, &val3);
10287
+ if (!SWIG_IsOK(ecode3)) {
10288
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_LoadVector" "', argument " "3"" of type '" "bool""'");
10289
+ }
10290
+ arg3 = static_cast< bool >(val3);
10291
+ result = (int)(arg1)->LoadVector((char const *)arg2,arg3);
10292
+ resultobj = SWIG_From_int(static_cast< int >(result));
10293
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10294
+ return resultobj;
10295
+fail:
10296
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10297
+ return NULL;
10298
+}
10299
+
10300
+
10301
+SWIGINTERN PyObject *_wrap_Nviz_UnloadVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10302
+ PyObject *resultobj = 0;
10303
+ Nviz *arg1 = (Nviz *) 0 ;
10304
+ int arg2 ;
10305
+ bool arg3 ;
10306
+ void *argp1 = 0 ;
10307
+ int res1 = 0 ;
10308
+ int val2 ;
10309
+ int ecode2 = 0 ;
10310
+ bool val3 ;
10311
+ int ecode3 = 0 ;
10312
+ PyObject * obj0 = 0 ;
10313
+ PyObject * obj1 = 0 ;
10314
+ PyObject * obj2 = 0 ;
10315
+ int result;
10316
+
10317
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_UnloadVector",&obj0,&obj1,&obj2)) SWIG_fail;
10318
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10319
+ if (!SWIG_IsOK(res1)) {
10320
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_UnloadVector" "', argument " "1"" of type '" "Nviz *""'");
10321
+ }
10322
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10323
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
10324
+ if (!SWIG_IsOK(ecode2)) {
10325
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_UnloadVector" "', argument " "2"" of type '" "int""'");
10326
+ }
10327
+ arg2 = static_cast< int >(val2);
10328
+ ecode3 = SWIG_AsVal_bool(obj2, &val3);
10329
+ if (!SWIG_IsOK(ecode3)) {
10330
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_UnloadVector" "', argument " "3"" of type '" "bool""'");
10331
+ }
10332
+ arg3 = static_cast< bool >(val3);
10333
+ result = (int)(arg1)->UnloadVector(arg2,arg3);
10334
+ resultobj = SWIG_From_int(static_cast< int >(result));
10335
+ return resultobj;
10336
+fail:
10337
+ return NULL;
10338
+}
10339
+
10340
+
10341
+SWIGINTERN PyObject *_wrap_Nviz_LoadVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10342
+ PyObject *resultobj = 0;
10343
+ Nviz *arg1 = (Nviz *) 0 ;
10344
+ char *arg2 = (char *) 0 ;
10345
+ char *arg3 = (char *) 0 ;
10346
+ char *arg4 = (char *) 0 ;
10347
+ void *argp1 = 0 ;
10348
+ int res1 = 0 ;
10349
+ int res2 ;
10350
+ char *buf2 = 0 ;
10351
+ int alloc2 = 0 ;
10352
+ int res3 ;
10353
+ char *buf3 = 0 ;
10354
+ int alloc3 = 0 ;
10355
+ int res4 ;
10356
+ char *buf4 = 0 ;
10357
+ int alloc4 = 0 ;
10358
+ PyObject * obj0 = 0 ;
10359
+ PyObject * obj1 = 0 ;
10360
+ PyObject * obj2 = 0 ;
10361
+ PyObject * obj3 = 0 ;
10362
+ int result;
10363
+
10364
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:Nviz_LoadVolume",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10365
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10366
+ if (!SWIG_IsOK(res1)) {
10367
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_LoadVolume" "', argument " "1"" of type '" "Nviz *""'");
10368
+ }
10369
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10370
+ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10371
+ if (!SWIG_IsOK(res2)) {
10372
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nviz_LoadVolume" "', argument " "2"" of type '" "char const *""'");
10373
+ }
10374
+ arg2 = reinterpret_cast< char * >(buf2);
10375
+ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
10376
+ if (!SWIG_IsOK(res3)) {
10377
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Nviz_LoadVolume" "', argument " "3"" of type '" "char const *""'");
10378
+ }
10379
+ arg3 = reinterpret_cast< char * >(buf3);
10380
+ res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
10381
+ if (!SWIG_IsOK(res4)) {
10382
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Nviz_LoadVolume" "', argument " "4"" of type '" "char const *""'");
10383
+ }
10384
+ arg4 = reinterpret_cast< char * >(buf4);
10385
+ result = (int)(arg1)->LoadVolume((char const *)arg2,(char const *)arg3,(char const *)arg4);
10386
+ resultobj = SWIG_From_int(static_cast< int >(result));
10387
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10388
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
10389
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10390
+ return resultobj;
10391
+fail:
10392
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10393
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
10394
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10395
+ return NULL;
10396
+}
10397
+
10398
+
10399
+SWIGINTERN PyObject *_wrap_Nviz_UnloadVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10400
+ PyObject *resultobj = 0;
10401
+ Nviz *arg1 = (Nviz *) 0 ;
10402
+ int arg2 ;
10403
+ void *argp1 = 0 ;
10404
+ int res1 = 0 ;
10405
+ int val2 ;
10406
+ int ecode2 = 0 ;
10407
+ PyObject * obj0 = 0 ;
10408
+ PyObject * obj1 = 0 ;
10409
+ int result;
10410
+
10411
+ if (!PyArg_ParseTuple(args,(char *)"OO:Nviz_UnloadVolume",&obj0,&obj1)) SWIG_fail;
10412
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10413
+ if (!SWIG_IsOK(res1)) {
10414
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_UnloadVolume" "', argument " "1"" of type '" "Nviz *""'");
10415
+ }
10416
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10417
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
10418
+ if (!SWIG_IsOK(ecode2)) {
10419
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_UnloadVolume" "', argument " "2"" of type '" "int""'");
10420
+ }
10421
+ arg2 = static_cast< int >(val2);
10422
+ result = (int)(arg1)->UnloadVolume(arg2);
10423
+ resultobj = SWIG_From_int(static_cast< int >(result));
10424
+ return resultobj;
10425
+fail:
10426
+ return NULL;
10427
+}
10428
+
10429
+
10430
+SWIGINTERN PyObject *_wrap_Nviz_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10431
+ PyObject *resultobj = 0;
10432
+ Nviz *arg1 = (Nviz *) 0 ;
10433
+ bool arg2 ;
10434
+ int arg3 ;
10435
+ void *argp1 = 0 ;
10436
+ int res1 = 0 ;
10437
+ bool val2 ;
10438
+ int ecode2 = 0 ;
10439
+ int val3 ;
10440
+ int ecode3 = 0 ;
10441
+ PyObject * obj0 = 0 ;
10442
+ PyObject * obj1 = 0 ;
10443
+ PyObject * obj2 = 0 ;
10444
+
10445
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_Draw",&obj0,&obj1,&obj2)) SWIG_fail;
10446
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10447
+ if (!SWIG_IsOK(res1)) {
10448
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_Draw" "', argument " "1"" of type '" "Nviz *""'");
10449
+ }
10450
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10451
+ ecode2 = SWIG_AsVal_bool(obj1, &val2);
10452
+ if (!SWIG_IsOK(ecode2)) {
10453
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_Draw" "', argument " "2"" of type '" "bool""'");
10454
+ }
10455
+ arg2 = static_cast< bool >(val2);
10456
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
10457
+ if (!SWIG_IsOK(ecode3)) {
10458
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_Draw" "', argument " "3"" of type '" "int""'");
10459
+ }
10460
+ arg3 = static_cast< int >(val3);
10461
+ (arg1)->Draw(arg2,arg3);
10462
+ resultobj = SWIG_Py_Void();
10463
+ return resultobj;
10464
+fail:
10465
+ return NULL;
10466
+}
10467
+
10468
+
10469
+SWIGINTERN PyObject *_wrap_Nviz_EraseMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10470
+ PyObject *resultobj = 0;
10471
+ Nviz *arg1 = (Nviz *) 0 ;
10472
+ void *argp1 = 0 ;
10473
+ int res1 = 0 ;
10474
+ PyObject * obj0 = 0 ;
10475
+
10476
+ if (!PyArg_ParseTuple(args,(char *)"O:Nviz_EraseMap",&obj0)) SWIG_fail;
10477
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10478
+ if (!SWIG_IsOK(res1)) {
10479
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_EraseMap" "', argument " "1"" of type '" "Nviz *""'");
10480
+ }
10481
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10482
+ (arg1)->EraseMap();
10483
+ resultobj = SWIG_Py_Void();
10484
+ return resultobj;
10485
+fail:
10486
+ return NULL;
10487
+}
10488
+
10489
+
10490
+SWIGINTERN PyObject *_wrap_Nviz_SetSurfaceTopo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10491
+ PyObject *resultobj = 0;
10492
+ Nviz *arg1 = (Nviz *) 0 ;
10493
+ int arg2 ;
10494
+ bool arg3 ;
10495
+ char *arg4 = (char *) 0 ;
10496
+ void *argp1 = 0 ;
10497
+ int res1 = 0 ;
10498
+ int val2 ;
10499
+ int ecode2 = 0 ;
10500
+ bool val3 ;
10501
+ int ecode3 = 0 ;
10502
+ int res4 ;
10503
+ char *buf4 = 0 ;
10504
+ int alloc4 = 0 ;
10505
+ PyObject * obj0 = 0 ;
10506
+ PyObject * obj1 = 0 ;
10507
+ PyObject * obj2 = 0 ;
10508
+ PyObject * obj3 = 0 ;
10509
+ int result;
10510
+
10511
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:Nviz_SetSurfaceTopo",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10512
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10513
+ if (!SWIG_IsOK(res1)) {
10514
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetSurfaceTopo" "', argument " "1"" of type '" "Nviz *""'");
10515
+ }
10516
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10517
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
10518
+ if (!SWIG_IsOK(ecode2)) {
10519
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetSurfaceTopo" "', argument " "2"" of type '" "int""'");
10520
+ }
10521
+ arg2 = static_cast< int >(val2);
10522
+ ecode3 = SWIG_AsVal_bool(obj2, &val3);
10523
+ if (!SWIG_IsOK(ecode3)) {
10524
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetSurfaceTopo" "', argument " "3"" of type '" "bool""'");
10525
+ }
10526
+ arg3 = static_cast< bool >(val3);
10527
+ res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
10528
+ if (!SWIG_IsOK(res4)) {
10529
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Nviz_SetSurfaceTopo" "', argument " "4"" of type '" "char const *""'");
10530
+ }
10531
+ arg4 = reinterpret_cast< char * >(buf4);
10532
+ result = (int)(arg1)->SetSurfaceTopo(arg2,arg3,(char const *)arg4);
10533
+ resultobj = SWIG_From_int(static_cast< int >(result));
10534
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10535
+ return resultobj;
10536
+fail:
10537
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10538
+ return NULL;
10539
+}
10540
+
10541
+
10542
+SWIGINTERN PyObject *_wrap_Nviz_SetSurfaceColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10543
+ PyObject *resultobj = 0;
10544
+ Nviz *arg1 = (Nviz *) 0 ;
10545
+ int arg2 ;
10546
+ bool arg3 ;
10547
+ char *arg4 = (char *) 0 ;
10548
+ void *argp1 = 0 ;
10549
+ int res1 = 0 ;
10550
+ int val2 ;
10551
+ int ecode2 = 0 ;
10552
+ bool val3 ;
10553
+ int ecode3 = 0 ;
10554
+ int res4 ;
10555
+ char *buf4 = 0 ;
10556
+ int alloc4 = 0 ;
10557
+ PyObject * obj0 = 0 ;
10558
+ PyObject * obj1 = 0 ;
10559
+ PyObject * obj2 = 0 ;
10560
+ PyObject * obj3 = 0 ;
10561
+ int result;
10562
+
10563
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:Nviz_SetSurfaceColor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10564
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10565
+ if (!SWIG_IsOK(res1)) {
10566
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetSurfaceColor" "', argument " "1"" of type '" "Nviz *""'");
10567
+ }
10568
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10569
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
10570
+ if (!SWIG_IsOK(ecode2)) {
10571
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetSurfaceColor" "', argument " "2"" of type '" "int""'");
10572
+ }
10573
+ arg2 = static_cast< int >(val2);
10574
+ ecode3 = SWIG_AsVal_bool(obj2, &val3);
10575
+ if (!SWIG_IsOK(ecode3)) {
10576
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetSurfaceColor" "', argument " "3"" of type '" "bool""'");
10577
+ }
10578
+ arg3 = static_cast< bool >(val3);
10579
+ res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
10580
+ if (!SWIG_IsOK(res4)) {
10581
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Nviz_SetSurfaceColor" "', argument " "4"" of type '" "char const *""'");
10582
+ }
10583
+ arg4 = reinterpret_cast< char * >(buf4);
10584
+ result = (int)(arg1)->SetSurfaceColor(arg2,arg3,(char const *)arg4);
10585
+ resultobj = SWIG_From_int(static_cast< int >(result));
10586
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10587
+ return resultobj;
10588
+fail:
10589
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10590
+ return NULL;
10591
+}
10592
+
10593
+
10594
+SWIGINTERN PyObject *_wrap_Nviz_SetSurfaceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10595
+ PyObject *resultobj = 0;
10596
+ Nviz *arg1 = (Nviz *) 0 ;
10597
+ int arg2 ;
10598
+ bool arg3 ;
10599
+ char *arg4 = (char *) 0 ;
10600
+ void *argp1 = 0 ;
10601
+ int res1 = 0 ;
10602
+ int val2 ;
10603
+ int ecode2 = 0 ;
10604
+ bool val3 ;
10605
+ int ecode3 = 0 ;
10606
+ int res4 ;
10607
+ char *buf4 = 0 ;
10608
+ int alloc4 = 0 ;
10609
+ PyObject * obj0 = 0 ;
10610
+ PyObject * obj1 = 0 ;
10611
+ PyObject * obj2 = 0 ;
10612
+ PyObject * obj3 = 0 ;
10613
+ int result;
10614
+
10615
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:Nviz_SetSurfaceMask",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10616
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10617
+ if (!SWIG_IsOK(res1)) {
10618
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetSurfaceMask" "', argument " "1"" of type '" "Nviz *""'");
10619
+ }
10620
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10621
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
10622
+ if (!SWIG_IsOK(ecode2)) {
10623
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetSurfaceMask" "', argument " "2"" of type '" "int""'");
10624
+ }
10625
+ arg2 = static_cast< int >(val2);
10626
+ ecode3 = SWIG_AsVal_bool(obj2, &val3);
10627
+ if (!SWIG_IsOK(ecode3)) {
10628
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetSurfaceMask" "', argument " "3"" of type '" "bool""'");
10629
+ }
10630
+ arg3 = static_cast< bool >(val3);
10631
+ res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
10632
+ if (!SWIG_IsOK(res4)) {
10633
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Nviz_SetSurfaceMask" "', argument " "4"" of type '" "char const *""'");
10634
+ }
10635
+ arg4 = reinterpret_cast< char * >(buf4);
10636
+ result = (int)(arg1)->SetSurfaceMask(arg2,arg3,(char const *)arg4);
10637
+ resultobj = SWIG_From_int(static_cast< int >(result));
10638
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10639
+ return resultobj;
10640
+fail:
10641
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10642
+ return NULL;
10643
+}
10644
+
10645
+
10646
+SWIGINTERN PyObject *_wrap_Nviz_SetSurfaceTransp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10647
+ PyObject *resultobj = 0;
10648
+ Nviz *arg1 = (Nviz *) 0 ;
10649
+ int arg2 ;
10650
+ bool arg3 ;
10651
+ char *arg4 = (char *) 0 ;
10652
+ void *argp1 = 0 ;
10653
+ int res1 = 0 ;
10654
+ int val2 ;
10655
+ int ecode2 = 0 ;
10656
+ bool val3 ;
10657
+ int ecode3 = 0 ;
10658
+ int res4 ;
10659
+ char *buf4 = 0 ;
10660
+ int alloc4 = 0 ;
10661
+ PyObject * obj0 = 0 ;
10662
+ PyObject * obj1 = 0 ;
10663
+ PyObject * obj2 = 0 ;
10664
+ PyObject * obj3 = 0 ;
10665
+ int result;
10666
+
10667
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:Nviz_SetSurfaceTransp",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10668
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10669
+ if (!SWIG_IsOK(res1)) {
10670
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetSurfaceTransp" "', argument " "1"" of type '" "Nviz *""'");
10671
+ }
10672
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10673
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
10674
+ if (!SWIG_IsOK(ecode2)) {
10675
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetSurfaceTransp" "', argument " "2"" of type '" "int""'");
10676
+ }
10677
+ arg2 = static_cast< int >(val2);
10678
+ ecode3 = SWIG_AsVal_bool(obj2, &val3);
10679
+ if (!SWIG_IsOK(ecode3)) {
10680
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetSurfaceTransp" "', argument " "3"" of type '" "bool""'");
10681
+ }
10682
+ arg3 = static_cast< bool >(val3);
10683
+ res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
10684
+ if (!SWIG_IsOK(res4)) {
10685
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Nviz_SetSurfaceTransp" "', argument " "4"" of type '" "char const *""'");
10686
+ }
10687
+ arg4 = reinterpret_cast< char * >(buf4);
10688
+ result = (int)(arg1)->SetSurfaceTransp(arg2,arg3,(char const *)arg4);
10689
+ resultobj = SWIG_From_int(static_cast< int >(result));
10690
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10691
+ return resultobj;
10692
+fail:
10693
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10694
+ return NULL;
10695
+}
10696
+
10697
+
10698
+SWIGINTERN PyObject *_wrap_Nviz_SetSurfaceShine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10699
+ PyObject *resultobj = 0;
10700
+ Nviz *arg1 = (Nviz *) 0 ;
10701
+ int arg2 ;
10702
+ bool arg3 ;
10703
+ char *arg4 = (char *) 0 ;
10704
+ void *argp1 = 0 ;
10705
+ int res1 = 0 ;
10706
+ int val2 ;
10707
+ int ecode2 = 0 ;
10708
+ bool val3 ;
10709
+ int ecode3 = 0 ;
10710
+ int res4 ;
10711
+ char *buf4 = 0 ;
10712
+ int alloc4 = 0 ;
10713
+ PyObject * obj0 = 0 ;
10714
+ PyObject * obj1 = 0 ;
10715
+ PyObject * obj2 = 0 ;
10716
+ PyObject * obj3 = 0 ;
10717
+ int result;
10718
+
10719
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:Nviz_SetSurfaceShine",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10720
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10721
+ if (!SWIG_IsOK(res1)) {
10722
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetSurfaceShine" "', argument " "1"" of type '" "Nviz *""'");
10723
+ }
10724
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10725
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
10726
+ if (!SWIG_IsOK(ecode2)) {
10727
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetSurfaceShine" "', argument " "2"" of type '" "int""'");
10728
+ }
10729
+ arg2 = static_cast< int >(val2);
10730
+ ecode3 = SWIG_AsVal_bool(obj2, &val3);
10731
+ if (!SWIG_IsOK(ecode3)) {
10732
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetSurfaceShine" "', argument " "3"" of type '" "bool""'");
10733
+ }
10734
+ arg3 = static_cast< bool >(val3);
10735
+ res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
10736
+ if (!SWIG_IsOK(res4)) {
10737
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Nviz_SetSurfaceShine" "', argument " "4"" of type '" "char const *""'");
10738
+ }
10739
+ arg4 = reinterpret_cast< char * >(buf4);
10740
+ result = (int)(arg1)->SetSurfaceShine(arg2,arg3,(char const *)arg4);
10741
+ resultobj = SWIG_From_int(static_cast< int >(result));
10742
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10743
+ return resultobj;
10744
+fail:
10745
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10746
+ return NULL;
10747
+}
10748
+
10749
+
10750
+SWIGINTERN PyObject *_wrap_Nviz_SetSurfaceEmit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10751
+ PyObject *resultobj = 0;
10752
+ Nviz *arg1 = (Nviz *) 0 ;
10753
+ int arg2 ;
10754
+ bool arg3 ;
10755
+ char *arg4 = (char *) 0 ;
10756
+ void *argp1 = 0 ;
10757
+ int res1 = 0 ;
10758
+ int val2 ;
10759
+ int ecode2 = 0 ;
10760
+ bool val3 ;
10761
+ int ecode3 = 0 ;
10762
+ int res4 ;
10763
+ char *buf4 = 0 ;
10764
+ int alloc4 = 0 ;
10765
+ PyObject * obj0 = 0 ;
10766
+ PyObject * obj1 = 0 ;
10767
+ PyObject * obj2 = 0 ;
10768
+ PyObject * obj3 = 0 ;
10769
+ int result;
10770
+
10771
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:Nviz_SetSurfaceEmit",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10772
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10773
+ if (!SWIG_IsOK(res1)) {
10774
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetSurfaceEmit" "', argument " "1"" of type '" "Nviz *""'");
10775
+ }
10776
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10777
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
10778
+ if (!SWIG_IsOK(ecode2)) {
10779
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetSurfaceEmit" "', argument " "2"" of type '" "int""'");
10780
+ }
10781
+ arg2 = static_cast< int >(val2);
10782
+ ecode3 = SWIG_AsVal_bool(obj2, &val3);
10783
+ if (!SWIG_IsOK(ecode3)) {
10784
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetSurfaceEmit" "', argument " "3"" of type '" "bool""'");
10785
+ }
10786
+ arg3 = static_cast< bool >(val3);
10787
+ res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
10788
+ if (!SWIG_IsOK(res4)) {
10789
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Nviz_SetSurfaceEmit" "', argument " "4"" of type '" "char const *""'");
10790
+ }
10791
+ arg4 = reinterpret_cast< char * >(buf4);
10792
+ result = (int)(arg1)->SetSurfaceEmit(arg2,arg3,(char const *)arg4);
10793
+ resultobj = SWIG_From_int(static_cast< int >(result));
10794
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10795
+ return resultobj;
10796
+fail:
10797
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10798
+ return NULL;
10799
+}
10800
+
10801
+
10802
+SWIGINTERN PyObject *_wrap_Nviz_UnsetSurfaceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10803
+ PyObject *resultobj = 0;
10804
+ Nviz *arg1 = (Nviz *) 0 ;
10805
+ int arg2 ;
10806
+ void *argp1 = 0 ;
10807
+ int res1 = 0 ;
10808
+ int val2 ;
10809
+ int ecode2 = 0 ;
10810
+ PyObject * obj0 = 0 ;
10811
+ PyObject * obj1 = 0 ;
10812
+ int result;
10813
+
10814
+ if (!PyArg_ParseTuple(args,(char *)"OO:Nviz_UnsetSurfaceMask",&obj0,&obj1)) SWIG_fail;
10815
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10816
+ if (!SWIG_IsOK(res1)) {
10817
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_UnsetSurfaceMask" "', argument " "1"" of type '" "Nviz *""'");
10818
+ }
10819
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10820
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
10821
+ if (!SWIG_IsOK(ecode2)) {
10822
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_UnsetSurfaceMask" "', argument " "2"" of type '" "int""'");
10823
+ }
10824
+ arg2 = static_cast< int >(val2);
10825
+ result = (int)(arg1)->UnsetSurfaceMask(arg2);
10826
+ resultobj = SWIG_From_int(static_cast< int >(result));
10827
+ return resultobj;
10828
+fail:
10829
+ return NULL;
10830
+}
10831
+
10832
+
10833
+SWIGINTERN PyObject *_wrap_Nviz_UnsetSurfaceTransp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10834
+ PyObject *resultobj = 0;
10835
+ Nviz *arg1 = (Nviz *) 0 ;
10836
+ int arg2 ;
10837
+ void *argp1 = 0 ;
10838
+ int res1 = 0 ;
10839
+ int val2 ;
10840
+ int ecode2 = 0 ;
10841
+ PyObject * obj0 = 0 ;
10842
+ PyObject * obj1 = 0 ;
10843
+ int result;
10844
+
10845
+ if (!PyArg_ParseTuple(args,(char *)"OO:Nviz_UnsetSurfaceTransp",&obj0,&obj1)) SWIG_fail;
10846
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10847
+ if (!SWIG_IsOK(res1)) {
10848
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_UnsetSurfaceTransp" "', argument " "1"" of type '" "Nviz *""'");
10849
+ }
10850
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10851
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
10852
+ if (!SWIG_IsOK(ecode2)) {
10853
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_UnsetSurfaceTransp" "', argument " "2"" of type '" "int""'");
10854
+ }
10855
+ arg2 = static_cast< int >(val2);
10856
+ result = (int)(arg1)->UnsetSurfaceTransp(arg2);
10857
+ resultobj = SWIG_From_int(static_cast< int >(result));
10858
+ return resultobj;
10859
+fail:
10860
+ return NULL;
10861
+}
10862
+
10863
+
10864
+SWIGINTERN PyObject *_wrap_Nviz_UnsetSurfaceEmit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10865
+ PyObject *resultobj = 0;
10866
+ Nviz *arg1 = (Nviz *) 0 ;
10867
+ int arg2 ;
10868
+ void *argp1 = 0 ;
10869
+ int res1 = 0 ;
10870
+ int val2 ;
10871
+ int ecode2 = 0 ;
10872
+ PyObject * obj0 = 0 ;
10873
+ PyObject * obj1 = 0 ;
10874
+ int result;
10875
+
10876
+ if (!PyArg_ParseTuple(args,(char *)"OO:Nviz_UnsetSurfaceEmit",&obj0,&obj1)) SWIG_fail;
10877
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10878
+ if (!SWIG_IsOK(res1)) {
10879
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_UnsetSurfaceEmit" "', argument " "1"" of type '" "Nviz *""'");
10880
+ }
10881
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10882
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
10883
+ if (!SWIG_IsOK(ecode2)) {
10884
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_UnsetSurfaceEmit" "', argument " "2"" of type '" "int""'");
10885
+ }
10886
+ arg2 = static_cast< int >(val2);
10887
+ result = (int)(arg1)->UnsetSurfaceEmit(arg2);
10888
+ resultobj = SWIG_From_int(static_cast< int >(result));
10889
+ return resultobj;
10890
+fail:
10891
+ return NULL;
10892
+}
10893
+
10894
+
10895
+SWIGINTERN PyObject *_wrap_Nviz_SetSurfaceRes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10896
+ PyObject *resultobj = 0;
10897
+ Nviz *arg1 = (Nviz *) 0 ;
10898
+ int arg2 ;
10899
+ int arg3 ;
10900
+ int arg4 ;
10901
+ void *argp1 = 0 ;
10902
+ int res1 = 0 ;
10903
+ int val2 ;
10904
+ int ecode2 = 0 ;
10905
+ int val3 ;
10906
+ int ecode3 = 0 ;
10907
+ int val4 ;
10908
+ int ecode4 = 0 ;
10909
+ PyObject * obj0 = 0 ;
10910
+ PyObject * obj1 = 0 ;
10911
+ PyObject * obj2 = 0 ;
10912
+ PyObject * obj3 = 0 ;
10913
+ int result;
10914
+
10915
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:Nviz_SetSurfaceRes",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10916
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10917
+ if (!SWIG_IsOK(res1)) {
10918
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetSurfaceRes" "', argument " "1"" of type '" "Nviz *""'");
10919
+ }
10920
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10921
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
10922
+ if (!SWIG_IsOK(ecode2)) {
10923
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetSurfaceRes" "', argument " "2"" of type '" "int""'");
10924
+ }
10925
+ arg2 = static_cast< int >(val2);
10926
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
10927
+ if (!SWIG_IsOK(ecode3)) {
10928
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetSurfaceRes" "', argument " "3"" of type '" "int""'");
10929
+ }
10930
+ arg3 = static_cast< int >(val3);
10931
+ ecode4 = SWIG_AsVal_int(obj3, &val4);
10932
+ if (!SWIG_IsOK(ecode4)) {
10933
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Nviz_SetSurfaceRes" "', argument " "4"" of type '" "int""'");
10934
+ }
10935
+ arg4 = static_cast< int >(val4);
10936
+ result = (int)(arg1)->SetSurfaceRes(arg2,arg3,arg4);
10937
+ resultobj = SWIG_From_int(static_cast< int >(result));
10938
+ return resultobj;
10939
+fail:
10940
+ return NULL;
10941
+}
10942
+
10943
+
10944
+SWIGINTERN PyObject *_wrap_Nviz_SetSurfaceStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10945
+ PyObject *resultobj = 0;
10946
+ Nviz *arg1 = (Nviz *) 0 ;
10947
+ int arg2 ;
10948
+ int arg3 ;
10949
+ void *argp1 = 0 ;
10950
+ int res1 = 0 ;
10951
+ int val2 ;
10952
+ int ecode2 = 0 ;
10953
+ int val3 ;
10954
+ int ecode3 = 0 ;
10955
+ PyObject * obj0 = 0 ;
10956
+ PyObject * obj1 = 0 ;
10957
+ PyObject * obj2 = 0 ;
10958
+ int result;
10959
+
10960
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_SetSurfaceStyle",&obj0,&obj1,&obj2)) SWIG_fail;
10961
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
10962
+ if (!SWIG_IsOK(res1)) {
10963
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetSurfaceStyle" "', argument " "1"" of type '" "Nviz *""'");
10964
+ }
10965
+ arg1 = reinterpret_cast< Nviz * >(argp1);
10966
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
10967
+ if (!SWIG_IsOK(ecode2)) {
10968
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetSurfaceStyle" "', argument " "2"" of type '" "int""'");
10969
+ }
10970
+ arg2 = static_cast< int >(val2);
10971
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
10972
+ if (!SWIG_IsOK(ecode3)) {
10973
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetSurfaceStyle" "', argument " "3"" of type '" "int""'");
10974
+ }
10975
+ arg3 = static_cast< int >(val3);
10976
+ result = (int)(arg1)->SetSurfaceStyle(arg2,arg3);
10977
+ resultobj = SWIG_From_int(static_cast< int >(result));
10978
+ return resultobj;
10979
+fail:
10980
+ return NULL;
10981
+}
10982
+
10983
+
10984
+SWIGINTERN PyObject *_wrap_Nviz_SetWireColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10985
+ PyObject *resultobj = 0;
10986
+ Nviz *arg1 = (Nviz *) 0 ;
10987
+ int arg2 ;
10988
+ char *arg3 = (char *) 0 ;
10989
+ void *argp1 = 0 ;
10990
+ int res1 = 0 ;
10991
+ int val2 ;
10992
+ int ecode2 = 0 ;
10993
+ int res3 ;
10994
+ char *buf3 = 0 ;
10995
+ int alloc3 = 0 ;
10996
+ PyObject * obj0 = 0 ;
10997
+ PyObject * obj1 = 0 ;
10998
+ PyObject * obj2 = 0 ;
10999
+ int result;
11000
+
11001
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_SetWireColor",&obj0,&obj1,&obj2)) SWIG_fail;
11002
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11003
+ if (!SWIG_IsOK(res1)) {
11004
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetWireColor" "', argument " "1"" of type '" "Nviz *""'");
11005
+ }
11006
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11007
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11008
+ if (!SWIG_IsOK(ecode2)) {
11009
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetWireColor" "', argument " "2"" of type '" "int""'");
11010
+ }
11011
+ arg2 = static_cast< int >(val2);
11012
+ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
11013
+ if (!SWIG_IsOK(res3)) {
11014
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Nviz_SetWireColor" "', argument " "3"" of type '" "char const *""'");
11015
+ }
11016
+ arg3 = reinterpret_cast< char * >(buf3);
11017
+ result = (int)(arg1)->SetWireColor(arg2,(char const *)arg3);
11018
+ resultobj = SWIG_From_int(static_cast< int >(result));
11019
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11020
+ return resultobj;
11021
+fail:
11022
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11023
+ return NULL;
11024
+}
11025
+
11026
+
11027
+SWIGINTERN PyObject *_wrap_Nviz_GetSurfacePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11028
+ PyObject *resultobj = 0;
11029
+ Nviz *arg1 = (Nviz *) 0 ;
11030
+ int arg2 ;
11031
+ void *argp1 = 0 ;
11032
+ int res1 = 0 ;
11033
+ int val2 ;
11034
+ int ecode2 = 0 ;
11035
+ PyObject * obj0 = 0 ;
11036
+ PyObject * obj1 = 0 ;
11037
+ std::vector< double,std::allocator< double > > result;
11038
+
11039
+ if (!PyArg_ParseTuple(args,(char *)"OO:Nviz_GetSurfacePosition",&obj0,&obj1)) SWIG_fail;
11040
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11041
+ if (!SWIG_IsOK(res1)) {
11042
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_GetSurfacePosition" "', argument " "1"" of type '" "Nviz *""'");
11043
+ }
11044
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11045
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11046
+ if (!SWIG_IsOK(ecode2)) {
11047
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_GetSurfacePosition" "', argument " "2"" of type '" "int""'");
11048
+ }
11049
+ arg2 = static_cast< int >(val2);
11050
+ result = (arg1)->GetSurfacePosition(arg2);
11051
+ resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
11052
+ return resultobj;
11053
+fail:
11054
+ return NULL;
11055
+}
11056
+
11057
+
11058
+SWIGINTERN PyObject *_wrap_Nviz_SetSurfacePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11059
+ PyObject *resultobj = 0;
11060
+ Nviz *arg1 = (Nviz *) 0 ;
11061
+ int arg2 ;
11062
+ float arg3 ;
11063
+ float arg4 ;
11064
+ float arg5 ;
11065
+ void *argp1 = 0 ;
11066
+ int res1 = 0 ;
11067
+ int val2 ;
11068
+ int ecode2 = 0 ;
11069
+ float val3 ;
11070
+ int ecode3 = 0 ;
11071
+ float val4 ;
11072
+ int ecode4 = 0 ;
11073
+ float val5 ;
11074
+ int ecode5 = 0 ;
11075
+ PyObject * obj0 = 0 ;
11076
+ PyObject * obj1 = 0 ;
11077
+ PyObject * obj2 = 0 ;
11078
+ PyObject * obj3 = 0 ;
11079
+ PyObject * obj4 = 0 ;
11080
+ int result;
11081
+
11082
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:Nviz_SetSurfacePosition",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11083
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11084
+ if (!SWIG_IsOK(res1)) {
11085
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetSurfacePosition" "', argument " "1"" of type '" "Nviz *""'");
11086
+ }
11087
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11088
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11089
+ if (!SWIG_IsOK(ecode2)) {
11090
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetSurfacePosition" "', argument " "2"" of type '" "int""'");
11091
+ }
11092
+ arg2 = static_cast< int >(val2);
11093
+ ecode3 = SWIG_AsVal_float(obj2, &val3);
11094
+ if (!SWIG_IsOK(ecode3)) {
11095
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetSurfacePosition" "', argument " "3"" of type '" "float""'");
11096
+ }
11097
+ arg3 = static_cast< float >(val3);
11098
+ ecode4 = SWIG_AsVal_float(obj3, &val4);
11099
+ if (!SWIG_IsOK(ecode4)) {
11100
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Nviz_SetSurfacePosition" "', argument " "4"" of type '" "float""'");
11101
+ }
11102
+ arg4 = static_cast< float >(val4);
11103
+ ecode5 = SWIG_AsVal_float(obj4, &val5);
11104
+ if (!SWIG_IsOK(ecode5)) {
11105
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Nviz_SetSurfacePosition" "', argument " "5"" of type '" "float""'");
11106
+ }
11107
+ arg5 = static_cast< float >(val5);
11108
+ result = (int)(arg1)->SetSurfacePosition(arg2,arg3,arg4,arg5);
11109
+ resultobj = SWIG_From_int(static_cast< int >(result));
11110
+ return resultobj;
11111
+fail:
11112
+ return NULL;
11113
+}
11114
+
11115
+
11116
+SWIGINTERN PyObject *_wrap_Nviz_SetVectorLineMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11117
+ PyObject *resultobj = 0;
11118
+ Nviz *arg1 = (Nviz *) 0 ;
11119
+ int arg2 ;
11120
+ char *arg3 = (char *) 0 ;
11121
+ int arg4 ;
11122
+ int arg5 ;
11123
+ void *argp1 = 0 ;
11124
+ int res1 = 0 ;
11125
+ int val2 ;
11126
+ int ecode2 = 0 ;
11127
+ int res3 ;
11128
+ char *buf3 = 0 ;
11129
+ int alloc3 = 0 ;
11130
+ int val4 ;
11131
+ int ecode4 = 0 ;
11132
+ int val5 ;
11133
+ int ecode5 = 0 ;
11134
+ PyObject * obj0 = 0 ;
11135
+ PyObject * obj1 = 0 ;
11136
+ PyObject * obj2 = 0 ;
11137
+ PyObject * obj3 = 0 ;
11138
+ PyObject * obj4 = 0 ;
11139
+ int result;
11140
+
11141
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:Nviz_SetVectorLineMode",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11142
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11143
+ if (!SWIG_IsOK(res1)) {
11144
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetVectorLineMode" "', argument " "1"" of type '" "Nviz *""'");
11145
+ }
11146
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11147
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11148
+ if (!SWIG_IsOK(ecode2)) {
11149
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetVectorLineMode" "', argument " "2"" of type '" "int""'");
11150
+ }
11151
+ arg2 = static_cast< int >(val2);
11152
+ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
11153
+ if (!SWIG_IsOK(res3)) {
11154
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Nviz_SetVectorLineMode" "', argument " "3"" of type '" "char const *""'");
11155
+ }
11156
+ arg3 = reinterpret_cast< char * >(buf3);
11157
+ ecode4 = SWIG_AsVal_int(obj3, &val4);
11158
+ if (!SWIG_IsOK(ecode4)) {
11159
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Nviz_SetVectorLineMode" "', argument " "4"" of type '" "int""'");
11160
+ }
11161
+ arg4 = static_cast< int >(val4);
11162
+ ecode5 = SWIG_AsVal_int(obj4, &val5);
11163
+ if (!SWIG_IsOK(ecode5)) {
11164
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Nviz_SetVectorLineMode" "', argument " "5"" of type '" "int""'");
11165
+ }
11166
+ arg5 = static_cast< int >(val5);
11167
+ result = (int)(arg1)->SetVectorLineMode(arg2,(char const *)arg3,arg4,arg5);
11168
+ resultobj = SWIG_From_int(static_cast< int >(result));
11169
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11170
+ return resultobj;
11171
+fail:
11172
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11173
+ return NULL;
11174
+}
11175
+
11176
+
11177
+SWIGINTERN PyObject *_wrap_Nviz_SetVectorLineHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11178
+ PyObject *resultobj = 0;
11179
+ Nviz *arg1 = (Nviz *) 0 ;
11180
+ int arg2 ;
11181
+ float arg3 ;
11182
+ void *argp1 = 0 ;
11183
+ int res1 = 0 ;
11184
+ int val2 ;
11185
+ int ecode2 = 0 ;
11186
+ float val3 ;
11187
+ int ecode3 = 0 ;
11188
+ PyObject * obj0 = 0 ;
11189
+ PyObject * obj1 = 0 ;
11190
+ PyObject * obj2 = 0 ;
11191
+ int result;
11192
+
11193
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_SetVectorLineHeight",&obj0,&obj1,&obj2)) SWIG_fail;
11194
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11195
+ if (!SWIG_IsOK(res1)) {
11196
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetVectorLineHeight" "', argument " "1"" of type '" "Nviz *""'");
11197
+ }
11198
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11199
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11200
+ if (!SWIG_IsOK(ecode2)) {
11201
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetVectorLineHeight" "', argument " "2"" of type '" "int""'");
11202
+ }
11203
+ arg2 = static_cast< int >(val2);
11204
+ ecode3 = SWIG_AsVal_float(obj2, &val3);
11205
+ if (!SWIG_IsOK(ecode3)) {
11206
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetVectorLineHeight" "', argument " "3"" of type '" "float""'");
11207
+ }
11208
+ arg3 = static_cast< float >(val3);
11209
+ result = (int)(arg1)->SetVectorLineHeight(arg2,arg3);
11210
+ resultobj = SWIG_From_int(static_cast< int >(result));
11211
+ return resultobj;
11212
+fail:
11213
+ return NULL;
11214
+}
11215
+
11216
+
11217
+SWIGINTERN PyObject *_wrap_Nviz_SetVectorLineSurface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11218
+ PyObject *resultobj = 0;
11219
+ Nviz *arg1 = (Nviz *) 0 ;
11220
+ int arg2 ;
11221
+ int arg3 ;
11222
+ void *argp1 = 0 ;
11223
+ int res1 = 0 ;
11224
+ int val2 ;
11225
+ int ecode2 = 0 ;
11226
+ int val3 ;
11227
+ int ecode3 = 0 ;
11228
+ PyObject * obj0 = 0 ;
11229
+ PyObject * obj1 = 0 ;
11230
+ PyObject * obj2 = 0 ;
11231
+ int result;
11232
+
11233
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_SetVectorLineSurface",&obj0,&obj1,&obj2)) SWIG_fail;
11234
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11235
+ if (!SWIG_IsOK(res1)) {
11236
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetVectorLineSurface" "', argument " "1"" of type '" "Nviz *""'");
11237
+ }
11238
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11239
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11240
+ if (!SWIG_IsOK(ecode2)) {
11241
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetVectorLineSurface" "', argument " "2"" of type '" "int""'");
11242
+ }
11243
+ arg2 = static_cast< int >(val2);
11244
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
11245
+ if (!SWIG_IsOK(ecode3)) {
11246
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetVectorLineSurface" "', argument " "3"" of type '" "int""'");
11247
+ }
11248
+ arg3 = static_cast< int >(val3);
11249
+ result = (int)(arg1)->SetVectorLineSurface(arg2,arg3);
11250
+ resultobj = SWIG_From_int(static_cast< int >(result));
11251
+ return resultobj;
11252
+fail:
11253
+ return NULL;
11254
+}
11255
+
11256
+
11257
+SWIGINTERN PyObject *_wrap_Nviz_SetVectorPointMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11258
+ PyObject *resultobj = 0;
11259
+ Nviz *arg1 = (Nviz *) 0 ;
11260
+ int arg2 ;
11261
+ char *arg3 = (char *) 0 ;
11262
+ int arg4 ;
11263
+ float arg5 ;
11264
+ int arg6 ;
11265
+ void *argp1 = 0 ;
11266
+ int res1 = 0 ;
11267
+ int val2 ;
11268
+ int ecode2 = 0 ;
11269
+ int res3 ;
11270
+ char *buf3 = 0 ;
11271
+ int alloc3 = 0 ;
11272
+ int val4 ;
11273
+ int ecode4 = 0 ;
11274
+ float val5 ;
11275
+ int ecode5 = 0 ;
11276
+ int val6 ;
11277
+ int ecode6 = 0 ;
11278
+ PyObject * obj0 = 0 ;
11279
+ PyObject * obj1 = 0 ;
11280
+ PyObject * obj2 = 0 ;
11281
+ PyObject * obj3 = 0 ;
11282
+ PyObject * obj4 = 0 ;
11283
+ PyObject * obj5 = 0 ;
11284
+ int result;
11285
+
11286
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Nviz_SetVectorPointMode",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
11287
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11288
+ if (!SWIG_IsOK(res1)) {
11289
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetVectorPointMode" "', argument " "1"" of type '" "Nviz *""'");
11290
+ }
11291
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11292
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11293
+ if (!SWIG_IsOK(ecode2)) {
11294
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetVectorPointMode" "', argument " "2"" of type '" "int""'");
11295
+ }
11296
+ arg2 = static_cast< int >(val2);
11297
+ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
11298
+ if (!SWIG_IsOK(res3)) {
11299
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Nviz_SetVectorPointMode" "', argument " "3"" of type '" "char const *""'");
11300
+ }
11301
+ arg3 = reinterpret_cast< char * >(buf3);
11302
+ ecode4 = SWIG_AsVal_int(obj3, &val4);
11303
+ if (!SWIG_IsOK(ecode4)) {
11304
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Nviz_SetVectorPointMode" "', argument " "4"" of type '" "int""'");
11305
+ }
11306
+ arg4 = static_cast< int >(val4);
11307
+ ecode5 = SWIG_AsVal_float(obj4, &val5);
11308
+ if (!SWIG_IsOK(ecode5)) {
11309
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Nviz_SetVectorPointMode" "', argument " "5"" of type '" "float""'");
11310
+ }
11311
+ arg5 = static_cast< float >(val5);
11312
+ ecode6 = SWIG_AsVal_int(obj5, &val6);
11313
+ if (!SWIG_IsOK(ecode6)) {
11314
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Nviz_SetVectorPointMode" "', argument " "6"" of type '" "int""'");
11315
+ }
11316
+ arg6 = static_cast< int >(val6);
11317
+ result = (int)(arg1)->SetVectorPointMode(arg2,(char const *)arg3,arg4,arg5,arg6);
11318
+ resultobj = SWIG_From_int(static_cast< int >(result));
11319
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11320
+ return resultobj;
11321
+fail:
11322
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11323
+ return NULL;
11324
+}
11325
+
11326
+
11327
+SWIGINTERN PyObject *_wrap_Nviz_SetVectorPointHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11328
+ PyObject *resultobj = 0;
11329
+ Nviz *arg1 = (Nviz *) 0 ;
11330
+ int arg2 ;
11331
+ float arg3 ;
11332
+ void *argp1 = 0 ;
11333
+ int res1 = 0 ;
11334
+ int val2 ;
11335
+ int ecode2 = 0 ;
11336
+ float val3 ;
11337
+ int ecode3 = 0 ;
11338
+ PyObject * obj0 = 0 ;
11339
+ PyObject * obj1 = 0 ;
11340
+ PyObject * obj2 = 0 ;
11341
+ int result;
11342
+
11343
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_SetVectorPointHeight",&obj0,&obj1,&obj2)) SWIG_fail;
11344
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11345
+ if (!SWIG_IsOK(res1)) {
11346
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetVectorPointHeight" "', argument " "1"" of type '" "Nviz *""'");
11347
+ }
11348
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11349
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11350
+ if (!SWIG_IsOK(ecode2)) {
11351
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetVectorPointHeight" "', argument " "2"" of type '" "int""'");
11352
+ }
11353
+ arg2 = static_cast< int >(val2);
11354
+ ecode3 = SWIG_AsVal_float(obj2, &val3);
11355
+ if (!SWIG_IsOK(ecode3)) {
11356
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetVectorPointHeight" "', argument " "3"" of type '" "float""'");
11357
+ }
11358
+ arg3 = static_cast< float >(val3);
11359
+ result = (int)(arg1)->SetVectorPointHeight(arg2,arg3);
11360
+ resultobj = SWIG_From_int(static_cast< int >(result));
11361
+ return resultobj;
11362
+fail:
11363
+ return NULL;
11364
+}
11365
+
11366
+
11367
+SWIGINTERN PyObject *_wrap_Nviz_SetVectorPointSurface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11368
+ PyObject *resultobj = 0;
11369
+ Nviz *arg1 = (Nviz *) 0 ;
11370
+ int arg2 ;
11371
+ int arg3 ;
11372
+ void *argp1 = 0 ;
11373
+ int res1 = 0 ;
11374
+ int val2 ;
11375
+ int ecode2 = 0 ;
11376
+ int val3 ;
11377
+ int ecode3 = 0 ;
11378
+ PyObject * obj0 = 0 ;
11379
+ PyObject * obj1 = 0 ;
11380
+ PyObject * obj2 = 0 ;
11381
+ int result;
11382
+
11383
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_SetVectorPointSurface",&obj0,&obj1,&obj2)) SWIG_fail;
11384
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11385
+ if (!SWIG_IsOK(res1)) {
11386
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetVectorPointSurface" "', argument " "1"" of type '" "Nviz *""'");
11387
+ }
11388
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11389
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11390
+ if (!SWIG_IsOK(ecode2)) {
11391
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetVectorPointSurface" "', argument " "2"" of type '" "int""'");
11392
+ }
11393
+ arg2 = static_cast< int >(val2);
11394
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
11395
+ if (!SWIG_IsOK(ecode3)) {
11396
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetVectorPointSurface" "', argument " "3"" of type '" "int""'");
11397
+ }
11398
+ arg3 = static_cast< int >(val3);
11399
+ result = (int)(arg1)->SetVectorPointSurface(arg2,arg3);
11400
+ resultobj = SWIG_From_int(static_cast< int >(result));
11401
+ return resultobj;
11402
+fail:
11403
+ return NULL;
11404
+}
11405
+
11406
+
11407
+SWIGINTERN PyObject *_wrap_Nviz_AddIsosurface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11408
+ PyObject *resultobj = 0;
11409
+ Nviz *arg1 = (Nviz *) 0 ;
11410
+ int arg2 ;
11411
+ int arg3 ;
11412
+ void *argp1 = 0 ;
11413
+ int res1 = 0 ;
11414
+ int val2 ;
11415
+ int ecode2 = 0 ;
11416
+ int val3 ;
11417
+ int ecode3 = 0 ;
11418
+ PyObject * obj0 = 0 ;
11419
+ PyObject * obj1 = 0 ;
11420
+ PyObject * obj2 = 0 ;
11421
+ int result;
11422
+
11423
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_AddIsosurface",&obj0,&obj1,&obj2)) SWIG_fail;
11424
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11425
+ if (!SWIG_IsOK(res1)) {
11426
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_AddIsosurface" "', argument " "1"" of type '" "Nviz *""'");
11427
+ }
11428
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11429
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11430
+ if (!SWIG_IsOK(ecode2)) {
11431
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_AddIsosurface" "', argument " "2"" of type '" "int""'");
11432
+ }
11433
+ arg2 = static_cast< int >(val2);
11434
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
11435
+ if (!SWIG_IsOK(ecode3)) {
11436
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_AddIsosurface" "', argument " "3"" of type '" "int""'");
11437
+ }
11438
+ arg3 = static_cast< int >(val3);
11439
+ result = (int)(arg1)->AddIsosurface(arg2,arg3);
11440
+ resultobj = SWIG_From_int(static_cast< int >(result));
11441
+ return resultobj;
11442
+fail:
11443
+ return NULL;
11444
+}
11445
+
11446
+
11447
+SWIGINTERN PyObject *_wrap_Nviz_DeleteIsosurface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11448
+ PyObject *resultobj = 0;
11449
+ Nviz *arg1 = (Nviz *) 0 ;
11450
+ int arg2 ;
11451
+ int arg3 ;
11452
+ void *argp1 = 0 ;
11453
+ int res1 = 0 ;
11454
+ int val2 ;
11455
+ int ecode2 = 0 ;
11456
+ int val3 ;
11457
+ int ecode3 = 0 ;
11458
+ PyObject * obj0 = 0 ;
11459
+ PyObject * obj1 = 0 ;
11460
+ PyObject * obj2 = 0 ;
11461
+ int result;
11462
+
11463
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_DeleteIsosurface",&obj0,&obj1,&obj2)) SWIG_fail;
11464
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11465
+ if (!SWIG_IsOK(res1)) {
11466
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_DeleteIsosurface" "', argument " "1"" of type '" "Nviz *""'");
11467
+ }
11468
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11469
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11470
+ if (!SWIG_IsOK(ecode2)) {
11471
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_DeleteIsosurface" "', argument " "2"" of type '" "int""'");
11472
+ }
11473
+ arg2 = static_cast< int >(val2);
11474
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
11475
+ if (!SWIG_IsOK(ecode3)) {
11476
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_DeleteIsosurface" "', argument " "3"" of type '" "int""'");
11477
+ }
11478
+ arg3 = static_cast< int >(val3);
11479
+ result = (int)(arg1)->DeleteIsosurface(arg2,arg3);
11480
+ resultobj = SWIG_From_int(static_cast< int >(result));
11481
+ return resultobj;
11482
+fail:
11483
+ return NULL;
11484
+}
11485
+
11486
+
11487
+SWIGINTERN PyObject *_wrap_Nviz_MoveIsosurface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11488
+ PyObject *resultobj = 0;
11489
+ Nviz *arg1 = (Nviz *) 0 ;
11490
+ int arg2 ;
11491
+ int arg3 ;
11492
+ bool arg4 ;
11493
+ void *argp1 = 0 ;
11494
+ int res1 = 0 ;
11495
+ int val2 ;
11496
+ int ecode2 = 0 ;
11497
+ int val3 ;
11498
+ int ecode3 = 0 ;
11499
+ bool val4 ;
11500
+ int ecode4 = 0 ;
11501
+ PyObject * obj0 = 0 ;
11502
+ PyObject * obj1 = 0 ;
11503
+ PyObject * obj2 = 0 ;
11504
+ PyObject * obj3 = 0 ;
11505
+ int result;
11506
+
11507
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:Nviz_MoveIsosurface",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11508
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11509
+ if (!SWIG_IsOK(res1)) {
11510
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_MoveIsosurface" "', argument " "1"" of type '" "Nviz *""'");
11511
+ }
11512
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11513
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11514
+ if (!SWIG_IsOK(ecode2)) {
11515
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_MoveIsosurface" "', argument " "2"" of type '" "int""'");
11516
+ }
11517
+ arg2 = static_cast< int >(val2);
11518
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
11519
+ if (!SWIG_IsOK(ecode3)) {
11520
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_MoveIsosurface" "', argument " "3"" of type '" "int""'");
11521
+ }
11522
+ arg3 = static_cast< int >(val3);
11523
+ ecode4 = SWIG_AsVal_bool(obj3, &val4);
11524
+ if (!SWIG_IsOK(ecode4)) {
11525
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Nviz_MoveIsosurface" "', argument " "4"" of type '" "bool""'");
11526
+ }
11527
+ arg4 = static_cast< bool >(val4);
11528
+ result = (int)(arg1)->MoveIsosurface(arg2,arg3,arg4);
11529
+ resultobj = SWIG_From_int(static_cast< int >(result));
11530
+ return resultobj;
11531
+fail:
11532
+ return NULL;
11533
+}
11534
+
11535
+
11536
+SWIGINTERN PyObject *_wrap_Nviz_SetIsosurfaceColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11537
+ PyObject *resultobj = 0;
11538
+ Nviz *arg1 = (Nviz *) 0 ;
11539
+ int arg2 ;
11540
+ int arg3 ;
11541
+ bool arg4 ;
11542
+ char *arg5 = (char *) 0 ;
11543
+ void *argp1 = 0 ;
11544
+ int res1 = 0 ;
11545
+ int val2 ;
11546
+ int ecode2 = 0 ;
11547
+ int val3 ;
11548
+ int ecode3 = 0 ;
11549
+ bool val4 ;
11550
+ int ecode4 = 0 ;
11551
+ int res5 ;
11552
+ char *buf5 = 0 ;
11553
+ int alloc5 = 0 ;
11554
+ PyObject * obj0 = 0 ;
11555
+ PyObject * obj1 = 0 ;
11556
+ PyObject * obj2 = 0 ;
11557
+ PyObject * obj3 = 0 ;
11558
+ PyObject * obj4 = 0 ;
11559
+ int result;
11560
+
11561
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:Nviz_SetIsosurfaceColor",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11562
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11563
+ if (!SWIG_IsOK(res1)) {
11564
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetIsosurfaceColor" "', argument " "1"" of type '" "Nviz *""'");
11565
+ }
11566
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11567
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11568
+ if (!SWIG_IsOK(ecode2)) {
11569
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetIsosurfaceColor" "', argument " "2"" of type '" "int""'");
11570
+ }
11571
+ arg2 = static_cast< int >(val2);
11572
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
11573
+ if (!SWIG_IsOK(ecode3)) {
11574
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetIsosurfaceColor" "', argument " "3"" of type '" "int""'");
11575
+ }
11576
+ arg3 = static_cast< int >(val3);
11577
+ ecode4 = SWIG_AsVal_bool(obj3, &val4);
11578
+ if (!SWIG_IsOK(ecode4)) {
11579
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Nviz_SetIsosurfaceColor" "', argument " "4"" of type '" "bool""'");
11580
+ }
11581
+ arg4 = static_cast< bool >(val4);
11582
+ res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
11583
+ if (!SWIG_IsOK(res5)) {
11584
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Nviz_SetIsosurfaceColor" "', argument " "5"" of type '" "char const *""'");
11585
+ }
11586
+ arg5 = reinterpret_cast< char * >(buf5);
11587
+ result = (int)(arg1)->SetIsosurfaceColor(arg2,arg3,arg4,(char const *)arg5);
11588
+ resultobj = SWIG_From_int(static_cast< int >(result));
11589
+ if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
11590
+ return resultobj;
11591
+fail:
11592
+ if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
11593
+ return NULL;
11594
+}
11595
+
11596
+
11597
+SWIGINTERN PyObject *_wrap_Nviz_SetIsosurfaceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11598
+ PyObject *resultobj = 0;
11599
+ Nviz *arg1 = (Nviz *) 0 ;
11600
+ int arg2 ;
11601
+ int arg3 ;
11602
+ bool arg4 ;
11603
+ char *arg5 = (char *) 0 ;
11604
+ void *argp1 = 0 ;
11605
+ int res1 = 0 ;
11606
+ int val2 ;
11607
+ int ecode2 = 0 ;
11608
+ int val3 ;
11609
+ int ecode3 = 0 ;
11610
+ bool val4 ;
11611
+ int ecode4 = 0 ;
11612
+ int res5 ;
11613
+ char *buf5 = 0 ;
11614
+ int alloc5 = 0 ;
11615
+ PyObject * obj0 = 0 ;
11616
+ PyObject * obj1 = 0 ;
11617
+ PyObject * obj2 = 0 ;
11618
+ PyObject * obj3 = 0 ;
11619
+ PyObject * obj4 = 0 ;
11620
+ int result;
11621
+
11622
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:Nviz_SetIsosurfaceMask",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11623
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11624
+ if (!SWIG_IsOK(res1)) {
11625
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetIsosurfaceMask" "', argument " "1"" of type '" "Nviz *""'");
11626
+ }
11627
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11628
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11629
+ if (!SWIG_IsOK(ecode2)) {
11630
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetIsosurfaceMask" "', argument " "2"" of type '" "int""'");
11631
+ }
11632
+ arg2 = static_cast< int >(val2);
11633
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
11634
+ if (!SWIG_IsOK(ecode3)) {
11635
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetIsosurfaceMask" "', argument " "3"" of type '" "int""'");
11636
+ }
11637
+ arg3 = static_cast< int >(val3);
11638
+ ecode4 = SWIG_AsVal_bool(obj3, &val4);
11639
+ if (!SWIG_IsOK(ecode4)) {
11640
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Nviz_SetIsosurfaceMask" "', argument " "4"" of type '" "bool""'");
11641
+ }
11642
+ arg4 = static_cast< bool >(val4);
11643
+ res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
11644
+ if (!SWIG_IsOK(res5)) {
11645
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Nviz_SetIsosurfaceMask" "', argument " "5"" of type '" "char const *""'");
11646
+ }
11647
+ arg5 = reinterpret_cast< char * >(buf5);
11648
+ result = (int)(arg1)->SetIsosurfaceMask(arg2,arg3,arg4,(char const *)arg5);
11649
+ resultobj = SWIG_From_int(static_cast< int >(result));
11650
+ if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
11651
+ return resultobj;
11652
+fail:
11653
+ if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
11654
+ return NULL;
11655
+}
11656
+
11657
+
11658
+SWIGINTERN PyObject *_wrap_Nviz_SetIsosurfaceTransp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11659
+ PyObject *resultobj = 0;
11660
+ Nviz *arg1 = (Nviz *) 0 ;
11661
+ int arg2 ;
11662
+ int arg3 ;
11663
+ bool arg4 ;
11664
+ char *arg5 = (char *) 0 ;
11665
+ void *argp1 = 0 ;
11666
+ int res1 = 0 ;
11667
+ int val2 ;
11668
+ int ecode2 = 0 ;
11669
+ int val3 ;
11670
+ int ecode3 = 0 ;
11671
+ bool val4 ;
11672
+ int ecode4 = 0 ;
11673
+ int res5 ;
11674
+ char *buf5 = 0 ;
11675
+ int alloc5 = 0 ;
11676
+ PyObject * obj0 = 0 ;
11677
+ PyObject * obj1 = 0 ;
11678
+ PyObject * obj2 = 0 ;
11679
+ PyObject * obj3 = 0 ;
11680
+ PyObject * obj4 = 0 ;
11681
+ int result;
11682
+
11683
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:Nviz_SetIsosurfaceTransp",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11684
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11685
+ if (!SWIG_IsOK(res1)) {
11686
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetIsosurfaceTransp" "', argument " "1"" of type '" "Nviz *""'");
11687
+ }
11688
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11689
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11690
+ if (!SWIG_IsOK(ecode2)) {
11691
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetIsosurfaceTransp" "', argument " "2"" of type '" "int""'");
11692
+ }
11693
+ arg2 = static_cast< int >(val2);
11694
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
11695
+ if (!SWIG_IsOK(ecode3)) {
11696
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetIsosurfaceTransp" "', argument " "3"" of type '" "int""'");
11697
+ }
11698
+ arg3 = static_cast< int >(val3);
11699
+ ecode4 = SWIG_AsVal_bool(obj3, &val4);
11700
+ if (!SWIG_IsOK(ecode4)) {
11701
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Nviz_SetIsosurfaceTransp" "', argument " "4"" of type '" "bool""'");
11702
+ }
11703
+ arg4 = static_cast< bool >(val4);
11704
+ res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
11705
+ if (!SWIG_IsOK(res5)) {
11706
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Nviz_SetIsosurfaceTransp" "', argument " "5"" of type '" "char const *""'");
11707
+ }
11708
+ arg5 = reinterpret_cast< char * >(buf5);
11709
+ result = (int)(arg1)->SetIsosurfaceTransp(arg2,arg3,arg4,(char const *)arg5);
11710
+ resultobj = SWIG_From_int(static_cast< int >(result));
11711
+ if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
11712
+ return resultobj;
11713
+fail:
11714
+ if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
11715
+ return NULL;
11716
+}
11717
+
11718
+
11719
+SWIGINTERN PyObject *_wrap_Nviz_SetIsosurfaceShine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11720
+ PyObject *resultobj = 0;
11721
+ Nviz *arg1 = (Nviz *) 0 ;
11722
+ int arg2 ;
11723
+ int arg3 ;
11724
+ bool arg4 ;
11725
+ char *arg5 = (char *) 0 ;
11726
+ void *argp1 = 0 ;
11727
+ int res1 = 0 ;
11728
+ int val2 ;
11729
+ int ecode2 = 0 ;
11730
+ int val3 ;
11731
+ int ecode3 = 0 ;
11732
+ bool val4 ;
11733
+ int ecode4 = 0 ;
11734
+ int res5 ;
11735
+ char *buf5 = 0 ;
11736
+ int alloc5 = 0 ;
11737
+ PyObject * obj0 = 0 ;
11738
+ PyObject * obj1 = 0 ;
11739
+ PyObject * obj2 = 0 ;
11740
+ PyObject * obj3 = 0 ;
11741
+ PyObject * obj4 = 0 ;
11742
+ int result;
11743
+
11744
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:Nviz_SetIsosurfaceShine",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11745
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11746
+ if (!SWIG_IsOK(res1)) {
11747
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetIsosurfaceShine" "', argument " "1"" of type '" "Nviz *""'");
11748
+ }
11749
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11750
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11751
+ if (!SWIG_IsOK(ecode2)) {
11752
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetIsosurfaceShine" "', argument " "2"" of type '" "int""'");
11753
+ }
11754
+ arg2 = static_cast< int >(val2);
11755
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
11756
+ if (!SWIG_IsOK(ecode3)) {
11757
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetIsosurfaceShine" "', argument " "3"" of type '" "int""'");
11758
+ }
11759
+ arg3 = static_cast< int >(val3);
11760
+ ecode4 = SWIG_AsVal_bool(obj3, &val4);
11761
+ if (!SWIG_IsOK(ecode4)) {
11762
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Nviz_SetIsosurfaceShine" "', argument " "4"" of type '" "bool""'");
11763
+ }
11764
+ arg4 = static_cast< bool >(val4);
11765
+ res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
11766
+ if (!SWIG_IsOK(res5)) {
11767
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Nviz_SetIsosurfaceShine" "', argument " "5"" of type '" "char const *""'");
11768
+ }
11769
+ arg5 = reinterpret_cast< char * >(buf5);
11770
+ result = (int)(arg1)->SetIsosurfaceShine(arg2,arg3,arg4,(char const *)arg5);
11771
+ resultobj = SWIG_From_int(static_cast< int >(result));
11772
+ if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
11773
+ return resultobj;
11774
+fail:
11775
+ if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
11776
+ return NULL;
11777
+}
11778
+
11779
+
11780
+SWIGINTERN PyObject *_wrap_Nviz_SetIsosurfaceEmit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11781
+ PyObject *resultobj = 0;
11782
+ Nviz *arg1 = (Nviz *) 0 ;
11783
+ int arg2 ;
11784
+ int arg3 ;
11785
+ bool arg4 ;
11786
+ char *arg5 = (char *) 0 ;
11787
+ void *argp1 = 0 ;
11788
+ int res1 = 0 ;
11789
+ int val2 ;
11790
+ int ecode2 = 0 ;
11791
+ int val3 ;
11792
+ int ecode3 = 0 ;
11793
+ bool val4 ;
11794
+ int ecode4 = 0 ;
11795
+ int res5 ;
11796
+ char *buf5 = 0 ;
11797
+ int alloc5 = 0 ;
11798
+ PyObject * obj0 = 0 ;
11799
+ PyObject * obj1 = 0 ;
11800
+ PyObject * obj2 = 0 ;
11801
+ PyObject * obj3 = 0 ;
11802
+ PyObject * obj4 = 0 ;
11803
+ int result;
11804
+
11805
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:Nviz_SetIsosurfaceEmit",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11806
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11807
+ if (!SWIG_IsOK(res1)) {
11808
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetIsosurfaceEmit" "', argument " "1"" of type '" "Nviz *""'");
11809
+ }
11810
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11811
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11812
+ if (!SWIG_IsOK(ecode2)) {
11813
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetIsosurfaceEmit" "', argument " "2"" of type '" "int""'");
11814
+ }
11815
+ arg2 = static_cast< int >(val2);
11816
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
11817
+ if (!SWIG_IsOK(ecode3)) {
11818
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetIsosurfaceEmit" "', argument " "3"" of type '" "int""'");
11819
+ }
11820
+ arg3 = static_cast< int >(val3);
11821
+ ecode4 = SWIG_AsVal_bool(obj3, &val4);
11822
+ if (!SWIG_IsOK(ecode4)) {
11823
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Nviz_SetIsosurfaceEmit" "', argument " "4"" of type '" "bool""'");
11824
+ }
11825
+ arg4 = static_cast< bool >(val4);
11826
+ res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
11827
+ if (!SWIG_IsOK(res5)) {
11828
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Nviz_SetIsosurfaceEmit" "', argument " "5"" of type '" "char const *""'");
11829
+ }
11830
+ arg5 = reinterpret_cast< char * >(buf5);
11831
+ result = (int)(arg1)->SetIsosurfaceEmit(arg2,arg3,arg4,(char const *)arg5);
11832
+ resultobj = SWIG_From_int(static_cast< int >(result));
11833
+ if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
11834
+ return resultobj;
11835
+fail:
11836
+ if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
11837
+ return NULL;
11838
+}
11839
+
11840
+
11841
+SWIGINTERN PyObject *_wrap_Nviz_UnsetIsosurfaceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11842
+ PyObject *resultobj = 0;
11843
+ Nviz *arg1 = (Nviz *) 0 ;
11844
+ int arg2 ;
11845
+ int arg3 ;
11846
+ void *argp1 = 0 ;
11847
+ int res1 = 0 ;
11848
+ int val2 ;
11849
+ int ecode2 = 0 ;
11850
+ int val3 ;
11851
+ int ecode3 = 0 ;
11852
+ PyObject * obj0 = 0 ;
11853
+ PyObject * obj1 = 0 ;
11854
+ PyObject * obj2 = 0 ;
11855
+ int result;
11856
+
11857
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_UnsetIsosurfaceMask",&obj0,&obj1,&obj2)) SWIG_fail;
11858
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11859
+ if (!SWIG_IsOK(res1)) {
11860
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_UnsetIsosurfaceMask" "', argument " "1"" of type '" "Nviz *""'");
11861
+ }
11862
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11863
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11864
+ if (!SWIG_IsOK(ecode2)) {
11865
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_UnsetIsosurfaceMask" "', argument " "2"" of type '" "int""'");
11866
+ }
11867
+ arg2 = static_cast< int >(val2);
11868
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
11869
+ if (!SWIG_IsOK(ecode3)) {
11870
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_UnsetIsosurfaceMask" "', argument " "3"" of type '" "int""'");
11871
+ }
11872
+ arg3 = static_cast< int >(val3);
11873
+ result = (int)(arg1)->UnsetIsosurfaceMask(arg2,arg3);
11874
+ resultobj = SWIG_From_int(static_cast< int >(result));
11875
+ return resultobj;
11876
+fail:
11877
+ return NULL;
11878
+}
11879
+
11880
+
11881
+SWIGINTERN PyObject *_wrap_Nviz_UnsetIsosurfaceTransp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11882
+ PyObject *resultobj = 0;
11883
+ Nviz *arg1 = (Nviz *) 0 ;
11884
+ int arg2 ;
11885
+ int arg3 ;
11886
+ void *argp1 = 0 ;
11887
+ int res1 = 0 ;
11888
+ int val2 ;
11889
+ int ecode2 = 0 ;
11890
+ int val3 ;
11891
+ int ecode3 = 0 ;
11892
+ PyObject * obj0 = 0 ;
11893
+ PyObject * obj1 = 0 ;
11894
+ PyObject * obj2 = 0 ;
11895
+ int result;
11896
+
11897
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_UnsetIsosurfaceTransp",&obj0,&obj1,&obj2)) SWIG_fail;
11898
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11899
+ if (!SWIG_IsOK(res1)) {
11900
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_UnsetIsosurfaceTransp" "', argument " "1"" of type '" "Nviz *""'");
11901
+ }
11902
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11903
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11904
+ if (!SWIG_IsOK(ecode2)) {
11905
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_UnsetIsosurfaceTransp" "', argument " "2"" of type '" "int""'");
11906
+ }
11907
+ arg2 = static_cast< int >(val2);
11908
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
11909
+ if (!SWIG_IsOK(ecode3)) {
11910
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_UnsetIsosurfaceTransp" "', argument " "3"" of type '" "int""'");
11911
+ }
11912
+ arg3 = static_cast< int >(val3);
11913
+ result = (int)(arg1)->UnsetIsosurfaceTransp(arg2,arg3);
11914
+ resultobj = SWIG_From_int(static_cast< int >(result));
11915
+ return resultobj;
11916
+fail:
11917
+ return NULL;
11918
+}
11919
+
11920
+
11921
+SWIGINTERN PyObject *_wrap_Nviz_UnsetIsosurfaceEmit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11922
+ PyObject *resultobj = 0;
11923
+ Nviz *arg1 = (Nviz *) 0 ;
11924
+ int arg2 ;
11925
+ int arg3 ;
11926
+ void *argp1 = 0 ;
11927
+ int res1 = 0 ;
11928
+ int val2 ;
11929
+ int ecode2 = 0 ;
11930
+ int val3 ;
11931
+ int ecode3 = 0 ;
11932
+ PyObject * obj0 = 0 ;
11933
+ PyObject * obj1 = 0 ;
11934
+ PyObject * obj2 = 0 ;
11935
+ int result;
11936
+
11937
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_UnsetIsosurfaceEmit",&obj0,&obj1,&obj2)) SWIG_fail;
11938
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11939
+ if (!SWIG_IsOK(res1)) {
11940
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_UnsetIsosurfaceEmit" "', argument " "1"" of type '" "Nviz *""'");
11941
+ }
11942
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11943
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11944
+ if (!SWIG_IsOK(ecode2)) {
11945
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_UnsetIsosurfaceEmit" "', argument " "2"" of type '" "int""'");
11946
+ }
11947
+ arg2 = static_cast< int >(val2);
11948
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
11949
+ if (!SWIG_IsOK(ecode3)) {
11950
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_UnsetIsosurfaceEmit" "', argument " "3"" of type '" "int""'");
11951
+ }
11952
+ arg3 = static_cast< int >(val3);
11953
+ result = (int)(arg1)->UnsetIsosurfaceEmit(arg2,arg3);
11954
+ resultobj = SWIG_From_int(static_cast< int >(result));
11955
+ return resultobj;
11956
+fail:
11957
+ return NULL;
11958
+}
11959
+
11960
+
11961
+SWIGINTERN PyObject *_wrap_Nviz_SetIsosurfaceMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11962
+ PyObject *resultobj = 0;
11963
+ Nviz *arg1 = (Nviz *) 0 ;
11964
+ int arg2 ;
11965
+ int arg3 ;
11966
+ void *argp1 = 0 ;
11967
+ int res1 = 0 ;
11968
+ int val2 ;
11969
+ int ecode2 = 0 ;
11970
+ int val3 ;
11971
+ int ecode3 = 0 ;
11972
+ PyObject * obj0 = 0 ;
11973
+ PyObject * obj1 = 0 ;
11974
+ PyObject * obj2 = 0 ;
11975
+ int result;
11976
+
11977
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_SetIsosurfaceMode",&obj0,&obj1,&obj2)) SWIG_fail;
11978
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
11979
+ if (!SWIG_IsOK(res1)) {
11980
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetIsosurfaceMode" "', argument " "1"" of type '" "Nviz *""'");
11981
+ }
11982
+ arg1 = reinterpret_cast< Nviz * >(argp1);
11983
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
11984
+ if (!SWIG_IsOK(ecode2)) {
11985
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetIsosurfaceMode" "', argument " "2"" of type '" "int""'");
11986
+ }
11987
+ arg2 = static_cast< int >(val2);
11988
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
11989
+ if (!SWIG_IsOK(ecode3)) {
11990
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetIsosurfaceMode" "', argument " "3"" of type '" "int""'");
11991
+ }
11992
+ arg3 = static_cast< int >(val3);
11993
+ result = (int)(arg1)->SetIsosurfaceMode(arg2,arg3);
11994
+ resultobj = SWIG_From_int(static_cast< int >(result));
11995
+ return resultobj;
11996
+fail:
11997
+ return NULL;
11998
+}
11999
+
12000
+
12001
+SWIGINTERN PyObject *_wrap_Nviz_SetIsosurfaceRes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12002
+ PyObject *resultobj = 0;
12003
+ Nviz *arg1 = (Nviz *) 0 ;
12004
+ int arg2 ;
12005
+ int arg3 ;
12006
+ void *argp1 = 0 ;
12007
+ int res1 = 0 ;
12008
+ int val2 ;
12009
+ int ecode2 = 0 ;
12010
+ int val3 ;
12011
+ int ecode3 = 0 ;
12012
+ PyObject * obj0 = 0 ;
12013
+ PyObject * obj1 = 0 ;
12014
+ PyObject * obj2 = 0 ;
12015
+ int result;
12016
+
12017
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Nviz_SetIsosurfaceRes",&obj0,&obj1,&obj2)) SWIG_fail;
12018
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Nviz, 0 | 0 );
12019
+ if (!SWIG_IsOK(res1)) {
12020
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nviz_SetIsosurfaceRes" "', argument " "1"" of type '" "Nviz *""'");
12021
+ }
12022
+ arg1 = reinterpret_cast< Nviz * >(argp1);
12023
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
12024
+ if (!SWIG_IsOK(ecode2)) {
12025
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nviz_SetIsosurfaceRes" "', argument " "2"" of type '" "int""'");
12026
+ }
12027
+ arg2 = static_cast< int >(val2);
12028
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
12029
+ if (!SWIG_IsOK(ecode3)) {
12030
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nviz_SetIsosurfaceRes" "', argument " "3"" of type '" "int""'");
12031
+ }
12032
+ arg3 = static_cast< int >(val3);
12033
+ result = (int)(arg1)->SetIsosurfaceRes(arg2,arg3);
12034
+ resultobj = SWIG_From_int(static_cast< int >(result));
12035
+ return resultobj;
12036
+fail:
12037
+ return NULL;
12038
+}
12039
+
12040
+
12041
+SWIGINTERN PyObject *Nviz_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12042
+ PyObject *obj;
12043
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
12044
+ SWIG_TypeNewClientData(SWIGTYPE_p_Nviz, SWIG_NewClientData(obj));
12045
+ return SWIG_Py_Void();
12046
+}
12047
+
12048
+static PyMethodDef SwigMethods[] = {
12049
+ { (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, NULL},
12050
+ { (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, NULL},
12051
+ { (char *)"PySwigIterator_incr", _wrap_PySwigIterator_incr, METH_VARARGS, NULL},
12052
+ { (char *)"PySwigIterator_decr", _wrap_PySwigIterator_decr, METH_VARARGS, NULL},
12053
+ { (char *)"PySwigIterator_distance", _wrap_PySwigIterator_distance, METH_VARARGS, NULL},
12054
+ { (char *)"PySwigIterator_equal", _wrap_PySwigIterator_equal, METH_VARARGS, NULL},
12055
+ { (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, NULL},
12056
+ { (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, NULL},
12057
+ { (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, NULL},
12058
+ { (char *)"PySwigIterator_advance", _wrap_PySwigIterator_advance, METH_VARARGS, NULL},
12059
+ { (char *)"PySwigIterator___eq__", _wrap_PySwigIterator___eq__, METH_VARARGS, NULL},
12060
+ { (char *)"PySwigIterator___ne__", _wrap_PySwigIterator___ne__, METH_VARARGS, NULL},
12061
+ { (char *)"PySwigIterator___iadd__", _wrap_PySwigIterator___iadd__, METH_VARARGS, NULL},
12062
+ { (char *)"PySwigIterator___isub__", _wrap_PySwigIterator___isub__, METH_VARARGS, NULL},
12063
+ { (char *)"PySwigIterator___add__", _wrap_PySwigIterator___add__, METH_VARARGS, NULL},
12064
+ { (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, NULL},
12065
+ { (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
12066
+ { (char *)"IntVector_iterator", _wrap_IntVector_iterator, METH_VARARGS, NULL},
12067
+ { (char *)"IntVector___nonzero__", _wrap_IntVector___nonzero__, METH_VARARGS, NULL},
12068
+ { (char *)"IntVector___len__", _wrap_IntVector___len__, METH_VARARGS, NULL},
12069
+ { (char *)"IntVector_pop", _wrap_IntVector_pop, METH_VARARGS, NULL},
12070
+ { (char *)"IntVector___getslice__", _wrap_IntVector___getslice__, METH_VARARGS, NULL},
12071
+ { (char *)"IntVector___setslice__", _wrap_IntVector___setslice__, METH_VARARGS, NULL},
12072
+ { (char *)"IntVector___delslice__", _wrap_IntVector___delslice__, METH_VARARGS, NULL},
12073
+ { (char *)"IntVector___delitem__", _wrap_IntVector___delitem__, METH_VARARGS, NULL},
12074
+ { (char *)"IntVector___getitem__", _wrap_IntVector___getitem__, METH_VARARGS, NULL},
12075
+ { (char *)"IntVector___setitem__", _wrap_IntVector___setitem__, METH_VARARGS, NULL},
12076
+ { (char *)"IntVector_append", _wrap_IntVector_append, METH_VARARGS, NULL},
12077
+ { (char *)"IntVector_empty", _wrap_IntVector_empty, METH_VARARGS, NULL},
12078
+ { (char *)"IntVector_size", _wrap_IntVector_size, METH_VARARGS, NULL},
12079
+ { (char *)"IntVector_clear", _wrap_IntVector_clear, METH_VARARGS, NULL},
12080
+ { (char *)"IntVector_swap", _wrap_IntVector_swap, METH_VARARGS, NULL},
12081
+ { (char *)"IntVector_get_allocator", _wrap_IntVector_get_allocator, METH_VARARGS, NULL},
12082
+ { (char *)"IntVector_begin", _wrap_IntVector_begin, METH_VARARGS, NULL},
12083
+ { (char *)"IntVector_end", _wrap_IntVector_end, METH_VARARGS, NULL},
12084
+ { (char *)"IntVector_rbegin", _wrap_IntVector_rbegin, METH_VARARGS, NULL},
12085
+ { (char *)"IntVector_rend", _wrap_IntVector_rend, METH_VARARGS, NULL},
12086
+ { (char *)"IntVector_pop_back", _wrap_IntVector_pop_back, METH_VARARGS, NULL},
12087
+ { (char *)"IntVector_erase", _wrap_IntVector_erase, METH_VARARGS, NULL},
12088
+ { (char *)"new_IntVector", _wrap_new_IntVector, METH_VARARGS, NULL},
12089
+ { (char *)"IntVector_push_back", _wrap_IntVector_push_back, METH_VARARGS, NULL},
12090
+ { (char *)"IntVector_front", _wrap_IntVector_front, METH_VARARGS, NULL},
12091
+ { (char *)"IntVector_back", _wrap_IntVector_back, METH_VARARGS, NULL},
12092
+ { (char *)"IntVector_assign", _wrap_IntVector_assign, METH_VARARGS, NULL},
12093
+ { (char *)"IntVector_resize", _wrap_IntVector_resize, METH_VARARGS, NULL},
12094
+ { (char *)"IntVector_insert", _wrap_IntVector_insert, METH_VARARGS, NULL},
12095
+ { (char *)"IntVector_reserve", _wrap_IntVector_reserve, METH_VARARGS, NULL},
12096
+ { (char *)"IntVector_capacity", _wrap_IntVector_capacity, METH_VARARGS, NULL},
12097
+ { (char *)"delete_IntVector", _wrap_delete_IntVector, METH_VARARGS, NULL},
12098
+ { (char *)"IntVector_swigregister", IntVector_swigregister, METH_VARARGS, NULL},
12099
+ { (char *)"DoubleVector_iterator", _wrap_DoubleVector_iterator, METH_VARARGS, NULL},
12100
+ { (char *)"DoubleVector___nonzero__", _wrap_DoubleVector___nonzero__, METH_VARARGS, NULL},
12101
+ { (char *)"DoubleVector___len__", _wrap_DoubleVector___len__, METH_VARARGS, NULL},
12102
+ { (char *)"DoubleVector_pop", _wrap_DoubleVector_pop, METH_VARARGS, NULL},
12103
+ { (char *)"DoubleVector___getslice__", _wrap_DoubleVector___getslice__, METH_VARARGS, NULL},
12104
+ { (char *)"DoubleVector___setslice__", _wrap_DoubleVector___setslice__, METH_VARARGS, NULL},
12105
+ { (char *)"DoubleVector___delslice__", _wrap_DoubleVector___delslice__, METH_VARARGS, NULL},
12106
+ { (char *)"DoubleVector___delitem__", _wrap_DoubleVector___delitem__, METH_VARARGS, NULL},
12107
+ { (char *)"DoubleVector___getitem__", _wrap_DoubleVector___getitem__, METH_VARARGS, NULL},
12108
+ { (char *)"DoubleVector___setitem__", _wrap_DoubleVector___setitem__, METH_VARARGS, NULL},
12109
+ { (char *)"DoubleVector_append", _wrap_DoubleVector_append, METH_VARARGS, NULL},
12110
+ { (char *)"DoubleVector_empty", _wrap_DoubleVector_empty, METH_VARARGS, NULL},
12111
+ { (char *)"DoubleVector_size", _wrap_DoubleVector_size, METH_VARARGS, NULL},
12112
+ { (char *)"DoubleVector_clear", _wrap_DoubleVector_clear, METH_VARARGS, NULL},
12113
+ { (char *)"DoubleVector_swap", _wrap_DoubleVector_swap, METH_VARARGS, NULL},
12114
+ { (char *)"DoubleVector_get_allocator", _wrap_DoubleVector_get_allocator, METH_VARARGS, NULL},
12115
+ { (char *)"DoubleVector_begin", _wrap_DoubleVector_begin, METH_VARARGS, NULL},
12116
+ { (char *)"DoubleVector_end", _wrap_DoubleVector_end, METH_VARARGS, NULL},
12117
+ { (char *)"DoubleVector_rbegin", _wrap_DoubleVector_rbegin, METH_VARARGS, NULL},
12118
+ { (char *)"DoubleVector_rend", _wrap_DoubleVector_rend, METH_VARARGS, NULL},
12119
+ { (char *)"DoubleVector_pop_back", _wrap_DoubleVector_pop_back, METH_VARARGS, NULL},
12120
+ { (char *)"DoubleVector_erase", _wrap_DoubleVector_erase, METH_VARARGS, NULL},
12121
+ { (char *)"new_DoubleVector", _wrap_new_DoubleVector, METH_VARARGS, NULL},
12122
+ { (char *)"DoubleVector_push_back", _wrap_DoubleVector_push_back, METH_VARARGS, NULL},
12123
+ { (char *)"DoubleVector_front", _wrap_DoubleVector_front, METH_VARARGS, NULL},
12124
+ { (char *)"DoubleVector_back", _wrap_DoubleVector_back, METH_VARARGS, NULL},
12125
+ { (char *)"DoubleVector_assign", _wrap_DoubleVector_assign, METH_VARARGS, NULL},
12126
+ { (char *)"DoubleVector_resize", _wrap_DoubleVector_resize, METH_VARARGS, NULL},
12127
+ { (char *)"DoubleVector_insert", _wrap_DoubleVector_insert, METH_VARARGS, NULL},
12128
+ { (char *)"DoubleVector_reserve", _wrap_DoubleVector_reserve, METH_VARARGS, NULL},
12129
+ { (char *)"DoubleVector_capacity", _wrap_DoubleVector_capacity, METH_VARARGS, NULL},
12130
+ { (char *)"delete_DoubleVector", _wrap_delete_DoubleVector, METH_VARARGS, NULL},
12131
+ { (char *)"DoubleVector_swigregister", DoubleVector_swigregister, METH_VARARGS, NULL},
12132
+ { (char *)"IntVecIntMap_iterator", _wrap_IntVecIntMap_iterator, METH_VARARGS, NULL},
12133
+ { (char *)"IntVecIntMap___nonzero__", _wrap_IntVecIntMap___nonzero__, METH_VARARGS, NULL},
12134
+ { (char *)"IntVecIntMap___len__", _wrap_IntVecIntMap___len__, METH_VARARGS, NULL},
12135
+ { (char *)"IntVecIntMap___getitem__", _wrap_IntVecIntMap___getitem__, METH_VARARGS, NULL},
12136
+ { (char *)"IntVecIntMap___delitem__", _wrap_IntVecIntMap___delitem__, METH_VARARGS, NULL},
12137
+ { (char *)"IntVecIntMap_has_key", _wrap_IntVecIntMap_has_key, METH_VARARGS, NULL},
12138
+ { (char *)"IntVecIntMap_keys", _wrap_IntVecIntMap_keys, METH_VARARGS, NULL},
12139
+ { (char *)"IntVecIntMap_values", _wrap_IntVecIntMap_values, METH_VARARGS, NULL},
12140
+ { (char *)"IntVecIntMap_items", _wrap_IntVecIntMap_items, METH_VARARGS, NULL},
12141
+ { (char *)"IntVecIntMap___contains__", _wrap_IntVecIntMap___contains__, METH_VARARGS, NULL},
12142
+ { (char *)"IntVecIntMap_key_iterator", _wrap_IntVecIntMap_key_iterator, METH_VARARGS, NULL},
12143
+ { (char *)"IntVecIntMap_value_iterator", _wrap_IntVecIntMap_value_iterator, METH_VARARGS, NULL},
12144
+ { (char *)"IntVecIntMap___setitem__", _wrap_IntVecIntMap___setitem__, METH_VARARGS, NULL},
12145
+ { (char *)"new_IntVecIntMap", _wrap_new_IntVecIntMap, METH_VARARGS, NULL},
12146
+ { (char *)"IntVecIntMap_empty", _wrap_IntVecIntMap_empty, METH_VARARGS, NULL},
12147
+ { (char *)"IntVecIntMap_size", _wrap_IntVecIntMap_size, METH_VARARGS, NULL},
12148
+ { (char *)"IntVecIntMap_clear", _wrap_IntVecIntMap_clear, METH_VARARGS, NULL},
12149
+ { (char *)"IntVecIntMap_swap", _wrap_IntVecIntMap_swap, METH_VARARGS, NULL},
12150
+ { (char *)"IntVecIntMap_get_allocator", _wrap_IntVecIntMap_get_allocator, METH_VARARGS, NULL},
12151
+ { (char *)"IntVecIntMap_begin", _wrap_IntVecIntMap_begin, METH_VARARGS, NULL},
12152
+ { (char *)"IntVecIntMap_end", _wrap_IntVecIntMap_end, METH_VARARGS, NULL},
12153
+ { (char *)"IntVecIntMap_rbegin", _wrap_IntVecIntMap_rbegin, METH_VARARGS, NULL},
12154
+ { (char *)"IntVecIntMap_rend", _wrap_IntVecIntMap_rend, METH_VARARGS, NULL},
12155
+ { (char *)"IntVecIntMap_count", _wrap_IntVecIntMap_count, METH_VARARGS, NULL},
12156
+ { (char *)"IntVecIntMap_erase", _wrap_IntVecIntMap_erase, METH_VARARGS, NULL},
12157
+ { (char *)"IntVecIntMap_find", _wrap_IntVecIntMap_find, METH_VARARGS, NULL},
12158
+ { (char *)"IntVecIntMap_lower_bound", _wrap_IntVecIntMap_lower_bound, METH_VARARGS, NULL},
12159
+ { (char *)"IntVecIntMap_upper_bound", _wrap_IntVecIntMap_upper_bound, METH_VARARGS, NULL},
12160
+ { (char *)"delete_IntVecIntMap", _wrap_delete_IntVecIntMap, METH_VARARGS, NULL},
12161
+ { (char *)"IntVecIntMap_swigregister", IntVecIntMap_swigregister, METH_VARARGS, NULL},
12162
+ { (char *)"new_Nviz", _wrap_new_Nviz, METH_VARARGS, NULL},
12163
+ { (char *)"delete_Nviz", _wrap_delete_Nviz, METH_VARARGS, NULL},
12164
+ { (char *)"Nviz_ResizeWindow", _wrap_Nviz_ResizeWindow, METH_VARARGS, NULL},
12165
+ { (char *)"Nviz_SetViewDefault", _wrap_Nviz_SetViewDefault, METH_VARARGS, NULL},
12166
+ { (char *)"Nviz_SetView", _wrap_Nviz_SetView, METH_VARARGS, NULL},
12167
+ { (char *)"Nviz_SetZExag", _wrap_Nviz_SetZExag, METH_VARARGS, NULL},
12168
+ { (char *)"Nviz_SetDisplay", _wrap_Nviz_SetDisplay, METH_VARARGS, NULL},
12169
+ { (char *)"Nviz_InitView", _wrap_Nviz_InitView, METH_VARARGS, NULL},
12170
+ { (char *)"Nviz_SetBgColor", _wrap_Nviz_SetBgColor, METH_VARARGS, NULL},
12171
+ { (char *)"Nviz_SetLightsDefault", _wrap_Nviz_SetLightsDefault, METH_VARARGS, NULL},
12172
+ { (char *)"Nviz_LoadSurface", _wrap_Nviz_LoadSurface, METH_VARARGS, NULL},
12173
+ { (char *)"Nviz_UnloadSurface", _wrap_Nviz_UnloadSurface, METH_VARARGS, NULL},
12174
+ { (char *)"Nviz_LoadVector", _wrap_Nviz_LoadVector, METH_VARARGS, NULL},
12175
+ { (char *)"Nviz_UnloadVector", _wrap_Nviz_UnloadVector, METH_VARARGS, NULL},
12176
+ { (char *)"Nviz_LoadVolume", _wrap_Nviz_LoadVolume, METH_VARARGS, NULL},
12177
+ { (char *)"Nviz_UnloadVolume", _wrap_Nviz_UnloadVolume, METH_VARARGS, NULL},
12178
+ { (char *)"Nviz_Draw", _wrap_Nviz_Draw, METH_VARARGS, NULL},
12179
+ { (char *)"Nviz_EraseMap", _wrap_Nviz_EraseMap, METH_VARARGS, NULL},
12180
+ { (char *)"Nviz_SetSurfaceTopo", _wrap_Nviz_SetSurfaceTopo, METH_VARARGS, NULL},
12181
+ { (char *)"Nviz_SetSurfaceColor", _wrap_Nviz_SetSurfaceColor, METH_VARARGS, NULL},
12182
+ { (char *)"Nviz_SetSurfaceMask", _wrap_Nviz_SetSurfaceMask, METH_VARARGS, NULL},
12183
+ { (char *)"Nviz_SetSurfaceTransp", _wrap_Nviz_SetSurfaceTransp, METH_VARARGS, NULL},
12184
+ { (char *)"Nviz_SetSurfaceShine", _wrap_Nviz_SetSurfaceShine, METH_VARARGS, NULL},
12185
+ { (char *)"Nviz_SetSurfaceEmit", _wrap_Nviz_SetSurfaceEmit, METH_VARARGS, NULL},
12186
+ { (char *)"Nviz_UnsetSurfaceMask", _wrap_Nviz_UnsetSurfaceMask, METH_VARARGS, NULL},
12187
+ { (char *)"Nviz_UnsetSurfaceTransp", _wrap_Nviz_UnsetSurfaceTransp, METH_VARARGS, NULL},
12188
+ { (char *)"Nviz_UnsetSurfaceEmit", _wrap_Nviz_UnsetSurfaceEmit, METH_VARARGS, NULL},
12189
+ { (char *)"Nviz_SetSurfaceRes", _wrap_Nviz_SetSurfaceRes, METH_VARARGS, NULL},
12190
+ { (char *)"Nviz_SetSurfaceStyle", _wrap_Nviz_SetSurfaceStyle, METH_VARARGS, NULL},
12191
+ { (char *)"Nviz_SetWireColor", _wrap_Nviz_SetWireColor, METH_VARARGS, NULL},
12192
+ { (char *)"Nviz_GetSurfacePosition", _wrap_Nviz_GetSurfacePosition, METH_VARARGS, NULL},
12193
+ { (char *)"Nviz_SetSurfacePosition", _wrap_Nviz_SetSurfacePosition, METH_VARARGS, NULL},
12194
+ { (char *)"Nviz_SetVectorLineMode", _wrap_Nviz_SetVectorLineMode, METH_VARARGS, NULL},
12195
+ { (char *)"Nviz_SetVectorLineHeight", _wrap_Nviz_SetVectorLineHeight, METH_VARARGS, NULL},
12196
+ { (char *)"Nviz_SetVectorLineSurface", _wrap_Nviz_SetVectorLineSurface, METH_VARARGS, NULL},
12197
+ { (char *)"Nviz_SetVectorPointMode", _wrap_Nviz_SetVectorPointMode, METH_VARARGS, NULL},
12198
+ { (char *)"Nviz_SetVectorPointHeight", _wrap_Nviz_SetVectorPointHeight, METH_VARARGS, NULL},
12199
+ { (char *)"Nviz_SetVectorPointSurface", _wrap_Nviz_SetVectorPointSurface, METH_VARARGS, NULL},
12200
+ { (char *)"Nviz_AddIsosurface", _wrap_Nviz_AddIsosurface, METH_VARARGS, NULL},
12201
+ { (char *)"Nviz_DeleteIsosurface", _wrap_Nviz_DeleteIsosurface, METH_VARARGS, NULL},
12202
+ { (char *)"Nviz_MoveIsosurface", _wrap_Nviz_MoveIsosurface, METH_VARARGS, NULL},
12203
+ { (char *)"Nviz_SetIsosurfaceColor", _wrap_Nviz_SetIsosurfaceColor, METH_VARARGS, NULL},
12204
+ { (char *)"Nviz_SetIsosurfaceMask", _wrap_Nviz_SetIsosurfaceMask, METH_VARARGS, NULL},
12205
+ { (char *)"Nviz_SetIsosurfaceTransp", _wrap_Nviz_SetIsosurfaceTransp, METH_VARARGS, NULL},
12206
+ { (char *)"Nviz_SetIsosurfaceShine", _wrap_Nviz_SetIsosurfaceShine, METH_VARARGS, NULL},
12207
+ { (char *)"Nviz_SetIsosurfaceEmit", _wrap_Nviz_SetIsosurfaceEmit, METH_VARARGS, NULL},
12208
+ { (char *)"Nviz_UnsetIsosurfaceMask", _wrap_Nviz_UnsetIsosurfaceMask, METH_VARARGS, NULL},
12209
+ { (char *)"Nviz_UnsetIsosurfaceTransp", _wrap_Nviz_UnsetIsosurfaceTransp, METH_VARARGS, NULL},
12210
+ { (char *)"Nviz_UnsetIsosurfaceEmit", _wrap_Nviz_UnsetIsosurfaceEmit, METH_VARARGS, NULL},
12211
+ { (char *)"Nviz_SetIsosurfaceMode", _wrap_Nviz_SetIsosurfaceMode, METH_VARARGS, NULL},
12212
+ { (char *)"Nviz_SetIsosurfaceRes", _wrap_Nviz_SetIsosurfaceRes, METH_VARARGS, NULL},
12213
+ { (char *)"Nviz_swigregister", Nviz_swigregister, METH_VARARGS, NULL},
12214
+ { NULL, NULL, 0, NULL }
12215
+};
12216
+
12217
+
12218
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
12219
+
12220
+static swig_type_info _swigt__p_Nviz = {"_p_Nviz", "Nviz *", 0, 0, (void*)0, 0};
12221
+static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
12222
+static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
12223
+static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
12224
+static swig_type_info _swigt__p_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
12225
+static swig_type_info _swigt__p_mapped_type = {"_p_mapped_type", "mapped_type *", 0, 0, (void*)0, 0};
12226
+static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
12227
+static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
12228
+static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
12229
+static swig_type_info _swigt__p_std__lessT_int_t = {"_p_std__lessT_int_t", "std::less< int > *", 0, 0, (void*)0, 0};
12230
+static swig_type_info _swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t = {"_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t", "std::map< int,std::vector< int > > *|std::map< int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > > *|std::map< int,std::vector< int,std::allocator< int > > > *", 0, 0, (void*)0, 0};
12231
+static swig_type_info _swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type = {"_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type", "std::map< int,std::vector< int > >::allocator_type *|std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > *", 0, 0, (void*)0, 0};
12232
+static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t = {"_p_std__vectorT_double_std__allocatorT_double_t_t", "std::vector< double,std::allocator< double > > *|std::vector< double > *", 0, 0, (void*)0, 0};
12233
+static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type = {"_p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type", "std::vector< double >::allocator_type *|std::allocator< double > *", 0, 0, (void*)0, 0};
12234
+static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|std::vector< int > *", 0, 0, (void*)0, 0};
12235
+static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type = {"_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type", "std::vector< int >::allocator_type *|std::allocator< int > *", 0, 0, (void*)0, 0};
12236
+static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
12237
+static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
12238
+
12239
+static swig_type_info *swig_type_initial[] = {
12240
+ &_swigt__p_Nviz,
12241
+ &_swigt__p_allocator_type,
12242
+ &_swigt__p_char,
12243
+ &_swigt__p_difference_type,
12244
+ &_swigt__p_key_type,
12245
+ &_swigt__p_mapped_type,
12246
+ &_swigt__p_p_PyObject,
12247
+ &_swigt__p_size_type,
12248
+ &_swigt__p_std__invalid_argument,
12249
+ &_swigt__p_std__lessT_int_t,
12250
+ &_swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t,
12251
+ &_swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type,
12252
+ &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t,
12253
+ &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type,
12254
+ &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
12255
+ &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type,
12256
+ &_swigt__p_swig__PySwigIterator,
12257
+ &_swigt__p_value_type,
12258
+};
12259
+
12260
+static swig_cast_info _swigc__p_Nviz[] = { {&_swigt__p_Nviz, 0, 0, 0},{0, 0, 0, 0}};
12261
+static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
12262
+static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
12263
+static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
12264
+static swig_cast_info _swigc__p_key_type[] = { {&_swigt__p_key_type, 0, 0, 0},{0, 0, 0, 0}};
12265
+static swig_cast_info _swigc__p_mapped_type[] = { {&_swigt__p_mapped_type, 0, 0, 0},{0, 0, 0, 0}};
12266
+static swig_cast_info _swigc__p_p_PyObject[] = { {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
12267
+static swig_cast_info _swigc__p_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
12268
+static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
12269
+static swig_cast_info _swigc__p_std__lessT_int_t[] = { {&_swigt__p_std__lessT_int_t, 0, 0, 0},{0, 0, 0, 0}};
12270
+static swig_cast_info _swigc__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t[] = { {&_swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
12271
+static swig_cast_info _swigc__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type[] = { {&_swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
12272
+static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t[] = { {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
12273
+static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
12274
+static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = { {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
12275
+static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
12276
+static swig_cast_info _swigc__p_swig__PySwigIterator[] = { {&_swigt__p_swig__PySwigIterator, 0, 0, 0},{0, 0, 0, 0}};
12277
+static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
12278
+
12279
+static swig_cast_info *swig_cast_initial[] = {
12280
+ _swigc__p_Nviz,
12281
+ _swigc__p_allocator_type,
12282
+ _swigc__p_char,
12283
+ _swigc__p_difference_type,
12284
+ _swigc__p_key_type,
12285
+ _swigc__p_mapped_type,
12286
+ _swigc__p_p_PyObject,
12287
+ _swigc__p_size_type,
12288
+ _swigc__p_std__invalid_argument,
12289
+ _swigc__p_std__lessT_int_t,
12290
+ _swigc__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t,
12291
+ _swigc__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type,
12292
+ _swigc__p_std__vectorT_double_std__allocatorT_double_t_t,
12293
+ _swigc__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type,
12294
+ _swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
12295
+ _swigc__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type,
12296
+ _swigc__p_swig__PySwigIterator,
12297
+ _swigc__p_value_type,
12298
+};
12299
+
12300
+
12301
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
12302
+
12303
+static swig_const_info swig_const_table[] = {
12304
+{0, 0, 0, 0.0, 0, 0}};
12305
+
12306
+#ifdef __cplusplus
12307
+}
12308
+#endif
12309
+/* -----------------------------------------------------------------------------
12310
+ * Type initialization:
12311
+ * This problem is tough by the requirement that no dynamic
12312
+ * memory is used. Also, since swig_type_info structures store pointers to
12313
+ * swig_cast_info structures and swig_cast_info structures store pointers back
12314
+ * to swig_type_info structures, we need some lookup code at initialization.
12315
+ * The idea is that swig generates all the structures that are needed.
12316
+ * The runtime then collects these partially filled structures.
12317
+ * The SWIG_InitializeModule function takes these initial arrays out of
12318
+ * swig_module, and does all the lookup, filling in the swig_module.types
12319
+ * array with the correct data and linking the correct swig_cast_info
12320
+ * structures together.
12321
+ *
12322
+ * The generated swig_type_info structures are assigned staticly to an initial
12323
+ * array. We just loop through that array, and handle each type individually.
12324
+ * First we lookup if this type has been already loaded, and if so, use the
12325
+ * loaded structure instead of the generated one. Then we have to fill in the
12326
+ * cast linked list. The cast data is initially stored in something like a
12327
+ * two-dimensional array. Each row corresponds to a type (there are the same
12328
+ * number of rows as there are in the swig_type_initial array). Each entry in
12329
+ * a column is one of the swig_cast_info structures for that type.
12330
+ * The cast_initial array is actually an array of arrays, because each row has
12331
+ * a variable number of columns. So to actually build the cast linked list,
12332
+ * we find the array of casts associated with the type, and loop through it
12333
+ * adding the casts to the list. The one last trick we need to do is making
12334
+ * sure the type pointer in the swig_cast_info struct is correct.
12335
+ *
12336
+ * First off, we lookup the cast->type name to see if it is already loaded.
12337
+ * There are three cases to handle:
12338
+ * 1) If the cast->type has already been loaded AND the type we are adding
12339
+ * casting info to has not been loaded (it is in this module), THEN we
12340
+ * replace the cast->type pointer with the type pointer that has already
12341
+ * been loaded.
12342
+ * 2) If BOTH types (the one we are adding casting info to, and the
12343
+ * cast->type) are loaded, THEN the cast info has already been loaded by
12344
+ * the previous module so we just ignore it.
12345
+ * 3) Finally, if cast->type has not already been loaded, then we add that
12346
+ * swig_cast_info to the linked list (because the cast->type) pointer will
12347
+ * be correct.
12348
+ * ----------------------------------------------------------------------------- */
12349
+
12350
+#ifdef __cplusplus
12351
+extern "C" {
12352
+#if 0
12353
+} /* c-mode */
12354
+#endif
12355
+#endif
12356
+
12357
+#if 0
12358
+#define SWIGRUNTIME_DEBUG
12359
+#endif
12360
+
12361
+
12362
+SWIGRUNTIME void
12363
+SWIG_InitializeModule(void *clientdata) {
12364
+ size_t i;
12365
+ swig_module_info *module_head, *iter;
12366
+ int found, init;
12367
+
12368
+ clientdata = clientdata;
12369
+
12370
+ /* check to see if the circular list has been setup, if not, set it up */
12371
+ if (swig_module.next==0) {
12372
+ /* Initialize the swig_module */
12373
+ swig_module.type_initial = swig_type_initial;
12374
+ swig_module.cast_initial = swig_cast_initial;
12375
+ swig_module.next = &swig_module;
12376
+ init = 1;
12377
+ } else {
12378
+ init = 0;
12379
+ }
12380
+
12381
+ /* Try and load any already created modules */
12382
+ module_head = SWIG_GetModule(clientdata);
12383
+ if (!module_head) {
12384
+ /* This is the first module loaded for this interpreter */
12385
+ /* so set the swig module into the interpreter */
12386
+ SWIG_SetModule(clientdata, &swig_module);
12387
+ module_head = &swig_module;
12388
+ } else {
12389
+ /* the interpreter has loaded a SWIG module, but has it loaded this one? */
12390
+ found=0;
12391
+ iter=module_head;
12392
+ do {
12393
+ if (iter==&swig_module) {
12394
+ found=1;
12395
+ break;
12396
+ }
12397
+ iter=iter->next;
12398
+ } while (iter!= module_head);
12399
+
12400
+ /* if the is found in the list, then all is done and we may leave */
12401
+ if (found) return;
12402
+ /* otherwise we must add out module into the list */
12403
+ swig_module.next = module_head->next;
12404
+ module_head->next = &swig_module;
12405
+ }
12406
+
12407
+ /* When multiple interpeters are used, a module could have already been initialized in
12408
+ a different interpreter, but not yet have a pointer in this interpreter.
12409
+ In this case, we do not want to continue adding types... everything should be
12410
+ set up already */
12411
+ if (init == 0) return;
12412
+
12413
+ /* Now work on filling in swig_module.types */
12414
+#ifdef SWIGRUNTIME_DEBUG
12415
+ printf("SWIG_InitializeModule: size %d\n", swig_module.size);
12416
+#endif
12417
+ for (i = 0; i < swig_module.size; ++i) {
12418
+ swig_type_info *type = 0;
12419
+ swig_type_info *ret;
12420
+ swig_cast_info *cast;
12421
+
12422
+#ifdef SWIGRUNTIME_DEBUG
12423
+ printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
12424
+#endif
12425
+
12426
+ /* if there is another module already loaded */
12427
+ if (swig_module.next != &swig_module) {
12428
+ type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
12429
+ }
12430
+ if (type) {
12431
+ /* Overwrite clientdata field */
12432
+#ifdef SWIGRUNTIME_DEBUG
12433
+ printf("SWIG_InitializeModule: found type %s\n", type->name);
12434
+#endif
12435
+ if (swig_module.type_initial[i]->clientdata) {
12436
+ type->clientdata = swig_module.type_initial[i]->clientdata;
12437
+#ifdef SWIGRUNTIME_DEBUG
12438
+ printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
12439
+#endif
12440
+ }
12441
+ } else {
12442
+ type = swig_module.type_initial[i];
12443
+ }
12444
+
12445
+ /* Insert casting types */
12446
+ cast = swig_module.cast_initial[i];
12447
+ while (cast->type) {
12448
+ /* Don't need to add information already in the list */
12449
+ ret = 0;
12450
+#ifdef SWIGRUNTIME_DEBUG
12451
+ printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
12452
+#endif
12453
+ if (swig_module.next != &swig_module) {
12454
+ ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
12455
+#ifdef SWIGRUNTIME_DEBUG
12456
+ if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
12457
+#endif
12458
+ }
12459
+ if (ret) {
12460
+ if (type == swig_module.type_initial[i]) {
12461
+#ifdef SWIGRUNTIME_DEBUG
12462
+ printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
12463
+#endif
12464
+ cast->type = ret;
12465
+ ret = 0;
12466
+ } else {
12467
+ /* Check for casting already in the list */
12468
+ swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
12469
+#ifdef SWIGRUNTIME_DEBUG
12470
+ if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
12471
+#endif
12472
+ if (!ocast) ret = 0;
12473
+ }
12474
+ }
12475
+
12476
+ if (!ret) {
12477
+#ifdef SWIGRUNTIME_DEBUG
12478
+ printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
12479
+#endif
12480
+ if (type->cast) {
12481
+ type->cast->prev = cast;
12482
+ cast->next = type->cast;
12483
+ }
12484
+ type->cast = cast;
12485
+ }
12486
+ cast++;
12487
+ }
12488
+ /* Set entry in modules->types array equal to the type */
12489
+ swig_module.types[i] = type;
12490
+ }
12491
+ swig_module.types[i] = 0;
12492
+
12493
+#ifdef SWIGRUNTIME_DEBUG
12494
+ printf("**** SWIG_InitializeModule: Cast List ******\n");
12495
+ for (i = 0; i < swig_module.size; ++i) {
12496
+ int j = 0;
12497
+ swig_cast_info *cast = swig_module.cast_initial[i];
12498
+ printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
12499
+ while (cast->type) {
12500
+ printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
12501
+ cast++;
12502
+ ++j;
12503
+ }
12504
+ printf("---- Total casts: %d\n",j);
12505
+ }
12506
+ printf("**** SWIG_InitializeModule: Cast List ******\n");
12507
+#endif
12508
+}
12509
+
12510
+/* This function will propagate the clientdata field of type to
12511
+* any new swig_type_info structures that have been added into the list
12512
+* of equivalent types. It is like calling
12513
+* SWIG_TypeClientData(type, clientdata) a second time.
12514
+*/
12515
+SWIGRUNTIME void
12516
+SWIG_PropagateClientData(void) {
12517
+ size_t i;
12518
+ swig_cast_info *equiv;
12519
+ static int init_run = 0;
12520
+
12521
+ if (init_run) return;
12522
+ init_run = 1;
12523
+
12524
+ for (i = 0; i < swig_module.size; i++) {
12525
+ if (swig_module.types[i]->clientdata) {
12526
+ equiv = swig_module.types[i]->cast;
12527
+ while (equiv) {
12528
+ if (!equiv->converter) {
12529
+ if (equiv->type && !equiv->type->clientdata)
12530
+ SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
12531
+ }
12532
+ equiv = equiv->next;
12533
+ }
12534
+ }
12535
+ }
12536
+}
12537
+
12538
+#ifdef __cplusplus
12539
+#if 0
12540
+{
12541
+ /* c-mode */
12542
+#endif
12543
+}
12544
+#endif
12545
+
12546
+
12547
+
12548
+#ifdef __cplusplus
12549
+extern "C" {
12550
+#endif
12551
+
12552
+ /* Python-specific SWIG API */
12553
+#define SWIG_newvarlink() SWIG_Python_newvarlink()
12554
+#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
12555
+#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
12556
+
12557
+ /* -----------------------------------------------------------------------------
12558
+ * global variable support code.
12559
+ * ----------------------------------------------------------------------------- */
12560
+
12561
+ typedef struct swig_globalvar {
12562
+ char *name; /* Name of global variable */
12563
+ PyObject *(*get_attr)(void); /* Return the current value */
12564
+ int (*set_attr)(PyObject *); /* Set the value */
12565
+ struct swig_globalvar *next;
12566
+ } swig_globalvar;
12567
+
12568
+ typedef struct swig_varlinkobject {
12569
+ PyObject_HEAD
12570
+ swig_globalvar *vars;
12571
+ } swig_varlinkobject;
12572
+
12573
+ SWIGINTERN PyObject *
12574
+ swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
12575
+ return PyString_FromString("<Swig global variables>");
12576
+ }
12577
+
12578
+ SWIGINTERN PyObject *
12579
+ swig_varlink_str(swig_varlinkobject *v) {
12580
+ PyObject *str = PyString_FromString("(");
12581
+ swig_globalvar *var;
12582
+ for (var = v->vars; var; var=var->next) {
12583
+ PyString_ConcatAndDel(&str,PyString_FromString(var->name));
12584
+ if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
12585
+ }
12586
+ PyString_ConcatAndDel(&str,PyString_FromString(")"));
12587
+ return str;
12588
+ }
12589
+
12590
+ SWIGINTERN int
12591
+ swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
12592
+ PyObject *str = swig_varlink_str(v);
12593
+ fprintf(fp,"Swig global variables ");
12594
+ fprintf(fp,"%s\n", PyString_AsString(str));
12595
+ Py_DECREF(str);
12596
+ return 0;
12597
+ }
12598
+
12599
+ SWIGINTERN void
12600
+ swig_varlink_dealloc(swig_varlinkobject *v) {
12601
+ swig_globalvar *var = v->vars;
12602
+ while (var) {
12603
+ swig_globalvar *n = var->next;
12604
+ free(var->name);
12605
+ free(var);
12606
+ var = n;
12607
+ }
12608
+ }
12609
+
12610
+ SWIGINTERN PyObject *
12611
+ swig_varlink_getattr(swig_varlinkobject *v, char *n) {
12612
+ PyObject *res = NULL;
12613
+ swig_globalvar *var = v->vars;
12614
+ while (var) {
12615
+ if (strcmp(var->name,n) == 0) {
12616
+ res = (*var->get_attr)();
12617
+ break;
12618
+ }
12619
+ var = var->next;
12620
+ }
12621
+ if (res == NULL && !PyErr_Occurred()) {
12622
+ PyErr_SetString(PyExc_NameError,"Unknown C global variable");
12623
+ }
12624
+ return res;
12625
+ }
12626
+
12627
+ SWIGINTERN int
12628
+ swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
12629
+ int res = 1;
12630
+ swig_globalvar *var = v->vars;
12631
+ while (var) {
12632
+ if (strcmp(var->name,n) == 0) {
12633
+ res = (*var->set_attr)(p);
12634
+ break;
12635
+ }
12636
+ var = var->next;
12637
+ }
12638
+ if (res == 1 && !PyErr_Occurred()) {
12639
+ PyErr_SetString(PyExc_NameError,"Unknown C global variable");
12640
+ }
12641
+ return res;
12642
+ }
12643
+
12644
+ SWIGINTERN PyTypeObject*
12645
+ swig_varlink_type(void) {
12646
+ static char varlink__doc__[] = "Swig var link object";
12647
+ static PyTypeObject varlink_type;
12648
+ static int type_init = 0;
12649
+ if (!type_init) {
12650
+ const PyTypeObject tmp
12651
+ = {
12652
+ PyObject_HEAD_INIT(NULL)
12653
+ 0, /* Number of items in variable part (ob_size) */
12654
+ (char *)"swigvarlink", /* Type name (tp_name) */
12655
+ sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
12656
+ 0, /* Itemsize (tp_itemsize) */
12657
+ (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
12658
+ (printfunc) swig_varlink_print, /* Print (tp_print) */
12659
+ (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
12660
+ (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
12661
+ 0, /* tp_compare */
12662
+ (reprfunc) swig_varlink_repr, /* tp_repr */
12663
+ 0, /* tp_as_number */
12664
+ 0, /* tp_as_sequence */
12665
+ 0, /* tp_as_mapping */
12666
+ 0, /* tp_hash */
12667
+ 0, /* tp_call */
12668
+ (reprfunc)swig_varlink_str, /* tp_str */
12669
+ 0, /* tp_getattro */
12670
+ 0, /* tp_setattro */
12671
+ 0, /* tp_as_buffer */
12672
+ 0, /* tp_flags */
12673
+ varlink__doc__, /* tp_doc */
12674
+ 0, /* tp_traverse */
12675
+ 0, /* tp_clear */
12676
+ 0, /* tp_richcompare */
12677
+ 0, /* tp_weaklistoffset */
12678
+#if PY_VERSION_HEX >= 0x02020000
12679
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
12680
+#endif
12681
+#if PY_VERSION_HEX >= 0x02030000
12682
+ 0, /* tp_del */
12683
+#endif
12684
+#ifdef COUNT_ALLOCS
12685
+ 0,0,0,0 /* tp_alloc -> tp_next */
12686
+#endif
12687
+ };
12688
+ varlink_type = tmp;
12689
+ varlink_type.ob_type = &PyType_Type;
12690
+ type_init = 1;
12691
+ }
12692
+ return &varlink_type;
12693
+ }
12694
+
12695
+ /* Create a variable linking object for use later */
12696
+ SWIGINTERN PyObject *
12697
+ SWIG_Python_newvarlink(void) {
12698
+ swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
12699
+ if (result) {
12700
+ result->vars = 0;
12701
+ }
12702
+ return ((PyObject*) result);
12703
+ }
12704
+
12705
+ SWIGINTERN void
12706
+ SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
12707
+ swig_varlinkobject *v = (swig_varlinkobject *) p;
12708
+ swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
12709
+ if (gv) {
12710
+ size_t size = strlen(name)+1;
12711
+ gv->name = (char *)malloc(size);
12712
+ if (gv->name) {
12713
+ strncpy(gv->name,name,size);
12714
+ gv->get_attr = get_attr;
12715
+ gv->set_attr = set_attr;
12716
+ gv->next = v->vars;
12717
+ }
12718
+ }
12719
+ v->vars = gv;
12720
+ }
12721
+
12722
+ SWIGINTERN PyObject *
12723
+ SWIG_globals(void) {
12724
+ static PyObject *_SWIG_globals = 0;
12725
+ if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
12726
+ return _SWIG_globals;
12727
+ }
12728
+
12729
+ /* -----------------------------------------------------------------------------
12730
+ * constants/methods manipulation
12731
+ * ----------------------------------------------------------------------------- */
12732
+
12733
+ /* Install Constants */
12734
+ SWIGINTERN void
12735
+ SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
12736
+ PyObject *obj = 0;
12737
+ size_t i;
12738
+ for (i = 0; constants[i].type; ++i) {
12739
+ switch(constants[i].type) {
12740
+ case SWIG_PY_POINTER:
12741
+ obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
12742
+ break;
12743
+ case SWIG_PY_BINARY:
12744
+ obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
12745
+ break;
12746
+ default:
12747
+ obj = 0;
12748
+ break;
12749
+ }
12750
+ if (obj) {
12751
+ PyDict_SetItemString(d, constants[i].name, obj);
12752
+ Py_DECREF(obj);
12753
+ }
12754
+ }
12755
+ }
12756
+
12757
+ /* -----------------------------------------------------------------------------*/
12758
+ /* Fix SwigMethods to carry the callback ptrs when needed */
12759
+ /* -----------------------------------------------------------------------------*/
12760
+
12761
+ SWIGINTERN void
12762
+ SWIG_Python_FixMethods(PyMethodDef *methods,
12763
+ swig_const_info *const_table,
12764
+ swig_type_info **types,
12765
+ swig_type_info **types_initial) {
12766
+ size_t i;
12767
+ for (i = 0; methods[i].ml_name; ++i) {
12768
+ const char *c = methods[i].ml_doc;
12769
+ if (c && (c = strstr(c, "swig_ptr: "))) {
12770
+ int j;
12771
+ swig_const_info *ci = 0;
12772
+ const char *name = c + 10;
12773
+ for (j = 0; const_table[j].type; ++j) {
12774
+ if (strncmp(const_table[j].name, name,
12775
+ strlen(const_table[j].name)) == 0) {
12776
+ ci = &(const_table[j]);
12777
+ break;
12778
+ }
12779
+ }
12780
+ if (ci) {
12781
+ size_t shift = (ci->ptype) - types;
12782
+ swig_type_info *ty = types_initial[shift];
12783
+ size_t ldoc = (c - methods[i].ml_doc);
12784
+ size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
12785
+ char *ndoc = (char*)malloc(ldoc + lptr + 10);
12786
+ if (ndoc) {
12787
+ char *buff = ndoc;
12788
+ void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
12789
+ if (ptr) {
12790
+ strncpy(buff, methods[i].ml_doc, ldoc);
12791
+ buff += ldoc;
12792
+ strncpy(buff, "swig_ptr: ", 10);
12793
+ buff += 10;
12794
+ SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
12795
+ methods[i].ml_doc = ndoc;
12796
+ }
12797
+ }
12798
+ }
12799
+ }
12800
+ }
12801
+ }
12802
+
12803
+#ifdef __cplusplus
12804
+}
12805
+#endif
12806
+
12807
+/* -----------------------------------------------------------------------------*
12808
+ * Partial Init method
12809
+ * -----------------------------------------------------------------------------*/
12810
+
12811
+#ifdef __cplusplus
12812
+extern "C"
12813
+#endif
12814
+SWIGEXPORT void SWIG_init(void) {
12815
+ PyObject *m, *d;
12816
+
12817
+ /* Fix SwigMethods to carry the callback ptrs when needed */
12818
+ SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
12819
+
12820
+ m = Py_InitModule((char *) SWIG_name, SwigMethods);
12821
+ d = PyModule_GetDict(m);
12822
+
12823
+ SWIG_InitializeModule(0);
12824
+ SWIG_InstallConstants(d,swig_const_table);
12825
+
12826
+
12827
+ SWIG_Python_SetConstant(d, "GV_POINT",SWIG_From_int(static_cast< int >(0x01)));
12828
+ SWIG_Python_SetConstant(d, "GV_LINE",SWIG_From_int(static_cast< int >(0x02)));
12829
+ SWIG_Python_SetConstant(d, "GV_BOUNDARY",SWIG_From_int(static_cast< int >(0x04)));
12830
+ SWIG_Python_SetConstant(d, "GV_CENTROID",SWIG_From_int(static_cast< int >(0x08)));
12831
+ SWIG_Python_SetConstant(d, "GV_FACE",SWIG_From_int(static_cast< int >(0x10)));
12832
+ SWIG_Python_SetConstant(d, "GV_KERNEL",SWIG_From_int(static_cast< int >(0x20)));
12833
+ SWIG_Python_SetConstant(d, "GV_AREA",SWIG_From_int(static_cast< int >(0x40)));
12834
+ SWIG_Python_SetConstant(d, "GV_VOLUME",SWIG_From_int(static_cast< int >(0x80)));
12835
+ SWIG_Python_SetConstant(d, "GV_POINTS",SWIG_From_int(static_cast< int >((0x01|0x08))));
12836
+ SWIG_Python_SetConstant(d, "GV_LINES",SWIG_From_int(static_cast< int >((0x02|0x04))));
12837
+ SWIG_Python_SetConstant(d, "PORT_DOUBLE_MAX",SWIG_From_double(static_cast< double >(1.7976931348623157e+308)));
12838
+ SWIG_Python_SetConstant(d, "VIEW_DEFAULT_POS_X",SWIG_From_double(static_cast< double >(0.85)));
12839
+ SWIG_Python_SetConstant(d, "VIEW_DEFAULT_POS_Y",SWIG_From_double(static_cast< double >(0.85)));
12840
+ SWIG_Python_SetConstant(d, "VIEW_DEFAULT_PERSP",SWIG_From_double(static_cast< double >(40.0)));
12841
+ SWIG_Python_SetConstant(d, "VIEW_DEFAULT_TWIST",SWIG_From_double(static_cast< double >(0.0)));
12842
+ SWIG_Python_SetConstant(d, "VIEW_DEFAULT_ZEXAG",SWIG_From_double(static_cast< double >(1.0)));
12843
+ SWIG_Python_SetConstant(d, "DM_GOURAUD",SWIG_From_int(static_cast< int >(0x00000100)));
12844
+ SWIG_Python_SetConstant(d, "DM_FLAT",SWIG_From_int(static_cast< int >(0x00000200)));
12845
+ SWIG_Python_SetConstant(d, "DM_FRINGE",SWIG_From_int(static_cast< int >(0x00000010)));
12846
+ SWIG_Python_SetConstant(d, "DM_WIRE",SWIG_From_int(static_cast< int >(0x00000001)));
12847
+ SWIG_Python_SetConstant(d, "DM_COL_WIRE",SWIG_From_int(static_cast< int >(0x00000002)));
12848
+ SWIG_Python_SetConstant(d, "DM_POLY",SWIG_From_int(static_cast< int >(0x00000004)));
12849
+ SWIG_Python_SetConstant(d, "DM_WIRE_POLY",SWIG_From_int(static_cast< int >(0x00000008)));
12850
+ SWIG_Python_SetConstant(d, "DM_GRID_WIRE",SWIG_From_int(static_cast< int >(0x00000400)));
12851
+ SWIG_Python_SetConstant(d, "DM_GRID_SURF",SWIG_From_int(static_cast< int >(0x00000800)));
12852
+ SWIG_Python_SetConstant(d, "ST_X",SWIG_From_int(static_cast< int >(1)));
12853
+ SWIG_Python_SetConstant(d, "ST_BOX",SWIG_From_int(static_cast< int >(2)));
12854
+ SWIG_Python_SetConstant(d, "ST_SPHERE",SWIG_From_int(static_cast< int >(3)));
12855
+ SWIG_Python_SetConstant(d, "ST_CUBE",SWIG_From_int(static_cast< int >(4)));
12856
+ SWIG_Python_SetConstant(d, "ST_DIAMOND",SWIG_From_int(static_cast< int >(5)));
12857
+ SWIG_Python_SetConstant(d, "ST_DEC_TREE",SWIG_From_int(static_cast< int >(6)));
12858
+ SWIG_Python_SetConstant(d, "ST_CON_TREE",SWIG_From_int(static_cast< int >(7)));
12859
+ SWIG_Python_SetConstant(d, "ST_ASTER",SWIG_From_int(static_cast< int >(8)));
12860
+ SWIG_Python_SetConstant(d, "ST_GYRO",SWIG_From_int(static_cast< int >(9)));
12861
+ SWIG_Python_SetConstant(d, "ST_HISTOGRAM",SWIG_From_int(static_cast< int >(10)));
12862
+ SWIG_Python_SetConstant(d, "MAX_ISOSURFS",SWIG_From_int(static_cast< int >(12)));
12863
+ SWIG_Python_SetConstant(d, "MAX_SLICES",SWIG_From_int(static_cast< int >(12)));
12864
+ SWIG_Python_SetConstant(d, "DRAW_QUICK_SURFACE",SWIG_From_int(static_cast< int >(0x01)));
12865
+ SWIG_Python_SetConstant(d, "DRAW_QUICK_VLINES",SWIG_From_int(static_cast< int >(0x02)));
12866
+ SWIG_Python_SetConstant(d, "DRAW_QUICK_VPOINTS",SWIG_From_int(static_cast< int >(0x04)));
12867
+ SWIG_Python_SetConstant(d, "DRAW_QUICK_VOLUME",SWIG_From_int(static_cast< int >(0x08)));
12868
+}
12869
+
12870
diff -urNad grass-6.4.0~rc5+39426~/gui/wxpython/nviz/setup.py grass-6.4.0~rc5+39426/gui/wxpython/nviz/setup.py
12871
--- grass-6.4.0~rc5+39426~/gui/wxpython/nviz/setup.py 2009-06-09 15:22:20.000000000 +0200
12872
+++ grass-6.4.0~rc5+39426/gui/wxpython/nviz/setup.py 2009-10-08 00:04:10.000000000 +0200
12873
@@ -49,7 +49,7 @@
12874
"surface.cpp",
12875
"vector.cpp",
12876
"volume.cpp",
12877
- "grass6_wxnviz.i"],
12878
+ "grass6_wxnviz_wrap.cpp"],
12879
swig_opts = ['-c++',
12880
'-shadow'],
12881
define_macros = macros,
12882
diff -urNad grass-6.4.0~rc5+39426~/gui/wxpython/vdigit/Makefile grass-6.4.0~rc5+39426/gui/wxpython/vdigit/Makefile
12883
--- grass-6.4.0~rc5+39426~/gui/wxpython/vdigit/Makefile 2009-10-07 10:48:15.000000000 +0200
12884
+++ grass-6.4.0~rc5+39426/gui/wxpython/vdigit/Makefile 2009-10-08 00:05:02.000000000 +0200
12885
@@ -32,7 +32,7 @@
12886
12887
$(LIB_NAME).py: $(SHLIB)
12888
12889
-$(SHLIB): $(LIB_NAME).i
12890
+$(SHLIB): $(LIB_NAME)_wrap.cpp
12891
python setup.py build_ext --swig=$(SWIG) --swig-opts=-c++ --build-lib=$(OBJDIR) --build-temp=$(OBJDIR)
12892
12893
.NOTPARALLEL: $(LIB_NAME).py $(LIB_NAME)_wrap.cpp
12894
diff -urNad grass-6.4.0~rc5+39426~/gui/wxpython/vdigit/grass6_wxvdigit.i grass-6.4.0~rc5+39426/gui/wxpython/vdigit/grass6_wxvdigit.i
12895
--- grass-6.4.0~rc5+39426~/gui/wxpython/vdigit/grass6_wxvdigit.i 1970-01-01 01:00:00.000000000 +0100
12896
+++ grass-6.4.0~rc5+39426/gui/wxpython/vdigit/grass6_wxvdigit.i 2009-10-08 00:01:13.000000000 +0200
12897
@@ -0,0 +1,423 @@
12898
+/* File: digit.i */
12899
+
12900
+%module grass6_wxvdigit
12901
+%{
12902
+#include <grass/gis.h>
12903
+#include <grass/gisdefs.h>
12904
+#include <grass/Vect.h>
12905
+#include <grass/vect/dig_structs.h>
12906
+#include "driver.h"
12907
+#include "digit.h"
12908
+%}
12909
+
12910
+%include "std_vector.i"
12911
+namespace std {
12912
+ %template(IntVector) vector<int>;
12913
+ %template(DoubleVector) vector<double>;
12914
+}
12915
+%include "std_map.i"
12916
+namespace std {
12917
+ %template(IntVecIntMap) map<int, vector<int> >;
12918
+}
12919
+namespace std {
12920
+ %template(DoubleVecIntMap) map<int, vector<double> >;
12921
+}
12922
+
12923
+%include "driver.h"
12924
+%include "digit.h"
12925
+%{
12926
+#include <wx/wxPython/wxPython.h>
12927
+#include <wx/wxPython/pyclasses.h>
12928
+%}
12929
+
12930
+%{
12931
+#include "pseudodc.h"
12932
+%}
12933
+
12934
+%rename(PseudoDC) gwxPseudoDC;
12935
+
12936
+%typemap(out) wxRect {
12937
+ $result = Py_BuildValue("iiii", $1.x, $1.y, $1.width, $1.height);
12938
+}
12939
+
12940
+class gwxPseudoDC
12941
+{
12942
+public:
12943
+ gwxPseudoDC();
12944
+ ~gwxPseudoDC();
12945
+ void Clear();
12946
+ void RemoveAll();
12947
+ void RemoveId(int id);
12948
+ %extend {
12949
+ void DrawToDC(void *dc) {
12950
+ self->DrawToDC((wxDC *) dc);
12951
+ }
12952
+ void DrawToDCClipped(void *dc, const wxRect& rect) {
12953
+ self->DrawToDCClipped((wxDC *) dc, rect);
12954
+ }
12955
+ wxRect GetIdBounds(int id) {
12956
+ wxRect rect;
12957
+ self->GetIdBounds(id, rect);
12958
+ return rect;
12959
+ }
12960
+ }
12961
+};
12962
+
12963
+/* extracted from include/vect/dig_defines.h */
12964
+
12965
+#define GV_POINT 0x01
12966
+#define GV_LINE 0x02
12967
+#define GV_BOUNDARY 0x04
12968
+#define GV_CENTROID 0x08
12969
+#define GV_FACE 0x10
12970
+#define GV_KERNEL 0x20
12971
+#define GV_AREA 0x40
12972
+#define GV_VOLUME 0x80
12973
+
12974
+#define GV_POINTS (GV_POINT | GV_CENTROID )
12975
+#define GV_LINES (GV_LINE | GV_BOUNDARY )
12976
+
12977
+#define PORT_DOUBLE_MAX 1.7976931348623157e+308
12978
+
12979
+/* extracted from vector/v.edit/lib/vedit.h */
12980
+
12981
+#define NO_SNAP 0 /* snapping disabled */
12982
+#define SNAP 1 /* snapping enabled for nodes */
12983
+#define SNAPVERTEX 2 /* snapping enabled for vertex also */
12984
+
12985
+#define QUERY_UNKNOWN -1
12986
+#define QUERY_LENGTH 0 /* select by line length */
12987
+#define QUERY_DANGLE 1 /* select dangles */
12988
+/* auto-generated swig typedef file */
12989
+#ifndef WXVDIGIT_DRIVER_H
12990
+#define WXVDIGIT_DRIVER_H
12991
+
12992
+#include <iostream> // debug
12993
+#include <vector>
12994
+#include <map>
12995
+#include <cmath>
12996
+
12997
+// For compilers that support precompilation, includes "wx.h".
12998
+#include <wx/wxprec.h>
12999
+
13000
+#ifdef __BORLANDC__
13001
+#pragma hdrstop
13002
+#endif
13003
+
13004
+#ifndef WX_PRECOMP
13005
+// Include your minimal set of headers here, or wx.h
13006
+#include <wx/wx.h>
13007
+#endif
13008
+
13009
+#include <wx/dc.h>
13010
+#include <wx/list.h>
13011
+#include <wx/string.h>
13012
+
13013
+#include <Python.h>
13014
+#include "pseudodc.h"
13015
+#include <wx/gdicmn.h>
13016
+
13017
+extern "C" {
13018
+#include <grass/gis.h>
13019
+#include <grass/Vect.h>
13020
+}
13021
+
13022
+class DisplayDriver
13023
+{
13024
+private:
13025
+ friend class Digit;
13026
+ gwxPseudoDC *dc, *dcTmp; // device content
13027
+ wxWindow *parentWin;
13028
+
13029
+ /* disabled due to expensive calling dc->SetId()
13030
+ *
13031
+ * currently all objects are drawn without id
13032
+ *
13033
+ * only selected lines with id '1'
13034
+ *
13035
+ * segments with unique id (starting with '1')
13036
+ * are drawn only when line was selected using SelectLineByPoint()
13037
+ */
13038
+
13039
+ struct _selected {
13040
+ int field; // field number
13041
+ struct ilist *cats; // list of cats
13042
+ struct ilist *ids; // list of ids
13043
+ struct ilist *idsDupl; // list of duplicated features
13044
+ } selected;
13045
+
13046
+ bool drawSelected;
13047
+
13048
+ bool drawSegments; // draw segments of selected line
13049
+
13050
+ struct Map_info *mapInfo;
13051
+ struct line_pnts *points; // east, north, depth
13052
+ wxList *pointsScreen; // x, y, z
13053
+ struct line_cats *cats;
13054
+
13055
+ struct _region {
13056
+ // GRASS region section
13057
+ BOUND_BOX box; // W,E,N,S,T,B
13058
+ double ns_res;
13059
+ double ew_res;
13060
+ double center_easting;
13061
+ double center_northing;
13062
+
13063
+ // map window section
13064
+ double map_width; // px
13065
+ double map_height;
13066
+ double map_west;
13067
+ double map_north;
13068
+ double map_res;
13069
+ } region;
13070
+
13071
+ struct symbol {
13072
+ bool enabled;
13073
+ wxColor color;
13074
+ };
13075
+
13076
+ struct _settings {
13077
+ wxColor highlight;
13078
+ symbol highlightDupl;
13079
+
13080
+ symbol point;
13081
+ symbol line;
13082
+
13083
+ symbol boundaryNo;
13084
+ symbol boundaryOne;
13085
+ symbol boundaryTwo;
13086
+
13087
+ symbol centroidIn;
13088
+ symbol centroidOut;
13089
+ symbol centroidDup;
13090
+
13091
+ symbol nodeOne;
13092
+ symbol nodeTwo;
13093
+
13094
+ symbol vertex;
13095
+
13096
+ symbol area;
13097
+
13098
+ symbol direction;
13099
+
13100
+ int lineWidth; // screen units
13101
+ } settings;
13102
+
13103
+ struct _topology {
13104
+ long int highlight;
13105
+
13106
+ long int point;
13107
+ long int line;
13108
+
13109
+ long int boundaryNo;
13110
+ long int boundaryOne;
13111
+ long int boundaryTwo;
13112
+
13113
+ long int centroidIn;
13114
+ long int centroidOut;
13115
+ long int centroidDup;
13116
+
13117
+ long int nodeOne;
13118
+ long int nodeTwo;
13119
+
13120
+ long int vertex;
13121
+ } topology;
13122
+
13123
+ void Cell2Pixel (double, double, double,
13124
+ double *, double *, double *);
13125
+ double DistanceInPixels(double);
13126
+
13127
+ int DrawCross(gwxPseudoDC *, int, const wxPoint *, int size=5);
13128
+ int DrawArrow(double, double, double, double, double,
13129
+ int);
13130
+
13131
+ int DrawLine(int);
13132
+ int DrawLineVerteces(int);
13133
+ int DrawLineNodes(int);
13134
+ int DrawDirectionArrow();
13135
+
13136
+ int DrawArea(const line_pnts *);
13137
+
13138
+ /* debug */
13139
+ void PrintIds();
13140
+
13141
+ /* select feature */
13142
+ bool IsSelected(int, bool force=false);
13143
+ bool IsDuplicated(int);
13144
+
13145
+ std::vector<int> ListToVector(struct ilist *);
13146
+ int VectorToList(struct ilist *, const std::vector<int>&);
13147
+
13148
+ void ResetTopology();
13149
+
13150
+ /* message dialogs */
13151
+ wxString msgCaption;
13152
+ void DisplayMsg(void);
13153
+ void Only2DMsg(void);
13154
+ void ReadLineMsg(int);
13155
+ void DeadLineMsg(int);
13156
+ void WriteLineMsg(void);
13157
+ void BackgroundMapMsg(const char *);
13158
+ void DblinkMsg(int);
13159
+ void DbDriverMsg(const char *);
13160
+ void DbDatabaseMsg(const char *, const char *);
13161
+ void DbExecuteMsg(const char *);
13162
+ void DbSelectCursorMsg(const char *);
13163
+ void GetLineCatsMsg(int);
13164
+
13165
+public:
13166
+ /* constructor */
13167
+ DisplayDriver(void *, void *);
13168
+ /* destructor */
13169
+ ~DisplayDriver();
13170
+
13171
+ /* display */
13172
+ int DrawMap(bool);
13173
+
13174
+ /* select */
13175
+ int SelectLinesByBox(double, double, double, double,
13176
+ double, double, int, bool, bool);
13177
+ std::vector<double> SelectLineByPoint(double, double, double,
13178
+ double, int, int);
13179
+
13180
+ std::vector<int> GetSelected(bool);
13181
+ std::map<int, std::vector<double> > GetSelectedCoord();
13182
+ std::map<int, std::vector <int> > GetDuplicates();
13183
+ std::vector<double> GetRegionSelected();
13184
+ int SetSelected(std::vector<int>, int);
13185
+ int UnSelect(std::vector<int>);
13186
+ std::vector<int> GetSelectedVertex(double, double, double);
13187
+ void DrawSelected(bool);
13188
+
13189
+ /* general */
13190
+ int CloseMap();
13191
+ int OpenMap(const char *, const char *, bool);
13192
+ void ReloadMap();
13193
+ void SetDevice(void *);
13194
+
13195
+ /* misc */
13196
+ std::vector<double> GetMapBoundingBox();
13197
+ bool Is3D();
13198
+
13199
+ /* set */
13200
+ void SetRegion(double, double, double, double,
13201
+ double, double,
13202
+ double, double,
13203
+ double, double);
13204
+
13205
+ void UpdateSettings(unsigned long,
13206
+ bool, unsigned long,
13207
+ bool, unsigned long, /* enabled, color */
13208
+ bool, unsigned long,
13209
+ bool, unsigned long,
13210
+ bool, unsigned long,
13211
+ bool, unsigned long,
13212
+ bool, unsigned long,
13213
+ bool, unsigned long,
13214
+ bool, unsigned long,
13215
+ bool, unsigned long,
13216
+ bool, unsigned long,
13217
+ bool, unsigned long,
13218
+ bool, unsigned long,
13219
+ bool, unsigned long,
13220
+ int, int);
13221
+};
13222
+
13223
+int print_error(const char *, int);
13224
+
13225
+#endif /* WXVDIGIT_DRIVER_H */
13226
+#ifndef WXVDIGIT_DIGIT_H
13227
+#define WXVDIGIT_DIGIT_H
13228
+
13229
+#define GSQL_MAX 4000
13230
+
13231
+#include <vector>
13232
+#include <map>
13233
+
13234
+class Digit
13235
+{
13236
+private:
13237
+ /* layer / max category */
13238
+ std::map<int, int> cats;
13239
+
13240
+ DisplayDriver *display;
13241
+
13242
+ int SetCategory(int, int);
13243
+ struct Map_info** OpenBackgroundVectorMap(const char *);
13244
+ int BreakLineAtIntersection(int, struct line_pnts*, int);
13245
+
13246
+ int AddActionsBefore(void);
13247
+ void AddActionsAfter(int, int);
13248
+
13249
+ /* settings */
13250
+ struct _settings {
13251
+ bool breakLines;
13252
+ } settings;
13253
+
13254
+ /* undo/redo */
13255
+ enum action_type { ADD, DEL };
13256
+ struct action_meta {
13257
+ action_type type;
13258
+ int line;
13259
+ long offset;
13260
+ };
13261
+
13262
+ std::map<int, std::vector<action_meta> > changesets;
13263
+ int changesetCurrent; /* first changeset to apply */
13264
+ int changesetEnd; /* last changeset to be applied */
13265
+
13266
+ int AddActionToChangeset(int, action_type, int);
13267
+ int ApplyChangeset(int, bool);
13268
+ void FreeChangeset(int);
13269
+ int RemoveActionFromChangeset(int, action_type, int);
13270
+
13271
+public:
13272
+ Digit(DisplayDriver *, wxWindow *);
13273
+ ~Digit();
13274
+
13275
+ int InitCats();
13276
+
13277
+ int AddLine(int, std::vector<double>, int, int,
13278
+ const char*, int, double);
13279
+ int RewriteLine(int, std::vector<double>,
13280
+ const char*, int, double);
13281
+ int SplitLine(double, double, double,
13282
+ double);
13283
+
13284
+ int DeleteLines(bool);
13285
+ int MoveLines(double, double, double,
13286
+ const char*, int, double);
13287
+ int FlipLines();
13288
+ int MergeLines();
13289
+ int BreakLines();
13290
+ int SnapLines(double);
13291
+ int ConnectLines(double);
13292
+ int TypeConvLines();
13293
+ int ZBulkLabeling(double, double, double, double,
13294
+ double, double);
13295
+ int CopyLines(std::vector<int>, const char*);
13296
+
13297
+ int MoveVertex(double, double, double,
13298
+ double, double, double,
13299
+ const char*, int,
13300
+ double, double);
13301
+ int ModifyLineVertex(int, double, double, double,
13302
+ double);
13303
+
13304
+ std::vector<int> SelectLinesByQuery(double, double, double,
13305
+ double, double, double, bool,
13306
+ int, int, double);
13307
+
13308
+ int CopyCats(std::vector<int>, std::vector<int>, bool);
13309
+ int GetCategory(int);
13310
+ std::map<int, std::vector<int> > GetLineCats(int);
13311
+ int SetLineCats(int, int, std::vector<int>, bool);
13312
+ std::vector<int> GetLayers();
13313
+
13314
+ int Undo(int);
13315
+ int GetUndoLevel();
13316
+
13317
+ void UpdateSettings(bool);
13318
+};
13319
+
13320
+#endif /* WXVDIGIT_DIGIT_H */
13321
diff -urNad grass-6.4.0~rc5+39426~/gui/wxpython/vdigit/grass6_wxvdigit.py grass-6.4.0~rc5+39426/gui/wxpython/vdigit/grass6_wxvdigit.py
13322
--- grass-6.4.0~rc5+39426~/gui/wxpython/vdigit/grass6_wxvdigit.py 1970-01-01 01:00:00.000000000 +0100
13323
+++ grass-6.4.0~rc5+39426/gui/wxpython/vdigit/grass6_wxvdigit.py 2009-10-08 00:01:13.000000000 +0200
13324
@@ -0,0 +1,380 @@
13325
+# This file was automatically generated by SWIG (http://www.swig.org).
13326
+# Version 1.3.36
13327
+#
13328
+# Don't modify this file, modify the SWIG interface instead.
13329
+# This file is compatible with both classic and new-style classes.
13330
+
13331
+import _grass6_wxvdigit
13332
+import new
13333
+new_instancemethod = new.instancemethod
13334
+try:
13335
+ _swig_property = property
13336
+except NameError:
13337
+ pass # Python < 2.2 doesn't have 'property'.
13338
+def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
13339
+ if (name == "thisown"): return self.this.own(value)
13340
+ if (name == "this"):
13341
+ if type(value).__name__ == 'PySwigObject':
13342
+ self.__dict__[name] = value
13343
+ return
13344
+ method = class_type.__swig_setmethods__.get(name,None)
13345
+ if method: return method(self,value)
13346
+ if (not static) or hasattr(self,name):
13347
+ self.__dict__[name] = value
13348
+ else:
13349
+ raise AttributeError("You cannot add attributes to %s" % self)
13350
+
13351
+def _swig_setattr(self,class_type,name,value):
13352
+ return _swig_setattr_nondynamic(self,class_type,name,value,0)
13353
+
13354
+def _swig_getattr(self,class_type,name):
13355
+ if (name == "thisown"): return self.this.own()
13356
+ method = class_type.__swig_getmethods__.get(name,None)
13357
+ if method: return method(self)
13358
+ raise AttributeError,name
13359
+
13360
+def _swig_repr(self):
13361
+ try: strthis = "proxy of " + self.this.__repr__()
13362
+ except: strthis = ""
13363
+ return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
13364
+
13365
+import types
13366
+try:
13367
+ _object = types.ObjectType
13368
+ _newclass = 1
13369
+except AttributeError:
13370
+ class _object : pass
13371
+ _newclass = 0
13372
+del types
13373
+
13374
+
13375
+class PySwigIterator(_object):
13376
+ __swig_setmethods__ = {}
13377
+ __setattr__ = lambda self, name, value: _swig_setattr(self, PySwigIterator, name, value)
13378
+ __swig_getmethods__ = {}
13379
+ __getattr__ = lambda self, name: _swig_getattr(self, PySwigIterator, name)
13380
+ def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
13381
+ __repr__ = _swig_repr
13382
+ __swig_destroy__ = _grass6_wxvdigit.delete_PySwigIterator
13383
+ __del__ = lambda self : None;
13384
+ def value(*args): return _grass6_wxvdigit.PySwigIterator_value(*args)
13385
+ def incr(*args): return _grass6_wxvdigit.PySwigIterator_incr(*args)
13386
+ def decr(*args): return _grass6_wxvdigit.PySwigIterator_decr(*args)
13387
+ def distance(*args): return _grass6_wxvdigit.PySwigIterator_distance(*args)
13388
+ def equal(*args): return _grass6_wxvdigit.PySwigIterator_equal(*args)
13389
+ def copy(*args): return _grass6_wxvdigit.PySwigIterator_copy(*args)
13390
+ def next(*args): return _grass6_wxvdigit.PySwigIterator_next(*args)
13391
+ def previous(*args): return _grass6_wxvdigit.PySwigIterator_previous(*args)
13392
+ def advance(*args): return _grass6_wxvdigit.PySwigIterator_advance(*args)
13393
+ def __eq__(*args): return _grass6_wxvdigit.PySwigIterator___eq__(*args)
13394
+ def __ne__(*args): return _grass6_wxvdigit.PySwigIterator___ne__(*args)
13395
+ def __iadd__(*args): return _grass6_wxvdigit.PySwigIterator___iadd__(*args)
13396
+ def __isub__(*args): return _grass6_wxvdigit.PySwigIterator___isub__(*args)
13397
+ def __add__(*args): return _grass6_wxvdigit.PySwigIterator___add__(*args)
13398
+ def __sub__(*args): return _grass6_wxvdigit.PySwigIterator___sub__(*args)
13399
+ def __iter__(self): return self
13400
+PySwigIterator_swigregister = _grass6_wxvdigit.PySwigIterator_swigregister
13401
+PySwigIterator_swigregister(PySwigIterator)
13402
+
13403
+class IntVector(_object):
13404
+ __swig_setmethods__ = {}
13405
+ __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
13406
+ __swig_getmethods__ = {}
13407
+ __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
13408
+ __repr__ = _swig_repr
13409
+ def iterator(*args): return _grass6_wxvdigit.IntVector_iterator(*args)
13410
+ def __iter__(self): return self.iterator()
13411
+ def __nonzero__(*args): return _grass6_wxvdigit.IntVector___nonzero__(*args)
13412
+ def __len__(*args): return _grass6_wxvdigit.IntVector___len__(*args)
13413
+ def pop(*args): return _grass6_wxvdigit.IntVector_pop(*args)
13414
+ def __getslice__(*args): return _grass6_wxvdigit.IntVector___getslice__(*args)
13415
+ def __setslice__(*args): return _grass6_wxvdigit.IntVector___setslice__(*args)
13416
+ def __delslice__(*args): return _grass6_wxvdigit.IntVector___delslice__(*args)
13417
+ def __delitem__(*args): return _grass6_wxvdigit.IntVector___delitem__(*args)
13418
+ def __getitem__(*args): return _grass6_wxvdigit.IntVector___getitem__(*args)
13419
+ def __setitem__(*args): return _grass6_wxvdigit.IntVector___setitem__(*args)
13420
+ def append(*args): return _grass6_wxvdigit.IntVector_append(*args)
13421
+ def empty(*args): return _grass6_wxvdigit.IntVector_empty(*args)
13422
+ def size(*args): return _grass6_wxvdigit.IntVector_size(*args)
13423
+ def clear(*args): return _grass6_wxvdigit.IntVector_clear(*args)
13424
+ def swap(*args): return _grass6_wxvdigit.IntVector_swap(*args)
13425
+ def get_allocator(*args): return _grass6_wxvdigit.IntVector_get_allocator(*args)
13426
+ def begin(*args): return _grass6_wxvdigit.IntVector_begin(*args)
13427
+ def end(*args): return _grass6_wxvdigit.IntVector_end(*args)
13428
+ def rbegin(*args): return _grass6_wxvdigit.IntVector_rbegin(*args)
13429
+ def rend(*args): return _grass6_wxvdigit.IntVector_rend(*args)
13430
+ def pop_back(*args): return _grass6_wxvdigit.IntVector_pop_back(*args)
13431
+ def erase(*args): return _grass6_wxvdigit.IntVector_erase(*args)
13432
+ def __init__(self, *args):
13433
+ this = _grass6_wxvdigit.new_IntVector(*args)
13434
+ try: self.this.append(this)
13435
+ except: self.this = this
13436
+ def push_back(*args): return _grass6_wxvdigit.IntVector_push_back(*args)
13437
+ def front(*args): return _grass6_wxvdigit.IntVector_front(*args)
13438
+ def back(*args): return _grass6_wxvdigit.IntVector_back(*args)
13439
+ def assign(*args): return _grass6_wxvdigit.IntVector_assign(*args)
13440
+ def resize(*args): return _grass6_wxvdigit.IntVector_resize(*args)
13441
+ def insert(*args): return _grass6_wxvdigit.IntVector_insert(*args)
13442
+ def reserve(*args): return _grass6_wxvdigit.IntVector_reserve(*args)
13443
+ def capacity(*args): return _grass6_wxvdigit.IntVector_capacity(*args)
13444
+ __swig_destroy__ = _grass6_wxvdigit.delete_IntVector
13445
+ __del__ = lambda self : None;
13446
+IntVector_swigregister = _grass6_wxvdigit.IntVector_swigregister
13447
+IntVector_swigregister(IntVector)
13448
+
13449
+class DoubleVector(_object):
13450
+ __swig_setmethods__ = {}
13451
+ __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
13452
+ __swig_getmethods__ = {}
13453
+ __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
13454
+ __repr__ = _swig_repr
13455
+ def iterator(*args): return _grass6_wxvdigit.DoubleVector_iterator(*args)
13456
+ def __iter__(self): return self.iterator()
13457
+ def __nonzero__(*args): return _grass6_wxvdigit.DoubleVector___nonzero__(*args)
13458
+ def __len__(*args): return _grass6_wxvdigit.DoubleVector___len__(*args)
13459
+ def pop(*args): return _grass6_wxvdigit.DoubleVector_pop(*args)
13460
+ def __getslice__(*args): return _grass6_wxvdigit.DoubleVector___getslice__(*args)
13461
+ def __setslice__(*args): return _grass6_wxvdigit.DoubleVector___setslice__(*args)
13462
+ def __delslice__(*args): return _grass6_wxvdigit.DoubleVector___delslice__(*args)
13463
+ def __delitem__(*args): return _grass6_wxvdigit.DoubleVector___delitem__(*args)
13464
+ def __getitem__(*args): return _grass6_wxvdigit.DoubleVector___getitem__(*args)
13465
+ def __setitem__(*args): return _grass6_wxvdigit.DoubleVector___setitem__(*args)
13466
+ def append(*args): return _grass6_wxvdigit.DoubleVector_append(*args)
13467
+ def empty(*args): return _grass6_wxvdigit.DoubleVector_empty(*args)
13468
+ def size(*args): return _grass6_wxvdigit.DoubleVector_size(*args)
13469
+ def clear(*args): return _grass6_wxvdigit.DoubleVector_clear(*args)
13470
+ def swap(*args): return _grass6_wxvdigit.DoubleVector_swap(*args)
13471
+ def get_allocator(*args): return _grass6_wxvdigit.DoubleVector_get_allocator(*args)
13472
+ def begin(*args): return _grass6_wxvdigit.DoubleVector_begin(*args)
13473
+ def end(*args): return _grass6_wxvdigit.DoubleVector_end(*args)
13474
+ def rbegin(*args): return _grass6_wxvdigit.DoubleVector_rbegin(*args)
13475
+ def rend(*args): return _grass6_wxvdigit.DoubleVector_rend(*args)
13476
+ def pop_back(*args): return _grass6_wxvdigit.DoubleVector_pop_back(*args)
13477
+ def erase(*args): return _grass6_wxvdigit.DoubleVector_erase(*args)
13478
+ def __init__(self, *args):
13479
+ this = _grass6_wxvdigit.new_DoubleVector(*args)
13480
+ try: self.this.append(this)
13481
+ except: self.this = this
13482
+ def push_back(*args): return _grass6_wxvdigit.DoubleVector_push_back(*args)
13483
+ def front(*args): return _grass6_wxvdigit.DoubleVector_front(*args)
13484
+ def back(*args): return _grass6_wxvdigit.DoubleVector_back(*args)
13485
+ def assign(*args): return _grass6_wxvdigit.DoubleVector_assign(*args)
13486
+ def resize(*args): return _grass6_wxvdigit.DoubleVector_resize(*args)
13487
+ def insert(*args): return _grass6_wxvdigit.DoubleVector_insert(*args)
13488
+ def reserve(*args): return _grass6_wxvdigit.DoubleVector_reserve(*args)
13489
+ def capacity(*args): return _grass6_wxvdigit.DoubleVector_capacity(*args)
13490
+ __swig_destroy__ = _grass6_wxvdigit.delete_DoubleVector
13491
+ __del__ = lambda self : None;
13492
+DoubleVector_swigregister = _grass6_wxvdigit.DoubleVector_swigregister
13493
+DoubleVector_swigregister(DoubleVector)
13494
+
13495
+class IntVecIntMap(_object):
13496
+ __swig_setmethods__ = {}
13497
+ __setattr__ = lambda self, name, value: _swig_setattr(self, IntVecIntMap, name, value)
13498
+ __swig_getmethods__ = {}
13499
+ __getattr__ = lambda self, name: _swig_getattr(self, IntVecIntMap, name)
13500
+ __repr__ = _swig_repr
13501
+ def iterator(*args): return _grass6_wxvdigit.IntVecIntMap_iterator(*args)
13502
+ def __iter__(self): return self.iterator()
13503
+ def __nonzero__(*args): return _grass6_wxvdigit.IntVecIntMap___nonzero__(*args)
13504
+ def __len__(*args): return _grass6_wxvdigit.IntVecIntMap___len__(*args)
13505
+ def __getitem__(*args): return _grass6_wxvdigit.IntVecIntMap___getitem__(*args)
13506
+ def __delitem__(*args): return _grass6_wxvdigit.IntVecIntMap___delitem__(*args)
13507
+ def has_key(*args): return _grass6_wxvdigit.IntVecIntMap_has_key(*args)
13508
+ def keys(*args): return _grass6_wxvdigit.IntVecIntMap_keys(*args)
13509
+ def values(*args): return _grass6_wxvdigit.IntVecIntMap_values(*args)
13510
+ def items(*args): return _grass6_wxvdigit.IntVecIntMap_items(*args)
13511
+ def __contains__(*args): return _grass6_wxvdigit.IntVecIntMap___contains__(*args)
13512
+ def key_iterator(*args): return _grass6_wxvdigit.IntVecIntMap_key_iterator(*args)
13513
+ def value_iterator(*args): return _grass6_wxvdigit.IntVecIntMap_value_iterator(*args)
13514
+ def __iter__(self): return self.key_iterator()
13515
+ def iterkeys(self): return self.key_iterator()
13516
+ def itervalues(self): return self.value_iterator()
13517
+ def iteritems(self): return self.iterator()
13518
+ def __setitem__(*args): return _grass6_wxvdigit.IntVecIntMap___setitem__(*args)
13519
+ def __init__(self, *args):
13520
+ this = _grass6_wxvdigit.new_IntVecIntMap(*args)
13521
+ try: self.this.append(this)
13522
+ except: self.this = this
13523
+ def empty(*args): return _grass6_wxvdigit.IntVecIntMap_empty(*args)
13524
+ def size(*args): return _grass6_wxvdigit.IntVecIntMap_size(*args)
13525
+ def clear(*args): return _grass6_wxvdigit.IntVecIntMap_clear(*args)
13526
+ def swap(*args): return _grass6_wxvdigit.IntVecIntMap_swap(*args)
13527
+ def get_allocator(*args): return _grass6_wxvdigit.IntVecIntMap_get_allocator(*args)
13528
+ def begin(*args): return _grass6_wxvdigit.IntVecIntMap_begin(*args)
13529
+ def end(*args): return _grass6_wxvdigit.IntVecIntMap_end(*args)
13530
+ def rbegin(*args): return _grass6_wxvdigit.IntVecIntMap_rbegin(*args)
13531
+ def rend(*args): return _grass6_wxvdigit.IntVecIntMap_rend(*args)
13532
+ def count(*args): return _grass6_wxvdigit.IntVecIntMap_count(*args)
13533
+ def erase(*args): return _grass6_wxvdigit.IntVecIntMap_erase(*args)
13534
+ def find(*args): return _grass6_wxvdigit.IntVecIntMap_find(*args)
13535
+ def lower_bound(*args): return _grass6_wxvdigit.IntVecIntMap_lower_bound(*args)
13536
+ def upper_bound(*args): return _grass6_wxvdigit.IntVecIntMap_upper_bound(*args)
13537
+ __swig_destroy__ = _grass6_wxvdigit.delete_IntVecIntMap
13538
+ __del__ = lambda self : None;
13539
+IntVecIntMap_swigregister = _grass6_wxvdigit.IntVecIntMap_swigregister
13540
+IntVecIntMap_swigregister(IntVecIntMap)
13541
+
13542
+class DoubleVecIntMap(_object):
13543
+ __swig_setmethods__ = {}
13544
+ __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVecIntMap, name, value)
13545
+ __swig_getmethods__ = {}
13546
+ __getattr__ = lambda self, name: _swig_getattr(self, DoubleVecIntMap, name)
13547
+ __repr__ = _swig_repr
13548
+ def iterator(*args): return _grass6_wxvdigit.DoubleVecIntMap_iterator(*args)
13549
+ def __iter__(self): return self.iterator()
13550
+ def __nonzero__(*args): return _grass6_wxvdigit.DoubleVecIntMap___nonzero__(*args)
13551
+ def __len__(*args): return _grass6_wxvdigit.DoubleVecIntMap___len__(*args)
13552
+ def __getitem__(*args): return _grass6_wxvdigit.DoubleVecIntMap___getitem__(*args)
13553
+ def __delitem__(*args): return _grass6_wxvdigit.DoubleVecIntMap___delitem__(*args)
13554
+ def has_key(*args): return _grass6_wxvdigit.DoubleVecIntMap_has_key(*args)
13555
+ def keys(*args): return _grass6_wxvdigit.DoubleVecIntMap_keys(*args)
13556
+ def values(*args): return _grass6_wxvdigit.DoubleVecIntMap_values(*args)
13557
+ def items(*args): return _grass6_wxvdigit.DoubleVecIntMap_items(*args)
13558
+ def __contains__(*args): return _grass6_wxvdigit.DoubleVecIntMap___contains__(*args)
13559
+ def key_iterator(*args): return _grass6_wxvdigit.DoubleVecIntMap_key_iterator(*args)
13560
+ def value_iterator(*args): return _grass6_wxvdigit.DoubleVecIntMap_value_iterator(*args)
13561
+ def __iter__(self): return self.key_iterator()
13562
+ def iterkeys(self): return self.key_iterator()
13563
+ def itervalues(self): return self.value_iterator()
13564
+ def iteritems(self): return self.iterator()
13565
+ def __setitem__(*args): return _grass6_wxvdigit.DoubleVecIntMap___setitem__(*args)
13566
+ def __init__(self, *args):
13567
+ this = _grass6_wxvdigit.new_DoubleVecIntMap(*args)
13568
+ try: self.this.append(this)
13569
+ except: self.this = this
13570
+ def empty(*args): return _grass6_wxvdigit.DoubleVecIntMap_empty(*args)
13571
+ def size(*args): return _grass6_wxvdigit.DoubleVecIntMap_size(*args)
13572
+ def clear(*args): return _grass6_wxvdigit.DoubleVecIntMap_clear(*args)
13573
+ def swap(*args): return _grass6_wxvdigit.DoubleVecIntMap_swap(*args)
13574
+ def get_allocator(*args): return _grass6_wxvdigit.DoubleVecIntMap_get_allocator(*args)
13575
+ def begin(*args): return _grass6_wxvdigit.DoubleVecIntMap_begin(*args)
13576
+ def end(*args): return _grass6_wxvdigit.DoubleVecIntMap_end(*args)
13577
+ def rbegin(*args): return _grass6_wxvdigit.DoubleVecIntMap_rbegin(*args)
13578
+ def rend(*args): return _grass6_wxvdigit.DoubleVecIntMap_rend(*args)
13579
+ def count(*args): return _grass6_wxvdigit.DoubleVecIntMap_count(*args)
13580
+ def erase(*args): return _grass6_wxvdigit.DoubleVecIntMap_erase(*args)
13581
+ def find(*args): return _grass6_wxvdigit.DoubleVecIntMap_find(*args)
13582
+ def lower_bound(*args): return _grass6_wxvdigit.DoubleVecIntMap_lower_bound(*args)
13583
+ def upper_bound(*args): return _grass6_wxvdigit.DoubleVecIntMap_upper_bound(*args)
13584
+ __swig_destroy__ = _grass6_wxvdigit.delete_DoubleVecIntMap
13585
+ __del__ = lambda self : None;
13586
+DoubleVecIntMap_swigregister = _grass6_wxvdigit.DoubleVecIntMap_swigregister
13587
+DoubleVecIntMap_swigregister(DoubleVecIntMap)
13588
+
13589
+class DisplayDriver(_object):
13590
+ __swig_setmethods__ = {}
13591
+ __setattr__ = lambda self, name, value: _swig_setattr(self, DisplayDriver, name, value)
13592
+ __swig_getmethods__ = {}
13593
+ __getattr__ = lambda self, name: _swig_getattr(self, DisplayDriver, name)
13594
+ __repr__ = _swig_repr
13595
+ def __init__(self, *args):
13596
+ this = _grass6_wxvdigit.new_DisplayDriver(*args)
13597
+ try: self.this.append(this)
13598
+ except: self.this = this
13599
+ __swig_destroy__ = _grass6_wxvdigit.delete_DisplayDriver
13600
+ __del__ = lambda self : None;
13601
+ def DrawMap(*args): return _grass6_wxvdigit.DisplayDriver_DrawMap(*args)
13602
+ def SelectLinesByBox(*args): return _grass6_wxvdigit.DisplayDriver_SelectLinesByBox(*args)
13603
+ def SelectLineByPoint(*args): return _grass6_wxvdigit.DisplayDriver_SelectLineByPoint(*args)
13604
+ def GetSelected(*args): return _grass6_wxvdigit.DisplayDriver_GetSelected(*args)
13605
+ def GetSelectedCoord(*args): return _grass6_wxvdigit.DisplayDriver_GetSelectedCoord(*args)
13606
+ def GetDuplicates(*args): return _grass6_wxvdigit.DisplayDriver_GetDuplicates(*args)
13607
+ def GetRegionSelected(*args): return _grass6_wxvdigit.DisplayDriver_GetRegionSelected(*args)
13608
+ def SetSelected(*args): return _grass6_wxvdigit.DisplayDriver_SetSelected(*args)
13609
+ def UnSelect(*args): return _grass6_wxvdigit.DisplayDriver_UnSelect(*args)
13610
+ def GetSelectedVertex(*args): return _grass6_wxvdigit.DisplayDriver_GetSelectedVertex(*args)
13611
+ def DrawSelected(*args): return _grass6_wxvdigit.DisplayDriver_DrawSelected(*args)
13612
+ def CloseMap(*args): return _grass6_wxvdigit.DisplayDriver_CloseMap(*args)
13613
+ def OpenMap(*args): return _grass6_wxvdigit.DisplayDriver_OpenMap(*args)
13614
+ def ReloadMap(*args): return _grass6_wxvdigit.DisplayDriver_ReloadMap(*args)
13615
+ def SetDevice(*args): return _grass6_wxvdigit.DisplayDriver_SetDevice(*args)
13616
+ def GetMapBoundingBox(*args): return _grass6_wxvdigit.DisplayDriver_GetMapBoundingBox(*args)
13617
+ def Is3D(*args): return _grass6_wxvdigit.DisplayDriver_Is3D(*args)
13618
+ def SetRegion(*args): return _grass6_wxvdigit.DisplayDriver_SetRegion(*args)
13619
+ def UpdateSettings(*args): return _grass6_wxvdigit.DisplayDriver_UpdateSettings(*args)
13620
+DisplayDriver_swigregister = _grass6_wxvdigit.DisplayDriver_swigregister
13621
+DisplayDriver_swigregister(DisplayDriver)
13622
+
13623
+print_error = _grass6_wxvdigit.print_error
13624
+GSQL_MAX = _grass6_wxvdigit.GSQL_MAX
13625
+class Digit(_object):
13626
+ __swig_setmethods__ = {}
13627
+ __setattr__ = lambda self, name, value: _swig_setattr(self, Digit, name, value)
13628
+ __swig_getmethods__ = {}
13629
+ __getattr__ = lambda self, name: _swig_getattr(self, Digit, name)
13630
+ __repr__ = _swig_repr
13631
+ def __init__(self, *args):
13632
+ this = _grass6_wxvdigit.new_Digit(*args)
13633
+ try: self.this.append(this)
13634
+ except: self.this = this
13635
+ __swig_destroy__ = _grass6_wxvdigit.delete_Digit
13636
+ __del__ = lambda self : None;
13637
+ def InitCats(*args): return _grass6_wxvdigit.Digit_InitCats(*args)
13638
+ def AddLine(*args): return _grass6_wxvdigit.Digit_AddLine(*args)
13639
+ def RewriteLine(*args): return _grass6_wxvdigit.Digit_RewriteLine(*args)
13640
+ def SplitLine(*args): return _grass6_wxvdigit.Digit_SplitLine(*args)
13641
+ def DeleteLines(*args): return _grass6_wxvdigit.Digit_DeleteLines(*args)
13642
+ def MoveLines(*args): return _grass6_wxvdigit.Digit_MoveLines(*args)
13643
+ def FlipLines(*args): return _grass6_wxvdigit.Digit_FlipLines(*args)
13644
+ def MergeLines(*args): return _grass6_wxvdigit.Digit_MergeLines(*args)
13645
+ def BreakLines(*args): return _grass6_wxvdigit.Digit_BreakLines(*args)
13646
+ def SnapLines(*args): return _grass6_wxvdigit.Digit_SnapLines(*args)
13647
+ def ConnectLines(*args): return _grass6_wxvdigit.Digit_ConnectLines(*args)
13648
+ def TypeConvLines(*args): return _grass6_wxvdigit.Digit_TypeConvLines(*args)
13649
+ def ZBulkLabeling(*args): return _grass6_wxvdigit.Digit_ZBulkLabeling(*args)
13650
+ def CopyLines(*args): return _grass6_wxvdigit.Digit_CopyLines(*args)
13651
+ def MoveVertex(*args): return _grass6_wxvdigit.Digit_MoveVertex(*args)
13652
+ def ModifyLineVertex(*args): return _grass6_wxvdigit.Digit_ModifyLineVertex(*args)
13653
+ def SelectLinesByQuery(*args): return _grass6_wxvdigit.Digit_SelectLinesByQuery(*args)
13654
+ def CopyCats(*args): return _grass6_wxvdigit.Digit_CopyCats(*args)
13655
+ def GetCategory(*args): return _grass6_wxvdigit.Digit_GetCategory(*args)
13656
+ def GetLineCats(*args): return _grass6_wxvdigit.Digit_GetLineCats(*args)
13657
+ def SetLineCats(*args): return _grass6_wxvdigit.Digit_SetLineCats(*args)
13658
+ def GetLayers(*args): return _grass6_wxvdigit.Digit_GetLayers(*args)
13659
+ def Undo(*args): return _grass6_wxvdigit.Digit_Undo(*args)
13660
+ def GetUndoLevel(*args): return _grass6_wxvdigit.Digit_GetUndoLevel(*args)
13661
+ def UpdateSettings(*args): return _grass6_wxvdigit.Digit_UpdateSettings(*args)
13662
+Digit_swigregister = _grass6_wxvdigit.Digit_swigregister
13663
+Digit_swigregister(Digit)
13664
+
13665
+class PseudoDC(_object):
13666
+ __swig_setmethods__ = {}
13667
+ __setattr__ = lambda self, name, value: _swig_setattr(self, PseudoDC, name, value)
13668
+ __swig_getmethods__ = {}
13669
+ __getattr__ = lambda self, name: _swig_getattr(self, PseudoDC, name)
13670
+ __repr__ = _swig_repr
13671
+ def __init__(self, *args):
13672
+ this = _grass6_wxvdigit.new_PseudoDC(*args)
13673
+ try: self.this.append(this)
13674
+ except: self.this = this
13675
+ __swig_destroy__ = _grass6_wxvdigit.delete_PseudoDC
13676
+ __del__ = lambda self : None;
13677
+ def Clear(*args): return _grass6_wxvdigit.PseudoDC_Clear(*args)
13678
+ def RemoveAll(*args): return _grass6_wxvdigit.PseudoDC_RemoveAll(*args)
13679
+ def RemoveId(*args): return _grass6_wxvdigit.PseudoDC_RemoveId(*args)
13680
+ def DrawToDC(*args): return _grass6_wxvdigit.PseudoDC_DrawToDC(*args)
13681
+ def DrawToDCClipped(*args): return _grass6_wxvdigit.PseudoDC_DrawToDCClipped(*args)
13682
+ def GetIdBounds(*args): return _grass6_wxvdigit.PseudoDC_GetIdBounds(*args)
13683
+PseudoDC_swigregister = _grass6_wxvdigit.PseudoDC_swigregister
13684
+PseudoDC_swigregister(PseudoDC)
13685
+
13686
+GV_POINT = _grass6_wxvdigit.GV_POINT
13687
+GV_LINE = _grass6_wxvdigit.GV_LINE
13688
+GV_BOUNDARY = _grass6_wxvdigit.GV_BOUNDARY
13689
+GV_CENTROID = _grass6_wxvdigit.GV_CENTROID
13690
+GV_FACE = _grass6_wxvdigit.GV_FACE
13691
+GV_KERNEL = _grass6_wxvdigit.GV_KERNEL
13692
+GV_AREA = _grass6_wxvdigit.GV_AREA
13693
+GV_VOLUME = _grass6_wxvdigit.GV_VOLUME
13694
+GV_POINTS = _grass6_wxvdigit.GV_POINTS
13695
+GV_LINES = _grass6_wxvdigit.GV_LINES
13696
+PORT_DOUBLE_MAX = _grass6_wxvdigit.PORT_DOUBLE_MAX
13697
+NO_SNAP = _grass6_wxvdigit.NO_SNAP
13698
+SNAP = _grass6_wxvdigit.SNAP
13699
+SNAPVERTEX = _grass6_wxvdigit.SNAPVERTEX
13700
+QUERY_UNKNOWN = _grass6_wxvdigit.QUERY_UNKNOWN
13701
+QUERY_LENGTH = _grass6_wxvdigit.QUERY_LENGTH
13702
+QUERY_DANGLE = _grass6_wxvdigit.QUERY_DANGLE
13703
+
13704
+
13705
diff -urNad grass-6.4.0~rc5+39426~/gui/wxpython/vdigit/grass6_wxvdigit_wrap.cpp grass-6.4.0~rc5+39426/gui/wxpython/vdigit/grass6_wxvdigit_wrap.cpp
13706
--- grass-6.4.0~rc5+39426~/gui/wxpython/vdigit/grass6_wxvdigit_wrap.cpp 1970-01-01 01:00:00.000000000 +0100
13707
+++ grass-6.4.0~rc5+39426/gui/wxpython/vdigit/grass6_wxvdigit_wrap.cpp 2009-10-08 00:01:14.000000000 +0200
13708
@@ -0,0 +1,13942 @@
13709
+/* ----------------------------------------------------------------------------
13710
+ * This file was automatically generated by SWIG (http://www.swig.org).
13711
+ * Version 1.3.36
13712
+ *
13713
+ * This file is not intended to be easily readable and contains a number of
13714
+ * coding conventions designed to improve portability and efficiency. Do not make
13715
+ * changes to this file unless you know what you are doing--modify the SWIG
13716
+ * interface file instead.
13717
+ * ----------------------------------------------------------------------------- */
13718
+
13719
+#define SWIGPYTHON
13720
+#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13721
+
13722
+#ifdef __cplusplus
13723
+template<typename T> class SwigValueWrapper {
13724
+ T *tt;
13725
+public:
13726
+ SwigValueWrapper() : tt(0) { }
13727
+ SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
13728
+ SwigValueWrapper(const T& t) : tt(new T(t)) { }
13729
+ ~SwigValueWrapper() { delete tt; }
13730
+ SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
13731
+ operator T&() const { return *tt; }
13732
+ T *operator&() { return tt; }
13733
+private:
13734
+ SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
13735
+};
13736
+
13737
+template <typename T> T SwigValueInit() {
13738
+ return T();
13739
+}
13740
+#endif
13741
+
13742
+/* -----------------------------------------------------------------------------
13743
+ * This section contains generic SWIG labels for method/variable
13744
+ * declarations/attributes, and other compiler dependent labels.
13745
+ * ----------------------------------------------------------------------------- */
13746
+
13747
+/* template workaround for compilers that cannot correctly implement the C++ standard */
13748
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
13749
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
13750
+# define SWIGTEMPLATEDISAMBIGUATOR template
13751
+# elif defined(__HP_aCC)
13752
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
13753
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
13754
+# define SWIGTEMPLATEDISAMBIGUATOR template
13755
+# else
13756
+# define SWIGTEMPLATEDISAMBIGUATOR
13757
+# endif
13758
+#endif
13759
+
13760
+/* inline attribute */
13761
+#ifndef SWIGINLINE
13762
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
13763
+# define SWIGINLINE inline
13764
+# else
13765
+# define SWIGINLINE
13766
+# endif
13767
+#endif
13768
+
13769
+/* attribute recognised by some compilers to avoid 'unused' warnings */
13770
+#ifndef SWIGUNUSED
13771
+# if defined(__GNUC__)
13772
+# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
13773
+# define SWIGUNUSED __attribute__ ((__unused__))
13774
+# else
13775
+# define SWIGUNUSED
13776
+# endif
13777
+# elif defined(__ICC)
13778
+# define SWIGUNUSED __attribute__ ((__unused__))
13779
+# else
13780
+# define SWIGUNUSED
13781
+# endif
13782
+#endif
13783
+
13784
+#ifndef SWIG_MSC_UNSUPPRESS_4505
13785
+# if defined(_MSC_VER)
13786
+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
13787
+# endif
13788
+#endif
13789
+
13790
+#ifndef SWIGUNUSEDPARM
13791
+# ifdef __cplusplus
13792
+# define SWIGUNUSEDPARM(p)
13793
+# else
13794
+# define SWIGUNUSEDPARM(p) p SWIGUNUSED
13795
+# endif
13796
+#endif
13797
+
13798
+/* internal SWIG method */
13799
+#ifndef SWIGINTERN
13800
+# define SWIGINTERN static SWIGUNUSED
13801
+#endif
13802
+
13803
+/* internal inline SWIG method */
13804
+#ifndef SWIGINTERNINLINE
13805
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
13806
+#endif
13807
+
13808
+/* exporting methods */
13809
+#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
13810
+# ifndef GCC_HASCLASSVISIBILITY
13811
+# define GCC_HASCLASSVISIBILITY
13812
+# endif
13813
+#endif
13814
+
13815
+#ifndef SWIGEXPORT
13816
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
13817
+# if defined(STATIC_LINKED)
13818
+# define SWIGEXPORT
13819
+# else
13820
+# define SWIGEXPORT __declspec(dllexport)
13821
+# endif
13822
+# else
13823
+# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
13824
+# define SWIGEXPORT __attribute__ ((visibility("default")))
13825
+# else
13826
+# define SWIGEXPORT
13827
+# endif
13828
+# endif
13829
+#endif
13830
+
13831
+/* calling conventions for Windows */
13832
+#ifndef SWIGSTDCALL
13833
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
13834
+# define SWIGSTDCALL __stdcall
13835
+# else
13836
+# define SWIGSTDCALL
13837
+# endif
13838
+#endif
13839
+
13840
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
13841
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
13842
+# define _CRT_SECURE_NO_DEPRECATE
13843
+#endif
13844
+
13845
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
13846
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
13847
+# define _SCL_SECURE_NO_DEPRECATE
13848
+#endif
13849
+
13850
+
13851
+
13852
+/* Python.h has to appear first */
13853
+#include <Python.h>
13854
+
13855
+/* -----------------------------------------------------------------------------
13856
+ * swigrun.swg
13857
+ *
13858
+ * This file contains generic CAPI SWIG runtime support for pointer
13859
+ * type checking.
13860
+ * ----------------------------------------------------------------------------- */
13861
+
13862
+/* This should only be incremented when either the layout of swig_type_info changes,
13863
+ or for whatever reason, the runtime changes incompatibly */
13864
+#define SWIG_RUNTIME_VERSION "4"
13865
+
13866
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
13867
+#ifdef SWIG_TYPE_TABLE
13868
+# define SWIG_QUOTE_STRING(x) #x
13869
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
13870
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
13871
+#else
13872
+# define SWIG_TYPE_TABLE_NAME
13873
+#endif
13874
+
13875
+/*
13876
+ You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
13877
+ creating a static or dynamic library from the swig runtime code.
13878
+ In 99.9% of the cases, swig just needs to declare them as 'static'.
13879
+
13880
+ But only do this if is strictly necessary, ie, if you have problems
13881
+ with your compiler or so.
13882
+*/
13883
+
13884
+#ifndef SWIGRUNTIME
13885
+# define SWIGRUNTIME SWIGINTERN
13886
+#endif
13887
+
13888
+#ifndef SWIGRUNTIMEINLINE
13889
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
13890
+#endif
13891
+
13892
+/* Generic buffer size */
13893
+#ifndef SWIG_BUFFER_SIZE
13894
+# define SWIG_BUFFER_SIZE 1024
13895
+#endif
13896
+
13897
+/* Flags for pointer conversions */
13898
+#define SWIG_POINTER_DISOWN 0x1
13899
+#define SWIG_CAST_NEW_MEMORY 0x2
13900
+
13901
+/* Flags for new pointer objects */
13902
+#define SWIG_POINTER_OWN 0x1
13903
+
13904
+
13905
+/*
13906
+ Flags/methods for returning states.
13907
+
13908
+ The swig conversion methods, as ConvertPtr, return and integer
13909
+ that tells if the conversion was successful or not. And if not,
13910
+ an error code can be returned (see swigerrors.swg for the codes).
13911
+
13912
+ Use the following macros/flags to set or process the returning
13913
+ states.
13914
+
13915
+ In old swig versions, you usually write code as:
13916
+
13917
+ if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
13918
+ // success code
13919
+ } else {
13920
+ //fail code
13921
+ }
13922
+
13923
+ Now you can be more explicit as:
13924
+
13925
+ int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
13926
+ if (SWIG_IsOK(res)) {
13927
+ // success code
13928
+ } else {
13929
+ // fail code
13930
+ }
13931
+
13932
+ that seems to be the same, but now you can also do
13933
+
13934
+ Type *ptr;
13935
+ int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
13936
+ if (SWIG_IsOK(res)) {
13937
+ // success code
13938
+ if (SWIG_IsNewObj(res) {
13939
+ ...
13940
+ delete *ptr;
13941
+ } else {
13942
+ ...
13943
+ }
13944
+ } else {
13945
+ // fail code
13946
+ }
13947
+
13948
+ I.e., now SWIG_ConvertPtr can return new objects and you can
13949
+ identify the case and take care of the deallocation. Of course that
13950
+ requires also to SWIG_ConvertPtr to return new result values, as
13951
+
13952
+ int SWIG_ConvertPtr(obj, ptr,...) {
13953
+ if (<obj is ok>) {
13954
+ if (<need new object>) {
13955
+ *ptr = <ptr to new allocated object>;
13956
+ return SWIG_NEWOBJ;
13957
+ } else {
13958
+ *ptr = <ptr to old object>;
13959
+ return SWIG_OLDOBJ;
13960
+ }
13961
+ } else {
13962
+ return SWIG_BADOBJ;
13963
+ }
13964
+ }
13965
+
13966
+ Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
13967
+ more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
13968
+ swig errors code.
13969
+
13970
+ Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
13971
+ allows to return the 'cast rank', for example, if you have this
13972
+
13973
+ int food(double)
13974
+ int fooi(int);
13975
+
13976
+ and you call
13977
+
13978
+ food(1) // cast rank '1' (1 -> 1.0)
13979
+ fooi(1) // cast rank '0'
13980
+
13981
+ just use the SWIG_AddCast()/SWIG_CheckState()
13982
+
13983
+
13984
+ */
13985
+#define SWIG_OK (0)
13986
+#define SWIG_ERROR (-1)
13987
+#define SWIG_IsOK(r) (r >= 0)
13988
+#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
13989
+
13990
+/* The CastRankLimit says how many bits are used for the cast rank */
13991
+#define SWIG_CASTRANKLIMIT (1 << 8)
13992
+/* The NewMask denotes the object was created (using new/malloc) */
13993
+#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
13994
+/* The TmpMask is for in/out typemaps that use temporal objects */
13995
+#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
13996
+/* Simple returning values */
13997
+#define SWIG_BADOBJ (SWIG_ERROR)
13998
+#define SWIG_OLDOBJ (SWIG_OK)
13999
+#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
14000
+#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
14001
+/* Check, add and del mask methods */
14002
+#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
14003
+#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
14004
+#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
14005
+#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
14006
+#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
14007
+#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
14008
+
14009
+
14010
+/* Cast-Rank Mode */
14011
+#if defined(SWIG_CASTRANK_MODE)
14012
+# ifndef SWIG_TypeRank
14013
+# define SWIG_TypeRank unsigned long
14014
+# endif
14015
+# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
14016
+# define SWIG_MAXCASTRANK (2)
14017
+# endif
14018
+# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
14019
+# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
14020
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
14021
+ return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
14022
+}
14023
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
14024
+ return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
14025
+}
14026
+#else /* no cast-rank mode */
14027
+# define SWIG_AddCast
14028
+# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
14029
+#endif
14030
+
14031
+
14032
+
14033
+
14034
+#include <string.h>
14035
+
14036
+#ifdef __cplusplus
14037
+extern "C" {
14038
+#endif
14039
+
14040
+typedef void *(*swig_converter_func)(void *, int *);
14041
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
14042
+
14043
+/* Structure to store information on one type */
14044
+typedef struct swig_type_info {
14045
+ const char *name; /* mangled name of this type */
14046
+ const char *str; /* human readable name of this type */
14047
+ swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
14048
+ struct swig_cast_info *cast; /* linked list of types that can cast into this type */
14049
+ void *clientdata; /* language specific type data */
14050
+ int owndata; /* flag if the structure owns the clientdata */
14051
+} swig_type_info;
14052
+
14053
+/* Structure to store a type and conversion function used for casting */
14054
+typedef struct swig_cast_info {
14055
+ swig_type_info *type; /* pointer to type that is equivalent to this type */
14056
+ swig_converter_func converter; /* function to cast the void pointers */
14057
+ struct swig_cast_info *next; /* pointer to next cast in linked list */
14058
+ struct swig_cast_info *prev; /* pointer to the previous cast */
14059
+} swig_cast_info;
14060
+
14061
+/* Structure used to store module information
14062
+ * Each module generates one structure like this, and the runtime collects
14063
+ * all of these structures and stores them in a circularly linked list.*/
14064
+typedef struct swig_module_info {
14065
+ swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
14066
+ size_t size; /* Number of types in this module */
14067
+ struct swig_module_info *next; /* Pointer to next element in circularly linked list */
14068
+ swig_type_info **type_initial; /* Array of initially generated type structures */
14069
+ swig_cast_info **cast_initial; /* Array of initially generated casting structures */
14070
+ void *clientdata; /* Language specific module data */
14071
+} swig_module_info;
14072
+
14073
+/*
14074
+ Compare two type names skipping the space characters, therefore
14075
+ "char*" == "char *" and "Class<int>" == "Class<int >", etc.
14076
+
14077
+ Return 0 when the two name types are equivalent, as in
14078
+ strncmp, but skipping ' '.
14079
+*/
14080
+SWIGRUNTIME int
14081
+SWIG_TypeNameComp(const char *f1, const char *l1,
14082
+ const char *f2, const char *l2) {
14083
+ for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
14084
+ while ((*f1 == ' ') && (f1 != l1)) ++f1;
14085
+ while ((*f2 == ' ') && (f2 != l2)) ++f2;
14086
+ if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
14087
+ }
14088
+ return (int)((l1 - f1) - (l2 - f2));
14089
+}
14090
+
14091
+/*
14092
+ Check type equivalence in a name list like <name1>|<name2>|...
14093
+ Return 0 if not equal, 1 if equal
14094
+*/
14095
+SWIGRUNTIME int
14096
+SWIG_TypeEquiv(const char *nb, const char *tb) {
14097
+ int equiv = 0;
14098
+ const char* te = tb + strlen(tb);
14099
+ const char* ne = nb;
14100
+ while (!equiv && *ne) {
14101
+ for (nb = ne; *ne; ++ne) {
14102
+ if (*ne == '|') break;
14103
+ }
14104
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
14105
+ if (*ne) ++ne;
14106
+ }
14107
+ return equiv;
14108
+}
14109
+
14110
+/*
14111
+ Check type equivalence in a name list like <name1>|<name2>|...
14112
+ Return 0 if equal, -1 if nb < tb, 1 if nb > tb
14113
+*/
14114
+SWIGRUNTIME int
14115
+SWIG_TypeCompare(const char *nb, const char *tb) {
14116
+ int equiv = 0;
14117
+ const char* te = tb + strlen(tb);
14118
+ const char* ne = nb;
14119
+ while (!equiv && *ne) {
14120
+ for (nb = ne; *ne; ++ne) {
14121
+ if (*ne == '|') break;
14122
+ }
14123
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
14124
+ if (*ne) ++ne;
14125
+ }
14126
+ return equiv;
14127
+}
14128
+
14129
+
14130
+/* think of this as a c++ template<> or a scheme macro */
14131
+#define SWIG_TypeCheck_Template(comparison, ty) \
14132
+ if (ty) { \
14133
+ swig_cast_info *iter = ty->cast; \
14134
+ while (iter) { \
14135
+ if (comparison) { \
14136
+ if (iter == ty->cast) return iter; \
14137
+ /* Move iter to the top of the linked list */ \
14138
+ iter->prev->next = iter->next; \
14139
+ if (iter->next) \
14140
+ iter->next->prev = iter->prev; \
14141
+ iter->next = ty->cast; \
14142
+ iter->prev = 0; \
14143
+ if (ty->cast) ty->cast->prev = iter; \
14144
+ ty->cast = iter; \
14145
+ return iter; \
14146
+ } \
14147
+ iter = iter->next; \
14148
+ } \
14149
+ } \
14150
+ return 0
14151
+
14152
+/*
14153
+ Check the typename
14154
+*/
14155
+SWIGRUNTIME swig_cast_info *
14156
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
14157
+ SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
14158
+}
14159
+
14160
+/* Same as previous function, except strcmp is replaced with a pointer comparison */
14161
+SWIGRUNTIME swig_cast_info *
14162
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
14163
+ SWIG_TypeCheck_Template(iter->type == from, into);
14164
+}
14165
+
14166
+/*
14167
+ Cast a pointer up an inheritance hierarchy
14168
+*/
14169
+SWIGRUNTIMEINLINE void *
14170
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
14171
+ return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
14172
+}
14173
+
14174
+/*
14175
+ Dynamic pointer casting. Down an inheritance hierarchy
14176
+*/
14177
+SWIGRUNTIME swig_type_info *
14178
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
14179
+ swig_type_info *lastty = ty;
14180
+ if (!ty || !ty->dcast) return ty;
14181
+ while (ty && (ty->dcast)) {
14182
+ ty = (*ty->dcast)(ptr);
14183
+ if (ty) lastty = ty;
14184
+ }
14185
+ return lastty;
14186
+}
14187
+
14188
+/*
14189
+ Return the name associated with this type
14190
+*/
14191
+SWIGRUNTIMEINLINE const char *
14192
+SWIG_TypeName(const swig_type_info *ty) {
14193
+ return ty->name;
14194
+}
14195
+
14196
+/*
14197
+ Return the pretty name associated with this type,
14198
+ that is an unmangled type name in a form presentable to the user.
14199
+*/
14200
+SWIGRUNTIME const char *
14201
+SWIG_TypePrettyName(const swig_type_info *type) {
14202
+ /* The "str" field contains the equivalent pretty names of the
14203
+ type, separated by vertical-bar characters. We choose
14204
+ to print the last name, as it is often (?) the most
14205
+ specific. */
14206
+ if (!type) return NULL;
14207
+ if (type->str != NULL) {
14208
+ const char *last_name = type->str;
14209
+ const char *s;
14210
+ for (s = type->str; *s; s++)
14211
+ if (*s == '|') last_name = s+1;
14212
+ return last_name;
14213
+ }
14214
+ else
14215
+ return type->name;
14216
+}
14217
+
14218
+/*
14219
+ Set the clientdata field for a type
14220
+*/
14221
+SWIGRUNTIME void
14222
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
14223
+ swig_cast_info *cast = ti->cast;
14224
+ /* if (ti->clientdata == clientdata) return; */
14225
+ ti->clientdata = clientdata;
14226
+
14227
+ while (cast) {
14228
+ if (!cast->converter) {
14229
+ swig_type_info *tc = cast->type;
14230
+ if (!tc->clientdata) {
14231
+ SWIG_TypeClientData(tc, clientdata);
14232
+ }
14233
+ }
14234
+ cast = cast->next;
14235
+ }
14236
+}
14237
+SWIGRUNTIME void
14238
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
14239
+ SWIG_TypeClientData(ti, clientdata);
14240
+ ti->owndata = 1;
14241
+}
14242
+
14243
+/*
14244
+ Search for a swig_type_info structure only by mangled name
14245
+ Search is a O(log #types)
14246
+
14247
+ We start searching at module start, and finish searching when start == end.
14248
+ Note: if start == end at the beginning of the function, we go all the way around
14249
+ the circular list.
14250
+*/
14251
+SWIGRUNTIME swig_type_info *
14252
+SWIG_MangledTypeQueryModule(swig_module_info *start,
14253
+ swig_module_info *end,
14254
+ const char *name) {
14255
+ swig_module_info *iter = start;
14256
+ do {
14257
+ if (iter->size) {
14258
+ register size_t l = 0;
14259
+ register size_t r = iter->size - 1;
14260
+ do {
14261
+ /* since l+r >= 0, we can (>> 1) instead (/ 2) */
14262
+ register size_t i = (l + r) >> 1;
14263
+ const char *iname = iter->types[i]->name;
14264
+ if (iname) {
14265
+ register int compare = strcmp(name, iname);
14266
+ if (compare == 0) {
14267
+ return iter->types[i];
14268
+ } else if (compare < 0) {
14269
+ if (i) {
14270
+ r = i - 1;
14271
+ } else {
14272
+ break;
14273
+ }
14274
+ } else if (compare > 0) {
14275
+ l = i + 1;
14276
+ }
14277
+ } else {
14278
+ break; /* should never happen */
14279
+ }
14280
+ } while (l <= r);
14281
+ }
14282
+ iter = iter->next;
14283
+ } while (iter != end);
14284
+ return 0;
14285
+}
14286
+
14287
+/*
14288
+ Search for a swig_type_info structure for either a mangled name or a human readable name.
14289
+ It first searches the mangled names of the types, which is a O(log #types)
14290
+ If a type is not found it then searches the human readable names, which is O(#types).
14291
+
14292
+ We start searching at module start, and finish searching when start == end.
14293
+ Note: if start == end at the beginning of the function, we go all the way around
14294
+ the circular list.
14295
+*/
14296
+SWIGRUNTIME swig_type_info *
14297
+SWIG_TypeQueryModule(swig_module_info *start,
14298
+ swig_module_info *end,
14299
+ const char *name) {
14300
+ /* STEP 1: Search the name field using binary search */
14301
+ swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
14302
+ if (ret) {
14303
+ return ret;
14304
+ } else {
14305
+ /* STEP 2: If the type hasn't been found, do a complete search
14306
+ of the str field (the human readable name) */
14307
+ swig_module_info *iter = start;
14308
+ do {
14309
+ register size_t i = 0;
14310
+ for (; i < iter->size; ++i) {
14311
+ if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
14312
+ return iter->types[i];
14313
+ }
14314
+ iter = iter->next;
14315
+ } while (iter != end);
14316
+ }
14317
+
14318
+ /* neither found a match */
14319
+ return 0;
14320
+}
14321
+
14322
+/*
14323
+ Pack binary data into a string
14324
+*/
14325
+SWIGRUNTIME char *
14326
+SWIG_PackData(char *c, void *ptr, size_t sz) {
14327
+ static const char hex[17] = "0123456789abcdef";
14328
+ register const unsigned char *u = (unsigned char *) ptr;
14329
+ register const unsigned char *eu = u + sz;
14330
+ for (; u != eu; ++u) {
14331
+ register unsigned char uu = *u;
14332
+ *(c++) = hex[(uu & 0xf0) >> 4];
14333
+ *(c++) = hex[uu & 0xf];
14334
+ }
14335
+ return c;
14336
+}
14337
+
14338
+/*
14339
+ Unpack binary data from a string
14340
+*/
14341
+SWIGRUNTIME const char *
14342
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
14343
+ register unsigned char *u = (unsigned char *) ptr;
14344
+ register const unsigned char *eu = u + sz;
14345
+ for (; u != eu; ++u) {
14346
+ register char d = *(c++);
14347
+ register unsigned char uu;
14348
+ if ((d >= '0') && (d <= '9'))
14349
+ uu = ((d - '0') << 4);
14350
+ else if ((d >= 'a') && (d <= 'f'))
14351
+ uu = ((d - ('a'-10)) << 4);
14352
+ else
14353
+ return (char *) 0;
14354
+ d = *(c++);
14355
+ if ((d >= '0') && (d <= '9'))
14356
+ uu |= (d - '0');
14357
+ else if ((d >= 'a') && (d <= 'f'))
14358
+ uu |= (d - ('a'-10));
14359
+ else
14360
+ return (char *) 0;
14361
+ *u = uu;
14362
+ }
14363
+ return c;
14364
+}
14365
+
14366
+/*
14367
+ Pack 'void *' into a string buffer.
14368
+*/
14369
+SWIGRUNTIME char *
14370
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
14371
+ char *r = buff;
14372
+ if ((2*sizeof(void *) + 2) > bsz) return 0;
14373
+ *(r++) = '_';
14374
+ r = SWIG_PackData(r,&ptr,sizeof(void *));
14375
+ if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
14376
+ strcpy(r,name);
14377
+ return buff;
14378
+}
14379
+
14380
+SWIGRUNTIME const char *
14381
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
14382
+ if (*c != '_') {
14383
+ if (strcmp(c,"NULL") == 0) {
14384
+ *ptr = (void *) 0;
14385
+ return name;
14386
+ } else {
14387
+ return 0;
14388
+ }
14389
+ }
14390
+ return SWIG_UnpackData(++c,ptr,sizeof(void *));
14391
+}
14392
+
14393
+SWIGRUNTIME char *
14394
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
14395
+ char *r = buff;
14396
+ size_t lname = (name ? strlen(name) : 0);
14397
+ if ((2*sz + 2 + lname) > bsz) return 0;
14398
+ *(r++) = '_';
14399
+ r = SWIG_PackData(r,ptr,sz);
14400
+ if (lname) {
14401
+ strncpy(r,name,lname+1);
14402
+ } else {
14403
+ *r = 0;
14404
+ }
14405
+ return buff;
14406
+}
14407
+
14408
+SWIGRUNTIME const char *
14409
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
14410
+ if (*c != '_') {
14411
+ if (strcmp(c,"NULL") == 0) {
14412
+ memset(ptr,0,sz);
14413
+ return name;
14414
+ } else {
14415
+ return 0;
14416
+ }
14417
+ }
14418
+ return SWIG_UnpackData(++c,ptr,sz);
14419
+}
14420
+
14421
+#ifdef __cplusplus
14422
+}
14423
+#endif
14424
+
14425
+/* Errors in SWIG */
14426
+#define SWIG_UnknownError -1
14427
+#define SWIG_IOError -2
14428
+#define SWIG_RuntimeError -3
14429
+#define SWIG_IndexError -4
14430
+#define SWIG_TypeError -5
14431
+#define SWIG_DivisionByZero -6
14432
+#define SWIG_OverflowError -7
14433
+#define SWIG_SyntaxError -8
14434
+#define SWIG_ValueError -9
14435
+#define SWIG_SystemError -10
14436
+#define SWIG_AttributeError -11
14437
+#define SWIG_MemoryError -12
14438
+#define SWIG_NullReferenceError -13
14439
+
14440
+
14441
+
14442
+
14443
+/* Add PyOS_snprintf for old Pythons */
14444
+#if PY_VERSION_HEX < 0x02020000
14445
+# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
14446
+# define PyOS_snprintf _snprintf
14447
+# else
14448
+# define PyOS_snprintf snprintf
14449
+# endif
14450
+#endif
14451
+
14452
+/* A crude PyString_FromFormat implementation for old Pythons */
14453
+#if PY_VERSION_HEX < 0x02020000
14454
+
14455
+#ifndef SWIG_PYBUFFER_SIZE
14456
+# define SWIG_PYBUFFER_SIZE 1024
14457
+#endif
14458
+
14459
+static PyObject *
14460
+PyString_FromFormat(const char *fmt, ...) {
14461
+ va_list ap;
14462
+ char buf[SWIG_PYBUFFER_SIZE * 2];
14463
+ int res;
14464
+ va_start(ap, fmt);
14465
+ res = vsnprintf(buf, sizeof(buf), fmt, ap);
14466
+ va_end(ap);
14467
+ return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
14468
+}
14469
+#endif
14470
+
14471
+/* Add PyObject_Del for old Pythons */
14472
+#if PY_VERSION_HEX < 0x01060000
14473
+# define PyObject_Del(op) PyMem_DEL((op))
14474
+#endif
14475
+#ifndef PyObject_DEL
14476
+# define PyObject_DEL PyObject_Del
14477
+#endif
14478
+
14479
+/* A crude PyExc_StopIteration exception for old Pythons */
14480
+#if PY_VERSION_HEX < 0x02020000
14481
+# ifndef PyExc_StopIteration
14482
+# define PyExc_StopIteration PyExc_RuntimeError
14483
+# endif
14484
+# ifndef PyObject_GenericGetAttr
14485
+# define PyObject_GenericGetAttr 0
14486
+# endif
14487
+#endif
14488
+/* Py_NotImplemented is defined in 2.1 and up. */
14489
+#if PY_VERSION_HEX < 0x02010000
14490
+# ifndef Py_NotImplemented
14491
+# define Py_NotImplemented PyExc_RuntimeError
14492
+# endif
14493
+#endif
14494
+
14495
+
14496
+/* A crude PyString_AsStringAndSize implementation for old Pythons */
14497
+#if PY_VERSION_HEX < 0x02010000
14498
+# ifndef PyString_AsStringAndSize
14499
+# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
14500
+# endif
14501
+#endif
14502
+
14503
+/* PySequence_Size for old Pythons */
14504
+#if PY_VERSION_HEX < 0x02000000
14505
+# ifndef PySequence_Size
14506
+# define PySequence_Size PySequence_Length
14507
+# endif
14508
+#endif
14509
+
14510
+
14511
+/* PyBool_FromLong for old Pythons */
14512
+#if PY_VERSION_HEX < 0x02030000
14513
+static
14514
+PyObject *PyBool_FromLong(long ok)
14515
+{
14516
+ PyObject *result = ok ? Py_True : Py_False;
14517
+ Py_INCREF(result);
14518
+ return result;
14519
+}
14520
+#endif
14521
+
14522
+/* Py_ssize_t for old Pythons */
14523
+/* This code is as recommended by: */
14524
+/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
14525
+#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
14526
+typedef int Py_ssize_t;
14527
+# define PY_SSIZE_T_MAX INT_MAX
14528
+# define PY_SSIZE_T_MIN INT_MIN
14529
+#endif
14530
+
14531
+/* -----------------------------------------------------------------------------
14532
+ * error manipulation
14533
+ * ----------------------------------------------------------------------------- */
14534
+
14535
+SWIGRUNTIME PyObject*
14536
+SWIG_Python_ErrorType(int code) {
14537
+ PyObject* type = 0;
14538
+ switch(code) {
14539
+ case SWIG_MemoryError:
14540
+ type = PyExc_MemoryError;
14541
+ break;
14542
+ case SWIG_IOError:
14543
+ type = PyExc_IOError;
14544
+ break;
14545
+ case SWIG_RuntimeError:
14546
+ type = PyExc_RuntimeError;
14547
+ break;
14548
+ case SWIG_IndexError:
14549
+ type = PyExc_IndexError;
14550
+ break;
14551
+ case SWIG_TypeError:
14552
+ type = PyExc_TypeError;
14553
+ break;
14554
+ case SWIG_DivisionByZero:
14555
+ type = PyExc_ZeroDivisionError;
14556
+ break;
14557
+ case SWIG_OverflowError:
14558
+ type = PyExc_OverflowError;
14559
+ break;
14560
+ case SWIG_SyntaxError:
14561
+ type = PyExc_SyntaxError;
14562
+ break;
14563
+ case SWIG_ValueError:
14564
+ type = PyExc_ValueError;
14565
+ break;
14566
+ case SWIG_SystemError:
14567
+ type = PyExc_SystemError;
14568
+ break;
14569
+ case SWIG_AttributeError:
14570
+ type = PyExc_AttributeError;
14571
+ break;
14572
+ default:
14573
+ type = PyExc_RuntimeError;
14574
+ }
14575
+ return type;
14576
+}
14577
+
14578
+
14579
+SWIGRUNTIME void
14580
+SWIG_Python_AddErrorMsg(const char* mesg)
14581
+{
14582
+ PyObject *type = 0;
14583
+ PyObject *value = 0;
14584
+ PyObject *traceback = 0;
14585
+
14586
+ if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
14587
+ if (value) {
14588
+ PyObject *old_str = PyObject_Str(value);
14589
+ PyErr_Clear();
14590
+ Py_XINCREF(type);
14591
+ PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
14592
+ Py_DECREF(old_str);
14593
+ Py_DECREF(value);
14594
+ } else {
14595
+ PyErr_SetString(PyExc_RuntimeError, mesg);
14596
+ }
14597
+}
14598
+
14599
+
14600
+
14601
+#if defined(SWIG_PYTHON_NO_THREADS)
14602
+# if defined(SWIG_PYTHON_THREADS)
14603
+# undef SWIG_PYTHON_THREADS
14604
+# endif
14605
+#endif
14606
+#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
14607
+# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
14608
+# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
14609
+# define SWIG_PYTHON_USE_GIL
14610
+# endif
14611
+# endif
14612
+# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
14613
+# ifndef SWIG_PYTHON_INITIALIZE_THREADS
14614
+# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
14615
+# endif
14616
+# ifdef __cplusplus /* C++ code */
14617
+ class SWIG_Python_Thread_Block {
14618
+ bool status;
14619
+ PyGILState_STATE state;
14620
+ public:
14621
+ void end() { if (status) { PyGILState_Release(state); status = false;} }
14622
+ SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
14623
+ ~SWIG_Python_Thread_Block() { end(); }
14624
+ };
14625
+ class SWIG_Python_Thread_Allow {
14626
+ bool status;
14627
+ PyThreadState *save;
14628
+ public:
14629
+ void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
14630
+ SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
14631
+ ~SWIG_Python_Thread_Allow() { end(); }
14632
+ };
14633
+# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
14634
+# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
14635
+# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
14636
+# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
14637
+# else /* C code */
14638
+# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
14639
+# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
14640
+# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
14641
+# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
14642
+# endif
14643
+# else /* Old thread way, not implemented, user must provide it */
14644
+# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
14645
+# define SWIG_PYTHON_INITIALIZE_THREADS
14646
+# endif
14647
+# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
14648
+# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
14649
+# endif
14650
+# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
14651
+# define SWIG_PYTHON_THREAD_END_BLOCK
14652
+# endif
14653
+# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
14654
+# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
14655
+# endif
14656
+# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
14657
+# define SWIG_PYTHON_THREAD_END_ALLOW
14658
+# endif
14659
+# endif
14660
+#else /* No thread support */
14661
+# define SWIG_PYTHON_INITIALIZE_THREADS
14662
+# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
14663
+# define SWIG_PYTHON_THREAD_END_BLOCK
14664
+# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
14665
+# define SWIG_PYTHON_THREAD_END_ALLOW
14666
+#endif
14667
+
14668
+/* -----------------------------------------------------------------------------
14669
+ * Python API portion that goes into the runtime
14670
+ * ----------------------------------------------------------------------------- */
14671
+
14672
+#ifdef __cplusplus
14673
+extern "C" {
14674
+#if 0
14675
+} /* cc-mode */
14676
+#endif
14677
+#endif
14678
+
14679
+/* -----------------------------------------------------------------------------
14680
+ * Constant declarations
14681
+ * ----------------------------------------------------------------------------- */
14682
+
14683
+/* Constant Types */
14684
+#define SWIG_PY_POINTER 4
14685
+#define SWIG_PY_BINARY 5
14686
+
14687
+/* Constant information structure */
14688
+typedef struct swig_const_info {
14689
+ int type;
14690
+ char *name;
14691
+ long lvalue;
14692
+ double dvalue;
14693
+ void *pvalue;
14694
+ swig_type_info **ptype;
14695
+} swig_const_info;
14696
+
14697
+#ifdef __cplusplus
14698
+#if 0
14699
+{ /* cc-mode */
14700
+#endif
14701
+}
14702
+#endif
14703
+
14704
+
14705
+/* -----------------------------------------------------------------------------
14706
+ * See the LICENSE file for information on copyright, usage and redistribution
14707
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
14708
+ *
14709
+ * pyrun.swg
14710
+ *
14711
+ * This file contains the runtime support for Python modules
14712
+ * and includes code for managing global variables and pointer
14713
+ * type checking.
14714
+ *
14715
+ * ----------------------------------------------------------------------------- */
14716
+
14717
+/* Common SWIG API */
14718
+
14719
+/* for raw pointers */
14720
+#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
14721
+#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
14722
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
14723
+#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
14724
+#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
14725
+#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
14726
+#define swig_owntype int
14727
+
14728
+/* for raw packed data */
14729
+#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
14730
+#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
14731
+
14732
+/* for class or struct pointers */
14733
+#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
14734
+#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
14735
+
14736
+/* for C or C++ function pointers */
14737
+#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
14738
+#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
14739
+
14740
+/* for C++ member pointers, ie, member methods */
14741
+#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
14742
+#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
14743
+
14744
+
14745
+/* Runtime API */
14746
+
14747
+#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
14748
+#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
14749
+#define SWIG_NewClientData(obj) PySwigClientData_New(obj)
14750
+
14751
+#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
14752
+#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
14753
+#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
14754
+#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
14755
+#define SWIG_fail goto fail
14756
+
14757
+
14758
+/* Runtime API implementation */
14759
+
14760
+/* Error manipulation */
14761
+
14762
+SWIGINTERN void
14763
+SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
14764
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
14765
+ PyErr_SetObject(errtype, obj);
14766
+ Py_DECREF(obj);
14767
+ SWIG_PYTHON_THREAD_END_BLOCK;
14768
+}
14769
+
14770
+SWIGINTERN void
14771
+SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
14772
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
14773
+ PyErr_SetString(errtype, (char *) msg);
14774
+ SWIG_PYTHON_THREAD_END_BLOCK;
14775
+}
14776
+
14777
+#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
14778
+
14779
+/* Set a constant value */
14780
+
14781
+SWIGINTERN void
14782
+SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
14783
+ PyDict_SetItemString(d, (char*) name, obj);
14784
+ Py_DECREF(obj);
14785
+}
14786
+
14787
+/* Append a value to the result obj */
14788
+
14789
+SWIGINTERN PyObject*
14790
+SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
14791
+#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
14792
+ if (!result) {
14793
+ result = obj;
14794
+ } else if (result == Py_None) {
14795
+ Py_DECREF(result);
14796
+ result = obj;
14797
+ } else {
14798
+ if (!PyList_Check(result)) {
14799
+ PyObject *o2 = result;
14800
+ result = PyList_New(1);
14801
+ PyList_SetItem(result, 0, o2);
14802
+ }
14803
+ PyList_Append(result,obj);
14804
+ Py_DECREF(obj);
14805
+ }
14806
+ return result;
14807
+#else
14808
+ PyObject* o2;
14809
+ PyObject* o3;
14810
+ if (!result) {
14811
+ result = obj;
14812
+ } else if (result == Py_None) {
14813
+ Py_DECREF(result);
14814
+ result = obj;
14815
+ } else {
14816
+ if (!PyTuple_Check(result)) {
14817
+ o2 = result;
14818
+ result = PyTuple_New(1);
14819
+ PyTuple_SET_ITEM(result, 0, o2);
14820
+ }
14821
+ o3 = PyTuple_New(1);
14822
+ PyTuple_SET_ITEM(o3, 0, obj);
14823
+ o2 = result;
14824
+ result = PySequence_Concat(o2, o3);
14825
+ Py_DECREF(o2);
14826
+ Py_DECREF(o3);
14827
+ }
14828
+ return result;
14829
+#endif
14830
+}
14831
+
14832
+/* Unpack the argument tuple */
14833
+
14834
+SWIGINTERN int
14835
+SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
14836
+{
14837
+ if (!args) {
14838
+ if (!min && !max) {
14839
+ return 1;
14840
+ } else {
14841
+ PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
14842
+ name, (min == max ? "" : "at least "), (int)min);
14843
+ return 0;
14844
+ }
14845
+ }
14846
+ if (!PyTuple_Check(args)) {
14847
+ PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
14848
+ return 0;
14849
+ } else {
14850
+ register Py_ssize_t l = PyTuple_GET_SIZE(args);
14851
+ if (l < min) {
14852
+ PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
14853
+ name, (min == max ? "" : "at least "), (int)min, (int)l);
14854
+ return 0;
14855
+ } else if (l > max) {
14856
+ PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
14857
+ name, (min == max ? "" : "at most "), (int)max, (int)l);
14858
+ return 0;
14859
+ } else {
14860
+ register int i;
14861
+ for (i = 0; i < l; ++i) {
14862
+ objs[i] = PyTuple_GET_ITEM(args, i);
14863
+ }
14864
+ for (; l < max; ++l) {
14865
+ objs[l] = 0;
14866
+ }
14867
+ return i + 1;
14868
+ }
14869
+ }
14870
+}
14871
+
14872
+/* A functor is a function object with one single object argument */
14873
+#if PY_VERSION_HEX >= 0x02020000
14874
+#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
14875
+#else
14876
+#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
14877
+#endif
14878
+
14879
+/*
14880
+ Helper for static pointer initialization for both C and C++ code, for example
14881
+ static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
14882
+*/
14883
+#ifdef __cplusplus
14884
+#define SWIG_STATIC_POINTER(var) var
14885
+#else
14886
+#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
14887
+#endif
14888
+
14889
+/* -----------------------------------------------------------------------------
14890
+ * Pointer declarations
14891
+ * ----------------------------------------------------------------------------- */
14892
+
14893
+/* Flags for new pointer objects */
14894
+#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
14895
+#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
14896
+
14897
+#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
14898
+
14899
+#ifdef __cplusplus
14900
+extern "C" {
14901
+#if 0
14902
+} /* cc-mode */
14903
+#endif
14904
+#endif
14905
+
14906
+/* How to access Py_None */
14907
+#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
14908
+# ifndef SWIG_PYTHON_NO_BUILD_NONE
14909
+# ifndef SWIG_PYTHON_BUILD_NONE
14910
+# define SWIG_PYTHON_BUILD_NONE
14911
+# endif
14912
+# endif
14913
+#endif
14914
+
14915
+#ifdef SWIG_PYTHON_BUILD_NONE
14916
+# ifdef Py_None
14917
+# undef Py_None
14918
+# define Py_None SWIG_Py_None()
14919
+# endif
14920
+SWIGRUNTIMEINLINE PyObject *
14921
+_SWIG_Py_None(void)
14922
+{
14923
+ PyObject *none = Py_BuildValue((char*)"");
14924
+ Py_DECREF(none);
14925
+ return none;
14926
+}
14927
+SWIGRUNTIME PyObject *
14928
+SWIG_Py_None(void)
14929
+{
14930
+ static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
14931
+ return none;
14932
+}
14933
+#endif
14934
+
14935
+/* The python void return value */
14936
+
14937
+SWIGRUNTIMEINLINE PyObject *
14938
+SWIG_Py_Void(void)
14939
+{
14940
+ PyObject *none = Py_None;
14941
+ Py_INCREF(none);
14942
+ return none;
14943
+}
14944
+
14945
+/* PySwigClientData */
14946
+
14947
+typedef struct {
14948
+ PyObject *klass;
14949
+ PyObject *newraw;
14950
+ PyObject *newargs;
14951
+ PyObject *destroy;
14952
+ int delargs;
14953
+ int implicitconv;
14954
+} PySwigClientData;
14955
+
14956
+SWIGRUNTIMEINLINE int
14957
+SWIG_Python_CheckImplicit(swig_type_info *ty)
14958
+{
14959
+ PySwigClientData *data = (PySwigClientData *)ty->clientdata;
14960
+ return data ? data->implicitconv : 0;
14961
+}
14962
+
14963
+SWIGRUNTIMEINLINE PyObject *
14964
+SWIG_Python_ExceptionType(swig_type_info *desc) {
14965
+ PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
14966
+ PyObject *klass = data ? data->klass : 0;
14967
+ return (klass ? klass : PyExc_RuntimeError);
14968
+}
14969
+
14970
+
14971
+SWIGRUNTIME PySwigClientData *
14972
+PySwigClientData_New(PyObject* obj)
14973
+{
14974
+ if (!obj) {
14975
+ return 0;
14976
+ } else {
14977
+ PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
14978
+ /* the klass element */
14979
+ data->klass = obj;
14980
+ Py_INCREF(data->klass);
14981
+ /* the newraw method and newargs arguments used to create a new raw instance */
14982
+ if (PyClass_Check(obj)) {
14983
+ data->newraw = 0;
14984
+ data->newargs = obj;
14985
+ Py_INCREF(obj);
14986
+ } else {
14987
+#if (PY_VERSION_HEX < 0x02020000)
14988
+ data->newraw = 0;
14989
+#else
14990
+ data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
14991
+#endif
14992
+ if (data->newraw) {
14993
+ Py_INCREF(data->newraw);
14994
+ data->newargs = PyTuple_New(1);
14995
+ PyTuple_SetItem(data->newargs, 0, obj);
14996
+ } else {
14997
+ data->newargs = obj;
14998
+ }
14999
+ Py_INCREF(data->newargs);
15000
+ }
15001
+ /* the destroy method, aka as the C++ delete method */
15002
+ data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
15003
+ if (PyErr_Occurred()) {
15004
+ PyErr_Clear();
15005
+ data->destroy = 0;
15006
+ }
15007
+ if (data->destroy) {
15008
+ int flags;
15009
+ Py_INCREF(data->destroy);
15010
+ flags = PyCFunction_GET_FLAGS(data->destroy);
15011
+#ifdef METH_O
15012
+ data->delargs = !(flags & (METH_O));
15013
+#else
15014
+ data->delargs = 0;
15015
+#endif
15016
+ } else {
15017
+ data->delargs = 0;
15018
+ }
15019
+ data->implicitconv = 0;
15020
+ return data;
15021
+ }
15022
+}
15023
+
15024
+SWIGRUNTIME void
15025
+PySwigClientData_Del(PySwigClientData* data)
15026
+{
15027
+ Py_XDECREF(data->newraw);
15028
+ Py_XDECREF(data->newargs);
15029
+ Py_XDECREF(data->destroy);
15030
+}
15031
+
15032
+/* =============== PySwigObject =====================*/
15033
+
15034
+typedef struct {
15035
+ PyObject_HEAD
15036
+ void *ptr;
15037
+ swig_type_info *ty;
15038
+ int own;
15039
+ PyObject *next;
15040
+} PySwigObject;
15041
+
15042
+SWIGRUNTIME PyObject *
15043
+PySwigObject_long(PySwigObject *v)
15044
+{
15045
+ return PyLong_FromVoidPtr(v->ptr);
15046
+}
15047
+
15048
+SWIGRUNTIME PyObject *
15049
+PySwigObject_format(const char* fmt, PySwigObject *v)
15050
+{
15051
+ PyObject *res = NULL;
15052
+ PyObject *args = PyTuple_New(1);
15053
+ if (args) {
15054
+ if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
15055
+ PyObject *ofmt = PyString_FromString(fmt);
15056
+ if (ofmt) {
15057
+ res = PyString_Format(ofmt,args);
15058
+ Py_DECREF(ofmt);
15059
+ }
15060
+ Py_DECREF(args);
15061
+ }
15062
+ }
15063
+ return res;
15064
+}
15065
+
15066
+SWIGRUNTIME PyObject *
15067
+PySwigObject_oct(PySwigObject *v)
15068
+{
15069
+ return PySwigObject_format("%o",v);
15070
+}
15071
+
15072
+SWIGRUNTIME PyObject *
15073
+PySwigObject_hex(PySwigObject *v)
15074
+{
15075
+ return PySwigObject_format("%x",v);
15076
+}
15077
+
15078
+SWIGRUNTIME PyObject *
15079
+#ifdef METH_NOARGS
15080
+PySwigObject_repr(PySwigObject *v)
15081
+#else
15082
+PySwigObject_repr(PySwigObject *v, PyObject *args)
15083
+#endif
15084
+{
15085
+ const char *name = SWIG_TypePrettyName(v->ty);
15086
+ PyObject *hex = PySwigObject_hex(v);
15087
+ PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
15088
+ Py_DECREF(hex);
15089
+ if (v->next) {
15090
+#ifdef METH_NOARGS
15091
+ PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
15092
+#else
15093
+ PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
15094
+#endif
15095
+ PyString_ConcatAndDel(&repr,nrep);
15096
+ }
15097
+ return repr;
15098
+}
15099
+
15100
+SWIGRUNTIME int
15101
+PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
15102
+{
15103
+#ifdef METH_NOARGS
15104
+ PyObject *repr = PySwigObject_repr(v);
15105
+#else
15106
+ PyObject *repr = PySwigObject_repr(v, NULL);
15107
+#endif
15108
+ if (repr) {
15109
+ fputs(PyString_AsString(repr), fp);
15110
+ Py_DECREF(repr);
15111
+ return 0;
15112
+ } else {
15113
+ return 1;
15114
+ }
15115
+}
15116
+
15117
+SWIGRUNTIME PyObject *
15118
+PySwigObject_str(PySwigObject *v)
15119
+{
15120
+ char result[SWIG_BUFFER_SIZE];
15121
+ return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
15122
+ PyString_FromString(result) : 0;
15123
+}
15124
+
15125
+SWIGRUNTIME int
15126
+PySwigObject_compare(PySwigObject *v, PySwigObject *w)
15127
+{
15128
+ void *i = v->ptr;
15129
+ void *j = w->ptr;
15130
+ return (i < j) ? -1 : ((i > j) ? 1 : 0);
15131
+}
15132
+
15133
+SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
15134
+
15135
+SWIGRUNTIME PyTypeObject*
15136
+PySwigObject_type(void) {
15137
+ static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
15138
+ return type;
15139
+}
15140
+
15141
+SWIGRUNTIMEINLINE int
15142
+PySwigObject_Check(PyObject *op) {
15143
+ return ((op)->ob_type == PySwigObject_type())
15144
+ || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
15145
+}
15146
+
15147
+SWIGRUNTIME PyObject *
15148
+PySwigObject_New(void *ptr, swig_type_info *ty, int own);
15149
+
15150
+SWIGRUNTIME void
15151
+PySwigObject_dealloc(PyObject *v)
15152
+{
15153
+ PySwigObject *sobj = (PySwigObject *) v;
15154
+ PyObject *next = sobj->next;
15155
+ if (sobj->own == SWIG_POINTER_OWN) {
15156
+ swig_type_info *ty = sobj->ty;
15157
+ PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
15158
+ PyObject *destroy = data ? data->destroy : 0;
15159
+ if (destroy) {
15160
+ /* destroy is always a VARARGS method */
15161
+ PyObject *res;
15162
+ if (data->delargs) {
15163
+ /* we need to create a temporal object to carry the destroy operation */
15164
+ PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
15165
+ res = SWIG_Python_CallFunctor(destroy, tmp);
15166
+ Py_DECREF(tmp);
15167
+ } else {
15168
+ PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
15169
+ PyObject *mself = PyCFunction_GET_SELF(destroy);
15170
+ res = ((*meth)(mself, v));
15171
+ }
15172
+ Py_XDECREF(res);
15173
+ }
15174
+#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
15175
+ else {
15176
+ const char *name = SWIG_TypePrettyName(ty);
15177
+ printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
15178
+ }
15179
+#endif
15180
+ }
15181
+ Py_XDECREF(next);
15182
+ PyObject_DEL(v);
15183
+}
15184
+
15185
+SWIGRUNTIME PyObject*
15186
+PySwigObject_append(PyObject* v, PyObject* next)
15187
+{
15188
+ PySwigObject *sobj = (PySwigObject *) v;
15189
+#ifndef METH_O
15190
+ PyObject *tmp = 0;
15191
+ if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
15192
+ next = tmp;
15193
+#endif
15194
+ if (!PySwigObject_Check(next)) {
15195
+ return NULL;
15196
+ }
15197
+ sobj->next = next;
15198
+ Py_INCREF(next);
15199
+ return SWIG_Py_Void();
15200
+}
15201
+
15202
+SWIGRUNTIME PyObject*
15203
+#ifdef METH_NOARGS
15204
+PySwigObject_next(PyObject* v)
15205
+#else
15206
+PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
15207
+#endif
15208
+{
15209
+ PySwigObject *sobj = (PySwigObject *) v;
15210
+ if (sobj->next) {
15211
+ Py_INCREF(sobj->next);
15212
+ return sobj->next;
15213
+ } else {
15214
+ return SWIG_Py_Void();
15215
+ }
15216
+}
15217
+
15218
+SWIGINTERN PyObject*
15219
+#ifdef METH_NOARGS
15220
+PySwigObject_disown(PyObject *v)
15221
+#else
15222
+PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
15223
+#endif
15224
+{
15225
+ PySwigObject *sobj = (PySwigObject *)v;
15226
+ sobj->own = 0;
15227
+ return SWIG_Py_Void();
15228
+}
15229
+
15230
+SWIGINTERN PyObject*
15231
+#ifdef METH_NOARGS
15232
+PySwigObject_acquire(PyObject *v)
15233
+#else
15234
+PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
15235
+#endif
15236
+{
15237
+ PySwigObject *sobj = (PySwigObject *)v;
15238
+ sobj->own = SWIG_POINTER_OWN;
15239
+ return SWIG_Py_Void();
15240
+}
15241
+
15242
+SWIGINTERN PyObject*
15243
+PySwigObject_own(PyObject *v, PyObject *args)
15244
+{
15245
+ PyObject *val = 0;
15246
+#if (PY_VERSION_HEX < 0x02020000)
15247
+ if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
15248
+#else
15249
+ if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
15250
+#endif
15251
+ {
15252
+ return NULL;
15253
+ }
15254
+ else
15255
+ {
15256
+ PySwigObject *sobj = (PySwigObject *)v;
15257
+ PyObject *obj = PyBool_FromLong(sobj->own);
15258
+ if (val) {
15259
+#ifdef METH_NOARGS
15260
+ if (PyObject_IsTrue(val)) {
15261
+ PySwigObject_acquire(v);
15262
+ } else {
15263
+ PySwigObject_disown(v);
15264
+ }
15265
+#else
15266
+ if (PyObject_IsTrue(val)) {
15267
+ PySwigObject_acquire(v,args);
15268
+ } else {
15269
+ PySwigObject_disown(v,args);
15270
+ }
15271
+#endif
15272
+ }
15273
+ return obj;
15274
+ }
15275
+}
15276
+
15277
+#ifdef METH_O
15278
+static PyMethodDef
15279
+swigobject_methods[] = {
15280
+ {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
15281
+ {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
15282
+ {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
15283
+ {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
15284
+ {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
15285
+ {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
15286
+ {0, 0, 0, 0}
15287
+};
15288
+#else
15289
+static PyMethodDef
15290
+swigobject_methods[] = {
15291
+ {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
15292
+ {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
15293
+ {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
15294
+ {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
15295
+ {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
15296
+ {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
15297
+ {0, 0, 0, 0}
15298
+};
15299
+#endif
15300
+
15301
+#if PY_VERSION_HEX < 0x02020000
15302
+SWIGINTERN PyObject *
15303
+PySwigObject_getattr(PySwigObject *sobj,char *name)
15304
+{
15305
+ return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
15306
+}
15307
+#endif
15308
+
15309
+SWIGRUNTIME PyTypeObject*
15310
+_PySwigObject_type(void) {
15311
+ static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
15312
+
15313
+ static PyNumberMethods PySwigObject_as_number = {
15314
+ (binaryfunc)0, /*nb_add*/
15315
+ (binaryfunc)0, /*nb_subtract*/
15316
+ (binaryfunc)0, /*nb_multiply*/
15317
+ (binaryfunc)0, /*nb_divide*/
15318
+ (binaryfunc)0, /*nb_remainder*/
15319
+ (binaryfunc)0, /*nb_divmod*/
15320
+ (ternaryfunc)0,/*nb_power*/
15321
+ (unaryfunc)0, /*nb_negative*/
15322
+ (unaryfunc)0, /*nb_positive*/
15323
+ (unaryfunc)0, /*nb_absolute*/
15324
+ (inquiry)0, /*nb_nonzero*/
15325
+ 0, /*nb_invert*/
15326
+ 0, /*nb_lshift*/
15327
+ 0, /*nb_rshift*/
15328
+ 0, /*nb_and*/
15329
+ 0, /*nb_xor*/
15330
+ 0, /*nb_or*/
15331
+ (coercion)0, /*nb_coerce*/
15332
+ (unaryfunc)PySwigObject_long, /*nb_int*/
15333
+ (unaryfunc)PySwigObject_long, /*nb_long*/
15334
+ (unaryfunc)0, /*nb_float*/
15335
+ (unaryfunc)PySwigObject_oct, /*nb_oct*/
15336
+ (unaryfunc)PySwigObject_hex, /*nb_hex*/
15337
+#if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
15338
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
15339
+#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
15340
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
15341
+#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
15342
+ 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
15343
+#endif
15344
+ };
15345
+
15346
+ static PyTypeObject pyswigobject_type;
15347
+ static int type_init = 0;
15348
+ if (!type_init) {
15349
+ const PyTypeObject tmp
15350
+ = {
15351
+ PyObject_HEAD_INIT(NULL)
15352
+ 0, /* ob_size */
15353
+ (char *)"PySwigObject", /* tp_name */
15354
+ sizeof(PySwigObject), /* tp_basicsize */
15355
+ 0, /* tp_itemsize */
15356
+ (destructor)PySwigObject_dealloc, /* tp_dealloc */
15357
+ (printfunc)PySwigObject_print, /* tp_print */
15358
+#if PY_VERSION_HEX < 0x02020000
15359
+ (getattrfunc)PySwigObject_getattr, /* tp_getattr */
15360
+#else
15361
+ (getattrfunc)0, /* tp_getattr */
15362
+#endif
15363
+ (setattrfunc)0, /* tp_setattr */
15364
+ (cmpfunc)PySwigObject_compare, /* tp_compare */
15365
+ (reprfunc)PySwigObject_repr, /* tp_repr */
15366
+ &PySwigObject_as_number, /* tp_as_number */
15367
+ 0, /* tp_as_sequence */
15368
+ 0, /* tp_as_mapping */
15369
+ (hashfunc)0, /* tp_hash */
15370
+ (ternaryfunc)0, /* tp_call */
15371
+ (reprfunc)PySwigObject_str, /* tp_str */
15372
+ PyObject_GenericGetAttr, /* tp_getattro */
15373
+ 0, /* tp_setattro */
15374
+ 0, /* tp_as_buffer */
15375
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
15376
+ swigobject_doc, /* tp_doc */
15377
+ 0, /* tp_traverse */
15378
+ 0, /* tp_clear */
15379
+ 0, /* tp_richcompare */
15380
+ 0, /* tp_weaklistoffset */
15381
+#if PY_VERSION_HEX >= 0x02020000
15382
+ 0, /* tp_iter */
15383
+ 0, /* tp_iternext */
15384
+ swigobject_methods, /* tp_methods */
15385
+ 0, /* tp_members */
15386
+ 0, /* tp_getset */
15387
+ 0, /* tp_base */
15388
+ 0, /* tp_dict */
15389
+ 0, /* tp_descr_get */
15390
+ 0, /* tp_descr_set */
15391
+ 0, /* tp_dictoffset */
15392
+ 0, /* tp_init */
15393
+ 0, /* tp_alloc */
15394
+ 0, /* tp_new */
15395
+ 0, /* tp_free */
15396
+ 0, /* tp_is_gc */
15397
+ 0, /* tp_bases */
15398
+ 0, /* tp_mro */
15399
+ 0, /* tp_cache */
15400
+ 0, /* tp_subclasses */
15401
+ 0, /* tp_weaklist */
15402
+#endif
15403
+#if PY_VERSION_HEX >= 0x02030000
15404
+ 0, /* tp_del */
15405
+#endif
15406
+#ifdef COUNT_ALLOCS
15407
+ 0,0,0,0 /* tp_alloc -> tp_next */
15408
+#endif
15409
+ };
15410
+ pyswigobject_type = tmp;
15411
+ pyswigobject_type.ob_type = &PyType_Type;
15412
+ type_init = 1;
15413
+ }
15414
+ return &pyswigobject_type;
15415
+}
15416
+
15417
+SWIGRUNTIME PyObject *
15418
+PySwigObject_New(void *ptr, swig_type_info *ty, int own)
15419
+{
15420
+ PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
15421
+ if (sobj) {
15422
+ sobj->ptr = ptr;
15423
+ sobj->ty = ty;
15424
+ sobj->own = own;
15425
+ sobj->next = 0;
15426
+ }
15427
+ return (PyObject *)sobj;
15428
+}
15429
+
15430
+/* -----------------------------------------------------------------------------
15431
+ * Implements a simple Swig Packed type, and use it instead of string
15432
+ * ----------------------------------------------------------------------------- */
15433
+
15434
+typedef struct {
15435
+ PyObject_HEAD
15436
+ void *pack;
15437
+ swig_type_info *ty;
15438
+ size_t size;
15439
+} PySwigPacked;
15440
+
15441
+SWIGRUNTIME int
15442
+PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
15443
+{
15444
+ char result[SWIG_BUFFER_SIZE];
15445
+ fputs("<Swig Packed ", fp);
15446
+ if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
15447
+ fputs("at ", fp);
15448
+ fputs(result, fp);
15449
+ }
15450
+ fputs(v->ty->name,fp);
15451
+ fputs(">", fp);
15452
+ return 0;
15453
+}
15454
+
15455
+SWIGRUNTIME PyObject *
15456
+PySwigPacked_repr(PySwigPacked *v)
15457
+{
15458
+ char result[SWIG_BUFFER_SIZE];
15459
+ if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
15460
+ return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
15461
+ } else {
15462
+ return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
15463
+ }
15464
+}
15465
+
15466
+SWIGRUNTIME PyObject *
15467
+PySwigPacked_str(PySwigPacked *v)
15468
+{
15469
+ char result[SWIG_BUFFER_SIZE];
15470
+ if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
15471
+ return PyString_FromFormat("%s%s", result, v->ty->name);
15472
+ } else {
15473
+ return PyString_FromString(v->ty->name);
15474
+ }
15475
+}
15476
+
15477
+SWIGRUNTIME int
15478
+PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
15479
+{
15480
+ size_t i = v->size;
15481
+ size_t j = w->size;
15482
+ int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
15483
+ return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
15484
+}
15485
+
15486
+SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
15487
+
15488
+SWIGRUNTIME PyTypeObject*
15489
+PySwigPacked_type(void) {
15490
+ static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
15491
+ return type;
15492
+}
15493
+
15494
+SWIGRUNTIMEINLINE int
15495
+PySwigPacked_Check(PyObject *op) {
15496
+ return ((op)->ob_type == _PySwigPacked_type())
15497
+ || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
15498
+}
15499
+
15500
+SWIGRUNTIME void
15501
+PySwigPacked_dealloc(PyObject *v)
15502
+{
15503
+ if (PySwigPacked_Check(v)) {
15504
+ PySwigPacked *sobj = (PySwigPacked *) v;
15505
+ free(sobj->pack);
15506
+ }
15507
+ PyObject_DEL(v);
15508
+}
15509
+
15510
+SWIGRUNTIME PyTypeObject*
15511
+_PySwigPacked_type(void) {
15512
+ static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
15513
+ static PyTypeObject pyswigpacked_type;
15514
+ static int type_init = 0;
15515
+ if (!type_init) {
15516
+ const PyTypeObject tmp
15517
+ = {
15518
+ PyObject_HEAD_INIT(NULL)
15519
+ 0, /* ob_size */
15520
+ (char *)"PySwigPacked", /* tp_name */
15521
+ sizeof(PySwigPacked), /* tp_basicsize */
15522
+ 0, /* tp_itemsize */
15523
+ (destructor)PySwigPacked_dealloc, /* tp_dealloc */
15524
+ (printfunc)PySwigPacked_print, /* tp_print */
15525
+ (getattrfunc)0, /* tp_getattr */
15526
+ (setattrfunc)0, /* tp_setattr */
15527
+ (cmpfunc)PySwigPacked_compare, /* tp_compare */
15528
+ (reprfunc)PySwigPacked_repr, /* tp_repr */
15529
+ 0, /* tp_as_number */
15530
+ 0, /* tp_as_sequence */
15531
+ 0, /* tp_as_mapping */
15532
+ (hashfunc)0, /* tp_hash */
15533
+ (ternaryfunc)0, /* tp_call */
15534
+ (reprfunc)PySwigPacked_str, /* tp_str */
15535
+ PyObject_GenericGetAttr, /* tp_getattro */
15536
+ 0, /* tp_setattro */
15537
+ 0, /* tp_as_buffer */
15538
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
15539
+ swigpacked_doc, /* tp_doc */
15540
+ 0, /* tp_traverse */
15541
+ 0, /* tp_clear */
15542
+ 0, /* tp_richcompare */
15543
+ 0, /* tp_weaklistoffset */
15544
+#if PY_VERSION_HEX >= 0x02020000
15545
+ 0, /* tp_iter */
15546
+ 0, /* tp_iternext */
15547
+ 0, /* tp_methods */
15548
+ 0, /* tp_members */
15549
+ 0, /* tp_getset */
15550
+ 0, /* tp_base */
15551
+ 0, /* tp_dict */
15552
+ 0, /* tp_descr_get */
15553
+ 0, /* tp_descr_set */
15554
+ 0, /* tp_dictoffset */
15555
+ 0, /* tp_init */
15556
+ 0, /* tp_alloc */
15557
+ 0, /* tp_new */
15558
+ 0, /* tp_free */
15559
+ 0, /* tp_is_gc */
15560
+ 0, /* tp_bases */
15561
+ 0, /* tp_mro */
15562
+ 0, /* tp_cache */
15563
+ 0, /* tp_subclasses */
15564
+ 0, /* tp_weaklist */
15565
+#endif
15566
+#if PY_VERSION_HEX >= 0x02030000
15567
+ 0, /* tp_del */
15568
+#endif
15569
+#ifdef COUNT_ALLOCS
15570
+ 0,0,0,0 /* tp_alloc -> tp_next */
15571
+#endif
15572
+ };
15573
+ pyswigpacked_type = tmp;
15574
+ pyswigpacked_type.ob_type = &PyType_Type;
15575
+ type_init = 1;
15576
+ }
15577
+ return &pyswigpacked_type;
15578
+}
15579
+
15580
+SWIGRUNTIME PyObject *
15581
+PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
15582
+{
15583
+ PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
15584
+ if (sobj) {
15585
+ void *pack = malloc(size);
15586
+ if (pack) {
15587
+ memcpy(pack, ptr, size);
15588
+ sobj->pack = pack;
15589
+ sobj->ty = ty;
15590
+ sobj->size = size;
15591
+ } else {
15592
+ PyObject_DEL((PyObject *) sobj);
15593
+ sobj = 0;
15594
+ }
15595
+ }
15596
+ return (PyObject *) sobj;
15597
+}
15598
+
15599
+SWIGRUNTIME swig_type_info *
15600
+PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
15601
+{
15602
+ if (PySwigPacked_Check(obj)) {
15603
+ PySwigPacked *sobj = (PySwigPacked *)obj;
15604
+ if (sobj->size != size) return 0;
15605
+ memcpy(ptr, sobj->pack, size);
15606
+ return sobj->ty;
15607
+ } else {
15608
+ return 0;
15609
+ }
15610
+}
15611
+
15612
+/* -----------------------------------------------------------------------------
15613
+ * pointers/data manipulation
15614
+ * ----------------------------------------------------------------------------- */
15615
+
15616
+SWIGRUNTIMEINLINE PyObject *
15617
+_SWIG_This(void)
15618
+{
15619
+ return PyString_FromString("this");
15620
+}
15621
+
15622
+SWIGRUNTIME PyObject *
15623
+SWIG_This(void)
15624
+{
15625
+ static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
15626
+ return swig_this;
15627
+}
15628
+
15629
+/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
15630
+
15631
+SWIGRUNTIME PySwigObject *
15632
+SWIG_Python_GetSwigThis(PyObject *pyobj)
15633
+{
15634
+ if (PySwigObject_Check(pyobj)) {
15635
+ return (PySwigObject *) pyobj;
15636
+ } else {
15637
+ PyObject *obj = 0;
15638
+#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
15639
+ if (PyInstance_Check(pyobj)) {
15640
+ obj = _PyInstance_Lookup(pyobj, SWIG_This());
15641
+ } else {
15642
+ PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
15643
+ if (dictptr != NULL) {
15644
+ PyObject *dict = *dictptr;
15645
+ obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
15646
+ } else {
15647
+#ifdef PyWeakref_CheckProxy
15648
+ if (PyWeakref_CheckProxy(pyobj)) {
15649
+ PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
15650
+ return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
15651
+ }
15652
+#endif
15653
+ obj = PyObject_GetAttr(pyobj,SWIG_This());
15654
+ if (obj) {
15655
+ Py_DECREF(obj);
15656
+ } else {
15657
+ if (PyErr_Occurred()) PyErr_Clear();
15658
+ return 0;
15659
+ }
15660
+ }
15661
+ }
15662
+#else
15663
+ obj = PyObject_GetAttr(pyobj,SWIG_This());
15664
+ if (obj) {
15665
+ Py_DECREF(obj);
15666
+ } else {
15667
+ if (PyErr_Occurred()) PyErr_Clear();
15668
+ return 0;
15669
+ }
15670
+#endif
15671
+ if (obj && !PySwigObject_Check(obj)) {
15672
+ /* a PyObject is called 'this', try to get the 'real this'
15673
+ PySwigObject from it */
15674
+ return SWIG_Python_GetSwigThis(obj);
15675
+ }
15676
+ return (PySwigObject *)obj;
15677
+ }
15678
+}
15679
+
15680
+/* Acquire a pointer value */
15681
+
15682
+SWIGRUNTIME int
15683
+SWIG_Python_AcquirePtr(PyObject *obj, int own) {
15684
+ if (own == SWIG_POINTER_OWN) {
15685
+ PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
15686
+ if (sobj) {
15687
+ int oldown = sobj->own;
15688
+ sobj->own = own;
15689
+ return oldown;
15690
+ }
15691
+ }
15692
+ return 0;
15693
+}
15694
+
15695
+/* Convert a pointer value */
15696
+
15697
+SWIGRUNTIME int
15698
+SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
15699
+ if (!obj) return SWIG_ERROR;
15700
+ if (obj == Py_None) {
15701
+ if (ptr) *ptr = 0;
15702
+ return SWIG_OK;
15703
+ } else {
15704
+ PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
15705
+ if (own)
15706
+ *own = 0;
15707
+ while (sobj) {
15708
+ void *vptr = sobj->ptr;
15709
+ if (ty) {
15710
+ swig_type_info *to = sobj->ty;
15711
+ if (to == ty) {
15712
+ /* no type cast needed */
15713
+ if (ptr) *ptr = vptr;
15714
+ break;
15715
+ } else {
15716
+ swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
15717
+ if (!tc) {
15718
+ sobj = (PySwigObject *)sobj->next;
15719
+ } else {
15720
+ if (ptr) {
15721
+ int newmemory = 0;
15722
+ *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
15723
+ if (newmemory == SWIG_CAST_NEW_MEMORY) {
15724
+ assert(own);
15725
+ if (own)
15726
+ *own = *own | SWIG_CAST_NEW_MEMORY;
15727
+ }
15728
+ }
15729
+ break;
15730
+ }
15731
+ }
15732
+ } else {
15733
+ if (ptr) *ptr = vptr;
15734
+ break;
15735
+ }
15736
+ }
15737
+ if (sobj) {
15738
+ if (own)
15739
+ *own = *own | sobj->own;
15740
+ if (flags & SWIG_POINTER_DISOWN) {
15741
+ sobj->own = 0;
15742
+ }
15743
+ return SWIG_OK;
15744
+ } else {
15745
+ int res = SWIG_ERROR;
15746
+ if (flags & SWIG_POINTER_IMPLICIT_CONV) {
15747
+ PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
15748
+ if (data && !data->implicitconv) {
15749
+ PyObject *klass = data->klass;
15750
+ if (klass) {
15751
+ PyObject *impconv;
15752
+ data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
15753
+ impconv = SWIG_Python_CallFunctor(klass, obj);
15754
+ data->implicitconv = 0;
15755
+ if (PyErr_Occurred()) {
15756
+ PyErr_Clear();
15757
+ impconv = 0;
15758
+ }
15759
+ if (impconv) {
15760
+ PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
15761
+ if (iobj) {
15762
+ void *vptr;
15763
+ res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
15764
+ if (SWIG_IsOK(res)) {
15765
+ if (ptr) {
15766
+ *ptr = vptr;
15767
+ /* transfer the ownership to 'ptr' */
15768
+ iobj->own = 0;
15769
+ res = SWIG_AddCast(res);
15770
+ res = SWIG_AddNewMask(res);
15771
+ } else {
15772
+ res = SWIG_AddCast(res);
15773
+ }
15774
+ }
15775
+ }
15776
+ Py_DECREF(impconv);
15777
+ }
15778
+ }
15779
+ }
15780
+ }
15781
+ return res;
15782
+ }
15783
+ }
15784
+}
15785
+
15786
+/* Convert a function ptr value */
15787
+
15788
+SWIGRUNTIME int
15789
+SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
15790
+ if (!PyCFunction_Check(obj)) {
15791
+ return SWIG_ConvertPtr(obj, ptr, ty, 0);
15792
+ } else {
15793
+ void *vptr = 0;
15794
+
15795
+ /* here we get the method pointer for callbacks */
15796
+ const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
15797
+ const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
15798
+ if (desc) {
15799
+ desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
15800
+ if (!desc) return SWIG_ERROR;
15801
+ }
15802
+ if (ty) {
15803
+ swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
15804
+ if (tc) {
15805
+ int newmemory = 0;
15806
+ *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
15807
+ assert(!newmemory); /* newmemory handling not yet implemented */
15808
+ } else {
15809
+ return SWIG_ERROR;
15810
+ }
15811
+ } else {
15812
+ *ptr = vptr;
15813
+ }
15814
+ return SWIG_OK;
15815
+ }
15816
+}
15817
+
15818
+/* Convert a packed value value */
15819
+
15820
+SWIGRUNTIME int
15821
+SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
15822
+ swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
15823
+ if (!to) return SWIG_ERROR;
15824
+ if (ty) {
15825
+ if (to != ty) {
15826
+ /* check type cast? */
15827
+ swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
15828
+ if (!tc) return SWIG_ERROR;
15829
+ }
15830
+ }
15831
+ return SWIG_OK;
15832
+}
15833
+
15834
+/* -----------------------------------------------------------------------------
15835
+ * Create a new pointer object
15836
+ * ----------------------------------------------------------------------------- */
15837
+
15838
+/*
15839
+ Create a new instance object, whitout calling __init__, and set the
15840
+ 'this' attribute.
15841
+*/
15842
+
15843
+SWIGRUNTIME PyObject*
15844
+SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
15845
+{
15846
+#if (PY_VERSION_HEX >= 0x02020000)
15847
+ PyObject *inst = 0;
15848
+ PyObject *newraw = data->newraw;
15849
+ if (newraw) {
15850
+ inst = PyObject_Call(newraw, data->newargs, NULL);
15851
+ if (inst) {
15852
+#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
15853
+ PyObject **dictptr = _PyObject_GetDictPtr(inst);
15854
+ if (dictptr != NULL) {
15855
+ PyObject *dict = *dictptr;
15856
+ if (dict == NULL) {
15857
+ dict = PyDict_New();
15858
+ *dictptr = dict;
15859
+ PyDict_SetItem(dict, SWIG_This(), swig_this);
15860
+ }
15861
+ }
15862
+#else
15863
+ PyObject *key = SWIG_This();
15864
+ PyObject_SetAttr(inst, key, swig_this);
15865
+#endif
15866
+ }
15867
+ } else {
15868
+ PyObject *dict = PyDict_New();
15869
+ PyDict_SetItem(dict, SWIG_This(), swig_this);
15870
+ inst = PyInstance_NewRaw(data->newargs, dict);
15871
+ Py_DECREF(dict);
15872
+ }
15873
+ return inst;
15874
+#else
15875
+#if (PY_VERSION_HEX >= 0x02010000)
15876
+ PyObject *inst;
15877
+ PyObject *dict = PyDict_New();
15878
+ PyDict_SetItem(dict, SWIG_This(), swig_this);
15879
+ inst = PyInstance_NewRaw(data->newargs, dict);
15880
+ Py_DECREF(dict);
15881
+ return (PyObject *) inst;
15882
+#else
15883
+ PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
15884
+ if (inst == NULL) {
15885
+ return NULL;
15886
+ }
15887
+ inst->in_class = (PyClassObject *)data->newargs;
15888
+ Py_INCREF(inst->in_class);
15889
+ inst->in_dict = PyDict_New();
15890
+ if (inst->in_dict == NULL) {
15891
+ Py_DECREF(inst);
15892
+ return NULL;
15893
+ }
15894
+#ifdef Py_TPFLAGS_HAVE_WEAKREFS
15895
+ inst->in_weakreflist = NULL;
15896
+#endif
15897
+#ifdef Py_TPFLAGS_GC
15898
+ PyObject_GC_Init(inst);
15899
+#endif
15900
+ PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
15901
+ return (PyObject *) inst;
15902
+#endif
15903
+#endif
15904
+}
15905
+
15906
+SWIGRUNTIME void
15907
+SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
15908
+{
15909
+ PyObject *dict;
15910
+#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
15911
+ PyObject **dictptr = _PyObject_GetDictPtr(inst);
15912
+ if (dictptr != NULL) {
15913
+ dict = *dictptr;
15914
+ if (dict == NULL) {
15915
+ dict = PyDict_New();
15916
+ *dictptr = dict;
15917
+ }
15918
+ PyDict_SetItem(dict, SWIG_This(), swig_this);
15919
+ return;
15920
+ }
15921
+#endif
15922
+ dict = PyObject_GetAttrString(inst, (char*)"__dict__");
15923
+ PyDict_SetItem(dict, SWIG_This(), swig_this);
15924
+ Py_DECREF(dict);
15925
+}
15926
+
15927
+
15928
+SWIGINTERN PyObject *
15929
+SWIG_Python_InitShadowInstance(PyObject *args) {
15930
+ PyObject *obj[2];
15931
+ if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
15932
+ return NULL;
15933
+ } else {
15934
+ PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
15935
+ if (sthis) {
15936
+ PySwigObject_append((PyObject*) sthis, obj[1]);
15937
+ } else {
15938
+ SWIG_Python_SetSwigThis(obj[0], obj[1]);
15939
+ }
15940
+ return SWIG_Py_Void();
15941
+ }
15942
+}
15943
+
15944
+/* Create a new pointer object */
15945
+
15946
+SWIGRUNTIME PyObject *
15947
+SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
15948
+ if (!ptr) {
15949
+ return SWIG_Py_Void();
15950
+ } else {
15951
+ int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
15952
+ PyObject *robj = PySwigObject_New(ptr, type, own);
15953
+ PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
15954
+ if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
15955
+ PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
15956
+ if (inst) {
15957
+ Py_DECREF(robj);
15958
+ robj = inst;
15959
+ }
15960
+ }
15961
+ return robj;
15962
+ }
15963
+}
15964
+
15965
+/* Create a new packed object */
15966
+
15967
+SWIGRUNTIMEINLINE PyObject *
15968
+SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
15969
+ return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
15970
+}
15971
+
15972
+/* -----------------------------------------------------------------------------*
15973
+ * Get type list
15974
+ * -----------------------------------------------------------------------------*/
15975
+
15976
+#ifdef SWIG_LINK_RUNTIME
15977
+void *SWIG_ReturnGlobalTypeList(void *);
15978
+#endif
15979
+
15980
+SWIGRUNTIME swig_module_info *
15981
+SWIG_Python_GetModule(void) {
15982
+ static void *type_pointer = (void *)0;
15983
+ /* first check if module already created */
15984
+ if (!type_pointer) {
15985
+#ifdef SWIG_LINK_RUNTIME
15986
+ type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
15987
+#else
15988
+ type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
15989
+ (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
15990
+ if (PyErr_Occurred()) {
15991
+ PyErr_Clear();
15992
+ type_pointer = (void *)0;
15993
+ }
15994
+#endif
15995
+ }
15996
+ return (swig_module_info *) type_pointer;
15997
+}
15998
+
15999
+#if PY_MAJOR_VERSION < 2
16000
+/* PyModule_AddObject function was introduced in Python 2.0. The following function
16001
+ is copied out of Python/modsupport.c in python version 2.3.4 */
16002
+SWIGINTERN int
16003
+PyModule_AddObject(PyObject *m, char *name, PyObject *o)
16004
+{
16005
+ PyObject *dict;
16006
+ if (!PyModule_Check(m)) {
16007
+ PyErr_SetString(PyExc_TypeError,
16008
+ "PyModule_AddObject() needs module as first arg");
16009
+ return SWIG_ERROR;
16010
+ }
16011
+ if (!o) {
16012
+ PyErr_SetString(PyExc_TypeError,
16013
+ "PyModule_AddObject() needs non-NULL value");
16014
+ return SWIG_ERROR;
16015
+ }
16016
+
16017
+ dict = PyModule_GetDict(m);
16018
+ if (dict == NULL) {
16019
+ /* Internal error -- modules must have a dict! */
16020
+ PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
16021
+ PyModule_GetName(m));
16022
+ return SWIG_ERROR;
16023
+ }
16024
+ if (PyDict_SetItemString(dict, name, o))
16025
+ return SWIG_ERROR;
16026
+ Py_DECREF(o);
16027
+ return SWIG_OK;
16028
+}
16029
+#endif
16030
+
16031
+SWIGRUNTIME void
16032
+SWIG_Python_DestroyModule(void *vptr)
16033
+{
16034
+ swig_module_info *swig_module = (swig_module_info *) vptr;
16035
+ swig_type_info **types = swig_module->types;
16036
+ size_t i;
16037
+ for (i =0; i < swig_module->size; ++i) {
16038
+ swig_type_info *ty = types[i];
16039
+ if (ty->owndata) {
16040
+ PySwigClientData *data = (PySwigClientData *) ty->clientdata;
16041
+ if (data) PySwigClientData_Del(data);
16042
+ }
16043
+ }
16044
+ Py_DECREF(SWIG_This());
16045
+}
16046
+
16047
+SWIGRUNTIME void
16048
+SWIG_Python_SetModule(swig_module_info *swig_module) {
16049
+ static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
16050
+
16051
+ PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
16052
+ swig_empty_runtime_method_table);
16053
+ PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
16054
+ if (pointer && module) {
16055
+ PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
16056
+ } else {
16057
+ Py_XDECREF(pointer);
16058
+ }
16059
+}
16060
+
16061
+/* The python cached type query */
16062
+SWIGRUNTIME PyObject *
16063
+SWIG_Python_TypeCache(void) {
16064
+ static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
16065
+ return cache;
16066
+}
16067
+
16068
+SWIGRUNTIME swig_type_info *
16069
+SWIG_Python_TypeQuery(const char *type)
16070
+{
16071
+ PyObject *cache = SWIG_Python_TypeCache();
16072
+ PyObject *key = PyString_FromString(type);
16073
+ PyObject *obj = PyDict_GetItem(cache, key);
16074
+ swig_type_info *descriptor;
16075
+ if (obj) {
16076
+ descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
16077
+ } else {
16078
+ swig_module_info *swig_module = SWIG_Python_GetModule();
16079
+ descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
16080
+ if (descriptor) {
16081
+ obj = PyCObject_FromVoidPtr(descriptor, NULL);
16082
+ PyDict_SetItem(cache, key, obj);
16083
+ Py_DECREF(obj);
16084
+ }
16085
+ }
16086
+ Py_DECREF(key);
16087
+ return descriptor;
16088
+}
16089
+
16090
+/*
16091
+ For backward compatibility only
16092
+*/
16093
+#define SWIG_POINTER_EXCEPTION 0
16094
+#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
16095
+#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
16096
+
16097
+SWIGRUNTIME int
16098
+SWIG_Python_AddErrMesg(const char* mesg, int infront)
16099
+{
16100
+ if (PyErr_Occurred()) {
16101
+ PyObject *type = 0;
16102
+ PyObject *value = 0;
16103
+ PyObject *traceback = 0;
16104
+ PyErr_Fetch(&type, &value, &traceback);
16105
+ if (value) {
16106
+ PyObject *old_str = PyObject_Str(value);
16107
+ Py_XINCREF(type);
16108
+ PyErr_Clear();
16109
+ if (infront) {
16110
+ PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
16111
+ } else {
16112
+ PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
16113
+ }
16114
+ Py_DECREF(old_str);
16115
+ }
16116
+ return 1;
16117
+ } else {
16118
+ return 0;
16119
+ }
16120
+}
16121
+
16122
+SWIGRUNTIME int
16123
+SWIG_Python_ArgFail(int argnum)
16124
+{
16125
+ if (PyErr_Occurred()) {
16126
+ /* add information about failing argument */
16127
+ char mesg[256];
16128
+ PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
16129
+ return SWIG_Python_AddErrMesg(mesg, 1);
16130
+ } else {
16131
+ return 0;
16132
+ }
16133
+}
16134
+
16135
+SWIGRUNTIMEINLINE const char *
16136
+PySwigObject_GetDesc(PyObject *self)
16137
+{
16138
+ PySwigObject *v = (PySwigObject *)self;
16139
+ swig_type_info *ty = v ? v->ty : 0;
16140
+ return ty ? ty->str : (char*)"";
16141
+}
16142
+
16143
+SWIGRUNTIME void
16144
+SWIG_Python_TypeError(const char *type, PyObject *obj)
16145
+{
16146
+ if (type) {
16147
+#if defined(SWIG_COBJECT_TYPES)
16148
+ if (obj && PySwigObject_Check(obj)) {
16149
+ const char *otype = (const char *) PySwigObject_GetDesc(obj);
16150
+ if (otype) {
16151
+ PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
16152
+ type, otype);
16153
+ return;
16154
+ }
16155
+ } else
16156
+#endif
16157
+ {
16158
+ const char *otype = (obj ? obj->ob_type->tp_name : 0);
16159
+ if (otype) {
16160
+ PyObject *str = PyObject_Str(obj);
16161
+ const char *cstr = str ? PyString_AsString(str) : 0;
16162
+ if (cstr) {
16163
+ PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
16164
+ type, otype, cstr);
16165
+ } else {
16166
+ PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
16167
+ type, otype);
16168
+ }
16169
+ Py_XDECREF(str);
16170
+ return;
16171
+ }
16172
+ }
16173
+ PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
16174
+ } else {
16175
+ PyErr_Format(PyExc_TypeError, "unexpected type is received");
16176
+ }
16177
+}
16178
+
16179
+
16180
+/* Convert a pointer value, signal an exception on a type mismatch */
16181
+SWIGRUNTIME void *
16182
+SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
16183
+ void *result;
16184
+ if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
16185
+ PyErr_Clear();
16186
+ if (flags & SWIG_POINTER_EXCEPTION) {
16187
+ SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
16188
+ SWIG_Python_ArgFail(argnum);
16189
+ }
16190
+ }
16191
+ return result;
16192
+}
16193
+
16194
+
16195
+#ifdef __cplusplus
16196
+#if 0
16197
+{ /* cc-mode */
16198
+#endif
16199
+}
16200
+#endif
16201
+
16202
+
16203
+
16204
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
16205
+
16206
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
16207
+
16208
+
16209
+
16210
+ #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
16211
+
16212
+
16213
+/* -------- TYPES TABLE (BEGIN) -------- */
16214
+
16215
+#define SWIGTYPE_p_Digit swig_types[0]
16216
+#define SWIGTYPE_p_DisplayDriver swig_types[1]
16217
+#define SWIGTYPE_p_allocator_type swig_types[2]
16218
+#define SWIGTYPE_p_char swig_types[3]
16219
+#define SWIGTYPE_p_difference_type swig_types[4]
16220
+#define SWIGTYPE_p_gwxPseudoDC swig_types[5]
16221
+#define SWIGTYPE_p_key_type swig_types[6]
16222
+#define SWIGTYPE_p_mapped_type swig_types[7]
16223
+#define SWIGTYPE_p_p_PyObject swig_types[8]
16224
+#define SWIGTYPE_p_size_type swig_types[9]
16225
+#define SWIGTYPE_p_std__invalid_argument swig_types[10]
16226
+#define SWIGTYPE_p_std__lessT_int_t swig_types[11]
16227
+#define SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t swig_types[12]
16228
+#define SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t__allocator_type swig_types[13]
16229
+#define SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t swig_types[14]
16230
+#define SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type swig_types[15]
16231
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[16]
16232
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type swig_types[17]
16233
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[18]
16234
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type swig_types[19]
16235
+#define SWIGTYPE_p_swig__PySwigIterator swig_types[20]
16236
+#define SWIGTYPE_p_value_type swig_types[21]
16237
+#define SWIGTYPE_p_wxRect swig_types[22]
16238
+#define SWIGTYPE_p_wxWindow swig_types[23]
16239
+static swig_type_info *swig_types[25];
16240
+static swig_module_info swig_module = {swig_types, 24, 0, 0, 0, 0};
16241
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
16242
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
16243
+
16244
+/* -------- TYPES TABLE (END) -------- */
16245
+
16246
+#if (PY_VERSION_HEX <= 0x02000000)
16247
+# if !defined(SWIG_PYTHON_CLASSIC)
16248
+# error "This python version requires swig to be run with the '-classic' option"
16249
+# endif
16250
+#endif
16251
+
16252
+/*-----------------------------------------------
16253
+ @(target):= _grass6_wxvdigit.so
16254
+ ------------------------------------------------*/
16255
+#define SWIG_init init_grass6_wxvdigit
16256
+
16257
+#define SWIG_name "_grass6_wxvdigit"
16258
+
16259
+#define SWIGVERSION 0x010336
16260
+#define SWIG_VERSION SWIGVERSION
16261
+
16262
+
16263
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
16264
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
16265
+
16266
+
16267
+#include <stdexcept>
16268
+
16269
+
16270
+namespace swig {
16271
+ class PyObject_ptr {
16272
+ protected:
16273
+ PyObject *_obj;
16274
+
16275
+ public:
16276
+ PyObject_ptr() :_obj(0)
16277
+ {
16278
+ }
16279
+
16280
+ PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
16281
+ {
16282
+ Py_XINCREF(_obj);
16283
+ }
16284
+
16285
+ PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
16286
+ {
16287
+ if (initial_ref) {
16288
+ Py_XINCREF(_obj);
16289
+ }
16290
+ }
16291
+
16292
+ PyObject_ptr & operator=(const PyObject_ptr& item)
16293
+ {
16294
+ Py_XINCREF(item._obj);
16295
+ Py_XDECREF(_obj);
16296
+ _obj = item._obj;
16297
+ return *this;
16298
+ }
16299
+
16300
+ ~PyObject_ptr()
16301
+ {
16302
+ Py_XDECREF(_obj);
16303
+ }
16304
+
16305
+ operator PyObject *() const
16306
+ {
16307
+ return _obj;
16308
+ }
16309
+
16310
+ PyObject *operator->() const
16311
+ {
16312
+ return _obj;
16313
+ }
16314
+ };
16315
+}
16316
+
16317
+
16318
+namespace swig {
16319
+ struct PyObject_var : PyObject_ptr {
16320
+ PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
16321
+
16322
+ PyObject_var & operator = (PyObject* obj)
16323
+ {
16324
+ Py_XDECREF(_obj);
16325
+ _obj = obj;
16326
+ return *this;
16327
+ }
16328
+ };
16329
+}
16330
+
16331
+
16332
+#include <grass/gis.h>
16333
+#include <grass/gisdefs.h>
16334
+#include <grass/Vect.h>
16335
+#include <grass/vect/dig_structs.h>
16336
+#include "driver.h"
16337
+#include "digit.h"
16338
+
16339
+
16340
+#include <iostream>
16341
+
16342
+
16343
+#include <stdexcept>
16344
+
16345
+
16346
+#if defined(__GNUC__)
16347
+# if __GNUC__ == 2 && __GNUC_MINOR <= 96
16348
+# define SWIG_STD_NOMODERN_STL
16349
+# endif
16350
+#endif
16351
+
16352
+
16353
+#include <string>
16354
+#include <stdexcept>
16355
+
16356
+
16357
+namespace swig {
16358
+ struct stop_iteration {
16359
+ };
16360
+
16361
+ struct PySwigIterator {
16362
+ private:
16363
+ PyObject_ptr _seq;
16364
+
16365
+ protected:
16366
+ PySwigIterator(PyObject *seq) : _seq(seq)
16367
+ {
16368
+ }
16369
+
16370
+ public:
16371
+ virtual ~PySwigIterator() {}
16372
+
16373
+ // Access iterator method, required by Python
16374
+ virtual PyObject *value() const = 0;
16375
+
16376
+ // Forward iterator method, required by Python
16377
+ virtual PySwigIterator *incr(size_t n = 1) = 0;
16378
+
16379
+ // Backward iterator method, very common in C++, but not required in Python
16380
+ virtual PySwigIterator *decr(size_t /*n*/ = 1)
16381
+ {
16382
+ throw stop_iteration();
16383
+ }
16384
+
16385
+ // Random access iterator methods, but not required in Python
16386
+ virtual ptrdiff_t distance(const PySwigIterator &/*x*/) const
16387
+ {
16388
+ throw std::invalid_argument("operation not supported");
16389
+ }
16390
+
16391
+ virtual bool equal (const PySwigIterator &/*x*/) const
16392
+ {
16393
+ throw std::invalid_argument("operation not supported");
16394
+ }
16395
+
16396
+ // C++ common/needed methods
16397
+ virtual PySwigIterator *copy() const = 0;
16398
+
16399
+ PyObject *next()
16400
+ {
16401
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
16402
+ PyObject *obj = value();
16403
+ incr();
16404
+ SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
16405
+ return obj;
16406
+ }
16407
+
16408
+ PyObject *previous()
16409
+ {
16410
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
16411
+ decr();
16412
+ PyObject *obj = value();
16413
+ SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
16414
+ return obj;
16415
+ }
16416
+
16417
+ PySwigIterator *advance(ptrdiff_t n)
16418
+ {
16419
+ return (n > 0) ? incr(n) : decr(-n);
16420
+ }
16421
+
16422
+ bool operator == (const PySwigIterator& x) const
16423
+ {
16424
+ return equal(x);
16425
+ }
16426
+
16427
+ bool operator != (const PySwigIterator& x) const
16428
+ {
16429
+ return ! operator==(x);
16430
+ }
16431
+
16432
+ PySwigIterator& operator += (ptrdiff_t n)
16433
+ {
16434
+ return *advance(n);
16435
+ }
16436
+
16437
+ PySwigIterator& operator -= (ptrdiff_t n)
16438
+ {
16439
+ return *advance(-n);
16440
+ }
16441
+
16442
+ PySwigIterator* operator + (ptrdiff_t n) const
16443
+ {
16444
+ return copy()->advance(n);
16445
+ }
16446
+
16447
+ PySwigIterator* operator - (ptrdiff_t n) const
16448
+ {
16449
+ return copy()->advance(-n);
16450
+ }
16451
+
16452
+ ptrdiff_t operator - (const PySwigIterator& x) const
16453
+ {
16454
+ return x.distance(*this);
16455
+ }
16456
+
16457
+ static swig_type_info* descriptor() {
16458
+ static int init = 0;
16459
+ static swig_type_info* desc = 0;
16460
+ if (!init) {
16461
+ desc = SWIG_TypeQuery("swig::PySwigIterator *");
16462
+ init = 1;
16463
+ }
16464
+ return desc;
16465
+ }
16466
+ };
16467
+}
16468
+
16469
+
16470
+SWIGINTERN int
16471
+SWIG_AsVal_double (PyObject *obj, double *val)
16472
+{
16473
+ int res = SWIG_TypeError;
16474
+ if (PyFloat_Check(obj)) {
16475
+ if (val) *val = PyFloat_AsDouble(obj);
16476
+ return SWIG_OK;
16477
+ } else if (PyInt_Check(obj)) {
16478
+ if (val) *val = PyInt_AsLong(obj);
16479
+ return SWIG_OK;
16480
+ } else if (PyLong_Check(obj)) {
16481
+ double v = PyLong_AsDouble(obj);
16482
+ if (!PyErr_Occurred()) {
16483
+ if (val) *val = v;
16484
+ return SWIG_OK;
16485
+ } else {
16486
+ PyErr_Clear();
16487
+ }
16488
+ }
16489
+#ifdef SWIG_PYTHON_CAST_MODE
16490
+ {
16491
+ int dispatch = 0;
16492
+ double d = PyFloat_AsDouble(obj);
16493
+ if (!PyErr_Occurred()) {
16494
+ if (val) *val = d;
16495
+ return SWIG_AddCast(SWIG_OK);
16496
+ } else {
16497
+ PyErr_Clear();
16498
+ }
16499
+ if (!dispatch) {
16500
+ long v = PyLong_AsLong(obj);
16501
+ if (!PyErr_Occurred()) {
16502
+ if (val) *val = v;
16503
+ return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
16504
+ } else {
16505
+ PyErr_Clear();
16506
+ }
16507
+ }
16508
+ }
16509
+#endif
16510
+ return res;
16511
+}
16512
+
16513
+
16514
+#include <float.h>
16515
+
16516
+
16517
+#include <math.h>
16518
+
16519
+
16520
+SWIGINTERNINLINE int
16521
+SWIG_CanCastAsInteger(double *d, double min, double max) {
16522
+ double x = *d;
16523
+ if ((min <= x && x <= max)) {
16524
+ double fx = floor(x);
16525
+ double cx = ceil(x);
16526
+ double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
16527
+ if ((errno == EDOM) || (errno == ERANGE)) {
16528
+ errno = 0;
16529
+ } else {
16530
+ double summ, reps, diff;
16531
+ if (rd < x) {
16532
+ diff = x - rd;
16533
+ } else if (rd > x) {
16534
+ diff = rd - x;
16535
+ } else {
16536
+ return 1;
16537
+ }
16538
+ summ = rd + x;
16539
+ reps = diff/summ;
16540
+ if (reps < 8*DBL_EPSILON) {
16541
+ *d = rd;
16542
+ return 1;
16543
+ }
16544
+ }
16545
+ }
16546
+ return 0;
16547
+}
16548
+
16549
+
16550
+SWIGINTERN int
16551
+SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
16552
+{
16553
+ if (PyInt_Check(obj)) {
16554
+ long v = PyInt_AsLong(obj);
16555
+ if (v >= 0) {
16556
+ if (val) *val = v;
16557
+ return SWIG_OK;
16558
+ } else {
16559
+ return SWIG_OverflowError;
16560
+ }
16561
+ } else if (PyLong_Check(obj)) {
16562
+ unsigned long v = PyLong_AsUnsignedLong(obj);
16563
+ if (!PyErr_Occurred()) {
16564
+ if (val) *val = v;
16565
+ return SWIG_OK;
16566
+ } else {
16567
+ PyErr_Clear();
16568
+ }
16569
+ }
16570
+#ifdef SWIG_PYTHON_CAST_MODE
16571
+ {
16572
+ int dispatch = 0;
16573
+ unsigned long v = PyLong_AsUnsignedLong(obj);
16574
+ if (!PyErr_Occurred()) {
16575
+ if (val) *val = v;
16576
+ return SWIG_AddCast(SWIG_OK);
16577
+ } else {
16578
+ PyErr_Clear();
16579
+ }
16580
+ if (!dispatch) {
16581
+ double d;
16582
+ int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
16583
+ if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
16584
+ if (val) *val = (unsigned long)(d);
16585
+ return res;
16586
+ }
16587
+ }
16588
+ }
16589
+#endif
16590
+ return SWIG_TypeError;
16591
+}
16592
+
16593
+
16594
+SWIGINTERNINLINE int
16595
+SWIG_AsVal_size_t (PyObject * obj, size_t *val)
16596
+{
16597
+ unsigned long v;
16598
+ int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
16599
+ if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
16600
+ return res;
16601
+}
16602
+
16603
+
16604
+ #define SWIG_From_long PyInt_FromLong
16605
+
16606
+
16607
+SWIGINTERNINLINE PyObject *
16608
+SWIG_From_ptrdiff_t (ptrdiff_t value)
16609
+{
16610
+ return SWIG_From_long (static_cast< long >(value));
16611
+}
16612
+
16613
+
16614
+SWIGINTERNINLINE PyObject*
16615
+ SWIG_From_bool (bool value)
16616
+{
16617
+ return PyBool_FromLong(value ? 1 : 0);
16618
+}
16619
+
16620
+
16621
+SWIGINTERN int
16622
+SWIG_AsVal_long (PyObject *obj, long* val)
16623
+{
16624
+ if (PyInt_Check(obj)) {
16625
+ if (val) *val = PyInt_AsLong(obj);
16626
+ return SWIG_OK;
16627
+ } else if (PyLong_Check(obj)) {
16628
+ long v = PyLong_AsLong(obj);
16629
+ if (!PyErr_Occurred()) {
16630
+ if (val) *val = v;
16631
+ return SWIG_OK;
16632
+ } else {
16633
+ PyErr_Clear();
16634
+ }
16635
+ }
16636
+#ifdef SWIG_PYTHON_CAST_MODE
16637
+ {
16638
+ int dispatch = 0;
16639
+ long v = PyInt_AsLong(obj);
16640
+ if (!PyErr_Occurred()) {
16641
+ if (val) *val = v;
16642
+ return SWIG_AddCast(SWIG_OK);
16643
+ } else {
16644
+ PyErr_Clear();
16645
+ }
16646
+ if (!dispatch) {
16647
+ double d;
16648
+ int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
16649
+ if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
16650
+ if (val) *val = (long)(d);
16651
+ return res;
16652
+ }
16653
+ }
16654
+ }
16655
+#endif
16656
+ return SWIG_TypeError;
16657
+}
16658
+
16659
+
16660
+SWIGINTERNINLINE int
16661
+SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
16662
+{
16663
+ long v;
16664
+ int res = SWIG_AsVal_long (obj, val ? &v : 0);
16665
+ if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
16666
+ return res;
16667
+}
16668
+
16669
+
16670
+#include <stdexcept>
16671
+
16672
+
16673
+#include <algorithm>
16674
+
16675
+
16676
+#include <vector>
16677
+
16678
+
16679
+namespace swig {
16680
+ template <class Type>
16681
+ struct noconst_traits {
16682
+ typedef Type noconst_type;
16683
+ };
16684
+
16685
+ template <class Type>
16686
+ struct noconst_traits<const Type> {
16687
+ typedef Type noconst_type;
16688
+ };
16689
+
16690
+ /*
16691
+ type categories
16692
+ */
16693
+ struct pointer_category { };
16694
+ struct value_category { };
16695
+
16696
+ /*
16697
+ General traits that provides type_name and type_info
16698
+ */
16699
+ template <class Type> struct traits { };
16700
+
16701
+ template <class Type>
16702
+ inline const char* type_name() {
16703
+ return traits<typename noconst_traits<Type >::noconst_type >::type_name();
16704
+ }
16705
+
16706
+ template <class Type>
16707
+ struct traits_info {
16708
+ static swig_type_info *type_query(std::string name) {
16709
+ name += " *";
16710
+ return SWIG_TypeQuery(name.c_str());
16711
+ }
16712
+ static swig_type_info *type_info() {
16713
+ static swig_type_info *info = type_query(type_name<Type>());
16714
+ return info;
16715
+ }
16716
+ };
16717
+
16718
+ template <class Type>
16719
+ inline swig_type_info *type_info() {
16720
+ return traits_info<Type>::type_info();
16721
+ }
16722
+
16723
+ /*
16724
+ Partial specialization for pointers
16725
+ */
16726
+ template <class Type> struct traits <Type *> {
16727
+ typedef pointer_category category;
16728
+ static std::string make_ptr_name(const char* name) {
16729
+ std::string ptrname = name;
16730
+ ptrname += " *";
16731
+ return ptrname;
16732
+ }
16733
+ static const char* type_name() {
16734
+ static std::string name = make_ptr_name(swig::type_name<Type>());
16735
+ return name.c_str();
16736
+ }
16737
+ };
16738
+
16739
+ template <class Type, class Category>
16740
+ struct traits_as { };
16741
+
16742
+ template <class Type, class Category>
16743
+ struct traits_check { };
16744
+
16745
+}
16746
+
16747
+
16748
+namespace swig {
16749
+ /*
16750
+ Traits that provides the from method
16751
+ */
16752
+ template <class Type> struct traits_from_ptr {
16753
+ static PyObject *from(Type *val, int owner = 0) {
16754
+ return SWIG_NewPointerObj(val, type_info<Type>(), owner);
16755
+ }
16756
+ };
16757
+
16758
+ template <class Type> struct traits_from {
16759
+ static PyObject *from(const Type& val) {
16760
+ return traits_from_ptr<Type>::from(new Type(val), 1);
16761
+ }
16762
+ };
16763
+
16764
+ template <class Type> struct traits_from<Type *> {
16765
+ static PyObject *from(Type* val) {
16766
+ return traits_from_ptr<Type>::from(val, 0);
16767
+ }
16768
+ };
16769
+
16770
+ template <class Type> struct traits_from<const Type *> {
16771
+ static PyObject *from(const Type* val) {
16772
+ return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
16773
+ }
16774
+ };
16775
+
16776
+
16777
+ template <class Type>
16778
+ inline PyObject *from(const Type& val) {
16779
+ return traits_from<Type>::from(val);
16780
+ }
16781
+
16782
+ template <class Type>
16783
+ inline PyObject *from_ptr(Type* val, int owner) {
16784
+ return traits_from_ptr<Type>::from(val, owner);
16785
+ }
16786
+
16787
+ /*
16788
+ Traits that provides the asval/as/check method
16789
+ */
16790
+ template <class Type>
16791
+ struct traits_asptr {
16792
+ static int asptr(PyObject *obj, Type **val) {
16793
+ Type *p;
16794
+ int res = (SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0) == SWIG_OK) ? SWIG_OLDOBJ : 0;
16795
+ if (SWIG_IsOK(res)) {
16796
+ if (val) *val = p;
16797
+ }
16798
+ return res;
16799
+ }
16800
+ };
16801
+
16802
+ template <class Type>
16803
+ inline int asptr(PyObject *obj, Type **vptr) {
16804
+ return traits_asptr<Type>::asptr(obj, vptr);
16805
+ }
16806
+
16807
+ template <class Type>
16808
+ struct traits_asval {
16809
+ static int asval(PyObject *obj, Type *val) {
16810
+ if (val) {
16811
+ Type *p = 0;
16812
+ int res = traits_asptr<Type>::asptr(obj, &p);
16813
+ if (!SWIG_IsOK(res)) return res;
16814
+ if (p) {
16815
+ typedef typename noconst_traits<Type>::noconst_type noconst_type;
16816
+ *(const_cast<noconst_type*>(val)) = *p;
16817
+ if (SWIG_IsNewObj(res)){
16818
+ delete p;
16819
+ res = SWIG_DelNewMask(res);
16820
+ }
16821
+ return res;
16822
+ } else {
16823
+ return SWIG_ERROR;
16824
+ }
16825
+ } else {
16826
+ return traits_asptr<Type>::asptr(obj, (Type **)(0));
16827
+ }
16828
+ }
16829
+ };
16830
+
16831
+ template <class Type> struct traits_asval<Type*> {
16832
+ static int asval(PyObject *obj, Type **val) {
16833
+ if (val) {
16834
+ typedef typename noconst_traits<Type>::noconst_type noconst_type;
16835
+ noconst_type *p = 0;
16836
+ int res = traits_asptr<noconst_type>::asptr(obj, &p);
16837
+ if (SWIG_IsOK(res)) {
16838
+ *(const_cast<noconst_type**>(val)) = p;
16839
+ }
16840
+ return res;
16841
+ } else {
16842
+ return traits_asptr<Type>::asptr(obj, (Type **)(0));
16843
+ }
16844
+ }
16845
+ };
16846
+
16847
+ template <class Type>
16848
+ inline int asval(PyObject *obj, Type *val) {
16849
+ return traits_asval<Type>::asval(obj, val);
16850
+ }
16851
+
16852
+ template <class Type>
16853
+ struct traits_as<Type, value_category> {
16854
+ static Type as(PyObject *obj, bool throw_error) {
16855
+ Type v;
16856
+ int res = asval(obj, &v);
16857
+ if (!obj || !SWIG_IsOK(res)) {
16858
+ if (!PyErr_Occurred()) {
16859
+ ::SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
16860
+ }
16861
+ if (throw_error) throw std::invalid_argument("bad type");
16862
+ }
16863
+ return v;
16864
+ }
16865
+ };
16866
+
16867
+ template <class Type>
16868
+ struct traits_as<Type, pointer_category> {
16869
+ static Type as(PyObject *obj, bool throw_error) {
16870
+ Type *v = 0;
16871
+ int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
16872
+ if (SWIG_IsOK(res) && v) {
16873
+ if (SWIG_IsNewObj(res)) {
16874
+ Type r(*v);
16875
+ delete v;
16876
+ return r;
16877
+ } else {
16878
+ return *v;
16879
+ }
16880
+ } else {
16881
+ // Uninitialized return value, no Type() constructor required.
16882
+ static Type *v_def = (Type*) malloc(sizeof(Type));
16883
+ if (!PyErr_Occurred()) {
16884
+ SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
16885
+ }
16886
+ if (throw_error) throw std::invalid_argument("bad type");
16887
+ memset(v_def,0,sizeof(Type));
16888
+ return *v_def;
16889
+ }
16890
+ }
16891
+ };
16892
+
16893
+ template <class Type>
16894
+ struct traits_as<Type*, pointer_category> {
16895
+ static Type* as(PyObject *obj, bool throw_error) {
16896
+ Type *v = 0;
16897
+ int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
16898
+ if (SWIG_IsOK(res)) {
16899
+ return v;
16900
+ } else {
16901
+ if (!PyErr_Occurred()) {
16902
+ SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
16903
+ }
16904
+ if (throw_error) throw std::invalid_argument("bad type");
16905
+ return 0;
16906
+ }
16907
+ }
16908
+ };
16909
+
16910
+ template <class Type>
16911
+ inline Type as(PyObject *obj, bool te = false) {
16912
+ return traits_as<Type, typename traits<Type>::category>::as(obj, te);
16913
+ }
16914
+
16915
+ template <class Type>
16916
+ struct traits_check<Type, value_category> {
16917
+ static bool check(PyObject *obj) {
16918
+ int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
16919
+ return SWIG_IsOK(res) ? true : false;
16920
+ }
16921
+ };
16922
+
16923
+ template <class Type>
16924
+ struct traits_check<Type, pointer_category> {
16925
+ static bool check(PyObject *obj) {
16926
+ int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
16927
+ return SWIG_IsOK(res) ? true : false;
16928
+ }
16929
+ };
16930
+
16931
+ template <class Type>
16932
+ inline bool check(PyObject *obj) {
16933
+ return traits_check<Type, typename traits<Type>::category>::check(obj);
16934
+ }
16935
+}
16936
+
16937
+
16938
+#include <functional>
16939
+
16940
+namespace std {
16941
+ template <>
16942
+ struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
16943
+ {
16944
+ bool
16945
+ operator()(PyObject * v, PyObject *w) const
16946
+ {
16947
+ bool res;
16948
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
16949
+ res = PyObject_Compare(v, w) < 0;
16950
+ SWIG_PYTHON_THREAD_END_BLOCK;
16951
+ return res;
16952
+ }
16953
+ };
16954
+
16955
+ template <>
16956
+ struct less <swig::PyObject_ptr>: public binary_function<swig::PyObject_ptr, swig::PyObject_ptr, bool>
16957
+ {
16958
+ bool
16959
+ operator()(const swig::PyObject_ptr& v, const swig::PyObject_ptr& w) const
16960
+ {
16961
+ return std::less<PyObject *>()(v, w);
16962
+ }
16963
+ };
16964
+
16965
+ template <>
16966
+ struct less <swig::PyObject_var>: public binary_function<swig::PyObject_var, swig::PyObject_var, bool>
16967
+ {
16968
+ bool
16969
+ operator()(const swig::PyObject_var& v, const swig::PyObject_var& w) const
16970
+ {
16971
+ return std::less<PyObject *>()(v, w);
16972
+ }
16973
+ };
16974
+
16975
+}
16976
+
16977
+namespace swig {
16978
+ template <> struct traits<PyObject *> {
16979
+ typedef value_category category;
16980
+ static const char* type_name() { return "PyObject *"; }
16981
+ };
16982
+
16983
+ template <> struct traits_asval<PyObject * > {
16984
+ typedef PyObject * value_type;
16985
+ static int asval(PyObject *obj, value_type *val) {
16986
+ if (val) *val = obj;
16987
+ return SWIG_OK;
16988
+ }
16989
+ };
16990
+
16991
+ template <>
16992
+ struct traits_check<PyObject *, value_category> {
16993
+ static bool check(PyObject *) {
16994
+ return true;
16995
+ }
16996
+ };
16997
+
16998
+ template <> struct traits_from<PyObject *> {
16999
+ typedef PyObject * value_type;
17000
+ static PyObject *from(const value_type& val) {
17001
+ Py_XINCREF(val);
17002
+ return val;
17003
+ }
17004
+ };
17005
+
17006
+}
17007
+
17008
+namespace swig {
17009
+ inline size_t
17010
+ check_index(ptrdiff_t i, size_t size, bool insert = false) {
17011
+ if ( i < 0 ) {
17012
+ if ((size_t) (-i) <= size)
17013
+ return (size_t) (i + size);
17014
+ } else if ( (size_t) i < size ) {
17015
+ return (size_t) i;
17016
+ } else if (insert && ((size_t) i == size)) {
17017
+ return size;
17018
+ }
17019
+
17020
+ throw std::out_of_range("index out of range");
17021
+ }
17022
+
17023
+ inline size_t
17024
+ slice_index(ptrdiff_t i, size_t size) {
17025
+ if ( i < 0 ) {
17026
+ if ((size_t) (-i) <= size) {
17027
+ return (size_t) (i + size);
17028
+ } else {
17029
+ throw std::out_of_range("index out of range");
17030
+ }
17031
+ } else {
17032
+ return ( (size_t) i < size ) ? ((size_t) i) : size;
17033
+ }
17034
+ }
17035
+
17036
+ template <class Sequence, class Difference>
17037
+ inline typename Sequence::iterator
17038
+ getpos(Sequence* self, Difference i) {
17039
+ typename Sequence::iterator pos = self->begin();
17040
+ std::advance(pos, check_index(i,self->size()));
17041
+ return pos;
17042
+ }
17043
+
17044
+ template <class Sequence, class Difference>
17045
+ inline typename Sequence::const_iterator
17046
+ cgetpos(const Sequence* self, Difference i) {
17047
+ typename Sequence::const_iterator pos = self->begin();
17048
+ std::advance(pos, check_index(i,self->size()));
17049
+ return pos;
17050
+ }
17051
+
17052
+ template <class Sequence, class Difference>
17053
+ inline Sequence*
17054
+ getslice(const Sequence* self, Difference i, Difference j) {
17055
+ typename Sequence::size_type size = self->size();
17056
+ typename Sequence::size_type ii = swig::check_index(i, size);
17057
+ typename Sequence::size_type jj = swig::slice_index(j, size);
17058
+
17059
+ if (jj > ii) {
17060
+ typename Sequence::const_iterator vb = self->begin();
17061
+ typename Sequence::const_iterator ve = self->begin();
17062
+ std::advance(vb,ii);
17063
+ std::advance(ve,jj);
17064
+ return new Sequence(vb, ve);
17065
+ } else {
17066
+ return new Sequence();
17067
+ }
17068
+ }
17069
+
17070
+ template <class Sequence, class Difference, class InputSeq>
17071
+ inline void
17072
+ setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
17073
+ typename Sequence::size_type size = self->size();
17074
+ typename Sequence::size_type ii = swig::check_index(i, size, true);
17075
+ typename Sequence::size_type jj = swig::slice_index(j, size);
17076
+ if (jj < ii) jj = ii;
17077
+ size_t ssize = jj - ii;
17078
+ if (ssize <= v.size()) {
17079
+ typename Sequence::iterator sb = self->begin();
17080
+ typename InputSeq::const_iterator vmid = v.begin();
17081
+ std::advance(sb,ii);
17082
+ std::advance(vmid, jj - ii);
17083
+ self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
17084
+ } else {
17085
+ typename Sequence::iterator sb = self->begin();
17086
+ typename Sequence::iterator se = self->begin();
17087
+ std::advance(sb,ii);
17088
+ std::advance(se,jj);
17089
+ self->erase(sb,se);
17090
+ self->insert(sb, v.begin(), v.end());
17091
+ }
17092
+ }
17093
+
17094
+ template <class Sequence, class Difference>
17095
+ inline void
17096
+ delslice(Sequence* self, Difference i, Difference j) {
17097
+ typename Sequence::size_type size = self->size();
17098
+ typename Sequence::size_type ii = swig::check_index(i, size, true);
17099
+ typename Sequence::size_type jj = swig::slice_index(j, size);
17100
+ if (jj > ii) {
17101
+ typename Sequence::iterator sb = self->begin();
17102
+ typename Sequence::iterator se = self->begin();
17103
+ std::advance(sb,ii);
17104
+ std::advance(se,jj);
17105
+ self->erase(sb,se);
17106
+ }
17107
+ }
17108
+}
17109
+
17110
+
17111
+#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
17112
+# if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
17113
+# define SWIG_STD_NOITERATOR_TRAITS_STL
17114
+# endif
17115
+#endif
17116
+
17117
+#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
17118
+#include <iterator>
17119
+#else
17120
+namespace std {
17121
+ template <class Iterator>
17122
+ struct iterator_traits {
17123
+ typedef ptrdiff_t difference_type;
17124
+ typedef typename Iterator::value_type value_type;
17125
+ };
17126
+
17127
+ template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
17128
+ struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
17129
+ typedef Distance difference_type;
17130
+ typedef T value_type;
17131
+ };
17132
+
17133
+ template <class T>
17134
+ struct iterator_traits<T*> {
17135
+ typedef T value_type;
17136
+ typedef ptrdiff_t difference_type;
17137
+ };
17138
+
17139
+ template<typename _InputIterator>
17140
+ inline typename iterator_traits<_InputIterator>::difference_type
17141
+ distance(_InputIterator __first, _InputIterator __last)
17142
+ {
17143
+ typename iterator_traits<_InputIterator>::difference_type __n = 0;
17144
+ while (__first != __last) {
17145
+ ++__first; ++__n;
17146
+ }
17147
+ return __n;
17148
+ }
17149
+}
17150
+#endif
17151
+
17152
+
17153
+namespace swig {
17154
+ template<typename OutIterator>
17155
+ class PySwigIterator_T : public PySwigIterator
17156
+ {
17157
+ public:
17158
+ typedef OutIterator out_iterator;
17159
+ typedef typename std::iterator_traits<out_iterator>::value_type value_type;
17160
+ typedef PySwigIterator_T<out_iterator> self_type;
17161
+
17162
+ PySwigIterator_T(out_iterator curr, PyObject *seq)
17163
+ : PySwigIterator(seq), current(curr)
17164
+ {
17165
+ }
17166
+
17167
+ const out_iterator& get_current() const
17168
+ {
17169
+ return current;
17170
+ }
17171
+
17172
+
17173
+ bool equal (const PySwigIterator &iter) const
17174
+ {
17175
+ const self_type *iters = dynamic_cast<const self_type *>(&iter);
17176
+ if (iters) {
17177
+ return (current == iters->get_current());
17178
+ } else {
17179
+ throw std::invalid_argument("bad iterator type");
17180
+ }
17181
+ }
17182
+
17183
+ ptrdiff_t distance(const PySwigIterator &iter) const
17184
+ {
17185
+ const self_type *iters = dynamic_cast<const self_type *>(&iter);
17186
+ if (iters) {
17187
+ return std::distance(current, iters->get_current());
17188
+ } else {
17189
+ throw std::invalid_argument("bad iterator type");
17190
+ }
17191
+ }
17192
+
17193
+ protected:
17194
+ out_iterator current;
17195
+ };
17196
+
17197
+ template <class ValueType>
17198
+ struct from_oper
17199
+ {
17200
+ typedef const ValueType& argument_type;
17201
+ typedef PyObject *result_type;
17202
+ result_type operator()(argument_type v) const
17203
+ {
17204
+ return swig::from(v);
17205
+ }
17206
+ };
17207
+
17208
+ template<typename OutIterator,
17209
+ typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
17210
+ typename FromOper = from_oper<ValueType> >
17211
+ class PySwigIteratorOpen_T : public PySwigIterator_T<OutIterator>
17212
+ {
17213
+ public:
17214
+ FromOper from;
17215
+ typedef OutIterator out_iterator;
17216
+ typedef ValueType value_type;
17217
+ typedef PySwigIterator_T<out_iterator> base;
17218
+ typedef PySwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
17219
+
17220
+ PySwigIteratorOpen_T(out_iterator curr, PyObject *seq)
17221
+ : PySwigIterator_T<OutIterator>(curr, seq)
17222
+ {
17223
+ }
17224
+
17225
+ PyObject *value() const {
17226
+ return from(static_cast<const value_type&>(*(base::current)));
17227
+ }
17228
+
17229
+ PySwigIterator *copy() const
17230
+ {
17231
+ return new self_type(*this);
17232
+ }
17233
+
17234
+ PySwigIterator *incr(size_t n = 1)
17235
+ {
17236
+ while (n--) {
17237
+ ++base::current;
17238
+ }
17239
+ return this;
17240
+ }
17241
+
17242
+ PySwigIterator *decr(size_t n = 1)
17243
+ {
17244
+ while (n--) {
17245
+ --base::current;
17246
+ }
17247
+ return this;
17248
+ }
17249
+ };
17250
+
17251
+ template<typename OutIterator,
17252
+ typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
17253
+ typename FromOper = from_oper<ValueType> >
17254
+ class PySwigIteratorClosed_T : public PySwigIterator_T<OutIterator>
17255
+ {
17256
+ public:
17257
+ FromOper from;
17258
+ typedef OutIterator out_iterator;
17259
+ typedef ValueType value_type;
17260
+ typedef PySwigIterator_T<out_iterator> base;
17261
+ typedef PySwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
17262
+
17263
+ PySwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
17264
+ : PySwigIterator_T<OutIterator>(curr, seq), begin(first), end(last)
17265
+ {
17266
+ }
17267
+
17268
+ PyObject *value() const {
17269
+ if (base::current == end) {
17270
+ throw stop_iteration();
17271
+ } else {
17272
+ return from(static_cast<const value_type&>(*(base::current)));
17273
+ }
17274
+ }
17275
+
17276
+ PySwigIterator *copy() const
17277
+ {
17278
+ return new self_type(*this);
17279
+ }
17280
+
17281
+ PySwigIterator *incr(size_t n = 1)
17282
+ {
17283
+ while (n--) {
17284
+ if (base::current == end) {
17285
+ throw stop_iteration();
17286
+ } else {
17287
+ ++base::current;
17288
+ }
17289
+ }
17290
+ return this;
17291
+ }
17292
+
17293
+ PySwigIterator *decr(size_t n = 1)
17294
+ {
17295
+ while (n--) {
17296
+ if (base::current == begin) {
17297
+ throw stop_iteration();
17298
+ } else {
17299
+ --base::current;
17300
+ }
17301
+ }
17302
+ return this;
17303
+ }
17304
+
17305
+ private:
17306
+ out_iterator begin;
17307
+ out_iterator end;
17308
+ };
17309
+
17310
+ template<typename OutIter>
17311
+ inline PySwigIterator*
17312
+ make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
17313
+ {
17314
+ return new PySwigIteratorClosed_T<OutIter>(current, begin, end, seq);
17315
+ }
17316
+
17317
+ template<typename OutIter>
17318
+ inline PySwigIterator*
17319
+ make_output_iterator(const OutIter& current, PyObject *seq = 0)
17320
+ {
17321
+ return new PySwigIteratorOpen_T<OutIter>(current, seq);
17322
+ }
17323
+}
17324
+
17325
+
17326
+namespace swig
17327
+{
17328
+ template <class T>
17329
+ struct PySequence_Ref
17330
+ {
17331
+ PySequence_Ref(PyObject* seq, int index)
17332
+ : _seq(seq), _index(index)
17333
+ {
17334
+ }
17335
+
17336
+ operator T () const
17337
+ {
17338
+ swig::PyObject_var item = PySequence_GetItem(_seq, _index);
17339
+ try {
17340
+ return swig::as<T>(item, true);
17341
+ } catch (std::exception& e) {
17342
+ char msg[1024];
17343
+ sprintf(msg, "in sequence element %d ", _index);
17344
+ if (!PyErr_Occurred()) {
17345
+ ::SWIG_Error(SWIG_TypeError, swig::type_name<T>());
17346
+ }
17347
+ SWIG_Python_AddErrorMsg(msg);
17348
+ SWIG_Python_AddErrorMsg(e.what());
17349
+ throw;
17350
+ }
17351
+ }
17352
+
17353
+ PySequence_Ref& operator=(const T& v)
17354
+ {
17355
+ PySequence_SetItem(_seq, _index, swig::from<T>(v));
17356
+ return *this;
17357
+ }
17358
+
17359
+ private:
17360
+ PyObject* _seq;
17361
+ int _index;
17362
+ };
17363
+
17364
+ template <class T>
17365
+ struct PySequence_ArrowProxy
17366
+ {
17367
+ PySequence_ArrowProxy(const T& x): m_value(x) {}
17368
+ const T* operator->() const { return &m_value; }
17369
+ operator const T*() const { return &m_value; }
17370
+ T m_value;
17371
+ };
17372
+
17373
+ template <class T, class Reference >
17374
+ struct PySequence_InputIterator
17375
+ {
17376
+ typedef PySequence_InputIterator<T, Reference > self;
17377
+
17378
+ typedef std::random_access_iterator_tag iterator_category;
17379
+ typedef Reference reference;
17380
+ typedef T value_type;
17381
+ typedef T* pointer;
17382
+ typedef int difference_type;
17383
+
17384
+ PySequence_InputIterator()
17385
+ {
17386
+ }
17387
+
17388
+ PySequence_InputIterator(PyObject* seq, int index)
17389
+ : _seq(seq), _index(index)
17390
+ {
17391
+ }
17392
+
17393
+ reference operator*() const
17394
+ {
17395
+ return reference(_seq, _index);
17396
+ }
17397
+
17398
+ PySequence_ArrowProxy<T>
17399
+ operator->() const {
17400
+ return PySequence_ArrowProxy<T>(operator*());
17401
+ }
17402
+
17403
+ bool operator==(const self& ri) const
17404
+ {
17405
+ return (_index == ri._index) && (_seq == ri._seq);
17406
+ }
17407
+
17408
+ bool operator!=(const self& ri) const
17409
+ {
17410
+ return !(operator==(ri));
17411
+ }
17412
+
17413
+ self& operator ++ ()
17414
+ {
17415
+ ++_index;
17416
+ return *this;
17417
+ }
17418
+
17419
+ self& operator -- ()
17420
+ {
17421
+ --_index;
17422
+ return *this;
17423
+ }
17424
+
17425
+ self& operator += (difference_type n)
17426
+ {
17427
+ _index += n;
17428
+ return *this;
17429
+ }
17430
+
17431
+ self operator +(difference_type n) const
17432
+ {
17433
+ return self(_seq, _index + n);
17434
+ }
17435
+
17436
+ self& operator -= (difference_type n)
17437
+ {
17438
+ _index -= n;
17439
+ return *this;
17440
+ }
17441
+
17442
+ self operator -(difference_type n) const
17443
+ {
17444
+ return self(_seq, _index - n);
17445
+ }
17446
+
17447
+ difference_type operator - (const self& ri) const
17448
+ {
17449
+ return _index - ri._index;
17450
+ }
17451
+
17452
+ bool operator < (const self& ri) const
17453
+ {
17454
+ return _index < ri._index;
17455
+ }
17456
+
17457
+ reference
17458
+ operator[](difference_type n) const
17459
+ {
17460
+ return reference(_seq, _index + n);
17461
+ }
17462
+
17463
+ private:
17464
+ PyObject* _seq;
17465
+ difference_type _index;
17466
+ };
17467
+
17468
+ template <class T>
17469
+ struct PySequence_Cont
17470
+ {
17471
+ typedef PySequence_Ref<T> reference;
17472
+ typedef const PySequence_Ref<T> const_reference;
17473
+ typedef T value_type;
17474
+ typedef T* pointer;
17475
+ typedef int difference_type;
17476
+ typedef int size_type;
17477
+ typedef const pointer const_pointer;
17478
+ typedef PySequence_InputIterator<T, reference> iterator;
17479
+ typedef PySequence_InputIterator<T, const_reference> const_iterator;
17480
+
17481
+ PySequence_Cont(PyObject* seq) : _seq(0)
17482
+ {
17483
+ if (!PySequence_Check(seq)) {
17484
+ throw std::invalid_argument("a sequence is expected");
17485
+ }
17486
+ _seq = seq;
17487
+ Py_INCREF(_seq);
17488
+ }
17489
+
17490
+ ~PySequence_Cont()
17491
+ {
17492
+ Py_XDECREF(_seq);
17493
+ }
17494
+
17495
+ size_type size() const
17496
+ {
17497
+ return static_cast<size_type>(PySequence_Size(_seq));
17498
+ }
17499
+
17500
+ bool empty() const
17501
+ {
17502
+ return size() == 0;
17503
+ }
17504
+
17505
+ iterator begin()
17506
+ {
17507
+ return iterator(_seq, 0);
17508
+ }
17509
+
17510
+ const_iterator begin() const
17511
+ {
17512
+ return const_iterator(_seq, 0);
17513
+ }
17514
+
17515
+ iterator end()
17516
+ {
17517
+ return iterator(_seq, size());
17518
+ }
17519
+
17520
+ const_iterator end() const
17521
+ {
17522
+ return const_iterator(_seq, size());
17523
+ }
17524
+
17525
+ reference operator[](difference_type n)
17526
+ {
17527
+ return reference(_seq, n);
17528
+ }
17529
+
17530
+ const_reference operator[](difference_type n) const
17531
+ {
17532
+ return const_reference(_seq, n);
17533
+ }
17534
+
17535
+ bool check(bool set_err = true) const
17536
+ {
17537
+ int s = size();
17538
+ for (int i = 0; i < s; ++i) {
17539
+ swig::PyObject_var item = PySequence_GetItem(_seq, i);
17540
+ if (!swig::check<value_type>(item)) {
17541
+ if (set_err) {
17542
+ char msg[1024];
17543
+ sprintf(msg, "in sequence element %d", i);
17544
+ SWIG_Error(SWIG_RuntimeError, msg);
17545
+ }
17546
+ return false;
17547
+ }
17548
+ }
17549
+ return true;
17550
+ }
17551
+
17552
+ private:
17553
+ PyObject* _seq;
17554
+ };
17555
+
17556
+}
17557
+
17558
+
17559
+#include <limits.h>
17560
+#if !defined(SWIG_NO_LLONG_MAX)
17561
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
17562
+# define LLONG_MAX __LONG_LONG_MAX__
17563
+# define LLONG_MIN (-LLONG_MAX - 1LL)
17564
+# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
17565
+# endif
17566
+#endif
17567
+
17568
+
17569
+SWIGINTERN int
17570
+SWIG_AsVal_int (PyObject * obj, int *val)
17571
+{
17572
+ long v;
17573
+ int res = SWIG_AsVal_long (obj, &v);
17574
+ if (SWIG_IsOK(res)) {
17575
+ if ((v < INT_MIN || v > INT_MAX)) {
17576
+ return SWIG_OverflowError;
17577
+ } else {
17578
+ if (val) *val = static_cast< int >(v);
17579
+ }
17580
+ }
17581
+ return res;
17582
+}
17583
+
17584
+
17585
+SWIGINTERNINLINE PyObject *
17586
+SWIG_From_int (int value)
17587
+{
17588
+ return SWIG_From_long (value);
17589
+}
17590
+
17591
+
17592
+namespace swig {
17593
+ template <> struct traits<int > {
17594
+ typedef value_category category;
17595
+ static const char* type_name() { return"int"; }
17596
+ };
17597
+ template <> struct traits_asval<int > {
17598
+ typedef int value_type;
17599
+ static int asval(PyObject *obj, value_type *val) {
17600
+ return SWIG_AsVal_int (obj, val);
17601
+ }
17602
+ };
17603
+ template <> struct traits_from<int > {
17604
+ typedef int value_type;
17605
+ static PyObject *from(const value_type& val) {
17606
+ return SWIG_From_int (val);
17607
+ }
17608
+ };
17609
+}
17610
+
17611
+
17612
+namespace swig {
17613
+ template <class PySeq, class Seq>
17614
+ inline void
17615
+ assign(const PySeq& pyseq, Seq* seq) {
17616
+ // seq->assign(pyseq.begin(), pyseq.end()); // not used as not always implemented
17617
+ typedef typename PySeq::value_type value_type;
17618
+ typename PySeq::const_iterator it = pyseq.begin();
17619
+ for (;it != pyseq.end(); ++it) {
17620
+ seq->insert(seq->end(),(value_type)(*it));
17621
+ }
17622
+ }
17623
+
17624
+ template <class Seq, class T = typename Seq::value_type >
17625
+ struct traits_asptr_stdseq {
17626
+ typedef Seq sequence;
17627
+ typedef T value_type;
17628
+
17629
+ static int asptr(PyObject *obj, sequence **seq) {
17630
+ if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
17631
+ sequence *p;
17632
+ if (::SWIG_ConvertPtr(obj,(void**)&p,
17633
+ swig::type_info<sequence>(),0) == SWIG_OK) {
17634
+ if (seq) *seq = p;
17635
+ return SWIG_OLDOBJ;
17636
+ }
17637
+ } else if (PySequence_Check(obj)) {
17638
+ try {
17639
+ PySequence_Cont<value_type> pyseq(obj);
17640
+ if (seq) {
17641
+ sequence *pseq = new sequence();
17642
+ assign(pyseq, pseq);
17643
+ *seq = pseq;
17644
+ return SWIG_NEWOBJ;
17645
+ } else {
17646
+ return pyseq.check() ? SWIG_OK : SWIG_ERROR;
17647
+ }
17648
+ } catch (std::exception& e) {
17649
+ if (seq) {
17650
+ if (!PyErr_Occurred()) {
17651
+ PyErr_SetString(PyExc_TypeError, e.what());
17652
+ }
17653
+ }
17654
+ return SWIG_ERROR;
17655
+ }
17656
+ }
17657
+ return SWIG_ERROR;
17658
+ }
17659
+ };
17660
+
17661
+ template <class Seq, class T = typename Seq::value_type >
17662
+ struct traits_from_stdseq {
17663
+ typedef Seq sequence;
17664
+ typedef T value_type;
17665
+ typedef typename Seq::size_type size_type;
17666
+ typedef typename sequence::const_iterator const_iterator;
17667
+
17668
+ static PyObject *from(const sequence& seq) {
17669
+#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
17670
+ swig_type_info *desc = swig::type_info<sequence>();
17671
+ if (desc && desc->clientdata) {
17672
+ return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
17673
+ }
17674
+#endif
17675
+ size_type size = seq.size();
17676
+ if (size <= (size_type)INT_MAX) {
17677
+ PyObject *obj = PyTuple_New((int)size);
17678
+ int i = 0;
17679
+ for (const_iterator it = seq.begin();
17680
+ it != seq.end(); ++it, ++i) {
17681
+ PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
17682
+ }
17683
+ return obj;
17684
+ } else {
17685
+ PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
17686
+ return NULL;
17687
+ }
17688
+ }
17689
+ };
17690
+}
17691
+
17692
+
17693
+ namespace swig {
17694
+ template <class T>
17695
+ struct traits_asptr<std::vector<T> > {
17696
+ static int asptr(PyObject *obj, std::vector<T> **vec) {
17697
+ return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
17698
+ }
17699
+ };
17700
+
17701
+ template <class T>
17702
+ struct traits_from<std::vector<T> > {
17703
+ static PyObject *from(const std::vector<T>& vec) {
17704
+ return traits_from_stdseq<std::vector<T> >::from(vec);
17705
+ }
17706
+ };
17707
+ }
17708
+
17709
+
17710
+ namespace swig {
17711
+ template <> struct traits<std::vector<int, std::allocator< int > > > {
17712
+ typedef pointer_category category;
17713
+ static const char* type_name() {
17714
+ return "std::vector<" "int" "," "std::allocator< int >" " >";
17715
+ }
17716
+ };
17717
+ }
17718
+
17719
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
17720
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
17721
+ }
17722
+SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
17723
+ return !(self->empty());
17724
+ }
17725
+SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
17726
+ return self->size();
17727
+ }
17728
+
17729
+SWIGINTERNINLINE PyObject*
17730
+SWIG_From_unsigned_SS_long (unsigned long value)
17731
+{
17732
+ return (value > LONG_MAX) ?
17733
+ PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
17734
+}
17735
+
17736
+
17737
+SWIGINTERNINLINE PyObject *
17738
+SWIG_From_size_t (size_t value)
17739
+{
17740
+ return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
17741
+}
17742
+
17743
+SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
17744
+ if (self->size() == 0)
17745
+ throw std::out_of_range("pop from empty container");
17746
+ std::vector<int,std::allocator< int > >::value_type x = self->back();
17747
+ self->pop_back();
17748
+ return x;
17749
+ }
17750
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
17751
+ return swig::getslice(self, i, j);
17752
+ }
17753
+SWIGINTERN void std_vector_Sl_int_Sg____setslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
17754
+ swig::setslice(self, i, j, v);
17755
+ }
17756
+SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
17757
+ swig::delslice(self, i, j);
17758
+ }
17759
+SWIGINTERN void std_vector_Sl_int_Sg____delitem__(std::vector< int > *self,std::vector< int >::difference_type i){
17760
+ self->erase(swig::getpos(self,i));
17761
+ }
17762
+SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem__(std::vector< int > const *self,std::vector< int >::difference_type i){
17763
+ return *(swig::cgetpos(self, i));
17764
+ }
17765
+SWIGINTERN void std_vector_Sl_int_Sg____setitem__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
17766
+ *(swig::getpos(self,i)) = x;
17767
+ }
17768
+SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
17769
+ self->push_back(x);
17770
+ }
17771
+
17772
+ #define SWIG_From_double PyFloat_FromDouble
17773
+
17774
+
17775
+namespace swig {
17776
+ template <> struct traits<double > {
17777
+ typedef value_category category;
17778
+ static const char* type_name() { return"double"; }
17779
+ };
17780
+ template <> struct traits_asval<double > {
17781
+ typedef double value_type;
17782
+ static int asval(PyObject *obj, value_type *val) {
17783
+ return SWIG_AsVal_double (obj, val);
17784
+ }
17785
+ };
17786
+ template <> struct traits_from<double > {
17787
+ typedef double value_type;
17788
+ static PyObject *from(const value_type& val) {
17789
+ return SWIG_From_double (val);
17790
+ }
17791
+ };
17792
+}
17793
+
17794
+
17795
+ namespace swig {
17796
+ template <> struct traits<std::vector<double, std::allocator< double > > > {
17797
+ typedef pointer_category category;
17798
+ static const char* type_name() {
17799
+ return "std::vector<" "double" "," "std::allocator< double >" " >";
17800
+ }
17801
+ };
17802
+ }
17803
+
17804
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
17805
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
17806
+ }
17807
+SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
17808
+ return !(self->empty());
17809
+ }
17810
+SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
17811
+ return self->size();
17812
+ }
17813
+SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
17814
+ if (self->size() == 0)
17815
+ throw std::out_of_range("pop from empty container");
17816
+ std::vector<double,std::allocator< double > >::value_type x = self->back();
17817
+ self->pop_back();
17818
+ return x;
17819
+ }
17820
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
17821
+ return swig::getslice(self, i, j);
17822
+ }
17823
+SWIGINTERN void std_vector_Sl_double_Sg____setslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
17824
+ swig::setslice(self, i, j, v);
17825
+ }
17826
+SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
17827
+ swig::delslice(self, i, j);
17828
+ }
17829
+SWIGINTERN void std_vector_Sl_double_Sg____delitem__(std::vector< double > *self,std::vector< double >::difference_type i){
17830
+ self->erase(swig::getpos(self,i));
17831
+ }
17832
+SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem__(std::vector< double > const *self,std::vector< double >::difference_type i){
17833
+ return *(swig::cgetpos(self, i));
17834
+ }
17835
+SWIGINTERN void std_vector_Sl_double_Sg____setitem__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
17836
+ *(swig::getpos(self,i)) = x;
17837
+ }
17838
+SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
17839
+ self->push_back(x);
17840
+ }
17841
+
17842
+#include <utility>
17843
+
17844
+
17845
+#include <map>
17846
+#include <algorithm>
17847
+#include <stdexcept>
17848
+
17849
+
17850
+ namespace swig {
17851
+
17852
+
17853
+
17854
+
17855
+
17856
+
17857
+
17858
+
17859
+
17860
+
17861
+
17862
+
17863
+
17864
+
17865
+
17866
+
17867
+
17868
+
17869
+
17870
+
17871
+
17872
+
17873
+
17874
+
17875
+
17876
+
17877
+
17878
+
17879
+
17880
+
17881
+
17882
+
17883
+
17884
+
17885
+
17886
+
17887
+
17888
+
17889
+
17890
+
17891
+
17892
+
17893
+
17894
+
17895
+
17896
+
17897
+
17898
+
17899
+
17900
+ template <class T, class U >
17901
+ struct traits_asptr<std::pair<T,U> > {
17902
+ typedef std::pair<T,U> value_type;
17903
+
17904
+ static int get_pair(PyObject* first, PyObject* second,
17905
+ std::pair<T,U> **val)
17906
+ {
17907
+ if (val) {
17908
+ value_type *vp = (new std::pair<T,U>);
17909
+ T *pfirst = &(vp->first);
17910
+ int res1 = swig::asval((PyObject*)first, pfirst);
17911
+ if (!SWIG_IsOK(res1)) return res1;
17912
+ U *psecond = &(vp->second);
17913
+ int res2 = swig::asval((PyObject*)second, psecond);
17914
+ if (!SWIG_IsOK(res2)) return res2;
17915
+ *val = vp;
17916
+ return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
17917
+ } else {
17918
+ T *pfirst = 0;
17919
+ int res1 = swig::asval((PyObject*)first, pfirst);
17920
+ if (!SWIG_IsOK(res1)) return res1;
17921
+ U *psecond = 0;
17922
+ int res2 = swig::asval((PyObject*)second, psecond);
17923
+ if (!SWIG_IsOK(res2)) return res2;
17924
+ return res1 > res2 ? res1 : res2;
17925
+ }
17926
+ }
17927
+
17928
+ static int asptr(PyObject *obj, std::pair<T,U> **val) {
17929
+ int res = SWIG_ERROR;
17930
+ if (PyTuple_Check(obj)) {
17931
+ if (PyTuple_GET_SIZE(obj) == 2) {
17932
+ res = get_pair(PyTuple_GET_ITEM(obj,0),PyTuple_GET_ITEM(obj,1), val);
17933
+ }
17934
+ } else if (PySequence_Check(obj)) {
17935
+ if (PySequence_Size(obj) == 2) {
17936
+ swig::PyObject_var first = PySequence_GetItem(obj,0);
17937
+ swig::PyObject_var second = PySequence_GetItem(obj,1);
17938
+ res = get_pair(first, second, val);
17939
+ }
17940
+ } else {
17941
+ value_type *p;
17942
+ res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
17943
+ if (SWIG_IsOK(res) && val) *val = p;
17944
+ }
17945
+ return res;
17946
+ }
17947
+ };
17948
+
17949
+
17950
+ template <class T, class U >
17951
+ struct traits_from<std::pair<T,U> > {
17952
+ static PyObject *from(const std::pair<T,U>& val) {
17953
+ PyObject* obj = PyTuple_New(2);
17954
+ PyTuple_SetItem(obj,0,swig::from(val.first));
17955
+ PyTuple_SetItem(obj,1,swig::from(val.second));
17956
+ return obj;
17957
+ }
17958
+ };
17959
+ }
17960
+
17961
+
17962
+ namespace swig {
17963
+ template <> struct traits<std::pair< int, std::vector< int,std::allocator< int > > > > {
17964
+ typedef pointer_category category;
17965
+ static const char* type_name() {
17966
+ return "std::pair<" "int" "," "std::vector< int,std::allocator< int > >" " >";
17967
+ }
17968
+ };
17969
+ }
17970
+
17971
+
17972
+ namespace swig {
17973
+ template <class PySeq, class K, class T >
17974
+ inline void
17975
+ assign(const PySeq& pyseq, std::map<K,T > *map) {
17976
+ typedef typename std::map<K,T>::value_type value_type;
17977
+ typename PySeq::const_iterator it = pyseq.begin();
17978
+ for (;it != pyseq.end(); ++it) {
17979
+ map->insert(value_type(it->first, it->second));
17980
+ }
17981
+ }
17982
+
17983
+ template <class K, class T>
17984
+ struct traits_asptr<std::map<K,T> > {
17985
+ typedef std::map<K,T> map_type;
17986
+ static int asptr(PyObject *obj, map_type **val) {
17987
+ int res = SWIG_ERROR;
17988
+ if (PyDict_Check(obj)) {
17989
+ PyObject_var items = PyObject_CallMethod(obj,(char *)"items",NULL);
17990
+ res = traits_asptr_stdseq<std::map<K,T>, std::pair<K, T> >::asptr(items, val);
17991
+ } else {
17992
+ map_type *p;
17993
+ res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
17994
+ if (SWIG_IsOK(res) && val) *val = p;
17995
+ }
17996
+ return res;
17997
+ }
17998
+ };
17999
+
18000
+ template <class K, class T >
18001
+ struct traits_from<std::map<K,T> > {
18002
+ typedef std::map<K,T> map_type;
18003
+ typedef typename map_type::const_iterator const_iterator;
18004
+ typedef typename map_type::size_type size_type;
18005
+
18006
+ static PyObject *from(const map_type& map) {
18007
+ swig_type_info *desc = swig::type_info<map_type>();
18008
+ if (desc && desc->clientdata) {
18009
+ return SWIG_NewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
18010
+ } else {
18011
+ size_type size = map.size();
18012
+ int pysize = (size <= (size_type) INT_MAX) ? (int) size : -1;
18013
+ if (pysize < 0) {
18014
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
18015
+ PyErr_SetString(PyExc_OverflowError,
18016
+ "map size not valid in python");
18017
+ SWIG_PYTHON_THREAD_END_BLOCK;
18018
+ return NULL;
18019
+ }
18020
+ PyObject *obj = PyDict_New();
18021
+ for (const_iterator i= map.begin(); i!= map.end(); ++i) {
18022
+ swig::PyObject_var key = swig::from(i->first);
18023
+ swig::PyObject_var val = swig::from(i->second);
18024
+ PyDict_SetItem(obj, key, val);
18025
+ }
18026
+ return obj;
18027
+ }
18028
+ }
18029
+ };
18030
+
18031
+ template <class ValueType>
18032
+ struct from_key_oper
18033
+ {
18034
+ typedef const ValueType& argument_type;
18035
+ typedef PyObject *result_type;
18036
+ result_type operator()(argument_type v) const
18037
+ {
18038
+ return swig::from(v.first);
18039
+ }
18040
+ };
18041
+
18042
+ template <class ValueType>
18043
+ struct from_value_oper
18044
+ {
18045
+ typedef const ValueType& argument_type;
18046
+ typedef PyObject *result_type;
18047
+ result_type operator()(argument_type v) const
18048
+ {
18049
+ return swig::from(v.second);
18050
+ }
18051
+ };
18052
+
18053
+ template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
18054
+ struct PyMapIterator_T : PySwigIteratorClosed_T<OutIterator, ValueType, FromOper>
18055
+ {
18056
+ PyMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
18057
+ : PySwigIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
18058
+ {
18059
+ }
18060
+ };
18061
+
18062
+
18063
+ template<class OutIterator,
18064
+ class FromOper = from_key_oper<typename OutIterator::value_type> >
18065
+ struct PyMapKeyIterator_T : PyMapIterator_T<OutIterator, FromOper>
18066
+ {
18067
+ PyMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
18068
+ : PyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
18069
+ {
18070
+ }
18071
+ };
18072
+
18073
+ template<typename OutIter>
18074
+ inline PySwigIterator*
18075
+ make_output_key_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
18076
+ {
18077
+ return new PyMapKeyIterator_T<OutIter>(current, begin, end, seq);
18078
+ }
18079
+
18080
+ template<class OutIterator,
18081
+ class FromOper = from_value_oper<typename OutIterator::value_type> >
18082
+ struct PyMapValueIterator_T : PyMapIterator_T<OutIterator, FromOper>
18083
+ {
18084
+ PyMapValueIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
18085
+ : PyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
18086
+ {
18087
+ }
18088
+ };
18089
+
18090
+
18091
+ template<typename OutIter>
18092
+ inline PySwigIterator*
18093
+ make_output_value_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
18094
+ {
18095
+ return new PyMapValueIterator_T<OutIter>(current, begin, end, seq);
18096
+ }
18097
+ }
18098
+
18099
+
18100
+ namespace swig {
18101
+ template <> struct traits<std::map<int, std::vector< int,std::allocator< int > >, std::less< int >, std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > > > {
18102
+ typedef pointer_category category;
18103
+ static const char* type_name() {
18104
+ return "std::map<" "int" "," "std::vector< int,std::allocator< int > >" "," "std::less< int >" "," "std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > >" " >";
18105
+ }
18106
+ };
18107
+ }
18108
+
18109
+SWIGINTERN swig::PySwigIterator *std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__iterator(std::map< int,std::vector< int > > *self,PyObject **PYTHON_SELF){
18110
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
18111
+ }
18112
+SWIGINTERN bool std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____nonzero__(std::map< int,std::vector< int > > const *self){
18113
+ return !(self->empty());
18114
+ }
18115
+SWIGINTERN std::map< int,std::vector< int > >::size_type std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____len__(std::map< int,std::vector< int > > const *self){
18116
+ return self->size();
18117
+ }
18118
+SWIGINTERN std::map< int,std::vector< int > >::mapped_type std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____getitem__(std::map< int,std::vector< int > > const *self,std::map< int,std::vector< int > >::key_type const &key){
18119
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::const_iterator i = self->find(key);
18120
+ if (i != self->end())
18121
+ return i->second;
18122
+ else
18123
+ throw std::out_of_range("key not found");
18124
+ }
18125
+SWIGINTERN void std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____delitem__(std::map< int,std::vector< int > > *self,std::map< int,std::vector< int > >::key_type const &key){
18126
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::iterator i = self->find(key);
18127
+ if (i != self->end())
18128
+ self->erase(i);
18129
+ else
18130
+ throw std::out_of_range("key not found");
18131
+ }
18132
+SWIGINTERN bool std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__has_key(std::map< int,std::vector< int > > const *self,std::map< int,std::vector< int > >::key_type const &key){
18133
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::const_iterator i = self->find(key);
18134
+ return i != self->end();
18135
+ }
18136
+SWIGINTERN PyObject *std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__keys(std::map< int,std::vector< int > > *self){
18137
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::size_type size = self->size();
18138
+ int pysize = (size <= (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::size_type) INT_MAX) ? (int) size : -1;
18139
+ if (pysize < 0) {
18140
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
18141
+ PyErr_SetString(PyExc_OverflowError,
18142
+ "map size not valid in python");
18143
+ SWIG_PYTHON_THREAD_END_BLOCK;
18144
+ return NULL;
18145
+ }
18146
+ PyObject* keyList = PyList_New(pysize);
18147
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::const_iterator i = self->begin();
18148
+ for (int j = 0; j < pysize; ++i, ++j) {
18149
+ PyList_SET_ITEM(keyList, j, swig::from(i->first));
18150
+ }
18151
+ return keyList;
18152
+ }
18153
+SWIGINTERN PyObject *std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__values(std::map< int,std::vector< int > > *self){
18154
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::size_type size = self->size();
18155
+ int pysize = (size <= (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::size_type) INT_MAX) ? (int) size : -1;
18156
+ if (pysize < 0) {
18157
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
18158
+ PyErr_SetString(PyExc_OverflowError,
18159
+ "map size not valid in python");
18160
+ SWIG_PYTHON_THREAD_END_BLOCK;
18161
+ return NULL;
18162
+ }
18163
+ PyObject* valList = PyList_New(pysize);
18164
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::const_iterator i = self->begin();
18165
+ for (int j = 0; j < pysize; ++i, ++j) {
18166
+ PyList_SET_ITEM(valList, j, swig::from(i->second));
18167
+ }
18168
+ return valList;
18169
+ }
18170
+SWIGINTERN PyObject *std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__items(std::map< int,std::vector< int > > *self){
18171
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::size_type size = self->size();
18172
+ int pysize = (size <= (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::size_type) INT_MAX) ? (int) size : -1;
18173
+ if (pysize < 0) {
18174
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
18175
+ PyErr_SetString(PyExc_OverflowError,
18176
+ "map size not valid in python");
18177
+ SWIG_PYTHON_THREAD_END_BLOCK;
18178
+ return NULL;
18179
+ }
18180
+ PyObject* itemList = PyList_New(pysize);
18181
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >::const_iterator i = self->begin();
18182
+ for (int j = 0; j < pysize; ++i, ++j) {
18183
+ PyList_SET_ITEM(itemList, j, swig::from(*i));
18184
+ }
18185
+ return itemList;
18186
+ }
18187
+SWIGINTERN bool std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____contains__(std::map< int,std::vector< int > > *self,std::map< int,std::vector< int > >::key_type const &key){
18188
+ return self->find(key) != self->end();
18189
+ }
18190
+SWIGINTERN swig::PySwigIterator *std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__key_iterator(std::map< int,std::vector< int > > *self,PyObject **PYTHON_SELF){
18191
+ return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
18192
+ }
18193
+SWIGINTERN swig::PySwigIterator *std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__value_iterator(std::map< int,std::vector< int > > *self,PyObject **PYTHON_SELF){
18194
+ return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
18195
+ }
18196
+SWIGINTERN void std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____setitem__(std::map< int,std::vector< int > > *self,std::map< int,std::vector< int > >::key_type const &key,std::map< int,std::vector< int > >::mapped_type const &x){
18197
+ (*self)[key] = x;
18198
+ }
18199
+
18200
+ namespace swig {
18201
+ template <> struct traits<std::pair< int, std::vector< double,std::allocator< double > > > > {
18202
+ typedef pointer_category category;
18203
+ static const char* type_name() {
18204
+ return "std::pair<" "int" "," "std::vector< double,std::allocator< double > >" " >";
18205
+ }
18206
+ };
18207
+ }
18208
+
18209
+
18210
+ namespace swig {
18211
+ template <> struct traits<std::map<int, std::vector< double,std::allocator< double > >, std::less< int >, std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > > > {
18212
+ typedef pointer_category category;
18213
+ static const char* type_name() {
18214
+ return "std::map<" "int" "," "std::vector< double,std::allocator< double > >" "," "std::less< int >" "," "std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > >" " >";
18215
+ }
18216
+ };
18217
+ }
18218
+
18219
+SWIGINTERN swig::PySwigIterator *std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg__iterator(std::map< int,std::vector< double > > *self,PyObject **PYTHON_SELF){
18220
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
18221
+ }
18222
+SWIGINTERN bool std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg____nonzero__(std::map< int,std::vector< double > > const *self){
18223
+ return !(self->empty());
18224
+ }
18225
+SWIGINTERN std::map< int,std::vector< double > >::size_type std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg____len__(std::map< int,std::vector< double > > const *self){
18226
+ return self->size();
18227
+ }
18228
+SWIGINTERN std::map< int,std::vector< double > >::mapped_type std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg____getitem__(std::map< int,std::vector< double > > const *self,std::map< int,std::vector< double > >::key_type const &key){
18229
+ std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >::const_iterator i = self->find(key);
18230
+ if (i != self->end())
18231
+ return i->second;
18232
+ else
18233
+ throw std::out_of_range("key not found");
18234
+ }
18235
+SWIGINTERN void std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg____delitem__(std::map< int,std::vector< double > > *self,std::map< int,std::vector< double > >::key_type const &key){
18236
+ std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >::iterator i = self->find(key);
18237
+ if (i != self->end())
18238
+ self->erase(i);
18239
+ else
18240
+ throw std::out_of_range("key not found");
18241
+ }
18242
+SWIGINTERN bool std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg__has_key(std::map< int,std::vector< double > > const *self,std::map< int,std::vector< double > >::key_type const &key){
18243
+ std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >::const_iterator i = self->find(key);
18244
+ return i != self->end();
18245
+ }
18246
+SWIGINTERN PyObject *std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg__keys(std::map< int,std::vector< double > > *self){
18247
+ std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >::size_type size = self->size();
18248
+ int pysize = (size <= (std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >::size_type) INT_MAX) ? (int) size : -1;
18249
+ if (pysize < 0) {
18250
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
18251
+ PyErr_SetString(PyExc_OverflowError,
18252
+ "map size not valid in python");
18253
+ SWIG_PYTHON_THREAD_END_BLOCK;
18254
+ return NULL;
18255
+ }
18256
+ PyObject* keyList = PyList_New(pysize);
18257
+ std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >::const_iterator i = self->begin();
18258
+ for (int j = 0; j < pysize; ++i, ++j) {
18259
+ PyList_SET_ITEM(keyList, j, swig::from(i->first));
18260
+ }
18261
+ return keyList;
18262
+ }
18263
+SWIGINTERN PyObject *std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg__values(std::map< int,std::vector< double > > *self){
18264
+ std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >::size_type size = self->size();
18265
+ int pysize = (size <= (std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >::size_type) INT_MAX) ? (int) size : -1;
18266
+ if (pysize < 0) {
18267
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
18268
+ PyErr_SetString(PyExc_OverflowError,
18269
+ "map size not valid in python");
18270
+ SWIG_PYTHON_THREAD_END_BLOCK;
18271
+ return NULL;
18272
+ }
18273
+ PyObject* valList = PyList_New(pysize);
18274
+ std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >::const_iterator i = self->begin();
18275
+ for (int j = 0; j < pysize; ++i, ++j) {
18276
+ PyList_SET_ITEM(valList, j, swig::from(i->second));
18277
+ }
18278
+ return valList;
18279
+ }
18280
+SWIGINTERN PyObject *std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg__items(std::map< int,std::vector< double > > *self){
18281
+ std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >::size_type size = self->size();
18282
+ int pysize = (size <= (std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >::size_type) INT_MAX) ? (int) size : -1;
18283
+ if (pysize < 0) {
18284
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
18285
+ PyErr_SetString(PyExc_OverflowError,
18286
+ "map size not valid in python");
18287
+ SWIG_PYTHON_THREAD_END_BLOCK;
18288
+ return NULL;
18289
+ }
18290
+ PyObject* itemList = PyList_New(pysize);
18291
+ std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >::const_iterator i = self->begin();
18292
+ for (int j = 0; j < pysize; ++i, ++j) {
18293
+ PyList_SET_ITEM(itemList, j, swig::from(*i));
18294
+ }
18295
+ return itemList;
18296
+ }
18297
+SWIGINTERN bool std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg____contains__(std::map< int,std::vector< double > > *self,std::map< int,std::vector< double > >::key_type const &key){
18298
+ return self->find(key) != self->end();
18299
+ }
18300
+SWIGINTERN swig::PySwigIterator *std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg__key_iterator(std::map< int,std::vector< double > > *self,PyObject **PYTHON_SELF){
18301
+ return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
18302
+ }
18303
+SWIGINTERN swig::PySwigIterator *std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg__value_iterator(std::map< int,std::vector< double > > *self,PyObject **PYTHON_SELF){
18304
+ return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
18305
+ }
18306
+SWIGINTERN void std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg____setitem__(std::map< int,std::vector< double > > *self,std::map< int,std::vector< double > >::key_type const &key,std::map< int,std::vector< double > >::mapped_type const &x){
18307
+ (*self)[key] = x;
18308
+ }
18309
+
18310
+SWIGINTERN int
18311
+SWIG_AsVal_bool (PyObject *obj, bool *val)
18312
+{
18313
+ int r = PyObject_IsTrue(obj);
18314
+ if (r == -1)
18315
+ return SWIG_ERROR;
18316
+ if (val) *val = r ? true : false;
18317
+ return SWIG_OK;
18318
+}
18319
+
18320
+
18321
+SWIGINTERN swig_type_info*
18322
+SWIG_pchar_descriptor(void)
18323
+{
18324
+ static int init = 0;
18325
+ static swig_type_info* info = 0;
18326
+ if (!init) {
18327
+ info = SWIG_TypeQuery("_p_char");
18328
+ init = 1;
18329
+ }
18330
+ return info;
18331
+}
18332
+
18333
+
18334
+SWIGINTERN int
18335
+SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
18336
+{
18337
+ if (PyString_Check(obj)) {
18338
+ char *cstr; Py_ssize_t len;
18339
+ PyString_AsStringAndSize(obj, &cstr, &len);
18340
+ if (cptr) {
18341
+ if (alloc) {
18342
+ /*
18343
+ In python the user should not be able to modify the inner
18344
+ string representation. To warranty that, if you define
18345
+ SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
18346
+ buffer is always returned.
18347
+
18348
+ The default behavior is just to return the pointer value,
18349
+ so, be careful.
18350
+ */
18351
+#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
18352
+ if (*alloc != SWIG_OLDOBJ)
18353
+#else
18354
+ if (*alloc == SWIG_NEWOBJ)
18355
+#endif
18356
+ {
18357
+ *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
18358
+ *alloc = SWIG_NEWOBJ;
18359
+ }
18360
+ else {
18361
+ *cptr = cstr;
18362
+ *alloc = SWIG_OLDOBJ;
18363
+ }
18364
+ } else {
18365
+ *cptr = PyString_AsString(obj);
18366
+ }
18367
+ }
18368
+ if (psize) *psize = len + 1;
18369
+ return SWIG_OK;
18370
+ } else {
18371
+ swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
18372
+ if (pchar_descriptor) {
18373
+ void* vptr = 0;
18374
+ if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
18375
+ if (cptr) *cptr = (char *) vptr;
18376
+ if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
18377
+ if (alloc) *alloc = SWIG_OLDOBJ;
18378
+ return SWIG_OK;
18379
+ }
18380
+ }
18381
+ }
18382
+ return SWIG_TypeError;
18383
+}
18384
+
18385
+
18386
+
18387
+
18388
+
18389
+#include <wx/wxPython/wxPython.h>
18390
+#include <wx/wxPython/pyclasses.h>
18391
+
18392
+
18393
+#include "pseudodc.h"
18394
+
18395
+SWIGINTERN void gwxPseudoDC_DrawToDC(gwxPseudoDC *self,void *dc){
18396
+ self->DrawToDC((wxDC *) dc);
18397
+ }
18398
+SWIGINTERN void gwxPseudoDC_DrawToDCClipped(gwxPseudoDC *self,void *dc,wxRect const &rect){
18399
+ self->DrawToDCClipped((wxDC *) dc, rect);
18400
+ }
18401
+SWIGINTERN wxRect gwxPseudoDC_GetIdBounds(gwxPseudoDC *self,int id){
18402
+ wxRect rect;
18403
+ self->GetIdBounds(id, rect);
18404
+ return rect;
18405
+ }
18406
+#ifdef __cplusplus
18407
+extern "C" {
18408
+#endif
18409
+SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18410
+ PyObject *resultobj = 0;
18411
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18412
+ void *argp1 = 0 ;
18413
+ int res1 = 0 ;
18414
+ PyObject * obj0 = 0 ;
18415
+
18416
+ if (!PyArg_ParseTuple(args,(char *)"O:delete_PySwigIterator",&obj0)) SWIG_fail;
18417
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
18418
+ if (!SWIG_IsOK(res1)) {
18419
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySwigIterator" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
18420
+ }
18421
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18422
+ delete arg1;
18423
+ resultobj = SWIG_Py_Void();
18424
+ return resultobj;
18425
+fail:
18426
+ return NULL;
18427
+}
18428
+
18429
+
18430
+SWIGINTERN PyObject *_wrap_PySwigIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18431
+ PyObject *resultobj = 0;
18432
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18433
+ void *argp1 = 0 ;
18434
+ int res1 = 0 ;
18435
+ PyObject * obj0 = 0 ;
18436
+ PyObject *result = 0 ;
18437
+
18438
+ if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_value",&obj0)) SWIG_fail;
18439
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18440
+ if (!SWIG_IsOK(res1)) {
18441
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_value" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
18442
+ }
18443
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18444
+ try {
18445
+ result = (PyObject *)((swig::PySwigIterator const *)arg1)->value();
18446
+ }
18447
+ catch(swig::stop_iteration &_e) {
18448
+ {
18449
+ (void)_e;
18450
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
18451
+ SWIG_fail;
18452
+ }
18453
+ }
18454
+
18455
+ resultobj = result;
18456
+ return resultobj;
18457
+fail:
18458
+ return NULL;
18459
+}
18460
+
18461
+
18462
+SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18463
+ PyObject *resultobj = 0;
18464
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18465
+ size_t arg2 ;
18466
+ void *argp1 = 0 ;
18467
+ int res1 = 0 ;
18468
+ size_t val2 ;
18469
+ int ecode2 = 0 ;
18470
+ PyObject * obj0 = 0 ;
18471
+ PyObject * obj1 = 0 ;
18472
+ swig::PySwigIterator *result = 0 ;
18473
+
18474
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_incr",&obj0,&obj1)) SWIG_fail;
18475
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18476
+ if (!SWIG_IsOK(res1)) {
18477
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
18478
+ }
18479
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18480
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
18481
+ if (!SWIG_IsOK(ecode2)) {
18482
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
18483
+ }
18484
+ arg2 = static_cast< size_t >(val2);
18485
+ try {
18486
+ result = (swig::PySwigIterator *)(arg1)->incr(arg2);
18487
+ }
18488
+ catch(swig::stop_iteration &_e) {
18489
+ {
18490
+ (void)_e;
18491
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
18492
+ SWIG_fail;
18493
+ }
18494
+ }
18495
+
18496
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18497
+ return resultobj;
18498
+fail:
18499
+ return NULL;
18500
+}
18501
+
18502
+
18503
+SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18504
+ PyObject *resultobj = 0;
18505
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18506
+ void *argp1 = 0 ;
18507
+ int res1 = 0 ;
18508
+ PyObject * obj0 = 0 ;
18509
+ swig::PySwigIterator *result = 0 ;
18510
+
18511
+ if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_incr",&obj0)) SWIG_fail;
18512
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18513
+ if (!SWIG_IsOK(res1)) {
18514
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
18515
+ }
18516
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18517
+ try {
18518
+ result = (swig::PySwigIterator *)(arg1)->incr();
18519
+ }
18520
+ catch(swig::stop_iteration &_e) {
18521
+ {
18522
+ (void)_e;
18523
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
18524
+ SWIG_fail;
18525
+ }
18526
+ }
18527
+
18528
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18529
+ return resultobj;
18530
+fail:
18531
+ return NULL;
18532
+}
18533
+
18534
+
18535
+SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
18536
+ int argc;
18537
+ PyObject *argv[3];
18538
+ int ii;
18539
+
18540
+ if (!PyTuple_Check(args)) SWIG_fail;
18541
+ argc = (int)PyObject_Length(args);
18542
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
18543
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
18544
+ }
18545
+ if (argc == 1) {
18546
+ int _v;
18547
+ void *vptr = 0;
18548
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
18549
+ _v = SWIG_CheckState(res);
18550
+ if (_v) {
18551
+ return _wrap_PySwigIterator_incr__SWIG_1(self, args);
18552
+ }
18553
+ }
18554
+ if (argc == 2) {
18555
+ int _v;
18556
+ void *vptr = 0;
18557
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
18558
+ _v = SWIG_CheckState(res);
18559
+ if (_v) {
18560
+ {
18561
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
18562
+ _v = SWIG_CheckState(res);
18563
+ }
18564
+ if (_v) {
18565
+ return _wrap_PySwigIterator_incr__SWIG_0(self, args);
18566
+ }
18567
+ }
18568
+ }
18569
+
18570
+fail:
18571
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_incr'.\n"
18572
+ " Possible C/C++ prototypes are:\n"
18573
+ " incr(swig::PySwigIterator *,size_t)\n"
18574
+ " incr(swig::PySwigIterator *)\n");
18575
+ return NULL;
18576
+}
18577
+
18578
+
18579
+SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18580
+ PyObject *resultobj = 0;
18581
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18582
+ size_t arg2 ;
18583
+ void *argp1 = 0 ;
18584
+ int res1 = 0 ;
18585
+ size_t val2 ;
18586
+ int ecode2 = 0 ;
18587
+ PyObject * obj0 = 0 ;
18588
+ PyObject * obj1 = 0 ;
18589
+ swig::PySwigIterator *result = 0 ;
18590
+
18591
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_decr",&obj0,&obj1)) SWIG_fail;
18592
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18593
+ if (!SWIG_IsOK(res1)) {
18594
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
18595
+ }
18596
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18597
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
18598
+ if (!SWIG_IsOK(ecode2)) {
18599
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_decr" "', argument " "2"" of type '" "size_t""'");
18600
+ }
18601
+ arg2 = static_cast< size_t >(val2);
18602
+ try {
18603
+ result = (swig::PySwigIterator *)(arg1)->decr(arg2);
18604
+ }
18605
+ catch(swig::stop_iteration &_e) {
18606
+ {
18607
+ (void)_e;
18608
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
18609
+ SWIG_fail;
18610
+ }
18611
+ }
18612
+
18613
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18614
+ return resultobj;
18615
+fail:
18616
+ return NULL;
18617
+}
18618
+
18619
+
18620
+SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18621
+ PyObject *resultobj = 0;
18622
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18623
+ void *argp1 = 0 ;
18624
+ int res1 = 0 ;
18625
+ PyObject * obj0 = 0 ;
18626
+ swig::PySwigIterator *result = 0 ;
18627
+
18628
+ if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_decr",&obj0)) SWIG_fail;
18629
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18630
+ if (!SWIG_IsOK(res1)) {
18631
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
18632
+ }
18633
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18634
+ try {
18635
+ result = (swig::PySwigIterator *)(arg1)->decr();
18636
+ }
18637
+ catch(swig::stop_iteration &_e) {
18638
+ {
18639
+ (void)_e;
18640
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
18641
+ SWIG_fail;
18642
+ }
18643
+ }
18644
+
18645
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18646
+ return resultobj;
18647
+fail:
18648
+ return NULL;
18649
+}
18650
+
18651
+
18652
+SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *self, PyObject *args) {
18653
+ int argc;
18654
+ PyObject *argv[3];
18655
+ int ii;
18656
+
18657
+ if (!PyTuple_Check(args)) SWIG_fail;
18658
+ argc = (int)PyObject_Length(args);
18659
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
18660
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
18661
+ }
18662
+ if (argc == 1) {
18663
+ int _v;
18664
+ void *vptr = 0;
18665
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
18666
+ _v = SWIG_CheckState(res);
18667
+ if (_v) {
18668
+ return _wrap_PySwigIterator_decr__SWIG_1(self, args);
18669
+ }
18670
+ }
18671
+ if (argc == 2) {
18672
+ int _v;
18673
+ void *vptr = 0;
18674
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
18675
+ _v = SWIG_CheckState(res);
18676
+ if (_v) {
18677
+ {
18678
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
18679
+ _v = SWIG_CheckState(res);
18680
+ }
18681
+ if (_v) {
18682
+ return _wrap_PySwigIterator_decr__SWIG_0(self, args);
18683
+ }
18684
+ }
18685
+ }
18686
+
18687
+fail:
18688
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_decr'.\n"
18689
+ " Possible C/C++ prototypes are:\n"
18690
+ " decr(swig::PySwigIterator *,size_t)\n"
18691
+ " decr(swig::PySwigIterator *)\n");
18692
+ return NULL;
18693
+}
18694
+
18695
+
18696
+SWIGINTERN PyObject *_wrap_PySwigIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18697
+ PyObject *resultobj = 0;
18698
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18699
+ swig::PySwigIterator *arg2 = 0 ;
18700
+ void *argp1 = 0 ;
18701
+ int res1 = 0 ;
18702
+ void *argp2 = 0 ;
18703
+ int res2 = 0 ;
18704
+ PyObject * obj0 = 0 ;
18705
+ PyObject * obj1 = 0 ;
18706
+ ptrdiff_t result;
18707
+
18708
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_distance",&obj0,&obj1)) SWIG_fail;
18709
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18710
+ if (!SWIG_IsOK(res1)) {
18711
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_distance" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
18712
+ }
18713
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18714
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
18715
+ if (!SWIG_IsOK(res2)) {
18716
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
18717
+ }
18718
+ if (!argp2) {
18719
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
18720
+ }
18721
+ arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
18722
+ try {
18723
+ result = ((swig::PySwigIterator const *)arg1)->distance((swig::PySwigIterator const &)*arg2);
18724
+ }
18725
+ catch(std::invalid_argument &_e) {
18726
+ SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
18727
+ }
18728
+
18729
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
18730
+ return resultobj;
18731
+fail:
18732
+ return NULL;
18733
+}
18734
+
18735
+
18736
+SWIGINTERN PyObject *_wrap_PySwigIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18737
+ PyObject *resultobj = 0;
18738
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18739
+ swig::PySwigIterator *arg2 = 0 ;
18740
+ void *argp1 = 0 ;
18741
+ int res1 = 0 ;
18742
+ void *argp2 = 0 ;
18743
+ int res2 = 0 ;
18744
+ PyObject * obj0 = 0 ;
18745
+ PyObject * obj1 = 0 ;
18746
+ bool result;
18747
+
18748
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_equal",&obj0,&obj1)) SWIG_fail;
18749
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18750
+ if (!SWIG_IsOK(res1)) {
18751
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_equal" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
18752
+ }
18753
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18754
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
18755
+ if (!SWIG_IsOK(res2)) {
18756
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
18757
+ }
18758
+ if (!argp2) {
18759
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
18760
+ }
18761
+ arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
18762
+ try {
18763
+ result = (bool)((swig::PySwigIterator const *)arg1)->equal((swig::PySwigIterator const &)*arg2);
18764
+ }
18765
+ catch(std::invalid_argument &_e) {
18766
+ SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
18767
+ }
18768
+
18769
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
18770
+ return resultobj;
18771
+fail:
18772
+ return NULL;
18773
+}
18774
+
18775
+
18776
+SWIGINTERN PyObject *_wrap_PySwigIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18777
+ PyObject *resultobj = 0;
18778
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18779
+ void *argp1 = 0 ;
18780
+ int res1 = 0 ;
18781
+ PyObject * obj0 = 0 ;
18782
+ swig::PySwigIterator *result = 0 ;
18783
+
18784
+ if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_copy",&obj0)) SWIG_fail;
18785
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18786
+ if (!SWIG_IsOK(res1)) {
18787
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_copy" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
18788
+ }
18789
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18790
+ result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->copy();
18791
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
18792
+ return resultobj;
18793
+fail:
18794
+ return NULL;
18795
+}
18796
+
18797
+
18798
+SWIGINTERN PyObject *_wrap_PySwigIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18799
+ PyObject *resultobj = 0;
18800
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18801
+ void *argp1 = 0 ;
18802
+ int res1 = 0 ;
18803
+ PyObject * obj0 = 0 ;
18804
+ PyObject *result = 0 ;
18805
+
18806
+ if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_next",&obj0)) SWIG_fail;
18807
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18808
+ if (!SWIG_IsOK(res1)) {
18809
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_next" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
18810
+ }
18811
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18812
+ try {
18813
+ result = (PyObject *)(arg1)->next();
18814
+ }
18815
+ catch(swig::stop_iteration &_e) {
18816
+ {
18817
+ (void)_e;
18818
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
18819
+ SWIG_fail;
18820
+ }
18821
+ }
18822
+
18823
+ resultobj = result;
18824
+ return resultobj;
18825
+fail:
18826
+ return NULL;
18827
+}
18828
+
18829
+
18830
+SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18831
+ PyObject *resultobj = 0;
18832
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18833
+ void *argp1 = 0 ;
18834
+ int res1 = 0 ;
18835
+ PyObject * obj0 = 0 ;
18836
+ PyObject *result = 0 ;
18837
+
18838
+ if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_previous",&obj0)) SWIG_fail;
18839
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18840
+ if (!SWIG_IsOK(res1)) {
18841
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
18842
+ }
18843
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18844
+ try {
18845
+ result = (PyObject *)(arg1)->previous();
18846
+ }
18847
+ catch(swig::stop_iteration &_e) {
18848
+ {
18849
+ (void)_e;
18850
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
18851
+ SWIG_fail;
18852
+ }
18853
+ }
18854
+
18855
+ resultobj = result;
18856
+ return resultobj;
18857
+fail:
18858
+ return NULL;
18859
+}
18860
+
18861
+
18862
+SWIGINTERN PyObject *_wrap_PySwigIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18863
+ PyObject *resultobj = 0;
18864
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18865
+ ptrdiff_t arg2 ;
18866
+ void *argp1 = 0 ;
18867
+ int res1 = 0 ;
18868
+ ptrdiff_t val2 ;
18869
+ int ecode2 = 0 ;
18870
+ PyObject * obj0 = 0 ;
18871
+ PyObject * obj1 = 0 ;
18872
+ swig::PySwigIterator *result = 0 ;
18873
+
18874
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_advance",&obj0,&obj1)) SWIG_fail;
18875
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18876
+ if (!SWIG_IsOK(res1)) {
18877
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_advance" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
18878
+ }
18879
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18880
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18881
+ if (!SWIG_IsOK(ecode2)) {
18882
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
18883
+ }
18884
+ arg2 = static_cast< ptrdiff_t >(val2);
18885
+ try {
18886
+ result = (swig::PySwigIterator *)(arg1)->advance(arg2);
18887
+ }
18888
+ catch(swig::stop_iteration &_e) {
18889
+ {
18890
+ (void)_e;
18891
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
18892
+ SWIG_fail;
18893
+ }
18894
+ }
18895
+
18896
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18897
+ return resultobj;
18898
+fail:
18899
+ return NULL;
18900
+}
18901
+
18902
+
18903
+SWIGINTERN PyObject *_wrap_PySwigIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18904
+ PyObject *resultobj = 0;
18905
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18906
+ swig::PySwigIterator *arg2 = 0 ;
18907
+ void *argp1 = 0 ;
18908
+ int res1 = 0 ;
18909
+ void *argp2 = 0 ;
18910
+ int res2 = 0 ;
18911
+ PyObject * obj0 = 0 ;
18912
+ PyObject * obj1 = 0 ;
18913
+ bool result;
18914
+
18915
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___eq__",&obj0,&obj1)) SWIG_fail;
18916
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18917
+ if (!SWIG_IsOK(res1)) {
18918
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___eq__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
18919
+ }
18920
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18921
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
18922
+ if (!SWIG_IsOK(res2)) {
18923
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
18924
+ }
18925
+ if (!argp2) {
18926
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
18927
+ }
18928
+ arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
18929
+ result = (bool)((swig::PySwigIterator const *)arg1)->operator ==((swig::PySwigIterator const &)*arg2);
18930
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
18931
+ return resultobj;
18932
+fail:
18933
+ return NULL;
18934
+}
18935
+
18936
+
18937
+SWIGINTERN PyObject *_wrap_PySwigIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18938
+ PyObject *resultobj = 0;
18939
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18940
+ swig::PySwigIterator *arg2 = 0 ;
18941
+ void *argp1 = 0 ;
18942
+ int res1 = 0 ;
18943
+ void *argp2 = 0 ;
18944
+ int res2 = 0 ;
18945
+ PyObject * obj0 = 0 ;
18946
+ PyObject * obj1 = 0 ;
18947
+ bool result;
18948
+
18949
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___ne__",&obj0,&obj1)) SWIG_fail;
18950
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
18951
+ if (!SWIG_IsOK(res1)) {
18952
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___ne__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
18953
+ }
18954
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18955
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
18956
+ if (!SWIG_IsOK(res2)) {
18957
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
18958
+ }
18959
+ if (!argp2) {
18960
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
18961
+ }
18962
+ arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
18963
+ result = (bool)((swig::PySwigIterator const *)arg1)->operator !=((swig::PySwigIterator const &)*arg2);
18964
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
18965
+ return resultobj;
18966
+fail:
18967
+ return NULL;
18968
+}
18969
+
18970
+
18971
+SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18972
+ PyObject *resultobj = 0;
18973
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
18974
+ ptrdiff_t arg2 ;
18975
+ void *argp1 = 0 ;
18976
+ int res1 = 0 ;
18977
+ ptrdiff_t val2 ;
18978
+ int ecode2 = 0 ;
18979
+ PyObject * obj0 = 0 ;
18980
+ PyObject * obj1 = 0 ;
18981
+ swig::PySwigIterator *result = 0 ;
18982
+
18983
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___iadd__",&obj0,&obj1)) SWIG_fail;
18984
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
18985
+ if (!SWIG_IsOK(res1)) {
18986
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___iadd__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
18987
+ }
18988
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
18989
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18990
+ if (!SWIG_IsOK(ecode2)) {
18991
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
18992
+ }
18993
+ arg2 = static_cast< ptrdiff_t >(val2);
18994
+ try {
18995
+ {
18996
+ swig::PySwigIterator &_result_ref = (arg1)->operator +=(arg2);
18997
+ result = (swig::PySwigIterator *) &_result_ref;
18998
+ }
18999
+ }
19000
+ catch(swig::stop_iteration &_e) {
19001
+ {
19002
+ (void)_e;
19003
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
19004
+ SWIG_fail;
19005
+ }
19006
+ }
19007
+
19008
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
19009
+ return resultobj;
19010
+fail:
19011
+ return NULL;
19012
+}
19013
+
19014
+
19015
+SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19016
+ PyObject *resultobj = 0;
19017
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
19018
+ ptrdiff_t arg2 ;
19019
+ void *argp1 = 0 ;
19020
+ int res1 = 0 ;
19021
+ ptrdiff_t val2 ;
19022
+ int ecode2 = 0 ;
19023
+ PyObject * obj0 = 0 ;
19024
+ PyObject * obj1 = 0 ;
19025
+ swig::PySwigIterator *result = 0 ;
19026
+
19027
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___isub__",&obj0,&obj1)) SWIG_fail;
19028
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
19029
+ if (!SWIG_IsOK(res1)) {
19030
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___isub__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
19031
+ }
19032
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
19033
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
19034
+ if (!SWIG_IsOK(ecode2)) {
19035
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
19036
+ }
19037
+ arg2 = static_cast< ptrdiff_t >(val2);
19038
+ try {
19039
+ {
19040
+ swig::PySwigIterator &_result_ref = (arg1)->operator -=(arg2);
19041
+ result = (swig::PySwigIterator *) &_result_ref;
19042
+ }
19043
+ }
19044
+ catch(swig::stop_iteration &_e) {
19045
+ {
19046
+ (void)_e;
19047
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
19048
+ SWIG_fail;
19049
+ }
19050
+ }
19051
+
19052
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
19053
+ return resultobj;
19054
+fail:
19055
+ return NULL;
19056
+}
19057
+
19058
+
19059
+SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19060
+ PyObject *resultobj = 0;
19061
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
19062
+ ptrdiff_t arg2 ;
19063
+ void *argp1 = 0 ;
19064
+ int res1 = 0 ;
19065
+ ptrdiff_t val2 ;
19066
+ int ecode2 = 0 ;
19067
+ PyObject * obj0 = 0 ;
19068
+ PyObject * obj1 = 0 ;
19069
+ swig::PySwigIterator *result = 0 ;
19070
+
19071
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___add__",&obj0,&obj1)) SWIG_fail;
19072
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
19073
+ if (!SWIG_IsOK(res1)) {
19074
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___add__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
19075
+ }
19076
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
19077
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
19078
+ if (!SWIG_IsOK(ecode2)) {
19079
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
19080
+ }
19081
+ arg2 = static_cast< ptrdiff_t >(val2);
19082
+ try {
19083
+ result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator +(arg2);
19084
+ }
19085
+ catch(swig::stop_iteration &_e) {
19086
+ {
19087
+ (void)_e;
19088
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
19089
+ SWIG_fail;
19090
+ }
19091
+ }
19092
+
19093
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
19094
+ return resultobj;
19095
+fail:
19096
+ return NULL;
19097
+}
19098
+
19099
+
19100
+SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19101
+ PyObject *resultobj = 0;
19102
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
19103
+ ptrdiff_t arg2 ;
19104
+ void *argp1 = 0 ;
19105
+ int res1 = 0 ;
19106
+ ptrdiff_t val2 ;
19107
+ int ecode2 = 0 ;
19108
+ PyObject * obj0 = 0 ;
19109
+ PyObject * obj1 = 0 ;
19110
+ swig::PySwigIterator *result = 0 ;
19111
+
19112
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
19113
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
19114
+ if (!SWIG_IsOK(res1)) {
19115
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
19116
+ }
19117
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
19118
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
19119
+ if (!SWIG_IsOK(ecode2)) {
19120
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
19121
+ }
19122
+ arg2 = static_cast< ptrdiff_t >(val2);
19123
+ try {
19124
+ result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator -(arg2);
19125
+ }
19126
+ catch(swig::stop_iteration &_e) {
19127
+ {
19128
+ (void)_e;
19129
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
19130
+ SWIG_fail;
19131
+ }
19132
+ }
19133
+
19134
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
19135
+ return resultobj;
19136
+fail:
19137
+ return NULL;
19138
+}
19139
+
19140
+
19141
+SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19142
+ PyObject *resultobj = 0;
19143
+ swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
19144
+ swig::PySwigIterator *arg2 = 0 ;
19145
+ void *argp1 = 0 ;
19146
+ int res1 = 0 ;
19147
+ void *argp2 = 0 ;
19148
+ int res2 = 0 ;
19149
+ PyObject * obj0 = 0 ;
19150
+ PyObject * obj1 = 0 ;
19151
+ ptrdiff_t result;
19152
+
19153
+ if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
19154
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
19155
+ if (!SWIG_IsOK(res1)) {
19156
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
19157
+ }
19158
+ arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
19159
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
19160
+ if (!SWIG_IsOK(res2)) {
19161
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
19162
+ }
19163
+ if (!argp2) {
19164
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
19165
+ }
19166
+ arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
19167
+ result = ((swig::PySwigIterator const *)arg1)->operator -((swig::PySwigIterator const &)*arg2);
19168
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
19169
+ return resultobj;
19170
+fail:
19171
+ return NULL;
19172
+}
19173
+
19174
+
19175
+SWIGINTERN PyObject *_wrap_PySwigIterator___sub__(PyObject *self, PyObject *args) {
19176
+ int argc;
19177
+ PyObject *argv[3];
19178
+ int ii;
19179
+
19180
+ if (!PyTuple_Check(args)) SWIG_fail;
19181
+ argc = (int)PyObject_Length(args);
19182
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
19183
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
19184
+ }
19185
+ if (argc == 2) {
19186
+ int _v;
19187
+ void *vptr = 0;
19188
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
19189
+ _v = SWIG_CheckState(res);
19190
+ if (_v) {
19191
+ int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__PySwigIterator, 0);
19192
+ _v = SWIG_CheckState(res);
19193
+ if (_v) {
19194
+ return _wrap_PySwigIterator___sub____SWIG_1(self, args);
19195
+ }
19196
+ }
19197
+ }
19198
+ if (argc == 2) {
19199
+ int _v;
19200
+ void *vptr = 0;
19201
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
19202
+ _v = SWIG_CheckState(res);
19203
+ if (_v) {
19204
+ {
19205
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
19206
+ _v = SWIG_CheckState(res);
19207
+ }
19208
+ if (_v) {
19209
+ return _wrap_PySwigIterator___sub____SWIG_0(self, args);
19210
+ }
19211
+ }
19212
+ }
19213
+
19214
+fail:
19215
+ Py_INCREF(Py_NotImplemented);
19216
+ return Py_NotImplemented;
19217
+}
19218
+
19219
+
19220
+SWIGINTERN PyObject *PySwigIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19221
+ PyObject *obj;
19222
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
19223
+ SWIG_TypeNewClientData(SWIGTYPE_p_swig__PySwigIterator, SWIG_NewClientData(obj));
19224
+ return SWIG_Py_Void();
19225
+}
19226
+
19227
+SWIGINTERN PyObject *_wrap_IntVector_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19228
+ PyObject *resultobj = 0;
19229
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19230
+ PyObject **arg2 = (PyObject **) 0 ;
19231
+ void *argp1 = 0 ;
19232
+ int res1 = 0 ;
19233
+ PyObject * obj0 = 0 ;
19234
+ swig::PySwigIterator *result = 0 ;
19235
+
19236
+ arg2 = &obj0;
19237
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_iterator",&obj0)) SWIG_fail;
19238
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19239
+ if (!SWIG_IsOK(res1)) {
19240
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_iterator" "', argument " "1"" of type '" "std::vector< int > *""'");
19241
+ }
19242
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19243
+ result = (swig::PySwigIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
19244
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
19245
+ return resultobj;
19246
+fail:
19247
+ return NULL;
19248
+}
19249
+
19250
+
19251
+SWIGINTERN PyObject *_wrap_IntVector___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19252
+ PyObject *resultobj = 0;
19253
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19254
+ void *argp1 = 0 ;
19255
+ int res1 = 0 ;
19256
+ PyObject * obj0 = 0 ;
19257
+ bool result;
19258
+
19259
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector___nonzero__",&obj0)) SWIG_fail;
19260
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19261
+ if (!SWIG_IsOK(res1)) {
19262
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'");
19263
+ }
19264
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19265
+ result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< int > const *)arg1);
19266
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
19267
+ return resultobj;
19268
+fail:
19269
+ return NULL;
19270
+}
19271
+
19272
+
19273
+SWIGINTERN PyObject *_wrap_IntVector___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19274
+ PyObject *resultobj = 0;
19275
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19276
+ void *argp1 = 0 ;
19277
+ int res1 = 0 ;
19278
+ PyObject * obj0 = 0 ;
19279
+ std::vector< int >::size_type result;
19280
+
19281
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector___len__",&obj0)) SWIG_fail;
19282
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19283
+ if (!SWIG_IsOK(res1)) {
19284
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___len__" "', argument " "1"" of type '" "std::vector< int > const *""'");
19285
+ }
19286
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19287
+ result = std_vector_Sl_int_Sg____len__((std::vector< int > const *)arg1);
19288
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19289
+ return resultobj;
19290
+fail:
19291
+ return NULL;
19292
+}
19293
+
19294
+
19295
+SWIGINTERN PyObject *_wrap_IntVector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19296
+ PyObject *resultobj = 0;
19297
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19298
+ void *argp1 = 0 ;
19299
+ int res1 = 0 ;
19300
+ PyObject * obj0 = 0 ;
19301
+ std::vector< int >::value_type result;
19302
+
19303
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_pop",&obj0)) SWIG_fail;
19304
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19305
+ if (!SWIG_IsOK(res1)) {
19306
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_pop" "', argument " "1"" of type '" "std::vector< int > *""'");
19307
+ }
19308
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19309
+ try {
19310
+ result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
19311
+ }
19312
+ catch(std::out_of_range &_e) {
19313
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
19314
+ }
19315
+
19316
+ resultobj = SWIG_From_int(static_cast< int >(result));
19317
+ return resultobj;
19318
+fail:
19319
+ return NULL;
19320
+}
19321
+
19322
+
19323
+SWIGINTERN PyObject *_wrap_IntVector___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19324
+ PyObject *resultobj = 0;
19325
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19326
+ std::vector< int >::difference_type arg2 ;
19327
+ std::vector< int >::difference_type arg3 ;
19328
+ void *argp1 = 0 ;
19329
+ int res1 = 0 ;
19330
+ ptrdiff_t val2 ;
19331
+ int ecode2 = 0 ;
19332
+ ptrdiff_t val3 ;
19333
+ int ecode3 = 0 ;
19334
+ PyObject * obj0 = 0 ;
19335
+ PyObject * obj1 = 0 ;
19336
+ PyObject * obj2 = 0 ;
19337
+ std::vector< int,std::allocator< int > > *result = 0 ;
19338
+
19339
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
19340
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19341
+ if (!SWIG_IsOK(res1)) {
19342
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
19343
+ }
19344
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19345
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
19346
+ if (!SWIG_IsOK(ecode2)) {
19347
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___getslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
19348
+ }
19349
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
19350
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
19351
+ if (!SWIG_IsOK(ecode3)) {
19352
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___getslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
19353
+ }
19354
+ arg3 = static_cast< std::vector< int >::difference_type >(val3);
19355
+ try {
19356
+ result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3);
19357
+ }
19358
+ catch(std::out_of_range &_e) {
19359
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
19360
+ }
19361
+
19362
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN | 0 );
19363
+ return resultobj;
19364
+fail:
19365
+ return NULL;
19366
+}
19367
+
19368
+
19369
+SWIGINTERN PyObject *_wrap_IntVector___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19370
+ PyObject *resultobj = 0;
19371
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19372
+ std::vector< int >::difference_type arg2 ;
19373
+ std::vector< int >::difference_type arg3 ;
19374
+ std::vector< int,std::allocator< int > > *arg4 = 0 ;
19375
+ void *argp1 = 0 ;
19376
+ int res1 = 0 ;
19377
+ ptrdiff_t val2 ;
19378
+ int ecode2 = 0 ;
19379
+ ptrdiff_t val3 ;
19380
+ int ecode3 = 0 ;
19381
+ int res4 = SWIG_OLDOBJ ;
19382
+ PyObject * obj0 = 0 ;
19383
+ PyObject * obj1 = 0 ;
19384
+ PyObject * obj2 = 0 ;
19385
+ PyObject * obj3 = 0 ;
19386
+
19387
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:IntVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19388
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19389
+ if (!SWIG_IsOK(res1)) {
19390
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
19391
+ }
19392
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19393
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
19394
+ if (!SWIG_IsOK(ecode2)) {
19395
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
19396
+ }
19397
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
19398
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
19399
+ if (!SWIG_IsOK(ecode3)) {
19400
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
19401
+ }
19402
+ arg3 = static_cast< std::vector< int >::difference_type >(val3);
19403
+ {
19404
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
19405
+ res4 = swig::asptr(obj3, &ptr);
19406
+ if (!SWIG_IsOK(res4)) {
19407
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntVector___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'");
19408
+ }
19409
+ if (!ptr) {
19410
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVector___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'");
19411
+ }
19412
+ arg4 = ptr;
19413
+ }
19414
+ try {
19415
+ std_vector_Sl_int_Sg____setslice__(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
19416
+ }
19417
+ catch(std::out_of_range &_e) {
19418
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
19419
+ }
19420
+ catch(std::invalid_argument &_e) {
19421
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
19422
+ }
19423
+
19424
+ resultobj = SWIG_Py_Void();
19425
+ if (SWIG_IsNewObj(res4)) delete arg4;
19426
+ return resultobj;
19427
+fail:
19428
+ if (SWIG_IsNewObj(res4)) delete arg4;
19429
+ return NULL;
19430
+}
19431
+
19432
+
19433
+SWIGINTERN PyObject *_wrap_IntVector___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19434
+ PyObject *resultobj = 0;
19435
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19436
+ std::vector< int >::difference_type arg2 ;
19437
+ std::vector< int >::difference_type arg3 ;
19438
+ void *argp1 = 0 ;
19439
+ int res1 = 0 ;
19440
+ ptrdiff_t val2 ;
19441
+ int ecode2 = 0 ;
19442
+ ptrdiff_t val3 ;
19443
+ int ecode3 = 0 ;
19444
+ PyObject * obj0 = 0 ;
19445
+ PyObject * obj1 = 0 ;
19446
+ PyObject * obj2 = 0 ;
19447
+
19448
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
19449
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19450
+ if (!SWIG_IsOK(res1)) {
19451
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
19452
+ }
19453
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19454
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
19455
+ if (!SWIG_IsOK(ecode2)) {
19456
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___delslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
19457
+ }
19458
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
19459
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
19460
+ if (!SWIG_IsOK(ecode3)) {
19461
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___delslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
19462
+ }
19463
+ arg3 = static_cast< std::vector< int >::difference_type >(val3);
19464
+ try {
19465
+ std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3);
19466
+ }
19467
+ catch(std::out_of_range &_e) {
19468
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
19469
+ }
19470
+
19471
+ resultobj = SWIG_Py_Void();
19472
+ return resultobj;
19473
+fail:
19474
+ return NULL;
19475
+}
19476
+
19477
+
19478
+SWIGINTERN PyObject *_wrap_IntVector___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19479
+ PyObject *resultobj = 0;
19480
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19481
+ std::vector< int >::difference_type arg2 ;
19482
+ void *argp1 = 0 ;
19483
+ int res1 = 0 ;
19484
+ ptrdiff_t val2 ;
19485
+ int ecode2 = 0 ;
19486
+ PyObject * obj0 = 0 ;
19487
+ PyObject * obj1 = 0 ;
19488
+
19489
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector___delitem__",&obj0,&obj1)) SWIG_fail;
19490
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19491
+ if (!SWIG_IsOK(res1)) {
19492
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
19493
+ }
19494
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19495
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
19496
+ if (!SWIG_IsOK(ecode2)) {
19497
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___delitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
19498
+ }
19499
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
19500
+ try {
19501
+ std_vector_Sl_int_Sg____delitem__(arg1,arg2);
19502
+ }
19503
+ catch(std::out_of_range &_e) {
19504
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
19505
+ }
19506
+
19507
+ resultobj = SWIG_Py_Void();
19508
+ return resultobj;
19509
+fail:
19510
+ return NULL;
19511
+}
19512
+
19513
+
19514
+SWIGINTERN PyObject *_wrap_IntVector___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19515
+ PyObject *resultobj = 0;
19516
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19517
+ std::vector< int >::difference_type arg2 ;
19518
+ void *argp1 = 0 ;
19519
+ int res1 = 0 ;
19520
+ ptrdiff_t val2 ;
19521
+ int ecode2 = 0 ;
19522
+ PyObject * obj0 = 0 ;
19523
+ PyObject * obj1 = 0 ;
19524
+ std::vector< int >::value_type *result = 0 ;
19525
+
19526
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector___getitem__",&obj0,&obj1)) SWIG_fail;
19527
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19528
+ if (!SWIG_IsOK(res1)) {
19529
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'");
19530
+ }
19531
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19532
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
19533
+ if (!SWIG_IsOK(ecode2)) {
19534
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___getitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
19535
+ }
19536
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
19537
+ try {
19538
+ {
19539
+ std::vector< int >::value_type const &_result_ref = std_vector_Sl_int_Sg____getitem__((std::vector< int > const *)arg1,arg2);
19540
+ result = (std::vector< int >::value_type *) &_result_ref;
19541
+ }
19542
+ }
19543
+ catch(std::out_of_range &_e) {
19544
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
19545
+ }
19546
+
19547
+ resultobj = SWIG_From_int(static_cast< int >(*result));
19548
+ return resultobj;
19549
+fail:
19550
+ return NULL;
19551
+}
19552
+
19553
+
19554
+SWIGINTERN PyObject *_wrap_IntVector___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19555
+ PyObject *resultobj = 0;
19556
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19557
+ std::vector< int >::difference_type arg2 ;
19558
+ std::vector< int >::value_type *arg3 = 0 ;
19559
+ void *argp1 = 0 ;
19560
+ int res1 = 0 ;
19561
+ ptrdiff_t val2 ;
19562
+ int ecode2 = 0 ;
19563
+ std::vector< int >::value_type temp3 ;
19564
+ int val3 ;
19565
+ int ecode3 = 0 ;
19566
+ PyObject * obj0 = 0 ;
19567
+ PyObject * obj1 = 0 ;
19568
+ PyObject * obj2 = 0 ;
19569
+
19570
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
19571
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19572
+ if (!SWIG_IsOK(res1)) {
19573
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
19574
+ }
19575
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19576
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
19577
+ if (!SWIG_IsOK(ecode2)) {
19578
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___setitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
19579
+ }
19580
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
19581
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
19582
+ if (!SWIG_IsOK(ecode3)) {
19583
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___setitem__" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
19584
+ }
19585
+ temp3 = static_cast< std::vector< int >::value_type >(val3);
19586
+ arg3 = &temp3;
19587
+ try {
19588
+ std_vector_Sl_int_Sg____setitem__(arg1,arg2,(int const &)*arg3);
19589
+ }
19590
+ catch(std::out_of_range &_e) {
19591
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
19592
+ }
19593
+
19594
+ resultobj = SWIG_Py_Void();
19595
+ return resultobj;
19596
+fail:
19597
+ return NULL;
19598
+}
19599
+
19600
+
19601
+SWIGINTERN PyObject *_wrap_IntVector_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19602
+ PyObject *resultobj = 0;
19603
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19604
+ std::vector< int >::value_type *arg2 = 0 ;
19605
+ void *argp1 = 0 ;
19606
+ int res1 = 0 ;
19607
+ std::vector< int >::value_type temp2 ;
19608
+ int val2 ;
19609
+ int ecode2 = 0 ;
19610
+ PyObject * obj0 = 0 ;
19611
+ PyObject * obj1 = 0 ;
19612
+
19613
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_append",&obj0,&obj1)) SWIG_fail;
19614
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19615
+ if (!SWIG_IsOK(res1)) {
19616
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_append" "', argument " "1"" of type '" "std::vector< int > *""'");
19617
+ }
19618
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19619
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
19620
+ if (!SWIG_IsOK(ecode2)) {
19621
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
19622
+ }
19623
+ temp2 = static_cast< std::vector< int >::value_type >(val2);
19624
+ arg2 = &temp2;
19625
+ std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2);
19626
+ resultobj = SWIG_Py_Void();
19627
+ return resultobj;
19628
+fail:
19629
+ return NULL;
19630
+}
19631
+
19632
+
19633
+SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19634
+ PyObject *resultobj = 0;
19635
+ std::vector< int > *result = 0 ;
19636
+
19637
+ if (!PyArg_ParseTuple(args,(char *)":new_IntVector")) SWIG_fail;
19638
+ result = (std::vector< int > *)new std::vector< int >();
19639
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
19640
+ return resultobj;
19641
+fail:
19642
+ return NULL;
19643
+}
19644
+
19645
+
19646
+SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19647
+ PyObject *resultobj = 0;
19648
+ std::vector< int > *arg1 = 0 ;
19649
+ int res1 = SWIG_OLDOBJ ;
19650
+ PyObject * obj0 = 0 ;
19651
+ std::vector< int > *result = 0 ;
19652
+
19653
+ if (!PyArg_ParseTuple(args,(char *)"O:new_IntVector",&obj0)) SWIG_fail;
19654
+ {
19655
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
19656
+ res1 = swig::asptr(obj0, &ptr);
19657
+ if (!SWIG_IsOK(res1)) {
19658
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int > const &""'");
19659
+ }
19660
+ if (!ptr) {
19661
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int > const &""'");
19662
+ }
19663
+ arg1 = ptr;
19664
+ }
19665
+ result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
19666
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
19667
+ if (SWIG_IsNewObj(res1)) delete arg1;
19668
+ return resultobj;
19669
+fail:
19670
+ if (SWIG_IsNewObj(res1)) delete arg1;
19671
+ return NULL;
19672
+}
19673
+
19674
+
19675
+SWIGINTERN PyObject *_wrap_IntVector_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19676
+ PyObject *resultobj = 0;
19677
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19678
+ void *argp1 = 0 ;
19679
+ int res1 = 0 ;
19680
+ PyObject * obj0 = 0 ;
19681
+ bool result;
19682
+
19683
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_empty",&obj0)) SWIG_fail;
19684
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19685
+ if (!SWIG_IsOK(res1)) {
19686
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_empty" "', argument " "1"" of type '" "std::vector< int > const *""'");
19687
+ }
19688
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19689
+ result = (bool)((std::vector< int > const *)arg1)->empty();
19690
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
19691
+ return resultobj;
19692
+fail:
19693
+ return NULL;
19694
+}
19695
+
19696
+
19697
+SWIGINTERN PyObject *_wrap_IntVector_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19698
+ PyObject *resultobj = 0;
19699
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19700
+ void *argp1 = 0 ;
19701
+ int res1 = 0 ;
19702
+ PyObject * obj0 = 0 ;
19703
+ std::vector< int >::size_type result;
19704
+
19705
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_size",&obj0)) SWIG_fail;
19706
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19707
+ if (!SWIG_IsOK(res1)) {
19708
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_size" "', argument " "1"" of type '" "std::vector< int > const *""'");
19709
+ }
19710
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19711
+ result = ((std::vector< int > const *)arg1)->size();
19712
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19713
+ return resultobj;
19714
+fail:
19715
+ return NULL;
19716
+}
19717
+
19718
+
19719
+SWIGINTERN PyObject *_wrap_IntVector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19720
+ PyObject *resultobj = 0;
19721
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19722
+ void *argp1 = 0 ;
19723
+ int res1 = 0 ;
19724
+ PyObject * obj0 = 0 ;
19725
+
19726
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_clear",&obj0)) SWIG_fail;
19727
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19728
+ if (!SWIG_IsOK(res1)) {
19729
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_clear" "', argument " "1"" of type '" "std::vector< int > *""'");
19730
+ }
19731
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19732
+ (arg1)->clear();
19733
+ resultobj = SWIG_Py_Void();
19734
+ return resultobj;
19735
+fail:
19736
+ return NULL;
19737
+}
19738
+
19739
+
19740
+SWIGINTERN PyObject *_wrap_IntVector_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19741
+ PyObject *resultobj = 0;
19742
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19743
+ std::vector< int > *arg2 = 0 ;
19744
+ void *argp1 = 0 ;
19745
+ int res1 = 0 ;
19746
+ void *argp2 = 0 ;
19747
+ int res2 = 0 ;
19748
+ PyObject * obj0 = 0 ;
19749
+ PyObject * obj1 = 0 ;
19750
+
19751
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_swap",&obj0,&obj1)) SWIG_fail;
19752
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19753
+ if (!SWIG_IsOK(res1)) {
19754
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_swap" "', argument " "1"" of type '" "std::vector< int > *""'");
19755
+ }
19756
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19757
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 );
19758
+ if (!SWIG_IsOK(res2)) {
19759
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntVector_swap" "', argument " "2"" of type '" "std::vector< int > &""'");
19760
+ }
19761
+ if (!argp2) {
19762
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVector_swap" "', argument " "2"" of type '" "std::vector< int > &""'");
19763
+ }
19764
+ arg2 = reinterpret_cast< std::vector< int > * >(argp2);
19765
+ (arg1)->swap(*arg2);
19766
+ resultobj = SWIG_Py_Void();
19767
+ return resultobj;
19768
+fail:
19769
+ return NULL;
19770
+}
19771
+
19772
+
19773
+SWIGINTERN PyObject *_wrap_IntVector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19774
+ PyObject *resultobj = 0;
19775
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19776
+ void *argp1 = 0 ;
19777
+ int res1 = 0 ;
19778
+ PyObject * obj0 = 0 ;
19779
+ SwigValueWrapper< std::allocator< int > > result;
19780
+
19781
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_get_allocator",&obj0)) SWIG_fail;
19782
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19783
+ if (!SWIG_IsOK(res1)) {
19784
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'");
19785
+ }
19786
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19787
+ result = ((std::vector< int > const *)arg1)->get_allocator();
19788
+ resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
19789
+ return resultobj;
19790
+fail:
19791
+ return NULL;
19792
+}
19793
+
19794
+
19795
+SWIGINTERN PyObject *_wrap_IntVector_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19796
+ PyObject *resultobj = 0;
19797
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19798
+ void *argp1 = 0 ;
19799
+ int res1 = 0 ;
19800
+ PyObject * obj0 = 0 ;
19801
+ std::vector< int >::const_iterator result;
19802
+
19803
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_begin",&obj0)) SWIG_fail;
19804
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19805
+ if (!SWIG_IsOK(res1)) {
19806
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_begin" "', argument " "1"" of type '" "std::vector< int > const *""'");
19807
+ }
19808
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19809
+ result = ((std::vector< int > const *)arg1)->begin();
19810
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_iterator & >(result)),
19811
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
19812
+ return resultobj;
19813
+fail:
19814
+ return NULL;
19815
+}
19816
+
19817
+
19818
+SWIGINTERN PyObject *_wrap_IntVector_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19819
+ PyObject *resultobj = 0;
19820
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19821
+ void *argp1 = 0 ;
19822
+ int res1 = 0 ;
19823
+ PyObject * obj0 = 0 ;
19824
+ std::vector< int >::const_iterator result;
19825
+
19826
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_end",&obj0)) SWIG_fail;
19827
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19828
+ if (!SWIG_IsOK(res1)) {
19829
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_end" "', argument " "1"" of type '" "std::vector< int > const *""'");
19830
+ }
19831
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19832
+ result = ((std::vector< int > const *)arg1)->end();
19833
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_iterator & >(result)),
19834
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
19835
+ return resultobj;
19836
+fail:
19837
+ return NULL;
19838
+}
19839
+
19840
+
19841
+SWIGINTERN PyObject *_wrap_IntVector_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19842
+ PyObject *resultobj = 0;
19843
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19844
+ void *argp1 = 0 ;
19845
+ int res1 = 0 ;
19846
+ PyObject * obj0 = 0 ;
19847
+ std::vector< int >::const_reverse_iterator result;
19848
+
19849
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_rbegin",&obj0)) SWIG_fail;
19850
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19851
+ if (!SWIG_IsOK(res1)) {
19852
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_rbegin" "', argument " "1"" of type '" "std::vector< int > const *""'");
19853
+ }
19854
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19855
+ result = ((std::vector< int > const *)arg1)->rbegin();
19856
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_reverse_iterator & >(result)),
19857
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
19858
+ return resultobj;
19859
+fail:
19860
+ return NULL;
19861
+}
19862
+
19863
+
19864
+SWIGINTERN PyObject *_wrap_IntVector_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19865
+ PyObject *resultobj = 0;
19866
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19867
+ void *argp1 = 0 ;
19868
+ int res1 = 0 ;
19869
+ PyObject * obj0 = 0 ;
19870
+ std::vector< int >::const_reverse_iterator result;
19871
+
19872
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_rend",&obj0)) SWIG_fail;
19873
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19874
+ if (!SWIG_IsOK(res1)) {
19875
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_rend" "', argument " "1"" of type '" "std::vector< int > const *""'");
19876
+ }
19877
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19878
+ result = ((std::vector< int > const *)arg1)->rend();
19879
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_reverse_iterator & >(result)),
19880
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
19881
+ return resultobj;
19882
+fail:
19883
+ return NULL;
19884
+}
19885
+
19886
+
19887
+SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19888
+ PyObject *resultobj = 0;
19889
+ std::vector< int >::size_type arg1 ;
19890
+ size_t val1 ;
19891
+ int ecode1 = 0 ;
19892
+ PyObject * obj0 = 0 ;
19893
+ std::vector< int > *result = 0 ;
19894
+
19895
+ if (!PyArg_ParseTuple(args,(char *)"O:new_IntVector",&obj0)) SWIG_fail;
19896
+ ecode1 = SWIG_AsVal_size_t(obj0, &val1);
19897
+ if (!SWIG_IsOK(ecode1)) {
19898
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
19899
+ }
19900
+ arg1 = static_cast< std::vector< int >::size_type >(val1);
19901
+ result = (std::vector< int > *)new std::vector< int >(arg1);
19902
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
19903
+ return resultobj;
19904
+fail:
19905
+ return NULL;
19906
+}
19907
+
19908
+
19909
+SWIGINTERN PyObject *_wrap_IntVector_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19910
+ PyObject *resultobj = 0;
19911
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19912
+ void *argp1 = 0 ;
19913
+ int res1 = 0 ;
19914
+ PyObject * obj0 = 0 ;
19915
+
19916
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_pop_back",&obj0)) SWIG_fail;
19917
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19918
+ if (!SWIG_IsOK(res1)) {
19919
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'");
19920
+ }
19921
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19922
+ (arg1)->pop_back();
19923
+ resultobj = SWIG_Py_Void();
19924
+ return resultobj;
19925
+fail:
19926
+ return NULL;
19927
+}
19928
+
19929
+
19930
+SWIGINTERN PyObject *_wrap_IntVector_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19931
+ PyObject *resultobj = 0;
19932
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19933
+ std::vector< int >::size_type arg2 ;
19934
+ void *argp1 = 0 ;
19935
+ int res1 = 0 ;
19936
+ size_t val2 ;
19937
+ int ecode2 = 0 ;
19938
+ PyObject * obj0 = 0 ;
19939
+ PyObject * obj1 = 0 ;
19940
+
19941
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_resize",&obj0,&obj1)) SWIG_fail;
19942
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19943
+ if (!SWIG_IsOK(res1)) {
19944
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_resize" "', argument " "1"" of type '" "std::vector< int > *""'");
19945
+ }
19946
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19947
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
19948
+ if (!SWIG_IsOK(ecode2)) {
19949
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
19950
+ }
19951
+ arg2 = static_cast< std::vector< int >::size_type >(val2);
19952
+ (arg1)->resize(arg2);
19953
+ resultobj = SWIG_Py_Void();
19954
+ return resultobj;
19955
+fail:
19956
+ return NULL;
19957
+}
19958
+
19959
+
19960
+SWIGINTERN PyObject *_wrap_IntVector_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19961
+ PyObject *resultobj = 0;
19962
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19963
+ std::vector< int >::iterator arg2 ;
19964
+ void *argp1 = 0 ;
19965
+ int res1 = 0 ;
19966
+ swig::PySwigIterator *iter2 = 0 ;
19967
+ int res2 ;
19968
+ PyObject * obj0 = 0 ;
19969
+ PyObject * obj1 = 0 ;
19970
+ std::vector< int >::iterator result;
19971
+
19972
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_erase",&obj0,&obj1)) SWIG_fail;
19973
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19974
+ if (!SWIG_IsOK(res1)) {
19975
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_erase" "', argument " "1"" of type '" "std::vector< int > *""'");
19976
+ }
19977
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19978
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
19979
+ if (!SWIG_IsOK(res2) || !iter2) {
19980
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19981
+ } else {
19982
+ swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter2);
19983
+ if (iter_t) {
19984
+ arg2 = iter_t->get_current();
19985
+ } else {
19986
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19987
+ }
19988
+ }
19989
+ result = (arg1)->erase(arg2);
19990
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
19991
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
19992
+ return resultobj;
19993
+fail:
19994
+ return NULL;
19995
+}
19996
+
19997
+
19998
+SWIGINTERN PyObject *_wrap_IntVector_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19999
+ PyObject *resultobj = 0;
20000
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
20001
+ std::vector< int >::iterator arg2 ;
20002
+ std::vector< int >::iterator arg3 ;
20003
+ void *argp1 = 0 ;
20004
+ int res1 = 0 ;
20005
+ swig::PySwigIterator *iter2 = 0 ;
20006
+ int res2 ;
20007
+ swig::PySwigIterator *iter3 = 0 ;
20008
+ int res3 ;
20009
+ PyObject * obj0 = 0 ;
20010
+ PyObject * obj1 = 0 ;
20011
+ PyObject * obj2 = 0 ;
20012
+ std::vector< int >::iterator result;
20013
+
20014
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector_erase",&obj0,&obj1,&obj2)) SWIG_fail;
20015
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
20016
+ if (!SWIG_IsOK(res1)) {
20017
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_erase" "', argument " "1"" of type '" "std::vector< int > *""'");
20018
+ }
20019
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
20020
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
20021
+ if (!SWIG_IsOK(res2) || !iter2) {
20022
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
20023
+ } else {
20024
+ swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter2);
20025
+ if (iter_t) {
20026
+ arg2 = iter_t->get_current();
20027
+ } else {
20028
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
20029
+ }
20030
+ }
20031
+ res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
20032
+ if (!SWIG_IsOK(res3) || !iter3) {
20033
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
20034
+ } else {
20035
+ swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter3);
20036
+ if (iter_t) {
20037
+ arg3 = iter_t->get_current();
20038
+ } else {
20039
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
20040
+ }
20041
+ }
20042
+ result = (arg1)->erase(arg2,arg3);
20043
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
20044
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
20045
+ return resultobj;
20046
+fail:
20047
+ return NULL;
20048
+}
20049
+
20050
+
20051
+SWIGINTERN PyObject *_wrap_IntVector_erase(PyObject *self, PyObject *args) {
20052
+ int argc;
20053
+ PyObject *argv[4];
20054
+ int ii;
20055
+
20056
+ if (!PyTuple_Check(args)) SWIG_fail;
20057
+ argc = (int)PyObject_Length(args);
20058
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
20059
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
20060
+ }
20061
+ if (argc == 2) {
20062
+ int _v;
20063
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
20064
+ _v = SWIG_CheckState(res);
20065
+ if (_v) {
20066
+ swig::PySwigIterator *iter = 0;
20067
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
20068
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
20069
+ if (_v) {
20070
+ return _wrap_IntVector_erase__SWIG_0(self, args);
20071
+ }
20072
+ }
20073
+ }
20074
+ if (argc == 3) {
20075
+ int _v;
20076
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
20077
+ _v = SWIG_CheckState(res);
20078
+ if (_v) {
20079
+ swig::PySwigIterator *iter = 0;
20080
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
20081
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
20082
+ if (_v) {
20083
+ swig::PySwigIterator *iter = 0;
20084
+ int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
20085
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
20086
+ if (_v) {
20087
+ return _wrap_IntVector_erase__SWIG_1(self, args);
20088
+ }
20089
+ }
20090
+ }
20091
+ }
20092
+
20093
+fail:
20094
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IntVector_erase'.\n"
20095
+ " Possible C/C++ prototypes are:\n"
20096
+ " erase(std::vector< int > *,std::vector< int >::iterator)\n"
20097
+ " erase(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::iterator)\n");
20098
+ return NULL;
20099
+}
20100
+
20101
+
20102
+SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20103
+ PyObject *resultobj = 0;
20104
+ std::vector< int >::size_type arg1 ;
20105
+ std::vector< int >::value_type *arg2 = 0 ;
20106
+ size_t val1 ;
20107
+ int ecode1 = 0 ;
20108
+ std::vector< int >::value_type temp2 ;
20109
+ int val2 ;
20110
+ int ecode2 = 0 ;
20111
+ PyObject * obj0 = 0 ;
20112
+ PyObject * obj1 = 0 ;
20113
+ std::vector< int > *result = 0 ;
20114
+
20115
+ if (!PyArg_ParseTuple(args,(char *)"OO:new_IntVector",&obj0,&obj1)) SWIG_fail;
20116
+ ecode1 = SWIG_AsVal_size_t(obj0, &val1);
20117
+ if (!SWIG_IsOK(ecode1)) {
20118
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
20119
+ }
20120
+ arg1 = static_cast< std::vector< int >::size_type >(val1);
20121
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
20122
+ if (!SWIG_IsOK(ecode2)) {
20123
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IntVector" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
20124
+ }
20125
+ temp2 = static_cast< std::vector< int >::value_type >(val2);
20126
+ arg2 = &temp2;
20127
+ result = (std::vector< int > *)new std::vector< int >(arg1,(std::vector< int >::value_type const &)*arg2);
20128
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
20129
+ return resultobj;
20130
+fail:
20131
+ return NULL;
20132
+}
20133
+
20134
+
20135
+SWIGINTERN PyObject *_wrap_new_IntVector(PyObject *self, PyObject *args) {
20136
+ int argc;
20137
+ PyObject *argv[3];
20138
+ int ii;
20139
+
20140
+ if (!PyTuple_Check(args)) SWIG_fail;
20141
+ argc = (int)PyObject_Length(args);
20142
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
20143
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
20144
+ }
20145
+ if (argc == 0) {
20146
+ return _wrap_new_IntVector__SWIG_0(self, args);
20147
+ }
20148
+ if (argc == 1) {
20149
+ int _v;
20150
+ {
20151
+ int res = SWIG_AsVal_size_t(argv[0], NULL);
20152
+ _v = SWIG_CheckState(res);
20153
+ }
20154
+ if (_v) {
20155
+ return _wrap_new_IntVector__SWIG_2(self, args);
20156
+ }
20157
+ }
20158
+ if (argc == 1) {
20159
+ int _v;
20160
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
20161
+ _v = SWIG_CheckState(res);
20162
+ if (_v) {
20163
+ return _wrap_new_IntVector__SWIG_1(self, args);
20164
+ }
20165
+ }
20166
+ if (argc == 2) {
20167
+ int _v;
20168
+ {
20169
+ int res = SWIG_AsVal_size_t(argv[0], NULL);
20170
+ _v = SWIG_CheckState(res);
20171
+ }
20172
+ if (_v) {
20173
+ {
20174
+ int res = SWIG_AsVal_int(argv[1], NULL);
20175
+ _v = SWIG_CheckState(res);
20176
+ }
20177
+ if (_v) {
20178
+ return _wrap_new_IntVector__SWIG_3(self, args);
20179
+ }
20180
+ }
20181
+ }
20182
+
20183
+fail:
20184
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IntVector'.\n"
20185
+ " Possible C/C++ prototypes are:\n"
20186
+ " std::vector< int >()\n"
20187
+ " std::vector< int >(std::vector< int > const &)\n"
20188
+ " std::vector< int >(std::vector< int >::size_type)\n"
20189
+ " std::vector< int >(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
20190
+ return NULL;
20191
+}
20192
+
20193
+
20194
+SWIGINTERN PyObject *_wrap_IntVector_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20195
+ PyObject *resultobj = 0;
20196
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
20197
+ std::vector< int >::value_type *arg2 = 0 ;
20198
+ void *argp1 = 0 ;
20199
+ int res1 = 0 ;
20200
+ std::vector< int >::value_type temp2 ;
20201
+ int val2 ;
20202
+ int ecode2 = 0 ;
20203
+ PyObject * obj0 = 0 ;
20204
+ PyObject * obj1 = 0 ;
20205
+
20206
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_push_back",&obj0,&obj1)) SWIG_fail;
20207
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
20208
+ if (!SWIG_IsOK(res1)) {
20209
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_push_back" "', argument " "1"" of type '" "std::vector< int > *""'");
20210
+ }
20211
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
20212
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
20213
+ if (!SWIG_IsOK(ecode2)) {
20214
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
20215
+ }
20216
+ temp2 = static_cast< std::vector< int >::value_type >(val2);
20217
+ arg2 = &temp2;
20218
+ (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
20219
+ resultobj = SWIG_Py_Void();
20220
+ return resultobj;
20221
+fail:
20222
+ return NULL;
20223
+}
20224
+
20225
+
20226
+SWIGINTERN PyObject *_wrap_IntVector_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20227
+ PyObject *resultobj = 0;
20228
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
20229
+ void *argp1 = 0 ;
20230
+ int res1 = 0 ;
20231
+ PyObject * obj0 = 0 ;
20232
+ std::vector< int >::value_type *result = 0 ;
20233
+
20234
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_front",&obj0)) SWIG_fail;
20235
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
20236
+ if (!SWIG_IsOK(res1)) {
20237
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_front" "', argument " "1"" of type '" "std::vector< int > const *""'");
20238
+ }
20239
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
20240
+ {
20241
+ std::vector< int >::value_type const &_result_ref = ((std::vector< int > const *)arg1)->front();
20242
+ result = (std::vector< int >::value_type *) &_result_ref;
20243
+ }
20244
+ resultobj = SWIG_From_int(static_cast< int >(*result));
20245
+ return resultobj;
20246
+fail:
20247
+ return NULL;
20248
+}
20249
+
20250
+
20251
+SWIGINTERN PyObject *_wrap_IntVector_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20252
+ PyObject *resultobj = 0;
20253
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
20254
+ void *argp1 = 0 ;
20255
+ int res1 = 0 ;
20256
+ PyObject * obj0 = 0 ;
20257
+ std::vector< int >::value_type *result = 0 ;
20258
+
20259
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_back",&obj0)) SWIG_fail;
20260
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
20261
+ if (!SWIG_IsOK(res1)) {
20262
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_back" "', argument " "1"" of type '" "std::vector< int > const *""'");
20263
+ }
20264
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
20265
+ {
20266
+ std::vector< int >::value_type const &_result_ref = ((std::vector< int > const *)arg1)->back();
20267
+ result = (std::vector< int >::value_type *) &_result_ref;
20268
+ }
20269
+ resultobj = SWIG_From_int(static_cast< int >(*result));
20270
+ return resultobj;
20271
+fail:
20272
+ return NULL;
20273
+}
20274
+
20275
+
20276
+SWIGINTERN PyObject *_wrap_IntVector_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20277
+ PyObject *resultobj = 0;
20278
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
20279
+ std::vector< int >::size_type arg2 ;
20280
+ std::vector< int >::value_type *arg3 = 0 ;
20281
+ void *argp1 = 0 ;
20282
+ int res1 = 0 ;
20283
+ size_t val2 ;
20284
+ int ecode2 = 0 ;
20285
+ std::vector< int >::value_type temp3 ;
20286
+ int val3 ;
20287
+ int ecode3 = 0 ;
20288
+ PyObject * obj0 = 0 ;
20289
+ PyObject * obj1 = 0 ;
20290
+ PyObject * obj2 = 0 ;
20291
+
20292
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector_assign",&obj0,&obj1,&obj2)) SWIG_fail;
20293
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
20294
+ if (!SWIG_IsOK(res1)) {
20295
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_assign" "', argument " "1"" of type '" "std::vector< int > *""'");
20296
+ }
20297
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
20298
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
20299
+ if (!SWIG_IsOK(ecode2)) {
20300
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
20301
+ }
20302
+ arg2 = static_cast< std::vector< int >::size_type >(val2);
20303
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
20304
+ if (!SWIG_IsOK(ecode3)) {
20305
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
20306
+ }
20307
+ temp3 = static_cast< std::vector< int >::value_type >(val3);
20308
+ arg3 = &temp3;
20309
+ (arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3);
20310
+ resultobj = SWIG_Py_Void();
20311
+ return resultobj;
20312
+fail:
20313
+ return NULL;
20314
+}
20315
+
20316
+
20317
+SWIGINTERN PyObject *_wrap_IntVector_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20318
+ PyObject *resultobj = 0;
20319
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
20320
+ std::vector< int >::size_type arg2 ;
20321
+ std::vector< int >::value_type *arg3 = 0 ;
20322
+ void *argp1 = 0 ;
20323
+ int res1 = 0 ;
20324
+ size_t val2 ;
20325
+ int ecode2 = 0 ;
20326
+ std::vector< int >::value_type temp3 ;
20327
+ int val3 ;
20328
+ int ecode3 = 0 ;
20329
+ PyObject * obj0 = 0 ;
20330
+ PyObject * obj1 = 0 ;
20331
+ PyObject * obj2 = 0 ;
20332
+
20333
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector_resize",&obj0,&obj1,&obj2)) SWIG_fail;
20334
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
20335
+ if (!SWIG_IsOK(res1)) {
20336
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_resize" "', argument " "1"" of type '" "std::vector< int > *""'");
20337
+ }
20338
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
20339
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
20340
+ if (!SWIG_IsOK(ecode2)) {
20341
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
20342
+ }
20343
+ arg2 = static_cast< std::vector< int >::size_type >(val2);
20344
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
20345
+ if (!SWIG_IsOK(ecode3)) {
20346
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
20347
+ }
20348
+ temp3 = static_cast< std::vector< int >::value_type >(val3);
20349
+ arg3 = &temp3;
20350
+ (arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3);
20351
+ resultobj = SWIG_Py_Void();
20352
+ return resultobj;
20353
+fail:
20354
+ return NULL;
20355
+}
20356
+
20357
+
20358
+SWIGINTERN PyObject *_wrap_IntVector_resize(PyObject *self, PyObject *args) {
20359
+ int argc;
20360
+ PyObject *argv[4];
20361
+ int ii;
20362
+
20363
+ if (!PyTuple_Check(args)) SWIG_fail;
20364
+ argc = (int)PyObject_Length(args);
20365
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
20366
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
20367
+ }
20368
+ if (argc == 2) {
20369
+ int _v;
20370
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
20371
+ _v = SWIG_CheckState(res);
20372
+ if (_v) {
20373
+ {
20374
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
20375
+ _v = SWIG_CheckState(res);
20376
+ }
20377
+ if (_v) {
20378
+ return _wrap_IntVector_resize__SWIG_0(self, args);
20379
+ }
20380
+ }
20381
+ }
20382
+ if (argc == 3) {
20383
+ int _v;
20384
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
20385
+ _v = SWIG_CheckState(res);
20386
+ if (_v) {
20387
+ {
20388
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
20389
+ _v = SWIG_CheckState(res);
20390
+ }
20391
+ if (_v) {
20392
+ {
20393
+ int res = SWIG_AsVal_int(argv[2], NULL);
20394
+ _v = SWIG_CheckState(res);
20395
+ }
20396
+ if (_v) {
20397
+ return _wrap_IntVector_resize__SWIG_1(self, args);
20398
+ }
20399
+ }
20400
+ }
20401
+ }
20402
+
20403
+fail:
20404
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IntVector_resize'.\n"
20405
+ " Possible C/C++ prototypes are:\n"
20406
+ " resize(std::vector< int > *,std::vector< int >::size_type)\n"
20407
+ " resize(std::vector< int > *,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
20408
+ return NULL;
20409
+}
20410
+
20411
+
20412
+SWIGINTERN PyObject *_wrap_IntVector_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20413
+ PyObject *resultobj = 0;
20414
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
20415
+ std::vector< int >::iterator arg2 ;
20416
+ std::vector< int >::value_type *arg3 = 0 ;
20417
+ void *argp1 = 0 ;
20418
+ int res1 = 0 ;
20419
+ swig::PySwigIterator *iter2 = 0 ;
20420
+ int res2 ;
20421
+ std::vector< int >::value_type temp3 ;
20422
+ int val3 ;
20423
+ int ecode3 = 0 ;
20424
+ PyObject * obj0 = 0 ;
20425
+ PyObject * obj1 = 0 ;
20426
+ PyObject * obj2 = 0 ;
20427
+ std::vector< int >::iterator result;
20428
+
20429
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector_insert",&obj0,&obj1,&obj2)) SWIG_fail;
20430
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
20431
+ if (!SWIG_IsOK(res1)) {
20432
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_insert" "', argument " "1"" of type '" "std::vector< int > *""'");
20433
+ }
20434
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
20435
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
20436
+ if (!SWIG_IsOK(res2) || !iter2) {
20437
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
20438
+ } else {
20439
+ swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter2);
20440
+ if (iter_t) {
20441
+ arg2 = iter_t->get_current();
20442
+ } else {
20443
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
20444
+ }
20445
+ }
20446
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
20447
+ if (!SWIG_IsOK(ecode3)) {
20448
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
20449
+ }
20450
+ temp3 = static_cast< std::vector< int >::value_type >(val3);
20451
+ arg3 = &temp3;
20452
+ result = (arg1)->insert(arg2,(std::vector< int >::value_type const &)*arg3);
20453
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
20454
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
20455
+ return resultobj;
20456
+fail:
20457
+ return NULL;
20458
+}
20459
+
20460
+
20461
+SWIGINTERN PyObject *_wrap_IntVector_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20462
+ PyObject *resultobj = 0;
20463
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
20464
+ std::vector< int >::iterator arg2 ;
20465
+ std::vector< int >::size_type arg3 ;
20466
+ std::vector< int >::value_type *arg4 = 0 ;
20467
+ void *argp1 = 0 ;
20468
+ int res1 = 0 ;
20469
+ swig::PySwigIterator *iter2 = 0 ;
20470
+ int res2 ;
20471
+ size_t val3 ;
20472
+ int ecode3 = 0 ;
20473
+ std::vector< int >::value_type temp4 ;
20474
+ int val4 ;
20475
+ int ecode4 = 0 ;
20476
+ PyObject * obj0 = 0 ;
20477
+ PyObject * obj1 = 0 ;
20478
+ PyObject * obj2 = 0 ;
20479
+ PyObject * obj3 = 0 ;
20480
+
20481
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:IntVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20482
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
20483
+ if (!SWIG_IsOK(res1)) {
20484
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_insert" "', argument " "1"" of type '" "std::vector< int > *""'");
20485
+ }
20486
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
20487
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
20488
+ if (!SWIG_IsOK(res2) || !iter2) {
20489
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
20490
+ } else {
20491
+ swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter2);
20492
+ if (iter_t) {
20493
+ arg2 = iter_t->get_current();
20494
+ } else {
20495
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
20496
+ }
20497
+ }
20498
+ ecode3 = SWIG_AsVal_size_t(obj2, &val3);
20499
+ if (!SWIG_IsOK(ecode3)) {
20500
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'");
20501
+ }
20502
+ arg3 = static_cast< std::vector< int >::size_type >(val3);
20503
+ ecode4 = SWIG_AsVal_int(obj3, &val4);
20504
+ if (!SWIG_IsOK(ecode4)) {
20505
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IntVector_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'");
20506
+ }
20507
+ temp4 = static_cast< std::vector< int >::value_type >(val4);
20508
+ arg4 = &temp4;
20509
+ (arg1)->insert(arg2,arg3,(std::vector< int >::value_type const &)*arg4);
20510
+ resultobj = SWIG_Py_Void();
20511
+ return resultobj;
20512
+fail:
20513
+ return NULL;
20514
+}
20515
+
20516
+
20517
+SWIGINTERN PyObject *_wrap_IntVector_insert(PyObject *self, PyObject *args) {
20518
+ int argc;
20519
+ PyObject *argv[5];
20520
+ int ii;
20521
+
20522
+ if (!PyTuple_Check(args)) SWIG_fail;
20523
+ argc = (int)PyObject_Length(args);
20524
+ for (ii = 0; (ii < argc) && (ii < 4); ii++) {
20525
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
20526
+ }
20527
+ if (argc == 3) {
20528
+ int _v;
20529
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
20530
+ _v = SWIG_CheckState(res);
20531
+ if (_v) {
20532
+ swig::PySwigIterator *iter = 0;
20533
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
20534
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
20535
+ if (_v) {
20536
+ {
20537
+ int res = SWIG_AsVal_int(argv[2], NULL);
20538
+ _v = SWIG_CheckState(res);
20539
+ }
20540
+ if (_v) {
20541
+ return _wrap_IntVector_insert__SWIG_0(self, args);
20542
+ }
20543
+ }
20544
+ }
20545
+ }
20546
+ if (argc == 4) {
20547
+ int _v;
20548
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
20549
+ _v = SWIG_CheckState(res);
20550
+ if (_v) {
20551
+ swig::PySwigIterator *iter = 0;
20552
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
20553
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
20554
+ if (_v) {
20555
+ {
20556
+ int res = SWIG_AsVal_size_t(argv[2], NULL);
20557
+ _v = SWIG_CheckState(res);
20558
+ }
20559
+ if (_v) {
20560
+ {
20561
+ int res = SWIG_AsVal_int(argv[3], NULL);
20562
+ _v = SWIG_CheckState(res);
20563
+ }
20564
+ if (_v) {
20565
+ return _wrap_IntVector_insert__SWIG_1(self, args);
20566
+ }
20567
+ }
20568
+ }
20569
+ }
20570
+ }
20571
+
20572
+fail:
20573
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IntVector_insert'.\n"
20574
+ " Possible C/C++ prototypes are:\n"
20575
+ " insert(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::value_type const &)\n"
20576
+ " insert(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
20577
+ return NULL;
20578
+}
20579
+
20580
+
20581
+SWIGINTERN PyObject *_wrap_IntVector_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20582
+ PyObject *resultobj = 0;
20583
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
20584
+ std::vector< int >::size_type arg2 ;
20585
+ void *argp1 = 0 ;
20586
+ int res1 = 0 ;
20587
+ size_t val2 ;
20588
+ int ecode2 = 0 ;
20589
+ PyObject * obj0 = 0 ;
20590
+ PyObject * obj1 = 0 ;
20591
+
20592
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_reserve",&obj0,&obj1)) SWIG_fail;
20593
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
20594
+ if (!SWIG_IsOK(res1)) {
20595
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_reserve" "', argument " "1"" of type '" "std::vector< int > *""'");
20596
+ }
20597
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
20598
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
20599
+ if (!SWIG_IsOK(ecode2)) {
20600
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
20601
+ }
20602
+ arg2 = static_cast< std::vector< int >::size_type >(val2);
20603
+ (arg1)->reserve(arg2);
20604
+ resultobj = SWIG_Py_Void();
20605
+ return resultobj;
20606
+fail:
20607
+ return NULL;
20608
+}
20609
+
20610
+
20611
+SWIGINTERN PyObject *_wrap_IntVector_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20612
+ PyObject *resultobj = 0;
20613
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
20614
+ void *argp1 = 0 ;
20615
+ int res1 = 0 ;
20616
+ PyObject * obj0 = 0 ;
20617
+ std::vector< int >::size_type result;
20618
+
20619
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVector_capacity",&obj0)) SWIG_fail;
20620
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
20621
+ if (!SWIG_IsOK(res1)) {
20622
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'");
20623
+ }
20624
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
20625
+ result = ((std::vector< int > const *)arg1)->capacity();
20626
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20627
+ return resultobj;
20628
+fail:
20629
+ return NULL;
20630
+}
20631
+
20632
+
20633
+SWIGINTERN PyObject *_wrap_delete_IntVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20634
+ PyObject *resultobj = 0;
20635
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
20636
+ void *argp1 = 0 ;
20637
+ int res1 = 0 ;
20638
+ PyObject * obj0 = 0 ;
20639
+
20640
+ if (!PyArg_ParseTuple(args,(char *)"O:delete_IntVector",&obj0)) SWIG_fail;
20641
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_DISOWN | 0 );
20642
+ if (!SWIG_IsOK(res1)) {
20643
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntVector" "', argument " "1"" of type '" "std::vector< int > *""'");
20644
+ }
20645
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
20646
+ delete arg1;
20647
+ resultobj = SWIG_Py_Void();
20648
+ return resultobj;
20649
+fail:
20650
+ return NULL;
20651
+}
20652
+
20653
+
20654
+SWIGINTERN PyObject *IntVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20655
+ PyObject *obj;
20656
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
20657
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_NewClientData(obj));
20658
+ return SWIG_Py_Void();
20659
+}
20660
+
20661
+SWIGINTERN PyObject *_wrap_DoubleVector_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20662
+ PyObject *resultobj = 0;
20663
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
20664
+ PyObject **arg2 = (PyObject **) 0 ;
20665
+ void *argp1 = 0 ;
20666
+ int res1 = 0 ;
20667
+ PyObject * obj0 = 0 ;
20668
+ swig::PySwigIterator *result = 0 ;
20669
+
20670
+ arg2 = &obj0;
20671
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_iterator",&obj0)) SWIG_fail;
20672
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
20673
+ if (!SWIG_IsOK(res1)) {
20674
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_iterator" "', argument " "1"" of type '" "std::vector< double > *""'");
20675
+ }
20676
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
20677
+ result = (swig::PySwigIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
20678
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
20679
+ return resultobj;
20680
+fail:
20681
+ return NULL;
20682
+}
20683
+
20684
+
20685
+SWIGINTERN PyObject *_wrap_DoubleVector___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20686
+ PyObject *resultobj = 0;
20687
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
20688
+ void *argp1 = 0 ;
20689
+ int res1 = 0 ;
20690
+ PyObject * obj0 = 0 ;
20691
+ bool result;
20692
+
20693
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector___nonzero__",&obj0)) SWIG_fail;
20694
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
20695
+ if (!SWIG_IsOK(res1)) {
20696
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___nonzero__" "', argument " "1"" of type '" "std::vector< double > const *""'");
20697
+ }
20698
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
20699
+ result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector< double > const *)arg1);
20700
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
20701
+ return resultobj;
20702
+fail:
20703
+ return NULL;
20704
+}
20705
+
20706
+
20707
+SWIGINTERN PyObject *_wrap_DoubleVector___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20708
+ PyObject *resultobj = 0;
20709
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
20710
+ void *argp1 = 0 ;
20711
+ int res1 = 0 ;
20712
+ PyObject * obj0 = 0 ;
20713
+ std::vector< double >::size_type result;
20714
+
20715
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector___len__",&obj0)) SWIG_fail;
20716
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
20717
+ if (!SWIG_IsOK(res1)) {
20718
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___len__" "', argument " "1"" of type '" "std::vector< double > const *""'");
20719
+ }
20720
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
20721
+ result = std_vector_Sl_double_Sg____len__((std::vector< double > const *)arg1);
20722
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20723
+ return resultobj;
20724
+fail:
20725
+ return NULL;
20726
+}
20727
+
20728
+
20729
+SWIGINTERN PyObject *_wrap_DoubleVector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20730
+ PyObject *resultobj = 0;
20731
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
20732
+ void *argp1 = 0 ;
20733
+ int res1 = 0 ;
20734
+ PyObject * obj0 = 0 ;
20735
+ std::vector< double >::value_type result;
20736
+
20737
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_pop",&obj0)) SWIG_fail;
20738
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
20739
+ if (!SWIG_IsOK(res1)) {
20740
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_pop" "', argument " "1"" of type '" "std::vector< double > *""'");
20741
+ }
20742
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
20743
+ try {
20744
+ result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
20745
+ }
20746
+ catch(std::out_of_range &_e) {
20747
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
20748
+ }
20749
+
20750
+ resultobj = SWIG_From_double(static_cast< double >(result));
20751
+ return resultobj;
20752
+fail:
20753
+ return NULL;
20754
+}
20755
+
20756
+
20757
+SWIGINTERN PyObject *_wrap_DoubleVector___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20758
+ PyObject *resultobj = 0;
20759
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
20760
+ std::vector< double >::difference_type arg2 ;
20761
+ std::vector< double >::difference_type arg3 ;
20762
+ void *argp1 = 0 ;
20763
+ int res1 = 0 ;
20764
+ ptrdiff_t val2 ;
20765
+ int ecode2 = 0 ;
20766
+ ptrdiff_t val3 ;
20767
+ int ecode3 = 0 ;
20768
+ PyObject * obj0 = 0 ;
20769
+ PyObject * obj1 = 0 ;
20770
+ PyObject * obj2 = 0 ;
20771
+ std::vector< double,std::allocator< double > > *result = 0 ;
20772
+
20773
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
20774
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
20775
+ if (!SWIG_IsOK(res1)) {
20776
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
20777
+ }
20778
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
20779
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
20780
+ if (!SWIG_IsOK(ecode2)) {
20781
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
20782
+ }
20783
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
20784
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
20785
+ if (!SWIG_IsOK(ecode3)) {
20786
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
20787
+ }
20788
+ arg3 = static_cast< std::vector< double >::difference_type >(val3);
20789
+ try {
20790
+ result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getslice__(arg1,arg2,arg3);
20791
+ }
20792
+ catch(std::out_of_range &_e) {
20793
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
20794
+ }
20795
+
20796
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN | 0 );
20797
+ return resultobj;
20798
+fail:
20799
+ return NULL;
20800
+}
20801
+
20802
+
20803
+SWIGINTERN PyObject *_wrap_DoubleVector___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20804
+ PyObject *resultobj = 0;
20805
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
20806
+ std::vector< double >::difference_type arg2 ;
20807
+ std::vector< double >::difference_type arg3 ;
20808
+ std::vector< double,std::allocator< double > > *arg4 = 0 ;
20809
+ void *argp1 = 0 ;
20810
+ int res1 = 0 ;
20811
+ ptrdiff_t val2 ;
20812
+ int ecode2 = 0 ;
20813
+ ptrdiff_t val3 ;
20814
+ int ecode3 = 0 ;
20815
+ int res4 = SWIG_OLDOBJ ;
20816
+ PyObject * obj0 = 0 ;
20817
+ PyObject * obj1 = 0 ;
20818
+ PyObject * obj2 = 0 ;
20819
+ PyObject * obj3 = 0 ;
20820
+
20821
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:DoubleVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20822
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
20823
+ if (!SWIG_IsOK(res1)) {
20824
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
20825
+ }
20826
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
20827
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
20828
+ if (!SWIG_IsOK(ecode2)) {
20829
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
20830
+ }
20831
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
20832
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
20833
+ if (!SWIG_IsOK(ecode3)) {
20834
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
20835
+ }
20836
+ arg3 = static_cast< std::vector< double >::difference_type >(val3);
20837
+ {
20838
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
20839
+ res4 = swig::asptr(obj3, &ptr);
20840
+ if (!SWIG_IsOK(res4)) {
20841
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoubleVector___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
20842
+ }
20843
+ if (!ptr) {
20844
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVector___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
20845
+ }
20846
+ arg4 = ptr;
20847
+ }
20848
+ try {
20849
+ std_vector_Sl_double_Sg____setslice__(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
20850
+ }
20851
+ catch(std::out_of_range &_e) {
20852
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
20853
+ }
20854
+ catch(std::invalid_argument &_e) {
20855
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
20856
+ }
20857
+
20858
+ resultobj = SWIG_Py_Void();
20859
+ if (SWIG_IsNewObj(res4)) delete arg4;
20860
+ return resultobj;
20861
+fail:
20862
+ if (SWIG_IsNewObj(res4)) delete arg4;
20863
+ return NULL;
20864
+}
20865
+
20866
+
20867
+SWIGINTERN PyObject *_wrap_DoubleVector___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20868
+ PyObject *resultobj = 0;
20869
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
20870
+ std::vector< double >::difference_type arg2 ;
20871
+ std::vector< double >::difference_type arg3 ;
20872
+ void *argp1 = 0 ;
20873
+ int res1 = 0 ;
20874
+ ptrdiff_t val2 ;
20875
+ int ecode2 = 0 ;
20876
+ ptrdiff_t val3 ;
20877
+ int ecode3 = 0 ;
20878
+ PyObject * obj0 = 0 ;
20879
+ PyObject * obj1 = 0 ;
20880
+ PyObject * obj2 = 0 ;
20881
+
20882
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
20883
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
20884
+ if (!SWIG_IsOK(res1)) {
20885
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___delslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
20886
+ }
20887
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
20888
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
20889
+ if (!SWIG_IsOK(ecode2)) {
20890
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___delslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
20891
+ }
20892
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
20893
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
20894
+ if (!SWIG_IsOK(ecode3)) {
20895
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___delslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
20896
+ }
20897
+ arg3 = static_cast< std::vector< double >::difference_type >(val3);
20898
+ try {
20899
+ std_vector_Sl_double_Sg____delslice__(arg1,arg2,arg3);
20900
+ }
20901
+ catch(std::out_of_range &_e) {
20902
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
20903
+ }
20904
+
20905
+ resultobj = SWIG_Py_Void();
20906
+ return resultobj;
20907
+fail:
20908
+ return NULL;
20909
+}
20910
+
20911
+
20912
+SWIGINTERN PyObject *_wrap_DoubleVector___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20913
+ PyObject *resultobj = 0;
20914
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
20915
+ std::vector< double >::difference_type arg2 ;
20916
+ void *argp1 = 0 ;
20917
+ int res1 = 0 ;
20918
+ ptrdiff_t val2 ;
20919
+ int ecode2 = 0 ;
20920
+ PyObject * obj0 = 0 ;
20921
+ PyObject * obj1 = 0 ;
20922
+
20923
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector___delitem__",&obj0,&obj1)) SWIG_fail;
20924
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
20925
+ if (!SWIG_IsOK(res1)) {
20926
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
20927
+ }
20928
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
20929
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
20930
+ if (!SWIG_IsOK(ecode2)) {
20931
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___delitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
20932
+ }
20933
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
20934
+ try {
20935
+ std_vector_Sl_double_Sg____delitem__(arg1,arg2);
20936
+ }
20937
+ catch(std::out_of_range &_e) {
20938
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
20939
+ }
20940
+
20941
+ resultobj = SWIG_Py_Void();
20942
+ return resultobj;
20943
+fail:
20944
+ return NULL;
20945
+}
20946
+
20947
+
20948
+SWIGINTERN PyObject *_wrap_DoubleVector___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20949
+ PyObject *resultobj = 0;
20950
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
20951
+ std::vector< double >::difference_type arg2 ;
20952
+ void *argp1 = 0 ;
20953
+ int res1 = 0 ;
20954
+ ptrdiff_t val2 ;
20955
+ int ecode2 = 0 ;
20956
+ PyObject * obj0 = 0 ;
20957
+ PyObject * obj1 = 0 ;
20958
+ std::vector< double >::value_type *result = 0 ;
20959
+
20960
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector___getitem__",&obj0,&obj1)) SWIG_fail;
20961
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
20962
+ if (!SWIG_IsOK(res1)) {
20963
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___getitem__" "', argument " "1"" of type '" "std::vector< double > const *""'");
20964
+ }
20965
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
20966
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
20967
+ if (!SWIG_IsOK(ecode2)) {
20968
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___getitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
20969
+ }
20970
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
20971
+ try {
20972
+ {
20973
+ std::vector< double >::value_type const &_result_ref = std_vector_Sl_double_Sg____getitem__((std::vector< double > const *)arg1,arg2);
20974
+ result = (std::vector< double >::value_type *) &_result_ref;
20975
+ }
20976
+ }
20977
+ catch(std::out_of_range &_e) {
20978
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
20979
+ }
20980
+
20981
+ resultobj = SWIG_From_double(static_cast< double >(*result));
20982
+ return resultobj;
20983
+fail:
20984
+ return NULL;
20985
+}
20986
+
20987
+
20988
+SWIGINTERN PyObject *_wrap_DoubleVector___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20989
+ PyObject *resultobj = 0;
20990
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
20991
+ std::vector< double >::difference_type arg2 ;
20992
+ std::vector< double >::value_type *arg3 = 0 ;
20993
+ void *argp1 = 0 ;
20994
+ int res1 = 0 ;
20995
+ ptrdiff_t val2 ;
20996
+ int ecode2 = 0 ;
20997
+ std::vector< double >::value_type temp3 ;
20998
+ double val3 ;
20999
+ int ecode3 = 0 ;
21000
+ PyObject * obj0 = 0 ;
21001
+ PyObject * obj1 = 0 ;
21002
+ PyObject * obj2 = 0 ;
21003
+
21004
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
21005
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21006
+ if (!SWIG_IsOK(res1)) {
21007
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
21008
+ }
21009
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21010
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
21011
+ if (!SWIG_IsOK(ecode2)) {
21012
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___setitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
21013
+ }
21014
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
21015
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
21016
+ if (!SWIG_IsOK(ecode3)) {
21017
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___setitem__" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
21018
+ }
21019
+ temp3 = static_cast< std::vector< double >::value_type >(val3);
21020
+ arg3 = &temp3;
21021
+ try {
21022
+ std_vector_Sl_double_Sg____setitem__(arg1,arg2,(double const &)*arg3);
21023
+ }
21024
+ catch(std::out_of_range &_e) {
21025
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
21026
+ }
21027
+
21028
+ resultobj = SWIG_Py_Void();
21029
+ return resultobj;
21030
+fail:
21031
+ return NULL;
21032
+}
21033
+
21034
+
21035
+SWIGINTERN PyObject *_wrap_DoubleVector_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21036
+ PyObject *resultobj = 0;
21037
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21038
+ std::vector< double >::value_type *arg2 = 0 ;
21039
+ void *argp1 = 0 ;
21040
+ int res1 = 0 ;
21041
+ std::vector< double >::value_type temp2 ;
21042
+ double val2 ;
21043
+ int ecode2 = 0 ;
21044
+ PyObject * obj0 = 0 ;
21045
+ PyObject * obj1 = 0 ;
21046
+
21047
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector_append",&obj0,&obj1)) SWIG_fail;
21048
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21049
+ if (!SWIG_IsOK(res1)) {
21050
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_append" "', argument " "1"" of type '" "std::vector< double > *""'");
21051
+ }
21052
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21053
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
21054
+ if (!SWIG_IsOK(ecode2)) {
21055
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_append" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
21056
+ }
21057
+ temp2 = static_cast< std::vector< double >::value_type >(val2);
21058
+ arg2 = &temp2;
21059
+ std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2);
21060
+ resultobj = SWIG_Py_Void();
21061
+ return resultobj;
21062
+fail:
21063
+ return NULL;
21064
+}
21065
+
21066
+
21067
+SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21068
+ PyObject *resultobj = 0;
21069
+ std::vector< double > *result = 0 ;
21070
+
21071
+ if (!PyArg_ParseTuple(args,(char *)":new_DoubleVector")) SWIG_fail;
21072
+ result = (std::vector< double > *)new std::vector< double >();
21073
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
21074
+ return resultobj;
21075
+fail:
21076
+ return NULL;
21077
+}
21078
+
21079
+
21080
+SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21081
+ PyObject *resultobj = 0;
21082
+ std::vector< double > *arg1 = 0 ;
21083
+ int res1 = SWIG_OLDOBJ ;
21084
+ PyObject * obj0 = 0 ;
21085
+ std::vector< double > *result = 0 ;
21086
+
21087
+ if (!PyArg_ParseTuple(args,(char *)"O:new_DoubleVector",&obj0)) SWIG_fail;
21088
+ {
21089
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
21090
+ res1 = swig::asptr(obj0, &ptr);
21091
+ if (!SWIG_IsOK(res1)) {
21092
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double > const &""'");
21093
+ }
21094
+ if (!ptr) {
21095
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double > const &""'");
21096
+ }
21097
+ arg1 = ptr;
21098
+ }
21099
+ result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
21100
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
21101
+ if (SWIG_IsNewObj(res1)) delete arg1;
21102
+ return resultobj;
21103
+fail:
21104
+ if (SWIG_IsNewObj(res1)) delete arg1;
21105
+ return NULL;
21106
+}
21107
+
21108
+
21109
+SWIGINTERN PyObject *_wrap_DoubleVector_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21110
+ PyObject *resultobj = 0;
21111
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21112
+ void *argp1 = 0 ;
21113
+ int res1 = 0 ;
21114
+ PyObject * obj0 = 0 ;
21115
+ bool result;
21116
+
21117
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_empty",&obj0)) SWIG_fail;
21118
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21119
+ if (!SWIG_IsOK(res1)) {
21120
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_empty" "', argument " "1"" of type '" "std::vector< double > const *""'");
21121
+ }
21122
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21123
+ result = (bool)((std::vector< double > const *)arg1)->empty();
21124
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
21125
+ return resultobj;
21126
+fail:
21127
+ return NULL;
21128
+}
21129
+
21130
+
21131
+SWIGINTERN PyObject *_wrap_DoubleVector_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21132
+ PyObject *resultobj = 0;
21133
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21134
+ void *argp1 = 0 ;
21135
+ int res1 = 0 ;
21136
+ PyObject * obj0 = 0 ;
21137
+ std::vector< double >::size_type result;
21138
+
21139
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_size",&obj0)) SWIG_fail;
21140
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21141
+ if (!SWIG_IsOK(res1)) {
21142
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_size" "', argument " "1"" of type '" "std::vector< double > const *""'");
21143
+ }
21144
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21145
+ result = ((std::vector< double > const *)arg1)->size();
21146
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21147
+ return resultobj;
21148
+fail:
21149
+ return NULL;
21150
+}
21151
+
21152
+
21153
+SWIGINTERN PyObject *_wrap_DoubleVector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21154
+ PyObject *resultobj = 0;
21155
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21156
+ void *argp1 = 0 ;
21157
+ int res1 = 0 ;
21158
+ PyObject * obj0 = 0 ;
21159
+
21160
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_clear",&obj0)) SWIG_fail;
21161
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21162
+ if (!SWIG_IsOK(res1)) {
21163
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_clear" "', argument " "1"" of type '" "std::vector< double > *""'");
21164
+ }
21165
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21166
+ (arg1)->clear();
21167
+ resultobj = SWIG_Py_Void();
21168
+ return resultobj;
21169
+fail:
21170
+ return NULL;
21171
+}
21172
+
21173
+
21174
+SWIGINTERN PyObject *_wrap_DoubleVector_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21175
+ PyObject *resultobj = 0;
21176
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21177
+ std::vector< double > *arg2 = 0 ;
21178
+ void *argp1 = 0 ;
21179
+ int res1 = 0 ;
21180
+ void *argp2 = 0 ;
21181
+ int res2 = 0 ;
21182
+ PyObject * obj0 = 0 ;
21183
+ PyObject * obj1 = 0 ;
21184
+
21185
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector_swap",&obj0,&obj1)) SWIG_fail;
21186
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21187
+ if (!SWIG_IsOK(res1)) {
21188
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_swap" "', argument " "1"" of type '" "std::vector< double > *""'");
21189
+ }
21190
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21191
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 );
21192
+ if (!SWIG_IsOK(res2)) {
21193
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleVector_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
21194
+ }
21195
+ if (!argp2) {
21196
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVector_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
21197
+ }
21198
+ arg2 = reinterpret_cast< std::vector< double > * >(argp2);
21199
+ (arg1)->swap(*arg2);
21200
+ resultobj = SWIG_Py_Void();
21201
+ return resultobj;
21202
+fail:
21203
+ return NULL;
21204
+}
21205
+
21206
+
21207
+SWIGINTERN PyObject *_wrap_DoubleVector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21208
+ PyObject *resultobj = 0;
21209
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21210
+ void *argp1 = 0 ;
21211
+ int res1 = 0 ;
21212
+ PyObject * obj0 = 0 ;
21213
+ SwigValueWrapper< std::allocator< double > > result;
21214
+
21215
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_get_allocator",&obj0)) SWIG_fail;
21216
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21217
+ if (!SWIG_IsOK(res1)) {
21218
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'");
21219
+ }
21220
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21221
+ result = ((std::vector< double > const *)arg1)->get_allocator();
21222
+ resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
21223
+ return resultobj;
21224
+fail:
21225
+ return NULL;
21226
+}
21227
+
21228
+
21229
+SWIGINTERN PyObject *_wrap_DoubleVector_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21230
+ PyObject *resultobj = 0;
21231
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21232
+ void *argp1 = 0 ;
21233
+ int res1 = 0 ;
21234
+ PyObject * obj0 = 0 ;
21235
+ std::vector< double >::const_iterator result;
21236
+
21237
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_begin",&obj0)) SWIG_fail;
21238
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21239
+ if (!SWIG_IsOK(res1)) {
21240
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_begin" "', argument " "1"" of type '" "std::vector< double > const *""'");
21241
+ }
21242
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21243
+ result = ((std::vector< double > const *)arg1)->begin();
21244
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_iterator & >(result)),
21245
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
21246
+ return resultobj;
21247
+fail:
21248
+ return NULL;
21249
+}
21250
+
21251
+
21252
+SWIGINTERN PyObject *_wrap_DoubleVector_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21253
+ PyObject *resultobj = 0;
21254
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21255
+ void *argp1 = 0 ;
21256
+ int res1 = 0 ;
21257
+ PyObject * obj0 = 0 ;
21258
+ std::vector< double >::const_iterator result;
21259
+
21260
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_end",&obj0)) SWIG_fail;
21261
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21262
+ if (!SWIG_IsOK(res1)) {
21263
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_end" "', argument " "1"" of type '" "std::vector< double > const *""'");
21264
+ }
21265
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21266
+ result = ((std::vector< double > const *)arg1)->end();
21267
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_iterator & >(result)),
21268
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
21269
+ return resultobj;
21270
+fail:
21271
+ return NULL;
21272
+}
21273
+
21274
+
21275
+SWIGINTERN PyObject *_wrap_DoubleVector_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21276
+ PyObject *resultobj = 0;
21277
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21278
+ void *argp1 = 0 ;
21279
+ int res1 = 0 ;
21280
+ PyObject * obj0 = 0 ;
21281
+ std::vector< double >::const_reverse_iterator result;
21282
+
21283
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_rbegin",&obj0)) SWIG_fail;
21284
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21285
+ if (!SWIG_IsOK(res1)) {
21286
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_rbegin" "', argument " "1"" of type '" "std::vector< double > const *""'");
21287
+ }
21288
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21289
+ result = ((std::vector< double > const *)arg1)->rbegin();
21290
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_reverse_iterator & >(result)),
21291
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
21292
+ return resultobj;
21293
+fail:
21294
+ return NULL;
21295
+}
21296
+
21297
+
21298
+SWIGINTERN PyObject *_wrap_DoubleVector_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21299
+ PyObject *resultobj = 0;
21300
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21301
+ void *argp1 = 0 ;
21302
+ int res1 = 0 ;
21303
+ PyObject * obj0 = 0 ;
21304
+ std::vector< double >::const_reverse_iterator result;
21305
+
21306
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_rend",&obj0)) SWIG_fail;
21307
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21308
+ if (!SWIG_IsOK(res1)) {
21309
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_rend" "', argument " "1"" of type '" "std::vector< double > const *""'");
21310
+ }
21311
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21312
+ result = ((std::vector< double > const *)arg1)->rend();
21313
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_reverse_iterator & >(result)),
21314
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
21315
+ return resultobj;
21316
+fail:
21317
+ return NULL;
21318
+}
21319
+
21320
+
21321
+SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21322
+ PyObject *resultobj = 0;
21323
+ std::vector< double >::size_type arg1 ;
21324
+ size_t val1 ;
21325
+ int ecode1 = 0 ;
21326
+ PyObject * obj0 = 0 ;
21327
+ std::vector< double > *result = 0 ;
21328
+
21329
+ if (!PyArg_ParseTuple(args,(char *)"O:new_DoubleVector",&obj0)) SWIG_fail;
21330
+ ecode1 = SWIG_AsVal_size_t(obj0, &val1);
21331
+ if (!SWIG_IsOK(ecode1)) {
21332
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
21333
+ }
21334
+ arg1 = static_cast< std::vector< double >::size_type >(val1);
21335
+ result = (std::vector< double > *)new std::vector< double >(arg1);
21336
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
21337
+ return resultobj;
21338
+fail:
21339
+ return NULL;
21340
+}
21341
+
21342
+
21343
+SWIGINTERN PyObject *_wrap_DoubleVector_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21344
+ PyObject *resultobj = 0;
21345
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21346
+ void *argp1 = 0 ;
21347
+ int res1 = 0 ;
21348
+ PyObject * obj0 = 0 ;
21349
+
21350
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_pop_back",&obj0)) SWIG_fail;
21351
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21352
+ if (!SWIG_IsOK(res1)) {
21353
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_pop_back" "', argument " "1"" of type '" "std::vector< double > *""'");
21354
+ }
21355
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21356
+ (arg1)->pop_back();
21357
+ resultobj = SWIG_Py_Void();
21358
+ return resultobj;
21359
+fail:
21360
+ return NULL;
21361
+}
21362
+
21363
+
21364
+SWIGINTERN PyObject *_wrap_DoubleVector_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21365
+ PyObject *resultobj = 0;
21366
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21367
+ std::vector< double >::size_type arg2 ;
21368
+ void *argp1 = 0 ;
21369
+ int res1 = 0 ;
21370
+ size_t val2 ;
21371
+ int ecode2 = 0 ;
21372
+ PyObject * obj0 = 0 ;
21373
+ PyObject * obj1 = 0 ;
21374
+
21375
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector_resize",&obj0,&obj1)) SWIG_fail;
21376
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21377
+ if (!SWIG_IsOK(res1)) {
21378
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
21379
+ }
21380
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21381
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
21382
+ if (!SWIG_IsOK(ecode2)) {
21383
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
21384
+ }
21385
+ arg2 = static_cast< std::vector< double >::size_type >(val2);
21386
+ (arg1)->resize(arg2);
21387
+ resultobj = SWIG_Py_Void();
21388
+ return resultobj;
21389
+fail:
21390
+ return NULL;
21391
+}
21392
+
21393
+
21394
+SWIGINTERN PyObject *_wrap_DoubleVector_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21395
+ PyObject *resultobj = 0;
21396
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21397
+ std::vector< double >::iterator arg2 ;
21398
+ void *argp1 = 0 ;
21399
+ int res1 = 0 ;
21400
+ swig::PySwigIterator *iter2 = 0 ;
21401
+ int res2 ;
21402
+ PyObject * obj0 = 0 ;
21403
+ PyObject * obj1 = 0 ;
21404
+ std::vector< double >::iterator result;
21405
+
21406
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector_erase",&obj0,&obj1)) SWIG_fail;
21407
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21408
+ if (!SWIG_IsOK(res1)) {
21409
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
21410
+ }
21411
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21412
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
21413
+ if (!SWIG_IsOK(res2) || !iter2) {
21414
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
21415
+ } else {
21416
+ swig::PySwigIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter2);
21417
+ if (iter_t) {
21418
+ arg2 = iter_t->get_current();
21419
+ } else {
21420
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
21421
+ }
21422
+ }
21423
+ result = (arg1)->erase(arg2);
21424
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
21425
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
21426
+ return resultobj;
21427
+fail:
21428
+ return NULL;
21429
+}
21430
+
21431
+
21432
+SWIGINTERN PyObject *_wrap_DoubleVector_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21433
+ PyObject *resultobj = 0;
21434
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21435
+ std::vector< double >::iterator arg2 ;
21436
+ std::vector< double >::iterator arg3 ;
21437
+ void *argp1 = 0 ;
21438
+ int res1 = 0 ;
21439
+ swig::PySwigIterator *iter2 = 0 ;
21440
+ int res2 ;
21441
+ swig::PySwigIterator *iter3 = 0 ;
21442
+ int res3 ;
21443
+ PyObject * obj0 = 0 ;
21444
+ PyObject * obj1 = 0 ;
21445
+ PyObject * obj2 = 0 ;
21446
+ std::vector< double >::iterator result;
21447
+
21448
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVector_erase",&obj0,&obj1,&obj2)) SWIG_fail;
21449
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21450
+ if (!SWIG_IsOK(res1)) {
21451
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
21452
+ }
21453
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21454
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
21455
+ if (!SWIG_IsOK(res2) || !iter2) {
21456
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
21457
+ } else {
21458
+ swig::PySwigIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter2);
21459
+ if (iter_t) {
21460
+ arg2 = iter_t->get_current();
21461
+ } else {
21462
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
21463
+ }
21464
+ }
21465
+ res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
21466
+ if (!SWIG_IsOK(res3) || !iter3) {
21467
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
21468
+ } else {
21469
+ swig::PySwigIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter3);
21470
+ if (iter_t) {
21471
+ arg3 = iter_t->get_current();
21472
+ } else {
21473
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
21474
+ }
21475
+ }
21476
+ result = (arg1)->erase(arg2,arg3);
21477
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
21478
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
21479
+ return resultobj;
21480
+fail:
21481
+ return NULL;
21482
+}
21483
+
21484
+
21485
+SWIGINTERN PyObject *_wrap_DoubleVector_erase(PyObject *self, PyObject *args) {
21486
+ int argc;
21487
+ PyObject *argv[4];
21488
+ int ii;
21489
+
21490
+ if (!PyTuple_Check(args)) SWIG_fail;
21491
+ argc = (int)PyObject_Length(args);
21492
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
21493
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
21494
+ }
21495
+ if (argc == 2) {
21496
+ int _v;
21497
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
21498
+ _v = SWIG_CheckState(res);
21499
+ if (_v) {
21500
+ swig::PySwigIterator *iter = 0;
21501
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
21502
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter) != 0));
21503
+ if (_v) {
21504
+ return _wrap_DoubleVector_erase__SWIG_0(self, args);
21505
+ }
21506
+ }
21507
+ }
21508
+ if (argc == 3) {
21509
+ int _v;
21510
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
21511
+ _v = SWIG_CheckState(res);
21512
+ if (_v) {
21513
+ swig::PySwigIterator *iter = 0;
21514
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
21515
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter) != 0));
21516
+ if (_v) {
21517
+ swig::PySwigIterator *iter = 0;
21518
+ int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
21519
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter) != 0));
21520
+ if (_v) {
21521
+ return _wrap_DoubleVector_erase__SWIG_1(self, args);
21522
+ }
21523
+ }
21524
+ }
21525
+ }
21526
+
21527
+fail:
21528
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'DoubleVector_erase'.\n"
21529
+ " Possible C/C++ prototypes are:\n"
21530
+ " erase(std::vector< double > *,std::vector< double >::iterator)\n"
21531
+ " erase(std::vector< double > *,std::vector< double >::iterator,std::vector< double >::iterator)\n");
21532
+ return NULL;
21533
+}
21534
+
21535
+
21536
+SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21537
+ PyObject *resultobj = 0;
21538
+ std::vector< double >::size_type arg1 ;
21539
+ std::vector< double >::value_type *arg2 = 0 ;
21540
+ size_t val1 ;
21541
+ int ecode1 = 0 ;
21542
+ std::vector< double >::value_type temp2 ;
21543
+ double val2 ;
21544
+ int ecode2 = 0 ;
21545
+ PyObject * obj0 = 0 ;
21546
+ PyObject * obj1 = 0 ;
21547
+ std::vector< double > *result = 0 ;
21548
+
21549
+ if (!PyArg_ParseTuple(args,(char *)"OO:new_DoubleVector",&obj0,&obj1)) SWIG_fail;
21550
+ ecode1 = SWIG_AsVal_size_t(obj0, &val1);
21551
+ if (!SWIG_IsOK(ecode1)) {
21552
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
21553
+ }
21554
+ arg1 = static_cast< std::vector< double >::size_type >(val1);
21555
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
21556
+ if (!SWIG_IsOK(ecode2)) {
21557
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleVector" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
21558
+ }
21559
+ temp2 = static_cast< std::vector< double >::value_type >(val2);
21560
+ arg2 = &temp2;
21561
+ result = (std::vector< double > *)new std::vector< double >(arg1,(std::vector< double >::value_type const &)*arg2);
21562
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
21563
+ return resultobj;
21564
+fail:
21565
+ return NULL;
21566
+}
21567
+
21568
+
21569
+SWIGINTERN PyObject *_wrap_new_DoubleVector(PyObject *self, PyObject *args) {
21570
+ int argc;
21571
+ PyObject *argv[3];
21572
+ int ii;
21573
+
21574
+ if (!PyTuple_Check(args)) SWIG_fail;
21575
+ argc = (int)PyObject_Length(args);
21576
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
21577
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
21578
+ }
21579
+ if (argc == 0) {
21580
+ return _wrap_new_DoubleVector__SWIG_0(self, args);
21581
+ }
21582
+ if (argc == 1) {
21583
+ int _v;
21584
+ {
21585
+ int res = SWIG_AsVal_size_t(argv[0], NULL);
21586
+ _v = SWIG_CheckState(res);
21587
+ }
21588
+ if (_v) {
21589
+ return _wrap_new_DoubleVector__SWIG_2(self, args);
21590
+ }
21591
+ }
21592
+ if (argc == 1) {
21593
+ int _v;
21594
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
21595
+ _v = SWIG_CheckState(res);
21596
+ if (_v) {
21597
+ return _wrap_new_DoubleVector__SWIG_1(self, args);
21598
+ }
21599
+ }
21600
+ if (argc == 2) {
21601
+ int _v;
21602
+ {
21603
+ int res = SWIG_AsVal_size_t(argv[0], NULL);
21604
+ _v = SWIG_CheckState(res);
21605
+ }
21606
+ if (_v) {
21607
+ {
21608
+ int res = SWIG_AsVal_double(argv[1], NULL);
21609
+ _v = SWIG_CheckState(res);
21610
+ }
21611
+ if (_v) {
21612
+ return _wrap_new_DoubleVector__SWIG_3(self, args);
21613
+ }
21614
+ }
21615
+ }
21616
+
21617
+fail:
21618
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DoubleVector'.\n"
21619
+ " Possible C/C++ prototypes are:\n"
21620
+ " std::vector< double >()\n"
21621
+ " std::vector< double >(std::vector< double > const &)\n"
21622
+ " std::vector< double >(std::vector< double >::size_type)\n"
21623
+ " std::vector< double >(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
21624
+ return NULL;
21625
+}
21626
+
21627
+
21628
+SWIGINTERN PyObject *_wrap_DoubleVector_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21629
+ PyObject *resultobj = 0;
21630
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21631
+ std::vector< double >::value_type *arg2 = 0 ;
21632
+ void *argp1 = 0 ;
21633
+ int res1 = 0 ;
21634
+ std::vector< double >::value_type temp2 ;
21635
+ double val2 ;
21636
+ int ecode2 = 0 ;
21637
+ PyObject * obj0 = 0 ;
21638
+ PyObject * obj1 = 0 ;
21639
+
21640
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector_push_back",&obj0,&obj1)) SWIG_fail;
21641
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21642
+ if (!SWIG_IsOK(res1)) {
21643
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_push_back" "', argument " "1"" of type '" "std::vector< double > *""'");
21644
+ }
21645
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21646
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
21647
+ if (!SWIG_IsOK(ecode2)) {
21648
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_push_back" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
21649
+ }
21650
+ temp2 = static_cast< std::vector< double >::value_type >(val2);
21651
+ arg2 = &temp2;
21652
+ (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
21653
+ resultobj = SWIG_Py_Void();
21654
+ return resultobj;
21655
+fail:
21656
+ return NULL;
21657
+}
21658
+
21659
+
21660
+SWIGINTERN PyObject *_wrap_DoubleVector_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21661
+ PyObject *resultobj = 0;
21662
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21663
+ void *argp1 = 0 ;
21664
+ int res1 = 0 ;
21665
+ PyObject * obj0 = 0 ;
21666
+ std::vector< double >::value_type *result = 0 ;
21667
+
21668
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_front",&obj0)) SWIG_fail;
21669
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21670
+ if (!SWIG_IsOK(res1)) {
21671
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_front" "', argument " "1"" of type '" "std::vector< double > const *""'");
21672
+ }
21673
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21674
+ {
21675
+ std::vector< double >::value_type const &_result_ref = ((std::vector< double > const *)arg1)->front();
21676
+ result = (std::vector< double >::value_type *) &_result_ref;
21677
+ }
21678
+ resultobj = SWIG_From_double(static_cast< double >(*result));
21679
+ return resultobj;
21680
+fail:
21681
+ return NULL;
21682
+}
21683
+
21684
+
21685
+SWIGINTERN PyObject *_wrap_DoubleVector_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21686
+ PyObject *resultobj = 0;
21687
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21688
+ void *argp1 = 0 ;
21689
+ int res1 = 0 ;
21690
+ PyObject * obj0 = 0 ;
21691
+ std::vector< double >::value_type *result = 0 ;
21692
+
21693
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_back",&obj0)) SWIG_fail;
21694
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21695
+ if (!SWIG_IsOK(res1)) {
21696
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_back" "', argument " "1"" of type '" "std::vector< double > const *""'");
21697
+ }
21698
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21699
+ {
21700
+ std::vector< double >::value_type const &_result_ref = ((std::vector< double > const *)arg1)->back();
21701
+ result = (std::vector< double >::value_type *) &_result_ref;
21702
+ }
21703
+ resultobj = SWIG_From_double(static_cast< double >(*result));
21704
+ return resultobj;
21705
+fail:
21706
+ return NULL;
21707
+}
21708
+
21709
+
21710
+SWIGINTERN PyObject *_wrap_DoubleVector_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21711
+ PyObject *resultobj = 0;
21712
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21713
+ std::vector< double >::size_type arg2 ;
21714
+ std::vector< double >::value_type *arg3 = 0 ;
21715
+ void *argp1 = 0 ;
21716
+ int res1 = 0 ;
21717
+ size_t val2 ;
21718
+ int ecode2 = 0 ;
21719
+ std::vector< double >::value_type temp3 ;
21720
+ double val3 ;
21721
+ int ecode3 = 0 ;
21722
+ PyObject * obj0 = 0 ;
21723
+ PyObject * obj1 = 0 ;
21724
+ PyObject * obj2 = 0 ;
21725
+
21726
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVector_assign",&obj0,&obj1,&obj2)) SWIG_fail;
21727
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21728
+ if (!SWIG_IsOK(res1)) {
21729
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_assign" "', argument " "1"" of type '" "std::vector< double > *""'");
21730
+ }
21731
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21732
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
21733
+ if (!SWIG_IsOK(ecode2)) {
21734
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_assign" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
21735
+ }
21736
+ arg2 = static_cast< std::vector< double >::size_type >(val2);
21737
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
21738
+ if (!SWIG_IsOK(ecode3)) {
21739
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_assign" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
21740
+ }
21741
+ temp3 = static_cast< std::vector< double >::value_type >(val3);
21742
+ arg3 = &temp3;
21743
+ (arg1)->assign(arg2,(std::vector< double >::value_type const &)*arg3);
21744
+ resultobj = SWIG_Py_Void();
21745
+ return resultobj;
21746
+fail:
21747
+ return NULL;
21748
+}
21749
+
21750
+
21751
+SWIGINTERN PyObject *_wrap_DoubleVector_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21752
+ PyObject *resultobj = 0;
21753
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21754
+ std::vector< double >::size_type arg2 ;
21755
+ std::vector< double >::value_type *arg3 = 0 ;
21756
+ void *argp1 = 0 ;
21757
+ int res1 = 0 ;
21758
+ size_t val2 ;
21759
+ int ecode2 = 0 ;
21760
+ std::vector< double >::value_type temp3 ;
21761
+ double val3 ;
21762
+ int ecode3 = 0 ;
21763
+ PyObject * obj0 = 0 ;
21764
+ PyObject * obj1 = 0 ;
21765
+ PyObject * obj2 = 0 ;
21766
+
21767
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVector_resize",&obj0,&obj1,&obj2)) SWIG_fail;
21768
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21769
+ if (!SWIG_IsOK(res1)) {
21770
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
21771
+ }
21772
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21773
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
21774
+ if (!SWIG_IsOK(ecode2)) {
21775
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
21776
+ }
21777
+ arg2 = static_cast< std::vector< double >::size_type >(val2);
21778
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
21779
+ if (!SWIG_IsOK(ecode3)) {
21780
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_resize" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
21781
+ }
21782
+ temp3 = static_cast< std::vector< double >::value_type >(val3);
21783
+ arg3 = &temp3;
21784
+ (arg1)->resize(arg2,(std::vector< double >::value_type const &)*arg3);
21785
+ resultobj = SWIG_Py_Void();
21786
+ return resultobj;
21787
+fail:
21788
+ return NULL;
21789
+}
21790
+
21791
+
21792
+SWIGINTERN PyObject *_wrap_DoubleVector_resize(PyObject *self, PyObject *args) {
21793
+ int argc;
21794
+ PyObject *argv[4];
21795
+ int ii;
21796
+
21797
+ if (!PyTuple_Check(args)) SWIG_fail;
21798
+ argc = (int)PyObject_Length(args);
21799
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
21800
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
21801
+ }
21802
+ if (argc == 2) {
21803
+ int _v;
21804
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
21805
+ _v = SWIG_CheckState(res);
21806
+ if (_v) {
21807
+ {
21808
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
21809
+ _v = SWIG_CheckState(res);
21810
+ }
21811
+ if (_v) {
21812
+ return _wrap_DoubleVector_resize__SWIG_0(self, args);
21813
+ }
21814
+ }
21815
+ }
21816
+ if (argc == 3) {
21817
+ int _v;
21818
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
21819
+ _v = SWIG_CheckState(res);
21820
+ if (_v) {
21821
+ {
21822
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
21823
+ _v = SWIG_CheckState(res);
21824
+ }
21825
+ if (_v) {
21826
+ {
21827
+ int res = SWIG_AsVal_double(argv[2], NULL);
21828
+ _v = SWIG_CheckState(res);
21829
+ }
21830
+ if (_v) {
21831
+ return _wrap_DoubleVector_resize__SWIG_1(self, args);
21832
+ }
21833
+ }
21834
+ }
21835
+ }
21836
+
21837
+fail:
21838
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'DoubleVector_resize'.\n"
21839
+ " Possible C/C++ prototypes are:\n"
21840
+ " resize(std::vector< double > *,std::vector< double >::size_type)\n"
21841
+ " resize(std::vector< double > *,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
21842
+ return NULL;
21843
+}
21844
+
21845
+
21846
+SWIGINTERN PyObject *_wrap_DoubleVector_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21847
+ PyObject *resultobj = 0;
21848
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21849
+ std::vector< double >::iterator arg2 ;
21850
+ std::vector< double >::value_type *arg3 = 0 ;
21851
+ void *argp1 = 0 ;
21852
+ int res1 = 0 ;
21853
+ swig::PySwigIterator *iter2 = 0 ;
21854
+ int res2 ;
21855
+ std::vector< double >::value_type temp3 ;
21856
+ double val3 ;
21857
+ int ecode3 = 0 ;
21858
+ PyObject * obj0 = 0 ;
21859
+ PyObject * obj1 = 0 ;
21860
+ PyObject * obj2 = 0 ;
21861
+ std::vector< double >::iterator result;
21862
+
21863
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVector_insert",&obj0,&obj1,&obj2)) SWIG_fail;
21864
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21865
+ if (!SWIG_IsOK(res1)) {
21866
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
21867
+ }
21868
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21869
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
21870
+ if (!SWIG_IsOK(res2) || !iter2) {
21871
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
21872
+ } else {
21873
+ swig::PySwigIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter2);
21874
+ if (iter_t) {
21875
+ arg2 = iter_t->get_current();
21876
+ } else {
21877
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
21878
+ }
21879
+ }
21880
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
21881
+ if (!SWIG_IsOK(ecode3)) {
21882
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_insert" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
21883
+ }
21884
+ temp3 = static_cast< std::vector< double >::value_type >(val3);
21885
+ arg3 = &temp3;
21886
+ result = (arg1)->insert(arg2,(std::vector< double >::value_type const &)*arg3);
21887
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
21888
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
21889
+ return resultobj;
21890
+fail:
21891
+ return NULL;
21892
+}
21893
+
21894
+
21895
+SWIGINTERN PyObject *_wrap_DoubleVector_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21896
+ PyObject *resultobj = 0;
21897
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
21898
+ std::vector< double >::iterator arg2 ;
21899
+ std::vector< double >::size_type arg3 ;
21900
+ std::vector< double >::value_type *arg4 = 0 ;
21901
+ void *argp1 = 0 ;
21902
+ int res1 = 0 ;
21903
+ swig::PySwigIterator *iter2 = 0 ;
21904
+ int res2 ;
21905
+ size_t val3 ;
21906
+ int ecode3 = 0 ;
21907
+ std::vector< double >::value_type temp4 ;
21908
+ double val4 ;
21909
+ int ecode4 = 0 ;
21910
+ PyObject * obj0 = 0 ;
21911
+ PyObject * obj1 = 0 ;
21912
+ PyObject * obj2 = 0 ;
21913
+ PyObject * obj3 = 0 ;
21914
+
21915
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:DoubleVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21916
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
21917
+ if (!SWIG_IsOK(res1)) {
21918
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
21919
+ }
21920
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
21921
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
21922
+ if (!SWIG_IsOK(res2) || !iter2) {
21923
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
21924
+ } else {
21925
+ swig::PySwigIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter2);
21926
+ if (iter_t) {
21927
+ arg2 = iter_t->get_current();
21928
+ } else {
21929
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
21930
+ }
21931
+ }
21932
+ ecode3 = SWIG_AsVal_size_t(obj2, &val3);
21933
+ if (!SWIG_IsOK(ecode3)) {
21934
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_insert" "', argument " "3"" of type '" "std::vector< double >::size_type""'");
21935
+ }
21936
+ arg3 = static_cast< std::vector< double >::size_type >(val3);
21937
+ ecode4 = SWIG_AsVal_double(obj3, &val4);
21938
+ if (!SWIG_IsOK(ecode4)) {
21939
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleVector_insert" "', argument " "4"" of type '" "std::vector< double >::value_type""'");
21940
+ }
21941
+ temp4 = static_cast< std::vector< double >::value_type >(val4);
21942
+ arg4 = &temp4;
21943
+ (arg1)->insert(arg2,arg3,(std::vector< double >::value_type const &)*arg4);
21944
+ resultobj = SWIG_Py_Void();
21945
+ return resultobj;
21946
+fail:
21947
+ return NULL;
21948
+}
21949
+
21950
+
21951
+SWIGINTERN PyObject *_wrap_DoubleVector_insert(PyObject *self, PyObject *args) {
21952
+ int argc;
21953
+ PyObject *argv[5];
21954
+ int ii;
21955
+
21956
+ if (!PyTuple_Check(args)) SWIG_fail;
21957
+ argc = (int)PyObject_Length(args);
21958
+ for (ii = 0; (ii < argc) && (ii < 4); ii++) {
21959
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
21960
+ }
21961
+ if (argc == 3) {
21962
+ int _v;
21963
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
21964
+ _v = SWIG_CheckState(res);
21965
+ if (_v) {
21966
+ swig::PySwigIterator *iter = 0;
21967
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
21968
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter) != 0));
21969
+ if (_v) {
21970
+ {
21971
+ int res = SWIG_AsVal_double(argv[2], NULL);
21972
+ _v = SWIG_CheckState(res);
21973
+ }
21974
+ if (_v) {
21975
+ return _wrap_DoubleVector_insert__SWIG_0(self, args);
21976
+ }
21977
+ }
21978
+ }
21979
+ }
21980
+ if (argc == 4) {
21981
+ int _v;
21982
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
21983
+ _v = SWIG_CheckState(res);
21984
+ if (_v) {
21985
+ swig::PySwigIterator *iter = 0;
21986
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
21987
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< double >::iterator > *>(iter) != 0));
21988
+ if (_v) {
21989
+ {
21990
+ int res = SWIG_AsVal_size_t(argv[2], NULL);
21991
+ _v = SWIG_CheckState(res);
21992
+ }
21993
+ if (_v) {
21994
+ {
21995
+ int res = SWIG_AsVal_double(argv[3], NULL);
21996
+ _v = SWIG_CheckState(res);
21997
+ }
21998
+ if (_v) {
21999
+ return _wrap_DoubleVector_insert__SWIG_1(self, args);
22000
+ }
22001
+ }
22002
+ }
22003
+ }
22004
+ }
22005
+
22006
+fail:
22007
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'DoubleVector_insert'.\n"
22008
+ " Possible C/C++ prototypes are:\n"
22009
+ " insert(std::vector< double > *,std::vector< double >::iterator,std::vector< double >::value_type const &)\n"
22010
+ " insert(std::vector< double > *,std::vector< double >::iterator,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
22011
+ return NULL;
22012
+}
22013
+
22014
+
22015
+SWIGINTERN PyObject *_wrap_DoubleVector_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22016
+ PyObject *resultobj = 0;
22017
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
22018
+ std::vector< double >::size_type arg2 ;
22019
+ void *argp1 = 0 ;
22020
+ int res1 = 0 ;
22021
+ size_t val2 ;
22022
+ int ecode2 = 0 ;
22023
+ PyObject * obj0 = 0 ;
22024
+ PyObject * obj1 = 0 ;
22025
+
22026
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVector_reserve",&obj0,&obj1)) SWIG_fail;
22027
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
22028
+ if (!SWIG_IsOK(res1)) {
22029
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_reserve" "', argument " "1"" of type '" "std::vector< double > *""'");
22030
+ }
22031
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
22032
+ ecode2 = SWIG_AsVal_size_t(obj1, &val2);
22033
+ if (!SWIG_IsOK(ecode2)) {
22034
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_reserve" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
22035
+ }
22036
+ arg2 = static_cast< std::vector< double >::size_type >(val2);
22037
+ (arg1)->reserve(arg2);
22038
+ resultobj = SWIG_Py_Void();
22039
+ return resultobj;
22040
+fail:
22041
+ return NULL;
22042
+}
22043
+
22044
+
22045
+SWIGINTERN PyObject *_wrap_DoubleVector_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22046
+ PyObject *resultobj = 0;
22047
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
22048
+ void *argp1 = 0 ;
22049
+ int res1 = 0 ;
22050
+ PyObject * obj0 = 0 ;
22051
+ std::vector< double >::size_type result;
22052
+
22053
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVector_capacity",&obj0)) SWIG_fail;
22054
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
22055
+ if (!SWIG_IsOK(res1)) {
22056
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_capacity" "', argument " "1"" of type '" "std::vector< double > const *""'");
22057
+ }
22058
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
22059
+ result = ((std::vector< double > const *)arg1)->capacity();
22060
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
22061
+ return resultobj;
22062
+fail:
22063
+ return NULL;
22064
+}
22065
+
22066
+
22067
+SWIGINTERN PyObject *_wrap_delete_DoubleVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22068
+ PyObject *resultobj = 0;
22069
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
22070
+ void *argp1 = 0 ;
22071
+ int res1 = 0 ;
22072
+ PyObject * obj0 = 0 ;
22073
+
22074
+ if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleVector",&obj0)) SWIG_fail;
22075
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_DISOWN | 0 );
22076
+ if (!SWIG_IsOK(res1)) {
22077
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleVector" "', argument " "1"" of type '" "std::vector< double > *""'");
22078
+ }
22079
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
22080
+ delete arg1;
22081
+ resultobj = SWIG_Py_Void();
22082
+ return resultobj;
22083
+fail:
22084
+ return NULL;
22085
+}
22086
+
22087
+
22088
+SWIGINTERN PyObject *DoubleVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22089
+ PyObject *obj;
22090
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
22091
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_NewClientData(obj));
22092
+ return SWIG_Py_Void();
22093
+}
22094
+
22095
+SWIGINTERN PyObject *_wrap_new_IntVecIntMap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22096
+ PyObject *resultobj = 0;
22097
+ std::less< int > *arg1 = 0 ;
22098
+ void *argp1 = 0 ;
22099
+ int res1 = 0 ;
22100
+ PyObject * obj0 = 0 ;
22101
+ std::map< int,std::vector< int > > *result = 0 ;
22102
+
22103
+ if (!PyArg_ParseTuple(args,(char *)"O:new_IntVecIntMap",&obj0)) SWIG_fail;
22104
+ res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_int_t, 0 | 0);
22105
+ if (!SWIG_IsOK(res1)) {
22106
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntVecIntMap" "', argument " "1"" of type '" "std::less< int > const &""'");
22107
+ }
22108
+ if (!argp1) {
22109
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntVecIntMap" "', argument " "1"" of type '" "std::less< int > const &""'");
22110
+ }
22111
+ arg1 = reinterpret_cast< std::less< int > * >(argp1);
22112
+ result = (std::map< int,std::vector< int > > *)new std::map< int,std::vector< int > >((std::less< int > const &)*arg1);
22113
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, SWIG_POINTER_NEW | 0 );
22114
+ return resultobj;
22115
+fail:
22116
+ return NULL;
22117
+}
22118
+
22119
+
22120
+SWIGINTERN PyObject *_wrap_IntVecIntMap_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22121
+ PyObject *resultobj = 0;
22122
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22123
+ PyObject **arg2 = (PyObject **) 0 ;
22124
+ void *argp1 = 0 ;
22125
+ int res1 = 0 ;
22126
+ PyObject * obj0 = 0 ;
22127
+ swig::PySwigIterator *result = 0 ;
22128
+
22129
+ arg2 = &obj0;
22130
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_iterator",&obj0)) SWIG_fail;
22131
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22132
+ if (!SWIG_IsOK(res1)) {
22133
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_iterator" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
22134
+ }
22135
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22136
+ result = (swig::PySwigIterator *)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__iterator(arg1,arg2);
22137
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
22138
+ return resultobj;
22139
+fail:
22140
+ return NULL;
22141
+}
22142
+
22143
+
22144
+SWIGINTERN PyObject *_wrap_IntVecIntMap___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22145
+ PyObject *resultobj = 0;
22146
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22147
+ void *argp1 = 0 ;
22148
+ int res1 = 0 ;
22149
+ PyObject * obj0 = 0 ;
22150
+ bool result;
22151
+
22152
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap___nonzero__",&obj0)) SWIG_fail;
22153
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22154
+ if (!SWIG_IsOK(res1)) {
22155
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap___nonzero__" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
22156
+ }
22157
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22158
+ result = (bool)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____nonzero__((std::map< int,std::vector< int > > const *)arg1);
22159
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
22160
+ return resultobj;
22161
+fail:
22162
+ return NULL;
22163
+}
22164
+
22165
+
22166
+SWIGINTERN PyObject *_wrap_IntVecIntMap___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22167
+ PyObject *resultobj = 0;
22168
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22169
+ void *argp1 = 0 ;
22170
+ int res1 = 0 ;
22171
+ PyObject * obj0 = 0 ;
22172
+ std::map< int,std::vector< int > >::size_type result;
22173
+
22174
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap___len__",&obj0)) SWIG_fail;
22175
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22176
+ if (!SWIG_IsOK(res1)) {
22177
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap___len__" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
22178
+ }
22179
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22180
+ result = std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____len__((std::map< int,std::vector< int > > const *)arg1);
22181
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
22182
+ return resultobj;
22183
+fail:
22184
+ return NULL;
22185
+}
22186
+
22187
+
22188
+SWIGINTERN PyObject *_wrap_IntVecIntMap___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22189
+ PyObject *resultobj = 0;
22190
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22191
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
22192
+ void *argp1 = 0 ;
22193
+ int res1 = 0 ;
22194
+ std::map< int,std::vector< int > >::key_type temp2 ;
22195
+ int val2 ;
22196
+ int ecode2 = 0 ;
22197
+ PyObject * obj0 = 0 ;
22198
+ PyObject * obj1 = 0 ;
22199
+ std::map< int,std::vector< int > >::mapped_type result;
22200
+
22201
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap___getitem__",&obj0,&obj1)) SWIG_fail;
22202
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22203
+ if (!SWIG_IsOK(res1)) {
22204
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap___getitem__" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
22205
+ }
22206
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22207
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
22208
+ if (!SWIG_IsOK(ecode2)) {
22209
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap___getitem__" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
22210
+ }
22211
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
22212
+ arg2 = &temp2;
22213
+ try {
22214
+ result = std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____getitem__((std::map< int,std::vector< int > > const *)arg1,(int const &)*arg2);
22215
+ }
22216
+ catch(std::out_of_range &_e) {
22217
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
22218
+ }
22219
+
22220
+ resultobj = swig::from(static_cast< std::vector<int,std::allocator< int > > >(result));
22221
+ return resultobj;
22222
+fail:
22223
+ return NULL;
22224
+}
22225
+
22226
+
22227
+SWIGINTERN PyObject *_wrap_IntVecIntMap___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22228
+ PyObject *resultobj = 0;
22229
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22230
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
22231
+ void *argp1 = 0 ;
22232
+ int res1 = 0 ;
22233
+ std::map< int,std::vector< int > >::key_type temp2 ;
22234
+ int val2 ;
22235
+ int ecode2 = 0 ;
22236
+ PyObject * obj0 = 0 ;
22237
+ PyObject * obj1 = 0 ;
22238
+
22239
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap___delitem__",&obj0,&obj1)) SWIG_fail;
22240
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22241
+ if (!SWIG_IsOK(res1)) {
22242
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap___delitem__" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
22243
+ }
22244
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22245
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
22246
+ if (!SWIG_IsOK(ecode2)) {
22247
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap___delitem__" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
22248
+ }
22249
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
22250
+ arg2 = &temp2;
22251
+ try {
22252
+ std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____delitem__(arg1,(int const &)*arg2);
22253
+ }
22254
+ catch(std::out_of_range &_e) {
22255
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
22256
+ }
22257
+
22258
+ resultobj = SWIG_Py_Void();
22259
+ return resultobj;
22260
+fail:
22261
+ return NULL;
22262
+}
22263
+
22264
+
22265
+SWIGINTERN PyObject *_wrap_IntVecIntMap_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22266
+ PyObject *resultobj = 0;
22267
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22268
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
22269
+ void *argp1 = 0 ;
22270
+ int res1 = 0 ;
22271
+ std::map< int,std::vector< int > >::key_type temp2 ;
22272
+ int val2 ;
22273
+ int ecode2 = 0 ;
22274
+ PyObject * obj0 = 0 ;
22275
+ PyObject * obj1 = 0 ;
22276
+ bool result;
22277
+
22278
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_has_key",&obj0,&obj1)) SWIG_fail;
22279
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22280
+ if (!SWIG_IsOK(res1)) {
22281
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_has_key" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
22282
+ }
22283
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22284
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
22285
+ if (!SWIG_IsOK(ecode2)) {
22286
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap_has_key" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
22287
+ }
22288
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
22289
+ arg2 = &temp2;
22290
+ result = (bool)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__has_key((std::map< int,std::vector< int > > const *)arg1,(int const &)*arg2);
22291
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
22292
+ return resultobj;
22293
+fail:
22294
+ return NULL;
22295
+}
22296
+
22297
+
22298
+SWIGINTERN PyObject *_wrap_IntVecIntMap_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22299
+ PyObject *resultobj = 0;
22300
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22301
+ void *argp1 = 0 ;
22302
+ int res1 = 0 ;
22303
+ PyObject * obj0 = 0 ;
22304
+ PyObject *result = 0 ;
22305
+
22306
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_keys",&obj0)) SWIG_fail;
22307
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22308
+ if (!SWIG_IsOK(res1)) {
22309
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_keys" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
22310
+ }
22311
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22312
+ result = (PyObject *)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__keys(arg1);
22313
+ resultobj = result;
22314
+ return resultobj;
22315
+fail:
22316
+ return NULL;
22317
+}
22318
+
22319
+
22320
+SWIGINTERN PyObject *_wrap_IntVecIntMap_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22321
+ PyObject *resultobj = 0;
22322
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22323
+ void *argp1 = 0 ;
22324
+ int res1 = 0 ;
22325
+ PyObject * obj0 = 0 ;
22326
+ PyObject *result = 0 ;
22327
+
22328
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_values",&obj0)) SWIG_fail;
22329
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22330
+ if (!SWIG_IsOK(res1)) {
22331
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_values" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
22332
+ }
22333
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22334
+ result = (PyObject *)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__values(arg1);
22335
+ resultobj = result;
22336
+ return resultobj;
22337
+fail:
22338
+ return NULL;
22339
+}
22340
+
22341
+
22342
+SWIGINTERN PyObject *_wrap_IntVecIntMap_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22343
+ PyObject *resultobj = 0;
22344
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22345
+ void *argp1 = 0 ;
22346
+ int res1 = 0 ;
22347
+ PyObject * obj0 = 0 ;
22348
+ PyObject *result = 0 ;
22349
+
22350
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_items",&obj0)) SWIG_fail;
22351
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22352
+ if (!SWIG_IsOK(res1)) {
22353
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_items" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
22354
+ }
22355
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22356
+ result = (PyObject *)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__items(arg1);
22357
+ resultobj = result;
22358
+ return resultobj;
22359
+fail:
22360
+ return NULL;
22361
+}
22362
+
22363
+
22364
+SWIGINTERN PyObject *_wrap_IntVecIntMap___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22365
+ PyObject *resultobj = 0;
22366
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22367
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
22368
+ void *argp1 = 0 ;
22369
+ int res1 = 0 ;
22370
+ std::map< int,std::vector< int > >::key_type temp2 ;
22371
+ int val2 ;
22372
+ int ecode2 = 0 ;
22373
+ PyObject * obj0 = 0 ;
22374
+ PyObject * obj1 = 0 ;
22375
+ bool result;
22376
+
22377
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap___contains__",&obj0,&obj1)) SWIG_fail;
22378
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22379
+ if (!SWIG_IsOK(res1)) {
22380
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap___contains__" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
22381
+ }
22382
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22383
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
22384
+ if (!SWIG_IsOK(ecode2)) {
22385
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap___contains__" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
22386
+ }
22387
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
22388
+ arg2 = &temp2;
22389
+ result = (bool)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____contains__(arg1,(int const &)*arg2);
22390
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
22391
+ return resultobj;
22392
+fail:
22393
+ return NULL;
22394
+}
22395
+
22396
+
22397
+SWIGINTERN PyObject *_wrap_IntVecIntMap_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22398
+ PyObject *resultobj = 0;
22399
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22400
+ PyObject **arg2 = (PyObject **) 0 ;
22401
+ void *argp1 = 0 ;
22402
+ int res1 = 0 ;
22403
+ PyObject * obj0 = 0 ;
22404
+ swig::PySwigIterator *result = 0 ;
22405
+
22406
+ arg2 = &obj0;
22407
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_key_iterator",&obj0)) SWIG_fail;
22408
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22409
+ if (!SWIG_IsOK(res1)) {
22410
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_key_iterator" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
22411
+ }
22412
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22413
+ result = (swig::PySwigIterator *)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__key_iterator(arg1,arg2);
22414
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
22415
+ return resultobj;
22416
+fail:
22417
+ return NULL;
22418
+}
22419
+
22420
+
22421
+SWIGINTERN PyObject *_wrap_IntVecIntMap_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22422
+ PyObject *resultobj = 0;
22423
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22424
+ PyObject **arg2 = (PyObject **) 0 ;
22425
+ void *argp1 = 0 ;
22426
+ int res1 = 0 ;
22427
+ PyObject * obj0 = 0 ;
22428
+ swig::PySwigIterator *result = 0 ;
22429
+
22430
+ arg2 = &obj0;
22431
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_value_iterator",&obj0)) SWIG_fail;
22432
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22433
+ if (!SWIG_IsOK(res1)) {
22434
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_value_iterator" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
22435
+ }
22436
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22437
+ result = (swig::PySwigIterator *)std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg__value_iterator(arg1,arg2);
22438
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
22439
+ return resultobj;
22440
+fail:
22441
+ return NULL;
22442
+}
22443
+
22444
+
22445
+SWIGINTERN PyObject *_wrap_IntVecIntMap___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22446
+ PyObject *resultobj = 0;
22447
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22448
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
22449
+ std::map< int,std::vector< int > >::mapped_type *arg3 = 0 ;
22450
+ void *argp1 = 0 ;
22451
+ int res1 = 0 ;
22452
+ std::map< int,std::vector< int > >::key_type temp2 ;
22453
+ int val2 ;
22454
+ int ecode2 = 0 ;
22455
+ int res3 = SWIG_OLDOBJ ;
22456
+ PyObject * obj0 = 0 ;
22457
+ PyObject * obj1 = 0 ;
22458
+ PyObject * obj2 = 0 ;
22459
+
22460
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVecIntMap___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
22461
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22462
+ if (!SWIG_IsOK(res1)) {
22463
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap___setitem__" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
22464
+ }
22465
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22466
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
22467
+ if (!SWIG_IsOK(ecode2)) {
22468
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap___setitem__" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
22469
+ }
22470
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
22471
+ arg2 = &temp2;
22472
+ {
22473
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
22474
+ res3 = swig::asptr(obj2, &ptr);
22475
+ if (!SWIG_IsOK(res3)) {
22476
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntVecIntMap___setitem__" "', argument " "3"" of type '" "std::map< int,std::vector< int > >::mapped_type const &""'");
22477
+ }
22478
+ if (!ptr) {
22479
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVecIntMap___setitem__" "', argument " "3"" of type '" "std::map< int,std::vector< int > >::mapped_type const &""'");
22480
+ }
22481
+ arg3 = ptr;
22482
+ }
22483
+ try {
22484
+ std_map_Sl_int_Sc_std_vector_Sl_int_Sg__Sg____setitem__(arg1,(int const &)*arg2,(std::vector< int,std::allocator< int > > const &)*arg3);
22485
+ }
22486
+ catch(std::out_of_range &_e) {
22487
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
22488
+ }
22489
+
22490
+ resultobj = SWIG_Py_Void();
22491
+ if (SWIG_IsNewObj(res3)) delete arg3;
22492
+ return resultobj;
22493
+fail:
22494
+ if (SWIG_IsNewObj(res3)) delete arg3;
22495
+ return NULL;
22496
+}
22497
+
22498
+
22499
+SWIGINTERN PyObject *_wrap_new_IntVecIntMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22500
+ PyObject *resultobj = 0;
22501
+ std::map< int,std::vector< int > > *result = 0 ;
22502
+
22503
+ if (!PyArg_ParseTuple(args,(char *)":new_IntVecIntMap")) SWIG_fail;
22504
+ result = (std::map< int,std::vector< int > > *)new std::map< int,std::vector< int > >();
22505
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, SWIG_POINTER_NEW | 0 );
22506
+ return resultobj;
22507
+fail:
22508
+ return NULL;
22509
+}
22510
+
22511
+
22512
+SWIGINTERN PyObject *_wrap_new_IntVecIntMap__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22513
+ PyObject *resultobj = 0;
22514
+ std::map< int,std::vector< int,std::allocator< int > > > *arg1 = 0 ;
22515
+ int res1 = SWIG_OLDOBJ ;
22516
+ PyObject * obj0 = 0 ;
22517
+ std::map< int,std::vector< int > > *result = 0 ;
22518
+
22519
+ if (!PyArg_ParseTuple(args,(char *)"O:new_IntVecIntMap",&obj0)) SWIG_fail;
22520
+ {
22521
+ std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > > *ptr = (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > > *)0;
22522
+ res1 = swig::asptr(obj0, &ptr);
22523
+ if (!SWIG_IsOK(res1)) {
22524
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntVecIntMap" "', argument " "1"" of type '" "std::map< int,std::vector< int,std::allocator< int > > > const &""'");
22525
+ }
22526
+ if (!ptr) {
22527
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntVecIntMap" "', argument " "1"" of type '" "std::map< int,std::vector< int,std::allocator< int > > > const &""'");
22528
+ }
22529
+ arg1 = ptr;
22530
+ }
22531
+ result = (std::map< int,std::vector< int > > *)new std::map< int,std::vector< int > >((std::map< int,std::vector< int,std::allocator< int > > > const &)*arg1);
22532
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, SWIG_POINTER_NEW | 0 );
22533
+ if (SWIG_IsNewObj(res1)) delete arg1;
22534
+ return resultobj;
22535
+fail:
22536
+ if (SWIG_IsNewObj(res1)) delete arg1;
22537
+ return NULL;
22538
+}
22539
+
22540
+
22541
+SWIGINTERN PyObject *_wrap_new_IntVecIntMap(PyObject *self, PyObject *args) {
22542
+ int argc;
22543
+ PyObject *argv[2];
22544
+ int ii;
22545
+
22546
+ if (!PyTuple_Check(args)) SWIG_fail;
22547
+ argc = (int)PyObject_Length(args);
22548
+ for (ii = 0; (ii < argc) && (ii < 1); ii++) {
22549
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
22550
+ }
22551
+ if (argc == 0) {
22552
+ return _wrap_new_IntVecIntMap__SWIG_1(self, args);
22553
+ }
22554
+ if (argc == 1) {
22555
+ int _v;
22556
+ int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_int_t, 0);
22557
+ _v = SWIG_CheckState(res);
22558
+ if (_v) {
22559
+ return _wrap_new_IntVecIntMap__SWIG_0(self, args);
22560
+ }
22561
+ }
22562
+ if (argc == 1) {
22563
+ int _v;
22564
+ int res = swig::asptr(argv[0], (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >**)(0));
22565
+ _v = SWIG_CheckState(res);
22566
+ if (_v) {
22567
+ return _wrap_new_IntVecIntMap__SWIG_2(self, args);
22568
+ }
22569
+ }
22570
+
22571
+fail:
22572
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IntVecIntMap'.\n"
22573
+ " Possible C/C++ prototypes are:\n"
22574
+ " std::map< int,std::vector< int > >(std::less< int > const &)\n"
22575
+ " std::map< int,std::vector< int > >()\n"
22576
+ " std::map< int,std::vector< int > >(std::map< int,std::vector< int,std::allocator< int > > > const &)\n");
22577
+ return NULL;
22578
+}
22579
+
22580
+
22581
+SWIGINTERN PyObject *_wrap_IntVecIntMap_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22582
+ PyObject *resultobj = 0;
22583
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22584
+ void *argp1 = 0 ;
22585
+ int res1 = 0 ;
22586
+ PyObject * obj0 = 0 ;
22587
+ bool result;
22588
+
22589
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_empty",&obj0)) SWIG_fail;
22590
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22591
+ if (!SWIG_IsOK(res1)) {
22592
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_empty" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
22593
+ }
22594
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22595
+ result = (bool)((std::map< int,std::vector< int > > const *)arg1)->empty();
22596
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
22597
+ return resultobj;
22598
+fail:
22599
+ return NULL;
22600
+}
22601
+
22602
+
22603
+SWIGINTERN PyObject *_wrap_IntVecIntMap_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22604
+ PyObject *resultobj = 0;
22605
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22606
+ void *argp1 = 0 ;
22607
+ int res1 = 0 ;
22608
+ PyObject * obj0 = 0 ;
22609
+ std::map< int,std::vector< int > >::size_type result;
22610
+
22611
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_size",&obj0)) SWIG_fail;
22612
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22613
+ if (!SWIG_IsOK(res1)) {
22614
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_size" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
22615
+ }
22616
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22617
+ result = ((std::map< int,std::vector< int > > const *)arg1)->size();
22618
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
22619
+ return resultobj;
22620
+fail:
22621
+ return NULL;
22622
+}
22623
+
22624
+
22625
+SWIGINTERN PyObject *_wrap_IntVecIntMap_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22626
+ PyObject *resultobj = 0;
22627
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22628
+ void *argp1 = 0 ;
22629
+ int res1 = 0 ;
22630
+ PyObject * obj0 = 0 ;
22631
+
22632
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_clear",&obj0)) SWIG_fail;
22633
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22634
+ if (!SWIG_IsOK(res1)) {
22635
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_clear" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
22636
+ }
22637
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22638
+ (arg1)->clear();
22639
+ resultobj = SWIG_Py_Void();
22640
+ return resultobj;
22641
+fail:
22642
+ return NULL;
22643
+}
22644
+
22645
+
22646
+SWIGINTERN PyObject *_wrap_IntVecIntMap_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22647
+ PyObject *resultobj = 0;
22648
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22649
+ std::map< int,std::vector< int,std::allocator< int > > > *arg2 = 0 ;
22650
+ void *argp1 = 0 ;
22651
+ int res1 = 0 ;
22652
+ void *argp2 = 0 ;
22653
+ int res2 = 0 ;
22654
+ PyObject * obj0 = 0 ;
22655
+ PyObject * obj1 = 0 ;
22656
+
22657
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_swap",&obj0,&obj1)) SWIG_fail;
22658
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22659
+ if (!SWIG_IsOK(res1)) {
22660
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_swap" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
22661
+ }
22662
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22663
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 );
22664
+ if (!SWIG_IsOK(res2)) {
22665
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntVecIntMap_swap" "', argument " "2"" of type '" "std::map< int,std::vector< int,std::allocator< int > > > &""'");
22666
+ }
22667
+ if (!argp2) {
22668
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVecIntMap_swap" "', argument " "2"" of type '" "std::map< int,std::vector< int,std::allocator< int > > > &""'");
22669
+ }
22670
+ arg2 = reinterpret_cast< std::map< int,std::vector< int,std::allocator< int > > > * >(argp2);
22671
+ (arg1)->swap(*arg2);
22672
+ resultobj = SWIG_Py_Void();
22673
+ return resultobj;
22674
+fail:
22675
+ return NULL;
22676
+}
22677
+
22678
+
22679
+SWIGINTERN PyObject *_wrap_IntVecIntMap_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22680
+ PyObject *resultobj = 0;
22681
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22682
+ void *argp1 = 0 ;
22683
+ int res1 = 0 ;
22684
+ PyObject * obj0 = 0 ;
22685
+ SwigValueWrapper< std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > > result;
22686
+
22687
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_get_allocator",&obj0)) SWIG_fail;
22688
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22689
+ if (!SWIG_IsOK(res1)) {
22690
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_get_allocator" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
22691
+ }
22692
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22693
+ result = ((std::map< int,std::vector< int > > const *)arg1)->get_allocator();
22694
+ resultobj = SWIG_NewPointerObj((new std::map< int,std::vector< int > >::allocator_type(static_cast< const std::map< int,std::vector< int > >::allocator_type& >(result))), SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
22695
+ return resultobj;
22696
+fail:
22697
+ return NULL;
22698
+}
22699
+
22700
+
22701
+SWIGINTERN PyObject *_wrap_IntVecIntMap_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22702
+ PyObject *resultobj = 0;
22703
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22704
+ void *argp1 = 0 ;
22705
+ int res1 = 0 ;
22706
+ PyObject * obj0 = 0 ;
22707
+ std::map< int,std::vector< int > >::const_iterator result;
22708
+
22709
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_begin",&obj0)) SWIG_fail;
22710
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22711
+ if (!SWIG_IsOK(res1)) {
22712
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_begin" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
22713
+ }
22714
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22715
+ result = ((std::map< int,std::vector< int > > const *)arg1)->begin();
22716
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< int > >::const_iterator & >(result)),
22717
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
22718
+ return resultobj;
22719
+fail:
22720
+ return NULL;
22721
+}
22722
+
22723
+
22724
+SWIGINTERN PyObject *_wrap_IntVecIntMap_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22725
+ PyObject *resultobj = 0;
22726
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22727
+ void *argp1 = 0 ;
22728
+ int res1 = 0 ;
22729
+ PyObject * obj0 = 0 ;
22730
+ std::map< int,std::vector< int > >::const_iterator result;
22731
+
22732
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_end",&obj0)) SWIG_fail;
22733
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22734
+ if (!SWIG_IsOK(res1)) {
22735
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_end" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
22736
+ }
22737
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22738
+ result = ((std::map< int,std::vector< int > > const *)arg1)->end();
22739
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< int > >::const_iterator & >(result)),
22740
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
22741
+ return resultobj;
22742
+fail:
22743
+ return NULL;
22744
+}
22745
+
22746
+
22747
+SWIGINTERN PyObject *_wrap_IntVecIntMap_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22748
+ PyObject *resultobj = 0;
22749
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22750
+ void *argp1 = 0 ;
22751
+ int res1 = 0 ;
22752
+ PyObject * obj0 = 0 ;
22753
+ std::map< int,std::vector< int > >::const_reverse_iterator result;
22754
+
22755
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_rbegin",&obj0)) SWIG_fail;
22756
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22757
+ if (!SWIG_IsOK(res1)) {
22758
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_rbegin" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
22759
+ }
22760
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22761
+ result = ((std::map< int,std::vector< int > > const *)arg1)->rbegin();
22762
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< int > >::const_reverse_iterator & >(result)),
22763
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
22764
+ return resultobj;
22765
+fail:
22766
+ return NULL;
22767
+}
22768
+
22769
+
22770
+SWIGINTERN PyObject *_wrap_IntVecIntMap_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22771
+ PyObject *resultobj = 0;
22772
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22773
+ void *argp1 = 0 ;
22774
+ int res1 = 0 ;
22775
+ PyObject * obj0 = 0 ;
22776
+ std::map< int,std::vector< int > >::const_reverse_iterator result;
22777
+
22778
+ if (!PyArg_ParseTuple(args,(char *)"O:IntVecIntMap_rend",&obj0)) SWIG_fail;
22779
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22780
+ if (!SWIG_IsOK(res1)) {
22781
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_rend" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
22782
+ }
22783
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22784
+ result = ((std::map< int,std::vector< int > > const *)arg1)->rend();
22785
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< int > >::const_reverse_iterator & >(result)),
22786
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
22787
+ return resultobj;
22788
+fail:
22789
+ return NULL;
22790
+}
22791
+
22792
+
22793
+SWIGINTERN PyObject *_wrap_IntVecIntMap_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22794
+ PyObject *resultobj = 0;
22795
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22796
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
22797
+ void *argp1 = 0 ;
22798
+ int res1 = 0 ;
22799
+ std::map< int,std::vector< int > >::key_type temp2 ;
22800
+ int val2 ;
22801
+ int ecode2 = 0 ;
22802
+ PyObject * obj0 = 0 ;
22803
+ PyObject * obj1 = 0 ;
22804
+ std::map< int,std::vector< int > >::size_type result;
22805
+
22806
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_erase",&obj0,&obj1)) SWIG_fail;
22807
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22808
+ if (!SWIG_IsOK(res1)) {
22809
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_erase" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
22810
+ }
22811
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22812
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
22813
+ if (!SWIG_IsOK(ecode2)) {
22814
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
22815
+ }
22816
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
22817
+ arg2 = &temp2;
22818
+ result = (arg1)->erase((std::map< int,std::vector< int > >::key_type const &)*arg2);
22819
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
22820
+ return resultobj;
22821
+fail:
22822
+ return NULL;
22823
+}
22824
+
22825
+
22826
+SWIGINTERN PyObject *_wrap_IntVecIntMap_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22827
+ PyObject *resultobj = 0;
22828
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22829
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
22830
+ void *argp1 = 0 ;
22831
+ int res1 = 0 ;
22832
+ std::map< int,std::vector< int > >::key_type temp2 ;
22833
+ int val2 ;
22834
+ int ecode2 = 0 ;
22835
+ PyObject * obj0 = 0 ;
22836
+ PyObject * obj1 = 0 ;
22837
+ std::map< int,std::vector< int > >::size_type result;
22838
+
22839
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_count",&obj0,&obj1)) SWIG_fail;
22840
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22841
+ if (!SWIG_IsOK(res1)) {
22842
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_count" "', argument " "1"" of type '" "std::map< int,std::vector< int > > const *""'");
22843
+ }
22844
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22845
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
22846
+ if (!SWIG_IsOK(ecode2)) {
22847
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap_count" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
22848
+ }
22849
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
22850
+ arg2 = &temp2;
22851
+ result = ((std::map< int,std::vector< int > > const *)arg1)->count((std::map< int,std::vector< int > >::key_type const &)*arg2);
22852
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
22853
+ return resultobj;
22854
+fail:
22855
+ return NULL;
22856
+}
22857
+
22858
+
22859
+SWIGINTERN PyObject *_wrap_IntVecIntMap_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22860
+ PyObject *resultobj = 0;
22861
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22862
+ std::map< int,std::vector< int > >::iterator arg2 ;
22863
+ void *argp1 = 0 ;
22864
+ int res1 = 0 ;
22865
+ swig::PySwigIterator *iter2 = 0 ;
22866
+ int res2 ;
22867
+ PyObject * obj0 = 0 ;
22868
+ PyObject * obj1 = 0 ;
22869
+
22870
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_erase",&obj0,&obj1)) SWIG_fail;
22871
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22872
+ if (!SWIG_IsOK(res1)) {
22873
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_erase" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
22874
+ }
22875
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22876
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
22877
+ if (!SWIG_IsOK(res2) || !iter2) {
22878
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::iterator""'");
22879
+ } else {
22880
+ swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *>(iter2);
22881
+ if (iter_t) {
22882
+ arg2 = iter_t->get_current();
22883
+ } else {
22884
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::iterator""'");
22885
+ }
22886
+ }
22887
+ (arg1)->erase(arg2);
22888
+ resultobj = SWIG_Py_Void();
22889
+ return resultobj;
22890
+fail:
22891
+ return NULL;
22892
+}
22893
+
22894
+
22895
+SWIGINTERN PyObject *_wrap_IntVecIntMap_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22896
+ PyObject *resultobj = 0;
22897
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
22898
+ std::map< int,std::vector< int > >::iterator arg2 ;
22899
+ std::map< int,std::vector< int > >::iterator arg3 ;
22900
+ void *argp1 = 0 ;
22901
+ int res1 = 0 ;
22902
+ swig::PySwigIterator *iter2 = 0 ;
22903
+ int res2 ;
22904
+ swig::PySwigIterator *iter3 = 0 ;
22905
+ int res3 ;
22906
+ PyObject * obj0 = 0 ;
22907
+ PyObject * obj1 = 0 ;
22908
+ PyObject * obj2 = 0 ;
22909
+
22910
+ if (!PyArg_ParseTuple(args,(char *)"OOO:IntVecIntMap_erase",&obj0,&obj1,&obj2)) SWIG_fail;
22911
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
22912
+ if (!SWIG_IsOK(res1)) {
22913
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_erase" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
22914
+ }
22915
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
22916
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
22917
+ if (!SWIG_IsOK(res2) || !iter2) {
22918
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::iterator""'");
22919
+ } else {
22920
+ swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *>(iter2);
22921
+ if (iter_t) {
22922
+ arg2 = iter_t->get_current();
22923
+ } else {
22924
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::iterator""'");
22925
+ }
22926
+ }
22927
+ res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
22928
+ if (!SWIG_IsOK(res3) || !iter3) {
22929
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVecIntMap_erase" "', argument " "3"" of type '" "std::map< int,std::vector< int > >::iterator""'");
22930
+ } else {
22931
+ swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *>(iter3);
22932
+ if (iter_t) {
22933
+ arg3 = iter_t->get_current();
22934
+ } else {
22935
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVecIntMap_erase" "', argument " "3"" of type '" "std::map< int,std::vector< int > >::iterator""'");
22936
+ }
22937
+ }
22938
+ (arg1)->erase(arg2,arg3);
22939
+ resultobj = SWIG_Py_Void();
22940
+ return resultobj;
22941
+fail:
22942
+ return NULL;
22943
+}
22944
+
22945
+
22946
+SWIGINTERN PyObject *_wrap_IntVecIntMap_erase(PyObject *self, PyObject *args) {
22947
+ int argc;
22948
+ PyObject *argv[4];
22949
+ int ii;
22950
+
22951
+ if (!PyTuple_Check(args)) SWIG_fail;
22952
+ argc = (int)PyObject_Length(args);
22953
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
22954
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
22955
+ }
22956
+ if (argc == 2) {
22957
+ int _v;
22958
+ int res = swig::asptr(argv[0], (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >**)(0));
22959
+ _v = SWIG_CheckState(res);
22960
+ if (_v) {
22961
+ swig::PySwigIterator *iter = 0;
22962
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
22963
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *>(iter) != 0));
22964
+ if (_v) {
22965
+ return _wrap_IntVecIntMap_erase__SWIG_1(self, args);
22966
+ }
22967
+ }
22968
+ }
22969
+ if (argc == 2) {
22970
+ int _v;
22971
+ int res = swig::asptr(argv[0], (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >**)(0));
22972
+ _v = SWIG_CheckState(res);
22973
+ if (_v) {
22974
+ {
22975
+ int res = SWIG_AsVal_int(argv[1], NULL);
22976
+ _v = SWIG_CheckState(res);
22977
+ }
22978
+ if (_v) {
22979
+ return _wrap_IntVecIntMap_erase__SWIG_0(self, args);
22980
+ }
22981
+ }
22982
+ }
22983
+ if (argc == 3) {
22984
+ int _v;
22985
+ int res = swig::asptr(argv[0], (std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > >**)(0));
22986
+ _v = SWIG_CheckState(res);
22987
+ if (_v) {
22988
+ swig::PySwigIterator *iter = 0;
22989
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
22990
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *>(iter) != 0));
22991
+ if (_v) {
22992
+ swig::PySwigIterator *iter = 0;
22993
+ int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
22994
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< int > >::iterator > *>(iter) != 0));
22995
+ if (_v) {
22996
+ return _wrap_IntVecIntMap_erase__SWIG_2(self, args);
22997
+ }
22998
+ }
22999
+ }
23000
+ }
23001
+
23002
+fail:
23003
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IntVecIntMap_erase'.\n"
23004
+ " Possible C/C++ prototypes are:\n"
23005
+ " erase(std::map< int,std::vector< int > > *,std::map< int,std::vector< int > >::key_type const &)\n"
23006
+ " erase(std::map< int,std::vector< int > > *,std::map< int,std::vector< int > >::iterator)\n"
23007
+ " erase(std::map< int,std::vector< int > > *,std::map< int,std::vector< int > >::iterator,std::map< int,std::vector< int > >::iterator)\n");
23008
+ return NULL;
23009
+}
23010
+
23011
+
23012
+SWIGINTERN PyObject *_wrap_IntVecIntMap_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23013
+ PyObject *resultobj = 0;
23014
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
23015
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
23016
+ void *argp1 = 0 ;
23017
+ int res1 = 0 ;
23018
+ std::map< int,std::vector< int > >::key_type temp2 ;
23019
+ int val2 ;
23020
+ int ecode2 = 0 ;
23021
+ PyObject * obj0 = 0 ;
23022
+ PyObject * obj1 = 0 ;
23023
+ std::map< int,std::vector< int > >::iterator result;
23024
+
23025
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_find",&obj0,&obj1)) SWIG_fail;
23026
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
23027
+ if (!SWIG_IsOK(res1)) {
23028
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_find" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
23029
+ }
23030
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
23031
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
23032
+ if (!SWIG_IsOK(ecode2)) {
23033
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap_find" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
23034
+ }
23035
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
23036
+ arg2 = &temp2;
23037
+ result = (arg1)->find((std::map< int,std::vector< int > >::key_type const &)*arg2);
23038
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< int > >::iterator & >(result)),
23039
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
23040
+ return resultobj;
23041
+fail:
23042
+ return NULL;
23043
+}
23044
+
23045
+
23046
+SWIGINTERN PyObject *_wrap_IntVecIntMap_lower_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23047
+ PyObject *resultobj = 0;
23048
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
23049
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
23050
+ void *argp1 = 0 ;
23051
+ int res1 = 0 ;
23052
+ std::map< int,std::vector< int > >::key_type temp2 ;
23053
+ int val2 ;
23054
+ int ecode2 = 0 ;
23055
+ PyObject * obj0 = 0 ;
23056
+ PyObject * obj1 = 0 ;
23057
+ std::map< int,std::vector< int > >::iterator result;
23058
+
23059
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_lower_bound",&obj0,&obj1)) SWIG_fail;
23060
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
23061
+ if (!SWIG_IsOK(res1)) {
23062
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_lower_bound" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
23063
+ }
23064
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
23065
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
23066
+ if (!SWIG_IsOK(ecode2)) {
23067
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap_lower_bound" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
23068
+ }
23069
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
23070
+ arg2 = &temp2;
23071
+ result = (arg1)->lower_bound((std::map< int,std::vector< int > >::key_type const &)*arg2);
23072
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< int > >::iterator & >(result)),
23073
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
23074
+ return resultobj;
23075
+fail:
23076
+ return NULL;
23077
+}
23078
+
23079
+
23080
+SWIGINTERN PyObject *_wrap_IntVecIntMap_upper_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23081
+ PyObject *resultobj = 0;
23082
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
23083
+ std::map< int,std::vector< int > >::key_type *arg2 = 0 ;
23084
+ void *argp1 = 0 ;
23085
+ int res1 = 0 ;
23086
+ std::map< int,std::vector< int > >::key_type temp2 ;
23087
+ int val2 ;
23088
+ int ecode2 = 0 ;
23089
+ PyObject * obj0 = 0 ;
23090
+ PyObject * obj1 = 0 ;
23091
+ std::map< int,std::vector< int > >::iterator result;
23092
+
23093
+ if (!PyArg_ParseTuple(args,(char *)"OO:IntVecIntMap_upper_bound",&obj0,&obj1)) SWIG_fail;
23094
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0 | 0 );
23095
+ if (!SWIG_IsOK(res1)) {
23096
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVecIntMap_upper_bound" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
23097
+ }
23098
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
23099
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
23100
+ if (!SWIG_IsOK(ecode2)) {
23101
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVecIntMap_upper_bound" "', argument " "2"" of type '" "std::map< int,std::vector< int > >::key_type""'");
23102
+ }
23103
+ temp2 = static_cast< std::map< int,std::vector< int > >::key_type >(val2);
23104
+ arg2 = &temp2;
23105
+ result = (arg1)->upper_bound((std::map< int,std::vector< int > >::key_type const &)*arg2);
23106
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< int > >::iterator & >(result)),
23107
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
23108
+ return resultobj;
23109
+fail:
23110
+ return NULL;
23111
+}
23112
+
23113
+
23114
+SWIGINTERN PyObject *_wrap_delete_IntVecIntMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23115
+ PyObject *resultobj = 0;
23116
+ std::map< int,std::vector< int > > *arg1 = (std::map< int,std::vector< int > > *) 0 ;
23117
+ void *argp1 = 0 ;
23118
+ int res1 = 0 ;
23119
+ PyObject * obj0 = 0 ;
23120
+
23121
+ if (!PyArg_ParseTuple(args,(char *)"O:delete_IntVecIntMap",&obj0)) SWIG_fail;
23122
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, SWIG_POINTER_DISOWN | 0 );
23123
+ if (!SWIG_IsOK(res1)) {
23124
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntVecIntMap" "', argument " "1"" of type '" "std::map< int,std::vector< int > > *""'");
23125
+ }
23126
+ arg1 = reinterpret_cast< std::map< int,std::vector< int > > * >(argp1);
23127
+ delete arg1;
23128
+ resultobj = SWIG_Py_Void();
23129
+ return resultobj;
23130
+fail:
23131
+ return NULL;
23132
+}
23133
+
23134
+
23135
+SWIGINTERN PyObject *IntVecIntMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23136
+ PyObject *obj;
23137
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
23138
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, SWIG_NewClientData(obj));
23139
+ return SWIG_Py_Void();
23140
+}
23141
+
23142
+SWIGINTERN PyObject *_wrap_new_DoubleVecIntMap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23143
+ PyObject *resultobj = 0;
23144
+ std::less< int > *arg1 = 0 ;
23145
+ void *argp1 = 0 ;
23146
+ int res1 = 0 ;
23147
+ PyObject * obj0 = 0 ;
23148
+ std::map< int,std::vector< double > > *result = 0 ;
23149
+
23150
+ if (!PyArg_ParseTuple(args,(char *)"O:new_DoubleVecIntMap",&obj0)) SWIG_fail;
23151
+ res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_int_t, 0 | 0);
23152
+ if (!SWIG_IsOK(res1)) {
23153
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleVecIntMap" "', argument " "1"" of type '" "std::less< int > const &""'");
23154
+ }
23155
+ if (!argp1) {
23156
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleVecIntMap" "', argument " "1"" of type '" "std::less< int > const &""'");
23157
+ }
23158
+ arg1 = reinterpret_cast< std::less< int > * >(argp1);
23159
+ result = (std::map< int,std::vector< double > > *)new std::map< int,std::vector< double > >((std::less< int > const &)*arg1);
23160
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, SWIG_POINTER_NEW | 0 );
23161
+ return resultobj;
23162
+fail:
23163
+ return NULL;
23164
+}
23165
+
23166
+
23167
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23168
+ PyObject *resultobj = 0;
23169
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23170
+ PyObject **arg2 = (PyObject **) 0 ;
23171
+ void *argp1 = 0 ;
23172
+ int res1 = 0 ;
23173
+ PyObject * obj0 = 0 ;
23174
+ swig::PySwigIterator *result = 0 ;
23175
+
23176
+ arg2 = &obj0;
23177
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap_iterator",&obj0)) SWIG_fail;
23178
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23179
+ if (!SWIG_IsOK(res1)) {
23180
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_iterator" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
23181
+ }
23182
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23183
+ result = (swig::PySwigIterator *)std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg__iterator(arg1,arg2);
23184
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
23185
+ return resultobj;
23186
+fail:
23187
+ return NULL;
23188
+}
23189
+
23190
+
23191
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23192
+ PyObject *resultobj = 0;
23193
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23194
+ void *argp1 = 0 ;
23195
+ int res1 = 0 ;
23196
+ PyObject * obj0 = 0 ;
23197
+ bool result;
23198
+
23199
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap___nonzero__",&obj0)) SWIG_fail;
23200
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23201
+ if (!SWIG_IsOK(res1)) {
23202
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap___nonzero__" "', argument " "1"" of type '" "std::map< int,std::vector< double > > const *""'");
23203
+ }
23204
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23205
+ result = (bool)std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg____nonzero__((std::map< int,std::vector< double > > const *)arg1);
23206
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
23207
+ return resultobj;
23208
+fail:
23209
+ return NULL;
23210
+}
23211
+
23212
+
23213
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23214
+ PyObject *resultobj = 0;
23215
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23216
+ void *argp1 = 0 ;
23217
+ int res1 = 0 ;
23218
+ PyObject * obj0 = 0 ;
23219
+ std::map< int,std::vector< double > >::size_type result;
23220
+
23221
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap___len__",&obj0)) SWIG_fail;
23222
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23223
+ if (!SWIG_IsOK(res1)) {
23224
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap___len__" "', argument " "1"" of type '" "std::map< int,std::vector< double > > const *""'");
23225
+ }
23226
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23227
+ result = std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg____len__((std::map< int,std::vector< double > > const *)arg1);
23228
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
23229
+ return resultobj;
23230
+fail:
23231
+ return NULL;
23232
+}
23233
+
23234
+
23235
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23236
+ PyObject *resultobj = 0;
23237
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23238
+ std::map< int,std::vector< double > >::key_type *arg2 = 0 ;
23239
+ void *argp1 = 0 ;
23240
+ int res1 = 0 ;
23241
+ std::map< int,std::vector< double > >::key_type temp2 ;
23242
+ int val2 ;
23243
+ int ecode2 = 0 ;
23244
+ PyObject * obj0 = 0 ;
23245
+ PyObject * obj1 = 0 ;
23246
+ std::map< int,std::vector< double > >::mapped_type result;
23247
+
23248
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVecIntMap___getitem__",&obj0,&obj1)) SWIG_fail;
23249
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23250
+ if (!SWIG_IsOK(res1)) {
23251
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap___getitem__" "', argument " "1"" of type '" "std::map< int,std::vector< double > > const *""'");
23252
+ }
23253
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23254
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
23255
+ if (!SWIG_IsOK(ecode2)) {
23256
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVecIntMap___getitem__" "', argument " "2"" of type '" "std::map< int,std::vector< double > >::key_type""'");
23257
+ }
23258
+ temp2 = static_cast< std::map< int,std::vector< double > >::key_type >(val2);
23259
+ arg2 = &temp2;
23260
+ try {
23261
+ result = std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg____getitem__((std::map< int,std::vector< double > > const *)arg1,(int const &)*arg2);
23262
+ }
23263
+ catch(std::out_of_range &_e) {
23264
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
23265
+ }
23266
+
23267
+ resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
23268
+ return resultobj;
23269
+fail:
23270
+ return NULL;
23271
+}
23272
+
23273
+
23274
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23275
+ PyObject *resultobj = 0;
23276
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23277
+ std::map< int,std::vector< double > >::key_type *arg2 = 0 ;
23278
+ void *argp1 = 0 ;
23279
+ int res1 = 0 ;
23280
+ std::map< int,std::vector< double > >::key_type temp2 ;
23281
+ int val2 ;
23282
+ int ecode2 = 0 ;
23283
+ PyObject * obj0 = 0 ;
23284
+ PyObject * obj1 = 0 ;
23285
+
23286
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVecIntMap___delitem__",&obj0,&obj1)) SWIG_fail;
23287
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23288
+ if (!SWIG_IsOK(res1)) {
23289
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap___delitem__" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
23290
+ }
23291
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23292
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
23293
+ if (!SWIG_IsOK(ecode2)) {
23294
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVecIntMap___delitem__" "', argument " "2"" of type '" "std::map< int,std::vector< double > >::key_type""'");
23295
+ }
23296
+ temp2 = static_cast< std::map< int,std::vector< double > >::key_type >(val2);
23297
+ arg2 = &temp2;
23298
+ try {
23299
+ std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg____delitem__(arg1,(int const &)*arg2);
23300
+ }
23301
+ catch(std::out_of_range &_e) {
23302
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
23303
+ }
23304
+
23305
+ resultobj = SWIG_Py_Void();
23306
+ return resultobj;
23307
+fail:
23308
+ return NULL;
23309
+}
23310
+
23311
+
23312
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23313
+ PyObject *resultobj = 0;
23314
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23315
+ std::map< int,std::vector< double > >::key_type *arg2 = 0 ;
23316
+ void *argp1 = 0 ;
23317
+ int res1 = 0 ;
23318
+ std::map< int,std::vector< double > >::key_type temp2 ;
23319
+ int val2 ;
23320
+ int ecode2 = 0 ;
23321
+ PyObject * obj0 = 0 ;
23322
+ PyObject * obj1 = 0 ;
23323
+ bool result;
23324
+
23325
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVecIntMap_has_key",&obj0,&obj1)) SWIG_fail;
23326
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23327
+ if (!SWIG_IsOK(res1)) {
23328
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_has_key" "', argument " "1"" of type '" "std::map< int,std::vector< double > > const *""'");
23329
+ }
23330
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23331
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
23332
+ if (!SWIG_IsOK(ecode2)) {
23333
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVecIntMap_has_key" "', argument " "2"" of type '" "std::map< int,std::vector< double > >::key_type""'");
23334
+ }
23335
+ temp2 = static_cast< std::map< int,std::vector< double > >::key_type >(val2);
23336
+ arg2 = &temp2;
23337
+ result = (bool)std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg__has_key((std::map< int,std::vector< double > > const *)arg1,(int const &)*arg2);
23338
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
23339
+ return resultobj;
23340
+fail:
23341
+ return NULL;
23342
+}
23343
+
23344
+
23345
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23346
+ PyObject *resultobj = 0;
23347
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23348
+ void *argp1 = 0 ;
23349
+ int res1 = 0 ;
23350
+ PyObject * obj0 = 0 ;
23351
+ PyObject *result = 0 ;
23352
+
23353
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap_keys",&obj0)) SWIG_fail;
23354
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23355
+ if (!SWIG_IsOK(res1)) {
23356
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_keys" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
23357
+ }
23358
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23359
+ result = (PyObject *)std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg__keys(arg1);
23360
+ resultobj = result;
23361
+ return resultobj;
23362
+fail:
23363
+ return NULL;
23364
+}
23365
+
23366
+
23367
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23368
+ PyObject *resultobj = 0;
23369
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23370
+ void *argp1 = 0 ;
23371
+ int res1 = 0 ;
23372
+ PyObject * obj0 = 0 ;
23373
+ PyObject *result = 0 ;
23374
+
23375
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap_values",&obj0)) SWIG_fail;
23376
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23377
+ if (!SWIG_IsOK(res1)) {
23378
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_values" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
23379
+ }
23380
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23381
+ result = (PyObject *)std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg__values(arg1);
23382
+ resultobj = result;
23383
+ return resultobj;
23384
+fail:
23385
+ return NULL;
23386
+}
23387
+
23388
+
23389
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23390
+ PyObject *resultobj = 0;
23391
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23392
+ void *argp1 = 0 ;
23393
+ int res1 = 0 ;
23394
+ PyObject * obj0 = 0 ;
23395
+ PyObject *result = 0 ;
23396
+
23397
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap_items",&obj0)) SWIG_fail;
23398
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23399
+ if (!SWIG_IsOK(res1)) {
23400
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_items" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
23401
+ }
23402
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23403
+ result = (PyObject *)std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg__items(arg1);
23404
+ resultobj = result;
23405
+ return resultobj;
23406
+fail:
23407
+ return NULL;
23408
+}
23409
+
23410
+
23411
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23412
+ PyObject *resultobj = 0;
23413
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23414
+ std::map< int,std::vector< double > >::key_type *arg2 = 0 ;
23415
+ void *argp1 = 0 ;
23416
+ int res1 = 0 ;
23417
+ std::map< int,std::vector< double > >::key_type temp2 ;
23418
+ int val2 ;
23419
+ int ecode2 = 0 ;
23420
+ PyObject * obj0 = 0 ;
23421
+ PyObject * obj1 = 0 ;
23422
+ bool result;
23423
+
23424
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVecIntMap___contains__",&obj0,&obj1)) SWIG_fail;
23425
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23426
+ if (!SWIG_IsOK(res1)) {
23427
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap___contains__" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
23428
+ }
23429
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23430
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
23431
+ if (!SWIG_IsOK(ecode2)) {
23432
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVecIntMap___contains__" "', argument " "2"" of type '" "std::map< int,std::vector< double > >::key_type""'");
23433
+ }
23434
+ temp2 = static_cast< std::map< int,std::vector< double > >::key_type >(val2);
23435
+ arg2 = &temp2;
23436
+ result = (bool)std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg____contains__(arg1,(int const &)*arg2);
23437
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
23438
+ return resultobj;
23439
+fail:
23440
+ return NULL;
23441
+}
23442
+
23443
+
23444
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23445
+ PyObject *resultobj = 0;
23446
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23447
+ PyObject **arg2 = (PyObject **) 0 ;
23448
+ void *argp1 = 0 ;
23449
+ int res1 = 0 ;
23450
+ PyObject * obj0 = 0 ;
23451
+ swig::PySwigIterator *result = 0 ;
23452
+
23453
+ arg2 = &obj0;
23454
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap_key_iterator",&obj0)) SWIG_fail;
23455
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23456
+ if (!SWIG_IsOK(res1)) {
23457
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_key_iterator" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
23458
+ }
23459
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23460
+ result = (swig::PySwigIterator *)std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg__key_iterator(arg1,arg2);
23461
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
23462
+ return resultobj;
23463
+fail:
23464
+ return NULL;
23465
+}
23466
+
23467
+
23468
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23469
+ PyObject *resultobj = 0;
23470
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23471
+ PyObject **arg2 = (PyObject **) 0 ;
23472
+ void *argp1 = 0 ;
23473
+ int res1 = 0 ;
23474
+ PyObject * obj0 = 0 ;
23475
+ swig::PySwigIterator *result = 0 ;
23476
+
23477
+ arg2 = &obj0;
23478
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap_value_iterator",&obj0)) SWIG_fail;
23479
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23480
+ if (!SWIG_IsOK(res1)) {
23481
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_value_iterator" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
23482
+ }
23483
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23484
+ result = (swig::PySwigIterator *)std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg__value_iterator(arg1,arg2);
23485
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
23486
+ return resultobj;
23487
+fail:
23488
+ return NULL;
23489
+}
23490
+
23491
+
23492
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23493
+ PyObject *resultobj = 0;
23494
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23495
+ std::map< int,std::vector< double > >::key_type *arg2 = 0 ;
23496
+ std::map< int,std::vector< double > >::mapped_type *arg3 = 0 ;
23497
+ void *argp1 = 0 ;
23498
+ int res1 = 0 ;
23499
+ std::map< int,std::vector< double > >::key_type temp2 ;
23500
+ int val2 ;
23501
+ int ecode2 = 0 ;
23502
+ int res3 = SWIG_OLDOBJ ;
23503
+ PyObject * obj0 = 0 ;
23504
+ PyObject * obj1 = 0 ;
23505
+ PyObject * obj2 = 0 ;
23506
+
23507
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVecIntMap___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
23508
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23509
+ if (!SWIG_IsOK(res1)) {
23510
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap___setitem__" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
23511
+ }
23512
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23513
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
23514
+ if (!SWIG_IsOK(ecode2)) {
23515
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVecIntMap___setitem__" "', argument " "2"" of type '" "std::map< int,std::vector< double > >::key_type""'");
23516
+ }
23517
+ temp2 = static_cast< std::map< int,std::vector< double > >::key_type >(val2);
23518
+ arg2 = &temp2;
23519
+ {
23520
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
23521
+ res3 = swig::asptr(obj2, &ptr);
23522
+ if (!SWIG_IsOK(res3)) {
23523
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleVecIntMap___setitem__" "', argument " "3"" of type '" "std::map< int,std::vector< double > >::mapped_type const &""'");
23524
+ }
23525
+ if (!ptr) {
23526
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVecIntMap___setitem__" "', argument " "3"" of type '" "std::map< int,std::vector< double > >::mapped_type const &""'");
23527
+ }
23528
+ arg3 = ptr;
23529
+ }
23530
+ try {
23531
+ std_map_Sl_int_Sc_std_vector_Sl_double_Sg__Sg____setitem__(arg1,(int const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
23532
+ }
23533
+ catch(std::out_of_range &_e) {
23534
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
23535
+ }
23536
+
23537
+ resultobj = SWIG_Py_Void();
23538
+ if (SWIG_IsNewObj(res3)) delete arg3;
23539
+ return resultobj;
23540
+fail:
23541
+ if (SWIG_IsNewObj(res3)) delete arg3;
23542
+ return NULL;
23543
+}
23544
+
23545
+
23546
+SWIGINTERN PyObject *_wrap_new_DoubleVecIntMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23547
+ PyObject *resultobj = 0;
23548
+ std::map< int,std::vector< double > > *result = 0 ;
23549
+
23550
+ if (!PyArg_ParseTuple(args,(char *)":new_DoubleVecIntMap")) SWIG_fail;
23551
+ result = (std::map< int,std::vector< double > > *)new std::map< int,std::vector< double > >();
23552
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, SWIG_POINTER_NEW | 0 );
23553
+ return resultobj;
23554
+fail:
23555
+ return NULL;
23556
+}
23557
+
23558
+
23559
+SWIGINTERN PyObject *_wrap_new_DoubleVecIntMap__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23560
+ PyObject *resultobj = 0;
23561
+ std::map< int,std::vector< double,std::allocator< double > > > *arg1 = 0 ;
23562
+ int res1 = SWIG_OLDOBJ ;
23563
+ PyObject * obj0 = 0 ;
23564
+ std::map< int,std::vector< double > > *result = 0 ;
23565
+
23566
+ if (!PyArg_ParseTuple(args,(char *)"O:new_DoubleVecIntMap",&obj0)) SWIG_fail;
23567
+ {
23568
+ std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > > *ptr = (std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > > *)0;
23569
+ res1 = swig::asptr(obj0, &ptr);
23570
+ if (!SWIG_IsOK(res1)) {
23571
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleVecIntMap" "', argument " "1"" of type '" "std::map< int,std::vector< double,std::allocator< double > > > const &""'");
23572
+ }
23573
+ if (!ptr) {
23574
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleVecIntMap" "', argument " "1"" of type '" "std::map< int,std::vector< double,std::allocator< double > > > const &""'");
23575
+ }
23576
+ arg1 = ptr;
23577
+ }
23578
+ result = (std::map< int,std::vector< double > > *)new std::map< int,std::vector< double > >((std::map< int,std::vector< double,std::allocator< double > > > const &)*arg1);
23579
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, SWIG_POINTER_NEW | 0 );
23580
+ if (SWIG_IsNewObj(res1)) delete arg1;
23581
+ return resultobj;
23582
+fail:
23583
+ if (SWIG_IsNewObj(res1)) delete arg1;
23584
+ return NULL;
23585
+}
23586
+
23587
+
23588
+SWIGINTERN PyObject *_wrap_new_DoubleVecIntMap(PyObject *self, PyObject *args) {
23589
+ int argc;
23590
+ PyObject *argv[2];
23591
+ int ii;
23592
+
23593
+ if (!PyTuple_Check(args)) SWIG_fail;
23594
+ argc = (int)PyObject_Length(args);
23595
+ for (ii = 0; (ii < argc) && (ii < 1); ii++) {
23596
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
23597
+ }
23598
+ if (argc == 0) {
23599
+ return _wrap_new_DoubleVecIntMap__SWIG_1(self, args);
23600
+ }
23601
+ if (argc == 1) {
23602
+ int _v;
23603
+ int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_int_t, 0);
23604
+ _v = SWIG_CheckState(res);
23605
+ if (_v) {
23606
+ return _wrap_new_DoubleVecIntMap__SWIG_0(self, args);
23607
+ }
23608
+ }
23609
+ if (argc == 1) {
23610
+ int _v;
23611
+ int res = swig::asptr(argv[0], (std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >**)(0));
23612
+ _v = SWIG_CheckState(res);
23613
+ if (_v) {
23614
+ return _wrap_new_DoubleVecIntMap__SWIG_2(self, args);
23615
+ }
23616
+ }
23617
+
23618
+fail:
23619
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DoubleVecIntMap'.\n"
23620
+ " Possible C/C++ prototypes are:\n"
23621
+ " std::map< int,std::vector< double > >(std::less< int > const &)\n"
23622
+ " std::map< int,std::vector< double > >()\n"
23623
+ " std::map< int,std::vector< double > >(std::map< int,std::vector< double,std::allocator< double > > > const &)\n");
23624
+ return NULL;
23625
+}
23626
+
23627
+
23628
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23629
+ PyObject *resultobj = 0;
23630
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23631
+ void *argp1 = 0 ;
23632
+ int res1 = 0 ;
23633
+ PyObject * obj0 = 0 ;
23634
+ bool result;
23635
+
23636
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap_empty",&obj0)) SWIG_fail;
23637
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23638
+ if (!SWIG_IsOK(res1)) {
23639
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_empty" "', argument " "1"" of type '" "std::map< int,std::vector< double > > const *""'");
23640
+ }
23641
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23642
+ result = (bool)((std::map< int,std::vector< double > > const *)arg1)->empty();
23643
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
23644
+ return resultobj;
23645
+fail:
23646
+ return NULL;
23647
+}
23648
+
23649
+
23650
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23651
+ PyObject *resultobj = 0;
23652
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23653
+ void *argp1 = 0 ;
23654
+ int res1 = 0 ;
23655
+ PyObject * obj0 = 0 ;
23656
+ std::map< int,std::vector< double > >::size_type result;
23657
+
23658
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap_size",&obj0)) SWIG_fail;
23659
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23660
+ if (!SWIG_IsOK(res1)) {
23661
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_size" "', argument " "1"" of type '" "std::map< int,std::vector< double > > const *""'");
23662
+ }
23663
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23664
+ result = ((std::map< int,std::vector< double > > const *)arg1)->size();
23665
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
23666
+ return resultobj;
23667
+fail:
23668
+ return NULL;
23669
+}
23670
+
23671
+
23672
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23673
+ PyObject *resultobj = 0;
23674
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23675
+ void *argp1 = 0 ;
23676
+ int res1 = 0 ;
23677
+ PyObject * obj0 = 0 ;
23678
+
23679
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap_clear",&obj0)) SWIG_fail;
23680
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23681
+ if (!SWIG_IsOK(res1)) {
23682
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_clear" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
23683
+ }
23684
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23685
+ (arg1)->clear();
23686
+ resultobj = SWIG_Py_Void();
23687
+ return resultobj;
23688
+fail:
23689
+ return NULL;
23690
+}
23691
+
23692
+
23693
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23694
+ PyObject *resultobj = 0;
23695
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23696
+ std::map< int,std::vector< double,std::allocator< double > > > *arg2 = 0 ;
23697
+ void *argp1 = 0 ;
23698
+ int res1 = 0 ;
23699
+ void *argp2 = 0 ;
23700
+ int res2 = 0 ;
23701
+ PyObject * obj0 = 0 ;
23702
+ PyObject * obj1 = 0 ;
23703
+
23704
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVecIntMap_swap",&obj0,&obj1)) SWIG_fail;
23705
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23706
+ if (!SWIG_IsOK(res1)) {
23707
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_swap" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
23708
+ }
23709
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23710
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 );
23711
+ if (!SWIG_IsOK(res2)) {
23712
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleVecIntMap_swap" "', argument " "2"" of type '" "std::map< int,std::vector< double,std::allocator< double > > > &""'");
23713
+ }
23714
+ if (!argp2) {
23715
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVecIntMap_swap" "', argument " "2"" of type '" "std::map< int,std::vector< double,std::allocator< double > > > &""'");
23716
+ }
23717
+ arg2 = reinterpret_cast< std::map< int,std::vector< double,std::allocator< double > > > * >(argp2);
23718
+ (arg1)->swap(*arg2);
23719
+ resultobj = SWIG_Py_Void();
23720
+ return resultobj;
23721
+fail:
23722
+ return NULL;
23723
+}
23724
+
23725
+
23726
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23727
+ PyObject *resultobj = 0;
23728
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23729
+ void *argp1 = 0 ;
23730
+ int res1 = 0 ;
23731
+ PyObject * obj0 = 0 ;
23732
+ SwigValueWrapper< std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > > result;
23733
+
23734
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap_get_allocator",&obj0)) SWIG_fail;
23735
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23736
+ if (!SWIG_IsOK(res1)) {
23737
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_get_allocator" "', argument " "1"" of type '" "std::map< int,std::vector< double > > const *""'");
23738
+ }
23739
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23740
+ result = ((std::map< int,std::vector< double > > const *)arg1)->get_allocator();
23741
+ resultobj = SWIG_NewPointerObj((new std::map< int,std::vector< double > >::allocator_type(static_cast< const std::map< int,std::vector< double > >::allocator_type& >(result))), SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
23742
+ return resultobj;
23743
+fail:
23744
+ return NULL;
23745
+}
23746
+
23747
+
23748
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23749
+ PyObject *resultobj = 0;
23750
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23751
+ void *argp1 = 0 ;
23752
+ int res1 = 0 ;
23753
+ PyObject * obj0 = 0 ;
23754
+ std::map< int,std::vector< double > >::const_iterator result;
23755
+
23756
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap_begin",&obj0)) SWIG_fail;
23757
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23758
+ if (!SWIG_IsOK(res1)) {
23759
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_begin" "', argument " "1"" of type '" "std::map< int,std::vector< double > > const *""'");
23760
+ }
23761
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23762
+ result = ((std::map< int,std::vector< double > > const *)arg1)->begin();
23763
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< double > >::const_iterator & >(result)),
23764
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
23765
+ return resultobj;
23766
+fail:
23767
+ return NULL;
23768
+}
23769
+
23770
+
23771
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23772
+ PyObject *resultobj = 0;
23773
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23774
+ void *argp1 = 0 ;
23775
+ int res1 = 0 ;
23776
+ PyObject * obj0 = 0 ;
23777
+ std::map< int,std::vector< double > >::const_iterator result;
23778
+
23779
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap_end",&obj0)) SWIG_fail;
23780
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23781
+ if (!SWIG_IsOK(res1)) {
23782
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_end" "', argument " "1"" of type '" "std::map< int,std::vector< double > > const *""'");
23783
+ }
23784
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23785
+ result = ((std::map< int,std::vector< double > > const *)arg1)->end();
23786
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< double > >::const_iterator & >(result)),
23787
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
23788
+ return resultobj;
23789
+fail:
23790
+ return NULL;
23791
+}
23792
+
23793
+
23794
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23795
+ PyObject *resultobj = 0;
23796
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23797
+ void *argp1 = 0 ;
23798
+ int res1 = 0 ;
23799
+ PyObject * obj0 = 0 ;
23800
+ std::map< int,std::vector< double > >::const_reverse_iterator result;
23801
+
23802
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap_rbegin",&obj0)) SWIG_fail;
23803
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23804
+ if (!SWIG_IsOK(res1)) {
23805
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_rbegin" "', argument " "1"" of type '" "std::map< int,std::vector< double > > const *""'");
23806
+ }
23807
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23808
+ result = ((std::map< int,std::vector< double > > const *)arg1)->rbegin();
23809
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< double > >::const_reverse_iterator & >(result)),
23810
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
23811
+ return resultobj;
23812
+fail:
23813
+ return NULL;
23814
+}
23815
+
23816
+
23817
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23818
+ PyObject *resultobj = 0;
23819
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23820
+ void *argp1 = 0 ;
23821
+ int res1 = 0 ;
23822
+ PyObject * obj0 = 0 ;
23823
+ std::map< int,std::vector< double > >::const_reverse_iterator result;
23824
+
23825
+ if (!PyArg_ParseTuple(args,(char *)"O:DoubleVecIntMap_rend",&obj0)) SWIG_fail;
23826
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23827
+ if (!SWIG_IsOK(res1)) {
23828
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_rend" "', argument " "1"" of type '" "std::map< int,std::vector< double > > const *""'");
23829
+ }
23830
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23831
+ result = ((std::map< int,std::vector< double > > const *)arg1)->rend();
23832
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< double > >::const_reverse_iterator & >(result)),
23833
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
23834
+ return resultobj;
23835
+fail:
23836
+ return NULL;
23837
+}
23838
+
23839
+
23840
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23841
+ PyObject *resultobj = 0;
23842
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23843
+ std::map< int,std::vector< double > >::key_type *arg2 = 0 ;
23844
+ void *argp1 = 0 ;
23845
+ int res1 = 0 ;
23846
+ std::map< int,std::vector< double > >::key_type temp2 ;
23847
+ int val2 ;
23848
+ int ecode2 = 0 ;
23849
+ PyObject * obj0 = 0 ;
23850
+ PyObject * obj1 = 0 ;
23851
+ std::map< int,std::vector< double > >::size_type result;
23852
+
23853
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVecIntMap_erase",&obj0,&obj1)) SWIG_fail;
23854
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23855
+ if (!SWIG_IsOK(res1)) {
23856
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_erase" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
23857
+ }
23858
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23859
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
23860
+ if (!SWIG_IsOK(ecode2)) {
23861
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< double > >::key_type""'");
23862
+ }
23863
+ temp2 = static_cast< std::map< int,std::vector< double > >::key_type >(val2);
23864
+ arg2 = &temp2;
23865
+ result = (arg1)->erase((std::map< int,std::vector< double > >::key_type const &)*arg2);
23866
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
23867
+ return resultobj;
23868
+fail:
23869
+ return NULL;
23870
+}
23871
+
23872
+
23873
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23874
+ PyObject *resultobj = 0;
23875
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23876
+ std::map< int,std::vector< double > >::key_type *arg2 = 0 ;
23877
+ void *argp1 = 0 ;
23878
+ int res1 = 0 ;
23879
+ std::map< int,std::vector< double > >::key_type temp2 ;
23880
+ int val2 ;
23881
+ int ecode2 = 0 ;
23882
+ PyObject * obj0 = 0 ;
23883
+ PyObject * obj1 = 0 ;
23884
+ std::map< int,std::vector< double > >::size_type result;
23885
+
23886
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVecIntMap_count",&obj0,&obj1)) SWIG_fail;
23887
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23888
+ if (!SWIG_IsOK(res1)) {
23889
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_count" "', argument " "1"" of type '" "std::map< int,std::vector< double > > const *""'");
23890
+ }
23891
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23892
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
23893
+ if (!SWIG_IsOK(ecode2)) {
23894
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVecIntMap_count" "', argument " "2"" of type '" "std::map< int,std::vector< double > >::key_type""'");
23895
+ }
23896
+ temp2 = static_cast< std::map< int,std::vector< double > >::key_type >(val2);
23897
+ arg2 = &temp2;
23898
+ result = ((std::map< int,std::vector< double > > const *)arg1)->count((std::map< int,std::vector< double > >::key_type const &)*arg2);
23899
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
23900
+ return resultobj;
23901
+fail:
23902
+ return NULL;
23903
+}
23904
+
23905
+
23906
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23907
+ PyObject *resultobj = 0;
23908
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23909
+ std::map< int,std::vector< double > >::iterator arg2 ;
23910
+ void *argp1 = 0 ;
23911
+ int res1 = 0 ;
23912
+ swig::PySwigIterator *iter2 = 0 ;
23913
+ int res2 ;
23914
+ PyObject * obj0 = 0 ;
23915
+ PyObject * obj1 = 0 ;
23916
+
23917
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVecIntMap_erase",&obj0,&obj1)) SWIG_fail;
23918
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23919
+ if (!SWIG_IsOK(res1)) {
23920
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_erase" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
23921
+ }
23922
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23923
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
23924
+ if (!SWIG_IsOK(res2) || !iter2) {
23925
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< double > >::iterator""'");
23926
+ } else {
23927
+ swig::PySwigIterator_T<std::map< int,std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< double > >::iterator > *>(iter2);
23928
+ if (iter_t) {
23929
+ arg2 = iter_t->get_current();
23930
+ } else {
23931
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< double > >::iterator""'");
23932
+ }
23933
+ }
23934
+ (arg1)->erase(arg2);
23935
+ resultobj = SWIG_Py_Void();
23936
+ return resultobj;
23937
+fail:
23938
+ return NULL;
23939
+}
23940
+
23941
+
23942
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23943
+ PyObject *resultobj = 0;
23944
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
23945
+ std::map< int,std::vector< double > >::iterator arg2 ;
23946
+ std::map< int,std::vector< double > >::iterator arg3 ;
23947
+ void *argp1 = 0 ;
23948
+ int res1 = 0 ;
23949
+ swig::PySwigIterator *iter2 = 0 ;
23950
+ int res2 ;
23951
+ swig::PySwigIterator *iter3 = 0 ;
23952
+ int res3 ;
23953
+ PyObject * obj0 = 0 ;
23954
+ PyObject * obj1 = 0 ;
23955
+ PyObject * obj2 = 0 ;
23956
+
23957
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleVecIntMap_erase",&obj0,&obj1,&obj2)) SWIG_fail;
23958
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
23959
+ if (!SWIG_IsOK(res1)) {
23960
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_erase" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
23961
+ }
23962
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
23963
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
23964
+ if (!SWIG_IsOK(res2) || !iter2) {
23965
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< double > >::iterator""'");
23966
+ } else {
23967
+ swig::PySwigIterator_T<std::map< int,std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< double > >::iterator > *>(iter2);
23968
+ if (iter_t) {
23969
+ arg2 = iter_t->get_current();
23970
+ } else {
23971
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVecIntMap_erase" "', argument " "2"" of type '" "std::map< int,std::vector< double > >::iterator""'");
23972
+ }
23973
+ }
23974
+ res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
23975
+ if (!SWIG_IsOK(res3) || !iter3) {
23976
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVecIntMap_erase" "', argument " "3"" of type '" "std::map< int,std::vector< double > >::iterator""'");
23977
+ } else {
23978
+ swig::PySwigIterator_T<std::map< int,std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< double > >::iterator > *>(iter3);
23979
+ if (iter_t) {
23980
+ arg3 = iter_t->get_current();
23981
+ } else {
23982
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVecIntMap_erase" "', argument " "3"" of type '" "std::map< int,std::vector< double > >::iterator""'");
23983
+ }
23984
+ }
23985
+ (arg1)->erase(arg2,arg3);
23986
+ resultobj = SWIG_Py_Void();
23987
+ return resultobj;
23988
+fail:
23989
+ return NULL;
23990
+}
23991
+
23992
+
23993
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_erase(PyObject *self, PyObject *args) {
23994
+ int argc;
23995
+ PyObject *argv[4];
23996
+ int ii;
23997
+
23998
+ if (!PyTuple_Check(args)) SWIG_fail;
23999
+ argc = (int)PyObject_Length(args);
24000
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
24001
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
24002
+ }
24003
+ if (argc == 2) {
24004
+ int _v;
24005
+ int res = swig::asptr(argv[0], (std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >**)(0));
24006
+ _v = SWIG_CheckState(res);
24007
+ if (_v) {
24008
+ swig::PySwigIterator *iter = 0;
24009
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
24010
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< double > >::iterator > *>(iter) != 0));
24011
+ if (_v) {
24012
+ return _wrap_DoubleVecIntMap_erase__SWIG_1(self, args);
24013
+ }
24014
+ }
24015
+ }
24016
+ if (argc == 2) {
24017
+ int _v;
24018
+ int res = swig::asptr(argv[0], (std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >**)(0));
24019
+ _v = SWIG_CheckState(res);
24020
+ if (_v) {
24021
+ {
24022
+ int res = SWIG_AsVal_int(argv[1], NULL);
24023
+ _v = SWIG_CheckState(res);
24024
+ }
24025
+ if (_v) {
24026
+ return _wrap_DoubleVecIntMap_erase__SWIG_0(self, args);
24027
+ }
24028
+ }
24029
+ }
24030
+ if (argc == 3) {
24031
+ int _v;
24032
+ int res = swig::asptr(argv[0], (std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > >**)(0));
24033
+ _v = SWIG_CheckState(res);
24034
+ if (_v) {
24035
+ swig::PySwigIterator *iter = 0;
24036
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
24037
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< double > >::iterator > *>(iter) != 0));
24038
+ if (_v) {
24039
+ swig::PySwigIterator *iter = 0;
24040
+ int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
24041
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::map< int,std::vector< double > >::iterator > *>(iter) != 0));
24042
+ if (_v) {
24043
+ return _wrap_DoubleVecIntMap_erase__SWIG_2(self, args);
24044
+ }
24045
+ }
24046
+ }
24047
+ }
24048
+
24049
+fail:
24050
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'DoubleVecIntMap_erase'.\n"
24051
+ " Possible C/C++ prototypes are:\n"
24052
+ " erase(std::map< int,std::vector< double > > *,std::map< int,std::vector< double > >::key_type const &)\n"
24053
+ " erase(std::map< int,std::vector< double > > *,std::map< int,std::vector< double > >::iterator)\n"
24054
+ " erase(std::map< int,std::vector< double > > *,std::map< int,std::vector< double > >::iterator,std::map< int,std::vector< double > >::iterator)\n");
24055
+ return NULL;
24056
+}
24057
+
24058
+
24059
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24060
+ PyObject *resultobj = 0;
24061
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
24062
+ std::map< int,std::vector< double > >::key_type *arg2 = 0 ;
24063
+ void *argp1 = 0 ;
24064
+ int res1 = 0 ;
24065
+ std::map< int,std::vector< double > >::key_type temp2 ;
24066
+ int val2 ;
24067
+ int ecode2 = 0 ;
24068
+ PyObject * obj0 = 0 ;
24069
+ PyObject * obj1 = 0 ;
24070
+ std::map< int,std::vector< double > >::iterator result;
24071
+
24072
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVecIntMap_find",&obj0,&obj1)) SWIG_fail;
24073
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
24074
+ if (!SWIG_IsOK(res1)) {
24075
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_find" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
24076
+ }
24077
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
24078
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
24079
+ if (!SWIG_IsOK(ecode2)) {
24080
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVecIntMap_find" "', argument " "2"" of type '" "std::map< int,std::vector< double > >::key_type""'");
24081
+ }
24082
+ temp2 = static_cast< std::map< int,std::vector< double > >::key_type >(val2);
24083
+ arg2 = &temp2;
24084
+ result = (arg1)->find((std::map< int,std::vector< double > >::key_type const &)*arg2);
24085
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< double > >::iterator & >(result)),
24086
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
24087
+ return resultobj;
24088
+fail:
24089
+ return NULL;
24090
+}
24091
+
24092
+
24093
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_lower_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24094
+ PyObject *resultobj = 0;
24095
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
24096
+ std::map< int,std::vector< double > >::key_type *arg2 = 0 ;
24097
+ void *argp1 = 0 ;
24098
+ int res1 = 0 ;
24099
+ std::map< int,std::vector< double > >::key_type temp2 ;
24100
+ int val2 ;
24101
+ int ecode2 = 0 ;
24102
+ PyObject * obj0 = 0 ;
24103
+ PyObject * obj1 = 0 ;
24104
+ std::map< int,std::vector< double > >::iterator result;
24105
+
24106
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVecIntMap_lower_bound",&obj0,&obj1)) SWIG_fail;
24107
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
24108
+ if (!SWIG_IsOK(res1)) {
24109
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_lower_bound" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
24110
+ }
24111
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
24112
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
24113
+ if (!SWIG_IsOK(ecode2)) {
24114
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVecIntMap_lower_bound" "', argument " "2"" of type '" "std::map< int,std::vector< double > >::key_type""'");
24115
+ }
24116
+ temp2 = static_cast< std::map< int,std::vector< double > >::key_type >(val2);
24117
+ arg2 = &temp2;
24118
+ result = (arg1)->lower_bound((std::map< int,std::vector< double > >::key_type const &)*arg2);
24119
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< double > >::iterator & >(result)),
24120
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
24121
+ return resultobj;
24122
+fail:
24123
+ return NULL;
24124
+}
24125
+
24126
+
24127
+SWIGINTERN PyObject *_wrap_DoubleVecIntMap_upper_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24128
+ PyObject *resultobj = 0;
24129
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
24130
+ std::map< int,std::vector< double > >::key_type *arg2 = 0 ;
24131
+ void *argp1 = 0 ;
24132
+ int res1 = 0 ;
24133
+ std::map< int,std::vector< double > >::key_type temp2 ;
24134
+ int val2 ;
24135
+ int ecode2 = 0 ;
24136
+ PyObject * obj0 = 0 ;
24137
+ PyObject * obj1 = 0 ;
24138
+ std::map< int,std::vector< double > >::iterator result;
24139
+
24140
+ if (!PyArg_ParseTuple(args,(char *)"OO:DoubleVecIntMap_upper_bound",&obj0,&obj1)) SWIG_fail;
24141
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0 | 0 );
24142
+ if (!SWIG_IsOK(res1)) {
24143
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVecIntMap_upper_bound" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
24144
+ }
24145
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
24146
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
24147
+ if (!SWIG_IsOK(ecode2)) {
24148
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVecIntMap_upper_bound" "', argument " "2"" of type '" "std::map< int,std::vector< double > >::key_type""'");
24149
+ }
24150
+ temp2 = static_cast< std::map< int,std::vector< double > >::key_type >(val2);
24151
+ arg2 = &temp2;
24152
+ result = (arg1)->upper_bound((std::map< int,std::vector< double > >::key_type const &)*arg2);
24153
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,std::vector< double > >::iterator & >(result)),
24154
+ swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
24155
+ return resultobj;
24156
+fail:
24157
+ return NULL;
24158
+}
24159
+
24160
+
24161
+SWIGINTERN PyObject *_wrap_delete_DoubleVecIntMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24162
+ PyObject *resultobj = 0;
24163
+ std::map< int,std::vector< double > > *arg1 = (std::map< int,std::vector< double > > *) 0 ;
24164
+ void *argp1 = 0 ;
24165
+ int res1 = 0 ;
24166
+ PyObject * obj0 = 0 ;
24167
+
24168
+ if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleVecIntMap",&obj0)) SWIG_fail;
24169
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, SWIG_POINTER_DISOWN | 0 );
24170
+ if (!SWIG_IsOK(res1)) {
24171
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleVecIntMap" "', argument " "1"" of type '" "std::map< int,std::vector< double > > *""'");
24172
+ }
24173
+ arg1 = reinterpret_cast< std::map< int,std::vector< double > > * >(argp1);
24174
+ delete arg1;
24175
+ resultobj = SWIG_Py_Void();
24176
+ return resultobj;
24177
+fail:
24178
+ return NULL;
24179
+}
24180
+
24181
+
24182
+SWIGINTERN PyObject *DoubleVecIntMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24183
+ PyObject *obj;
24184
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
24185
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, SWIG_NewClientData(obj));
24186
+ return SWIG_Py_Void();
24187
+}
24188
+
24189
+SWIGINTERN PyObject *_wrap_new_DisplayDriver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24190
+ PyObject *resultobj = 0;
24191
+ void *arg1 = (void *) 0 ;
24192
+ void *arg2 = (void *) 0 ;
24193
+ int res1 ;
24194
+ int res2 ;
24195
+ PyObject * obj0 = 0 ;
24196
+ PyObject * obj1 = 0 ;
24197
+ DisplayDriver *result = 0 ;
24198
+
24199
+ if (!PyArg_ParseTuple(args,(char *)"OO:new_DisplayDriver",&obj0,&obj1)) SWIG_fail;
24200
+ res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
24201
+ if (!SWIG_IsOK(res1)) {
24202
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DisplayDriver" "', argument " "1"" of type '" "void *""'");
24203
+ }
24204
+ res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
24205
+ if (!SWIG_IsOK(res2)) {
24206
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DisplayDriver" "', argument " "2"" of type '" "void *""'");
24207
+ }
24208
+ result = (DisplayDriver *)new DisplayDriver(arg1,arg2);
24209
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DisplayDriver, SWIG_POINTER_NEW | 0 );
24210
+ return resultobj;
24211
+fail:
24212
+ return NULL;
24213
+}
24214
+
24215
+
24216
+SWIGINTERN PyObject *_wrap_delete_DisplayDriver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24217
+ PyObject *resultobj = 0;
24218
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24219
+ void *argp1 = 0 ;
24220
+ int res1 = 0 ;
24221
+ PyObject * obj0 = 0 ;
24222
+
24223
+ if (!PyArg_ParseTuple(args,(char *)"O:delete_DisplayDriver",&obj0)) SWIG_fail;
24224
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, SWIG_POINTER_DISOWN | 0 );
24225
+ if (!SWIG_IsOK(res1)) {
24226
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DisplayDriver" "', argument " "1"" of type '" "DisplayDriver *""'");
24227
+ }
24228
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24229
+ delete arg1;
24230
+ resultobj = SWIG_Py_Void();
24231
+ return resultobj;
24232
+fail:
24233
+ return NULL;
24234
+}
24235
+
24236
+
24237
+SWIGINTERN PyObject *_wrap_DisplayDriver_DrawMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24238
+ PyObject *resultobj = 0;
24239
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24240
+ bool arg2 ;
24241
+ void *argp1 = 0 ;
24242
+ int res1 = 0 ;
24243
+ bool val2 ;
24244
+ int ecode2 = 0 ;
24245
+ PyObject * obj0 = 0 ;
24246
+ PyObject * obj1 = 0 ;
24247
+ int result;
24248
+
24249
+ if (!PyArg_ParseTuple(args,(char *)"OO:DisplayDriver_DrawMap",&obj0,&obj1)) SWIG_fail;
24250
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24251
+ if (!SWIG_IsOK(res1)) {
24252
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_DrawMap" "', argument " "1"" of type '" "DisplayDriver *""'");
24253
+ }
24254
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24255
+ ecode2 = SWIG_AsVal_bool(obj1, &val2);
24256
+ if (!SWIG_IsOK(ecode2)) {
24257
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DisplayDriver_DrawMap" "', argument " "2"" of type '" "bool""'");
24258
+ }
24259
+ arg2 = static_cast< bool >(val2);
24260
+ result = (int)(arg1)->DrawMap(arg2);
24261
+ resultobj = SWIG_From_int(static_cast< int >(result));
24262
+ return resultobj;
24263
+fail:
24264
+ return NULL;
24265
+}
24266
+
24267
+
24268
+SWIGINTERN PyObject *_wrap_DisplayDriver_SelectLinesByBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24269
+ PyObject *resultobj = 0;
24270
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24271
+ double arg2 ;
24272
+ double arg3 ;
24273
+ double arg4 ;
24274
+ double arg5 ;
24275
+ double arg6 ;
24276
+ double arg7 ;
24277
+ int arg8 ;
24278
+ bool arg9 ;
24279
+ bool arg10 ;
24280
+ void *argp1 = 0 ;
24281
+ int res1 = 0 ;
24282
+ double val2 ;
24283
+ int ecode2 = 0 ;
24284
+ double val3 ;
24285
+ int ecode3 = 0 ;
24286
+ double val4 ;
24287
+ int ecode4 = 0 ;
24288
+ double val5 ;
24289
+ int ecode5 = 0 ;
24290
+ double val6 ;
24291
+ int ecode6 = 0 ;
24292
+ double val7 ;
24293
+ int ecode7 = 0 ;
24294
+ int val8 ;
24295
+ int ecode8 = 0 ;
24296
+ bool val9 ;
24297
+ int ecode9 = 0 ;
24298
+ bool val10 ;
24299
+ int ecode10 = 0 ;
24300
+ PyObject * obj0 = 0 ;
24301
+ PyObject * obj1 = 0 ;
24302
+ PyObject * obj2 = 0 ;
24303
+ PyObject * obj3 = 0 ;
24304
+ PyObject * obj4 = 0 ;
24305
+ PyObject * obj5 = 0 ;
24306
+ PyObject * obj6 = 0 ;
24307
+ PyObject * obj7 = 0 ;
24308
+ PyObject * obj8 = 0 ;
24309
+ PyObject * obj9 = 0 ;
24310
+ int result;
24311
+
24312
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:DisplayDriver_SelectLinesByBox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
24313
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24314
+ if (!SWIG_IsOK(res1)) {
24315
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_SelectLinesByBox" "', argument " "1"" of type '" "DisplayDriver *""'");
24316
+ }
24317
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24318
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
24319
+ if (!SWIG_IsOK(ecode2)) {
24320
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DisplayDriver_SelectLinesByBox" "', argument " "2"" of type '" "double""'");
24321
+ }
24322
+ arg2 = static_cast< double >(val2);
24323
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
24324
+ if (!SWIG_IsOK(ecode3)) {
24325
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DisplayDriver_SelectLinesByBox" "', argument " "3"" of type '" "double""'");
24326
+ }
24327
+ arg3 = static_cast< double >(val3);
24328
+ ecode4 = SWIG_AsVal_double(obj3, &val4);
24329
+ if (!SWIG_IsOK(ecode4)) {
24330
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DisplayDriver_SelectLinesByBox" "', argument " "4"" of type '" "double""'");
24331
+ }
24332
+ arg4 = static_cast< double >(val4);
24333
+ ecode5 = SWIG_AsVal_double(obj4, &val5);
24334
+ if (!SWIG_IsOK(ecode5)) {
24335
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DisplayDriver_SelectLinesByBox" "', argument " "5"" of type '" "double""'");
24336
+ }
24337
+ arg5 = static_cast< double >(val5);
24338
+ ecode6 = SWIG_AsVal_double(obj5, &val6);
24339
+ if (!SWIG_IsOK(ecode6)) {
24340
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DisplayDriver_SelectLinesByBox" "', argument " "6"" of type '" "double""'");
24341
+ }
24342
+ arg6 = static_cast< double >(val6);
24343
+ ecode7 = SWIG_AsVal_double(obj6, &val7);
24344
+ if (!SWIG_IsOK(ecode7)) {
24345
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DisplayDriver_SelectLinesByBox" "', argument " "7"" of type '" "double""'");
24346
+ }
24347
+ arg7 = static_cast< double >(val7);
24348
+ ecode8 = SWIG_AsVal_int(obj7, &val8);
24349
+ if (!SWIG_IsOK(ecode8)) {
24350
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DisplayDriver_SelectLinesByBox" "', argument " "8"" of type '" "int""'");
24351
+ }
24352
+ arg8 = static_cast< int >(val8);
24353
+ ecode9 = SWIG_AsVal_bool(obj8, &val9);
24354
+ if (!SWIG_IsOK(ecode9)) {
24355
+ SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "DisplayDriver_SelectLinesByBox" "', argument " "9"" of type '" "bool""'");
24356
+ }
24357
+ arg9 = static_cast< bool >(val9);
24358
+ ecode10 = SWIG_AsVal_bool(obj9, &val10);
24359
+ if (!SWIG_IsOK(ecode10)) {
24360
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "DisplayDriver_SelectLinesByBox" "', argument " "10"" of type '" "bool""'");
24361
+ }
24362
+ arg10 = static_cast< bool >(val10);
24363
+ result = (int)(arg1)->SelectLinesByBox(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
24364
+ resultobj = SWIG_From_int(static_cast< int >(result));
24365
+ return resultobj;
24366
+fail:
24367
+ return NULL;
24368
+}
24369
+
24370
+
24371
+SWIGINTERN PyObject *_wrap_DisplayDriver_SelectLineByPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24372
+ PyObject *resultobj = 0;
24373
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24374
+ double arg2 ;
24375
+ double arg3 ;
24376
+ double arg4 ;
24377
+ double arg5 ;
24378
+ int arg6 ;
24379
+ int arg7 ;
24380
+ void *argp1 = 0 ;
24381
+ int res1 = 0 ;
24382
+ double val2 ;
24383
+ int ecode2 = 0 ;
24384
+ double val3 ;
24385
+ int ecode3 = 0 ;
24386
+ double val4 ;
24387
+ int ecode4 = 0 ;
24388
+ double val5 ;
24389
+ int ecode5 = 0 ;
24390
+ int val6 ;
24391
+ int ecode6 = 0 ;
24392
+ int val7 ;
24393
+ int ecode7 = 0 ;
24394
+ PyObject * obj0 = 0 ;
24395
+ PyObject * obj1 = 0 ;
24396
+ PyObject * obj2 = 0 ;
24397
+ PyObject * obj3 = 0 ;
24398
+ PyObject * obj4 = 0 ;
24399
+ PyObject * obj5 = 0 ;
24400
+ PyObject * obj6 = 0 ;
24401
+ std::vector< double,std::allocator< double > > result;
24402
+
24403
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:DisplayDriver_SelectLineByPoint",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24404
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24405
+ if (!SWIG_IsOK(res1)) {
24406
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_SelectLineByPoint" "', argument " "1"" of type '" "DisplayDriver *""'");
24407
+ }
24408
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24409
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
24410
+ if (!SWIG_IsOK(ecode2)) {
24411
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DisplayDriver_SelectLineByPoint" "', argument " "2"" of type '" "double""'");
24412
+ }
24413
+ arg2 = static_cast< double >(val2);
24414
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
24415
+ if (!SWIG_IsOK(ecode3)) {
24416
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DisplayDriver_SelectLineByPoint" "', argument " "3"" of type '" "double""'");
24417
+ }
24418
+ arg3 = static_cast< double >(val3);
24419
+ ecode4 = SWIG_AsVal_double(obj3, &val4);
24420
+ if (!SWIG_IsOK(ecode4)) {
24421
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DisplayDriver_SelectLineByPoint" "', argument " "4"" of type '" "double""'");
24422
+ }
24423
+ arg4 = static_cast< double >(val4);
24424
+ ecode5 = SWIG_AsVal_double(obj4, &val5);
24425
+ if (!SWIG_IsOK(ecode5)) {
24426
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DisplayDriver_SelectLineByPoint" "', argument " "5"" of type '" "double""'");
24427
+ }
24428
+ arg5 = static_cast< double >(val5);
24429
+ ecode6 = SWIG_AsVal_int(obj5, &val6);
24430
+ if (!SWIG_IsOK(ecode6)) {
24431
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DisplayDriver_SelectLineByPoint" "', argument " "6"" of type '" "int""'");
24432
+ }
24433
+ arg6 = static_cast< int >(val6);
24434
+ ecode7 = SWIG_AsVal_int(obj6, &val7);
24435
+ if (!SWIG_IsOK(ecode7)) {
24436
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DisplayDriver_SelectLineByPoint" "', argument " "7"" of type '" "int""'");
24437
+ }
24438
+ arg7 = static_cast< int >(val7);
24439
+ result = (arg1)->SelectLineByPoint(arg2,arg3,arg4,arg5,arg6,arg7);
24440
+ resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
24441
+ return resultobj;
24442
+fail:
24443
+ return NULL;
24444
+}
24445
+
24446
+
24447
+SWIGINTERN PyObject *_wrap_DisplayDriver_GetSelected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24448
+ PyObject *resultobj = 0;
24449
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24450
+ bool arg2 ;
24451
+ void *argp1 = 0 ;
24452
+ int res1 = 0 ;
24453
+ bool val2 ;
24454
+ int ecode2 = 0 ;
24455
+ PyObject * obj0 = 0 ;
24456
+ PyObject * obj1 = 0 ;
24457
+ std::vector< int,std::allocator< int > > result;
24458
+
24459
+ if (!PyArg_ParseTuple(args,(char *)"OO:DisplayDriver_GetSelected",&obj0,&obj1)) SWIG_fail;
24460
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24461
+ if (!SWIG_IsOK(res1)) {
24462
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_GetSelected" "', argument " "1"" of type '" "DisplayDriver *""'");
24463
+ }
24464
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24465
+ ecode2 = SWIG_AsVal_bool(obj1, &val2);
24466
+ if (!SWIG_IsOK(ecode2)) {
24467
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DisplayDriver_GetSelected" "', argument " "2"" of type '" "bool""'");
24468
+ }
24469
+ arg2 = static_cast< bool >(val2);
24470
+ result = (arg1)->GetSelected(arg2);
24471
+ resultobj = swig::from(static_cast< std::vector<int,std::allocator< int > > >(result));
24472
+ return resultobj;
24473
+fail:
24474
+ return NULL;
24475
+}
24476
+
24477
+
24478
+SWIGINTERN PyObject *_wrap_DisplayDriver_GetSelectedCoord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24479
+ PyObject *resultobj = 0;
24480
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24481
+ void *argp1 = 0 ;
24482
+ int res1 = 0 ;
24483
+ PyObject * obj0 = 0 ;
24484
+ std::map< int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > > result;
24485
+
24486
+ if (!PyArg_ParseTuple(args,(char *)"O:DisplayDriver_GetSelectedCoord",&obj0)) SWIG_fail;
24487
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24488
+ if (!SWIG_IsOK(res1)) {
24489
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_GetSelectedCoord" "', argument " "1"" of type '" "DisplayDriver *""'");
24490
+ }
24491
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24492
+ result = (arg1)->GetSelectedCoord();
24493
+ resultobj = swig::from(static_cast< std::map<int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > > >(result));
24494
+ return resultobj;
24495
+fail:
24496
+ return NULL;
24497
+}
24498
+
24499
+
24500
+SWIGINTERN PyObject *_wrap_DisplayDriver_GetDuplicates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24501
+ PyObject *resultobj = 0;
24502
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24503
+ void *argp1 = 0 ;
24504
+ int res1 = 0 ;
24505
+ PyObject * obj0 = 0 ;
24506
+ std::map< int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > > result;
24507
+
24508
+ if (!PyArg_ParseTuple(args,(char *)"O:DisplayDriver_GetDuplicates",&obj0)) SWIG_fail;
24509
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24510
+ if (!SWIG_IsOK(res1)) {
24511
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_GetDuplicates" "', argument " "1"" of type '" "DisplayDriver *""'");
24512
+ }
24513
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24514
+ result = (arg1)->GetDuplicates();
24515
+ resultobj = swig::from(static_cast< std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > > >(result));
24516
+ return resultobj;
24517
+fail:
24518
+ return NULL;
24519
+}
24520
+
24521
+
24522
+SWIGINTERN PyObject *_wrap_DisplayDriver_GetRegionSelected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24523
+ PyObject *resultobj = 0;
24524
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24525
+ void *argp1 = 0 ;
24526
+ int res1 = 0 ;
24527
+ PyObject * obj0 = 0 ;
24528
+ std::vector< double,std::allocator< double > > result;
24529
+
24530
+ if (!PyArg_ParseTuple(args,(char *)"O:DisplayDriver_GetRegionSelected",&obj0)) SWIG_fail;
24531
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24532
+ if (!SWIG_IsOK(res1)) {
24533
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_GetRegionSelected" "', argument " "1"" of type '" "DisplayDriver *""'");
24534
+ }
24535
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24536
+ result = (arg1)->GetRegionSelected();
24537
+ resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
24538
+ return resultobj;
24539
+fail:
24540
+ return NULL;
24541
+}
24542
+
24543
+
24544
+SWIGINTERN PyObject *_wrap_DisplayDriver_SetSelected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24545
+ PyObject *resultobj = 0;
24546
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24547
+ std::vector< int,std::allocator< int > > arg2 ;
24548
+ int arg3 ;
24549
+ void *argp1 = 0 ;
24550
+ int res1 = 0 ;
24551
+ int val3 ;
24552
+ int ecode3 = 0 ;
24553
+ PyObject * obj0 = 0 ;
24554
+ PyObject * obj1 = 0 ;
24555
+ PyObject * obj2 = 0 ;
24556
+ int result;
24557
+
24558
+ if (!PyArg_ParseTuple(args,(char *)"OOO:DisplayDriver_SetSelected",&obj0,&obj1,&obj2)) SWIG_fail;
24559
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24560
+ if (!SWIG_IsOK(res1)) {
24561
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_SetSelected" "', argument " "1"" of type '" "DisplayDriver *""'");
24562
+ }
24563
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24564
+ {
24565
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
24566
+ int res = swig::asptr(obj1, &ptr);
24567
+ if (!SWIG_IsOK(res) || !ptr) {
24568
+ SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "DisplayDriver_SetSelected" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'");
24569
+ }
24570
+ arg2 = *ptr;
24571
+ if (SWIG_IsNewObj(res)) delete ptr;
24572
+ }
24573
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
24574
+ if (!SWIG_IsOK(ecode3)) {
24575
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DisplayDriver_SetSelected" "', argument " "3"" of type '" "int""'");
24576
+ }
24577
+ arg3 = static_cast< int >(val3);
24578
+ result = (int)(arg1)->SetSelected(arg2,arg3);
24579
+ resultobj = SWIG_From_int(static_cast< int >(result));
24580
+ return resultobj;
24581
+fail:
24582
+ return NULL;
24583
+}
24584
+
24585
+
24586
+SWIGINTERN PyObject *_wrap_DisplayDriver_UnSelect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24587
+ PyObject *resultobj = 0;
24588
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24589
+ std::vector< int,std::allocator< int > > arg2 ;
24590
+ void *argp1 = 0 ;
24591
+ int res1 = 0 ;
24592
+ PyObject * obj0 = 0 ;
24593
+ PyObject * obj1 = 0 ;
24594
+ int result;
24595
+
24596
+ if (!PyArg_ParseTuple(args,(char *)"OO:DisplayDriver_UnSelect",&obj0,&obj1)) SWIG_fail;
24597
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24598
+ if (!SWIG_IsOK(res1)) {
24599
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_UnSelect" "', argument " "1"" of type '" "DisplayDriver *""'");
24600
+ }
24601
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24602
+ {
24603
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
24604
+ int res = swig::asptr(obj1, &ptr);
24605
+ if (!SWIG_IsOK(res) || !ptr) {
24606
+ SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "DisplayDriver_UnSelect" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'");
24607
+ }
24608
+ arg2 = *ptr;
24609
+ if (SWIG_IsNewObj(res)) delete ptr;
24610
+ }
24611
+ result = (int)(arg1)->UnSelect(arg2);
24612
+ resultobj = SWIG_From_int(static_cast< int >(result));
24613
+ return resultobj;
24614
+fail:
24615
+ return NULL;
24616
+}
24617
+
24618
+
24619
+SWIGINTERN PyObject *_wrap_DisplayDriver_GetSelectedVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24620
+ PyObject *resultobj = 0;
24621
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24622
+ double arg2 ;
24623
+ double arg3 ;
24624
+ double arg4 ;
24625
+ void *argp1 = 0 ;
24626
+ int res1 = 0 ;
24627
+ double val2 ;
24628
+ int ecode2 = 0 ;
24629
+ double val3 ;
24630
+ int ecode3 = 0 ;
24631
+ double val4 ;
24632
+ int ecode4 = 0 ;
24633
+ PyObject * obj0 = 0 ;
24634
+ PyObject * obj1 = 0 ;
24635
+ PyObject * obj2 = 0 ;
24636
+ PyObject * obj3 = 0 ;
24637
+ std::vector< int,std::allocator< int > > result;
24638
+
24639
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:DisplayDriver_GetSelectedVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24640
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24641
+ if (!SWIG_IsOK(res1)) {
24642
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_GetSelectedVertex" "', argument " "1"" of type '" "DisplayDriver *""'");
24643
+ }
24644
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24645
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
24646
+ if (!SWIG_IsOK(ecode2)) {
24647
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DisplayDriver_GetSelectedVertex" "', argument " "2"" of type '" "double""'");
24648
+ }
24649
+ arg2 = static_cast< double >(val2);
24650
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
24651
+ if (!SWIG_IsOK(ecode3)) {
24652
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DisplayDriver_GetSelectedVertex" "', argument " "3"" of type '" "double""'");
24653
+ }
24654
+ arg3 = static_cast< double >(val3);
24655
+ ecode4 = SWIG_AsVal_double(obj3, &val4);
24656
+ if (!SWIG_IsOK(ecode4)) {
24657
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DisplayDriver_GetSelectedVertex" "', argument " "4"" of type '" "double""'");
24658
+ }
24659
+ arg4 = static_cast< double >(val4);
24660
+ result = (arg1)->GetSelectedVertex(arg2,arg3,arg4);
24661
+ resultobj = swig::from(static_cast< std::vector<int,std::allocator< int > > >(result));
24662
+ return resultobj;
24663
+fail:
24664
+ return NULL;
24665
+}
24666
+
24667
+
24668
+SWIGINTERN PyObject *_wrap_DisplayDriver_DrawSelected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24669
+ PyObject *resultobj = 0;
24670
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24671
+ bool arg2 ;
24672
+ void *argp1 = 0 ;
24673
+ int res1 = 0 ;
24674
+ bool val2 ;
24675
+ int ecode2 = 0 ;
24676
+ PyObject * obj0 = 0 ;
24677
+ PyObject * obj1 = 0 ;
24678
+
24679
+ if (!PyArg_ParseTuple(args,(char *)"OO:DisplayDriver_DrawSelected",&obj0,&obj1)) SWIG_fail;
24680
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24681
+ if (!SWIG_IsOK(res1)) {
24682
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_DrawSelected" "', argument " "1"" of type '" "DisplayDriver *""'");
24683
+ }
24684
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24685
+ ecode2 = SWIG_AsVal_bool(obj1, &val2);
24686
+ if (!SWIG_IsOK(ecode2)) {
24687
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DisplayDriver_DrawSelected" "', argument " "2"" of type '" "bool""'");
24688
+ }
24689
+ arg2 = static_cast< bool >(val2);
24690
+ (arg1)->DrawSelected(arg2);
24691
+ resultobj = SWIG_Py_Void();
24692
+ return resultobj;
24693
+fail:
24694
+ return NULL;
24695
+}
24696
+
24697
+
24698
+SWIGINTERN PyObject *_wrap_DisplayDriver_CloseMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24699
+ PyObject *resultobj = 0;
24700
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24701
+ void *argp1 = 0 ;
24702
+ int res1 = 0 ;
24703
+ PyObject * obj0 = 0 ;
24704
+ int result;
24705
+
24706
+ if (!PyArg_ParseTuple(args,(char *)"O:DisplayDriver_CloseMap",&obj0)) SWIG_fail;
24707
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24708
+ if (!SWIG_IsOK(res1)) {
24709
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_CloseMap" "', argument " "1"" of type '" "DisplayDriver *""'");
24710
+ }
24711
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24712
+ result = (int)(arg1)->CloseMap();
24713
+ resultobj = SWIG_From_int(static_cast< int >(result));
24714
+ return resultobj;
24715
+fail:
24716
+ return NULL;
24717
+}
24718
+
24719
+
24720
+SWIGINTERN PyObject *_wrap_DisplayDriver_OpenMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24721
+ PyObject *resultobj = 0;
24722
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24723
+ char *arg2 = (char *) 0 ;
24724
+ char *arg3 = (char *) 0 ;
24725
+ bool arg4 ;
24726
+ void *argp1 = 0 ;
24727
+ int res1 = 0 ;
24728
+ int res2 ;
24729
+ char *buf2 = 0 ;
24730
+ int alloc2 = 0 ;
24731
+ int res3 ;
24732
+ char *buf3 = 0 ;
24733
+ int alloc3 = 0 ;
24734
+ bool val4 ;
24735
+ int ecode4 = 0 ;
24736
+ PyObject * obj0 = 0 ;
24737
+ PyObject * obj1 = 0 ;
24738
+ PyObject * obj2 = 0 ;
24739
+ PyObject * obj3 = 0 ;
24740
+ int result;
24741
+
24742
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:DisplayDriver_OpenMap",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24743
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24744
+ if (!SWIG_IsOK(res1)) {
24745
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_OpenMap" "', argument " "1"" of type '" "DisplayDriver *""'");
24746
+ }
24747
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24748
+ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24749
+ if (!SWIG_IsOK(res2)) {
24750
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DisplayDriver_OpenMap" "', argument " "2"" of type '" "char const *""'");
24751
+ }
24752
+ arg2 = reinterpret_cast< char * >(buf2);
24753
+ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
24754
+ if (!SWIG_IsOK(res3)) {
24755
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DisplayDriver_OpenMap" "', argument " "3"" of type '" "char const *""'");
24756
+ }
24757
+ arg3 = reinterpret_cast< char * >(buf3);
24758
+ ecode4 = SWIG_AsVal_bool(obj3, &val4);
24759
+ if (!SWIG_IsOK(ecode4)) {
24760
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DisplayDriver_OpenMap" "', argument " "4"" of type '" "bool""'");
24761
+ }
24762
+ arg4 = static_cast< bool >(val4);
24763
+ result = (int)(arg1)->OpenMap((char const *)arg2,(char const *)arg3,arg4);
24764
+ resultobj = SWIG_From_int(static_cast< int >(result));
24765
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24766
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
24767
+ return resultobj;
24768
+fail:
24769
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24770
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
24771
+ return NULL;
24772
+}
24773
+
24774
+
24775
+SWIGINTERN PyObject *_wrap_DisplayDriver_ReloadMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24776
+ PyObject *resultobj = 0;
24777
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24778
+ void *argp1 = 0 ;
24779
+ int res1 = 0 ;
24780
+ PyObject * obj0 = 0 ;
24781
+
24782
+ if (!PyArg_ParseTuple(args,(char *)"O:DisplayDriver_ReloadMap",&obj0)) SWIG_fail;
24783
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24784
+ if (!SWIG_IsOK(res1)) {
24785
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_ReloadMap" "', argument " "1"" of type '" "DisplayDriver *""'");
24786
+ }
24787
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24788
+ (arg1)->ReloadMap();
24789
+ resultobj = SWIG_Py_Void();
24790
+ return resultobj;
24791
+fail:
24792
+ return NULL;
24793
+}
24794
+
24795
+
24796
+SWIGINTERN PyObject *_wrap_DisplayDriver_SetDevice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24797
+ PyObject *resultobj = 0;
24798
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24799
+ void *arg2 = (void *) 0 ;
24800
+ void *argp1 = 0 ;
24801
+ int res1 = 0 ;
24802
+ int res2 ;
24803
+ PyObject * obj0 = 0 ;
24804
+ PyObject * obj1 = 0 ;
24805
+
24806
+ if (!PyArg_ParseTuple(args,(char *)"OO:DisplayDriver_SetDevice",&obj0,&obj1)) SWIG_fail;
24807
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24808
+ if (!SWIG_IsOK(res1)) {
24809
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_SetDevice" "', argument " "1"" of type '" "DisplayDriver *""'");
24810
+ }
24811
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24812
+ res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
24813
+ if (!SWIG_IsOK(res2)) {
24814
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DisplayDriver_SetDevice" "', argument " "2"" of type '" "void *""'");
24815
+ }
24816
+ (arg1)->SetDevice(arg2);
24817
+ resultobj = SWIG_Py_Void();
24818
+ return resultobj;
24819
+fail:
24820
+ return NULL;
24821
+}
24822
+
24823
+
24824
+SWIGINTERN PyObject *_wrap_DisplayDriver_GetMapBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24825
+ PyObject *resultobj = 0;
24826
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24827
+ void *argp1 = 0 ;
24828
+ int res1 = 0 ;
24829
+ PyObject * obj0 = 0 ;
24830
+ std::vector< double,std::allocator< double > > result;
24831
+
24832
+ if (!PyArg_ParseTuple(args,(char *)"O:DisplayDriver_GetMapBoundingBox",&obj0)) SWIG_fail;
24833
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24834
+ if (!SWIG_IsOK(res1)) {
24835
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_GetMapBoundingBox" "', argument " "1"" of type '" "DisplayDriver *""'");
24836
+ }
24837
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24838
+ result = (arg1)->GetMapBoundingBox();
24839
+ resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
24840
+ return resultobj;
24841
+fail:
24842
+ return NULL;
24843
+}
24844
+
24845
+
24846
+SWIGINTERN PyObject *_wrap_DisplayDriver_Is3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24847
+ PyObject *resultobj = 0;
24848
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24849
+ void *argp1 = 0 ;
24850
+ int res1 = 0 ;
24851
+ PyObject * obj0 = 0 ;
24852
+ bool result;
24853
+
24854
+ if (!PyArg_ParseTuple(args,(char *)"O:DisplayDriver_Is3D",&obj0)) SWIG_fail;
24855
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24856
+ if (!SWIG_IsOK(res1)) {
24857
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_Is3D" "', argument " "1"" of type '" "DisplayDriver *""'");
24858
+ }
24859
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24860
+ result = (bool)(arg1)->Is3D();
24861
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
24862
+ return resultobj;
24863
+fail:
24864
+ return NULL;
24865
+}
24866
+
24867
+
24868
+SWIGINTERN PyObject *_wrap_DisplayDriver_SetRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24869
+ PyObject *resultobj = 0;
24870
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24871
+ double arg2 ;
24872
+ double arg3 ;
24873
+ double arg4 ;
24874
+ double arg5 ;
24875
+ double arg6 ;
24876
+ double arg7 ;
24877
+ double arg8 ;
24878
+ double arg9 ;
24879
+ double arg10 ;
24880
+ double arg11 ;
24881
+ void *argp1 = 0 ;
24882
+ int res1 = 0 ;
24883
+ double val2 ;
24884
+ int ecode2 = 0 ;
24885
+ double val3 ;
24886
+ int ecode3 = 0 ;
24887
+ double val4 ;
24888
+ int ecode4 = 0 ;
24889
+ double val5 ;
24890
+ int ecode5 = 0 ;
24891
+ double val6 ;
24892
+ int ecode6 = 0 ;
24893
+ double val7 ;
24894
+ int ecode7 = 0 ;
24895
+ double val8 ;
24896
+ int ecode8 = 0 ;
24897
+ double val9 ;
24898
+ int ecode9 = 0 ;
24899
+ double val10 ;
24900
+ int ecode10 = 0 ;
24901
+ double val11 ;
24902
+ int ecode11 = 0 ;
24903
+ PyObject * obj0 = 0 ;
24904
+ PyObject * obj1 = 0 ;
24905
+ PyObject * obj2 = 0 ;
24906
+ PyObject * obj3 = 0 ;
24907
+ PyObject * obj4 = 0 ;
24908
+ PyObject * obj5 = 0 ;
24909
+ PyObject * obj6 = 0 ;
24910
+ PyObject * obj7 = 0 ;
24911
+ PyObject * obj8 = 0 ;
24912
+ PyObject * obj9 = 0 ;
24913
+ PyObject * obj10 = 0 ;
24914
+
24915
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:DisplayDriver_SetRegion",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
24916
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
24917
+ if (!SWIG_IsOK(res1)) {
24918
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_SetRegion" "', argument " "1"" of type '" "DisplayDriver *""'");
24919
+ }
24920
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
24921
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
24922
+ if (!SWIG_IsOK(ecode2)) {
24923
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DisplayDriver_SetRegion" "', argument " "2"" of type '" "double""'");
24924
+ }
24925
+ arg2 = static_cast< double >(val2);
24926
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
24927
+ if (!SWIG_IsOK(ecode3)) {
24928
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DisplayDriver_SetRegion" "', argument " "3"" of type '" "double""'");
24929
+ }
24930
+ arg3 = static_cast< double >(val3);
24931
+ ecode4 = SWIG_AsVal_double(obj3, &val4);
24932
+ if (!SWIG_IsOK(ecode4)) {
24933
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DisplayDriver_SetRegion" "', argument " "4"" of type '" "double""'");
24934
+ }
24935
+ arg4 = static_cast< double >(val4);
24936
+ ecode5 = SWIG_AsVal_double(obj4, &val5);
24937
+ if (!SWIG_IsOK(ecode5)) {
24938
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DisplayDriver_SetRegion" "', argument " "5"" of type '" "double""'");
24939
+ }
24940
+ arg5 = static_cast< double >(val5);
24941
+ ecode6 = SWIG_AsVal_double(obj5, &val6);
24942
+ if (!SWIG_IsOK(ecode6)) {
24943
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DisplayDriver_SetRegion" "', argument " "6"" of type '" "double""'");
24944
+ }
24945
+ arg6 = static_cast< double >(val6);
24946
+ ecode7 = SWIG_AsVal_double(obj6, &val7);
24947
+ if (!SWIG_IsOK(ecode7)) {
24948
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DisplayDriver_SetRegion" "', argument " "7"" of type '" "double""'");
24949
+ }
24950
+ arg7 = static_cast< double >(val7);
24951
+ ecode8 = SWIG_AsVal_double(obj7, &val8);
24952
+ if (!SWIG_IsOK(ecode8)) {
24953
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DisplayDriver_SetRegion" "', argument " "8"" of type '" "double""'");
24954
+ }
24955
+ arg8 = static_cast< double >(val8);
24956
+ ecode9 = SWIG_AsVal_double(obj8, &val9);
24957
+ if (!SWIG_IsOK(ecode9)) {
24958
+ SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "DisplayDriver_SetRegion" "', argument " "9"" of type '" "double""'");
24959
+ }
24960
+ arg9 = static_cast< double >(val9);
24961
+ ecode10 = SWIG_AsVal_double(obj9, &val10);
24962
+ if (!SWIG_IsOK(ecode10)) {
24963
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "DisplayDriver_SetRegion" "', argument " "10"" of type '" "double""'");
24964
+ }
24965
+ arg10 = static_cast< double >(val10);
24966
+ ecode11 = SWIG_AsVal_double(obj10, &val11);
24967
+ if (!SWIG_IsOK(ecode11)) {
24968
+ SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "DisplayDriver_SetRegion" "', argument " "11"" of type '" "double""'");
24969
+ }
24970
+ arg11 = static_cast< double >(val11);
24971
+ (arg1)->SetRegion(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
24972
+ resultobj = SWIG_Py_Void();
24973
+ return resultobj;
24974
+fail:
24975
+ return NULL;
24976
+}
24977
+
24978
+
24979
+SWIGINTERN PyObject *_wrap_DisplayDriver_UpdateSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24980
+ PyObject *resultobj = 0;
24981
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
24982
+ unsigned long arg2 ;
24983
+ bool arg3 ;
24984
+ unsigned long arg4 ;
24985
+ bool arg5 ;
24986
+ unsigned long arg6 ;
24987
+ bool arg7 ;
24988
+ unsigned long arg8 ;
24989
+ bool arg9 ;
24990
+ unsigned long arg10 ;
24991
+ bool arg11 ;
24992
+ unsigned long arg12 ;
24993
+ bool arg13 ;
24994
+ unsigned long arg14 ;
24995
+ bool arg15 ;
24996
+ unsigned long arg16 ;
24997
+ bool arg17 ;
24998
+ unsigned long arg18 ;
24999
+ bool arg19 ;
25000
+ unsigned long arg20 ;
25001
+ bool arg21 ;
25002
+ unsigned long arg22 ;
25003
+ bool arg23 ;
25004
+ unsigned long arg24 ;
25005
+ bool arg25 ;
25006
+ unsigned long arg26 ;
25007
+ bool arg27 ;
25008
+ unsigned long arg28 ;
25009
+ bool arg29 ;
25010
+ unsigned long arg30 ;
25011
+ int arg31 ;
25012
+ int arg32 ;
25013
+ void *argp1 = 0 ;
25014
+ int res1 = 0 ;
25015
+ unsigned long val2 ;
25016
+ int ecode2 = 0 ;
25017
+ bool val3 ;
25018
+ int ecode3 = 0 ;
25019
+ unsigned long val4 ;
25020
+ int ecode4 = 0 ;
25021
+ bool val5 ;
25022
+ int ecode5 = 0 ;
25023
+ unsigned long val6 ;
25024
+ int ecode6 = 0 ;
25025
+ bool val7 ;
25026
+ int ecode7 = 0 ;
25027
+ unsigned long val8 ;
25028
+ int ecode8 = 0 ;
25029
+ bool val9 ;
25030
+ int ecode9 = 0 ;
25031
+ unsigned long val10 ;
25032
+ int ecode10 = 0 ;
25033
+ bool val11 ;
25034
+ int ecode11 = 0 ;
25035
+ unsigned long val12 ;
25036
+ int ecode12 = 0 ;
25037
+ bool val13 ;
25038
+ int ecode13 = 0 ;
25039
+ unsigned long val14 ;
25040
+ int ecode14 = 0 ;
25041
+ bool val15 ;
25042
+ int ecode15 = 0 ;
25043
+ unsigned long val16 ;
25044
+ int ecode16 = 0 ;
25045
+ bool val17 ;
25046
+ int ecode17 = 0 ;
25047
+ unsigned long val18 ;
25048
+ int ecode18 = 0 ;
25049
+ bool val19 ;
25050
+ int ecode19 = 0 ;
25051
+ unsigned long val20 ;
25052
+ int ecode20 = 0 ;
25053
+ bool val21 ;
25054
+ int ecode21 = 0 ;
25055
+ unsigned long val22 ;
25056
+ int ecode22 = 0 ;
25057
+ bool val23 ;
25058
+ int ecode23 = 0 ;
25059
+ unsigned long val24 ;
25060
+ int ecode24 = 0 ;
25061
+ bool val25 ;
25062
+ int ecode25 = 0 ;
25063
+ unsigned long val26 ;
25064
+ int ecode26 = 0 ;
25065
+ bool val27 ;
25066
+ int ecode27 = 0 ;
25067
+ unsigned long val28 ;
25068
+ int ecode28 = 0 ;
25069
+ bool val29 ;
25070
+ int ecode29 = 0 ;
25071
+ unsigned long val30 ;
25072
+ int ecode30 = 0 ;
25073
+ int val31 ;
25074
+ int ecode31 = 0 ;
25075
+ int val32 ;
25076
+ int ecode32 = 0 ;
25077
+ PyObject * obj0 = 0 ;
25078
+ PyObject * obj1 = 0 ;
25079
+ PyObject * obj2 = 0 ;
25080
+ PyObject * obj3 = 0 ;
25081
+ PyObject * obj4 = 0 ;
25082
+ PyObject * obj5 = 0 ;
25083
+ PyObject * obj6 = 0 ;
25084
+ PyObject * obj7 = 0 ;
25085
+ PyObject * obj8 = 0 ;
25086
+ PyObject * obj9 = 0 ;
25087
+ PyObject * obj10 = 0 ;
25088
+ PyObject * obj11 = 0 ;
25089
+ PyObject * obj12 = 0 ;
25090
+ PyObject * obj13 = 0 ;
25091
+ PyObject * obj14 = 0 ;
25092
+ PyObject * obj15 = 0 ;
25093
+ PyObject * obj16 = 0 ;
25094
+ PyObject * obj17 = 0 ;
25095
+ PyObject * obj18 = 0 ;
25096
+ PyObject * obj19 = 0 ;
25097
+ PyObject * obj20 = 0 ;
25098
+ PyObject * obj21 = 0 ;
25099
+ PyObject * obj22 = 0 ;
25100
+ PyObject * obj23 = 0 ;
25101
+ PyObject * obj24 = 0 ;
25102
+ PyObject * obj25 = 0 ;
25103
+ PyObject * obj26 = 0 ;
25104
+ PyObject * obj27 = 0 ;
25105
+ PyObject * obj28 = 0 ;
25106
+ PyObject * obj29 = 0 ;
25107
+ PyObject * obj30 = 0 ;
25108
+ PyObject * obj31 = 0 ;
25109
+
25110
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:DisplayDriver_UpdateSettings",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27,&obj28,&obj29,&obj30,&obj31)) SWIG_fail;
25111
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
25112
+ if (!SWIG_IsOK(res1)) {
25113
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DisplayDriver_UpdateSettings" "', argument " "1"" of type '" "DisplayDriver *""'");
25114
+ }
25115
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
25116
+ ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
25117
+ if (!SWIG_IsOK(ecode2)) {
25118
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DisplayDriver_UpdateSettings" "', argument " "2"" of type '" "unsigned long""'");
25119
+ }
25120
+ arg2 = static_cast< unsigned long >(val2);
25121
+ ecode3 = SWIG_AsVal_bool(obj2, &val3);
25122
+ if (!SWIG_IsOK(ecode3)) {
25123
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DisplayDriver_UpdateSettings" "', argument " "3"" of type '" "bool""'");
25124
+ }
25125
+ arg3 = static_cast< bool >(val3);
25126
+ ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
25127
+ if (!SWIG_IsOK(ecode4)) {
25128
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DisplayDriver_UpdateSettings" "', argument " "4"" of type '" "unsigned long""'");
25129
+ }
25130
+ arg4 = static_cast< unsigned long >(val4);
25131
+ ecode5 = SWIG_AsVal_bool(obj4, &val5);
25132
+ if (!SWIG_IsOK(ecode5)) {
25133
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DisplayDriver_UpdateSettings" "', argument " "5"" of type '" "bool""'");
25134
+ }
25135
+ arg5 = static_cast< bool >(val5);
25136
+ ecode6 = SWIG_AsVal_unsigned_SS_long(obj5, &val6);
25137
+ if (!SWIG_IsOK(ecode6)) {
25138
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DisplayDriver_UpdateSettings" "', argument " "6"" of type '" "unsigned long""'");
25139
+ }
25140
+ arg6 = static_cast< unsigned long >(val6);
25141
+ ecode7 = SWIG_AsVal_bool(obj6, &val7);
25142
+ if (!SWIG_IsOK(ecode7)) {
25143
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DisplayDriver_UpdateSettings" "', argument " "7"" of type '" "bool""'");
25144
+ }
25145
+ arg7 = static_cast< bool >(val7);
25146
+ ecode8 = SWIG_AsVal_unsigned_SS_long(obj7, &val8);
25147
+ if (!SWIG_IsOK(ecode8)) {
25148
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DisplayDriver_UpdateSettings" "', argument " "8"" of type '" "unsigned long""'");
25149
+ }
25150
+ arg8 = static_cast< unsigned long >(val8);
25151
+ ecode9 = SWIG_AsVal_bool(obj8, &val9);
25152
+ if (!SWIG_IsOK(ecode9)) {
25153
+ SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "DisplayDriver_UpdateSettings" "', argument " "9"" of type '" "bool""'");
25154
+ }
25155
+ arg9 = static_cast< bool >(val9);
25156
+ ecode10 = SWIG_AsVal_unsigned_SS_long(obj9, &val10);
25157
+ if (!SWIG_IsOK(ecode10)) {
25158
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "DisplayDriver_UpdateSettings" "', argument " "10"" of type '" "unsigned long""'");
25159
+ }
25160
+ arg10 = static_cast< unsigned long >(val10);
25161
+ ecode11 = SWIG_AsVal_bool(obj10, &val11);
25162
+ if (!SWIG_IsOK(ecode11)) {
25163
+ SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "DisplayDriver_UpdateSettings" "', argument " "11"" of type '" "bool""'");
25164
+ }
25165
+ arg11 = static_cast< bool >(val11);
25166
+ ecode12 = SWIG_AsVal_unsigned_SS_long(obj11, &val12);
25167
+ if (!SWIG_IsOK(ecode12)) {
25168
+ SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "DisplayDriver_UpdateSettings" "', argument " "12"" of type '" "unsigned long""'");
25169
+ }
25170
+ arg12 = static_cast< unsigned long >(val12);
25171
+ ecode13 = SWIG_AsVal_bool(obj12, &val13);
25172
+ if (!SWIG_IsOK(ecode13)) {
25173
+ SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "DisplayDriver_UpdateSettings" "', argument " "13"" of type '" "bool""'");
25174
+ }
25175
+ arg13 = static_cast< bool >(val13);
25176
+ ecode14 = SWIG_AsVal_unsigned_SS_long(obj13, &val14);
25177
+ if (!SWIG_IsOK(ecode14)) {
25178
+ SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "DisplayDriver_UpdateSettings" "', argument " "14"" of type '" "unsigned long""'");
25179
+ }
25180
+ arg14 = static_cast< unsigned long >(val14);
25181
+ ecode15 = SWIG_AsVal_bool(obj14, &val15);
25182
+ if (!SWIG_IsOK(ecode15)) {
25183
+ SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "DisplayDriver_UpdateSettings" "', argument " "15"" of type '" "bool""'");
25184
+ }
25185
+ arg15 = static_cast< bool >(val15);
25186
+ ecode16 = SWIG_AsVal_unsigned_SS_long(obj15, &val16);
25187
+ if (!SWIG_IsOK(ecode16)) {
25188
+ SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "DisplayDriver_UpdateSettings" "', argument " "16"" of type '" "unsigned long""'");
25189
+ }
25190
+ arg16 = static_cast< unsigned long >(val16);
25191
+ ecode17 = SWIG_AsVal_bool(obj16, &val17);
25192
+ if (!SWIG_IsOK(ecode17)) {
25193
+ SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "DisplayDriver_UpdateSettings" "', argument " "17"" of type '" "bool""'");
25194
+ }
25195
+ arg17 = static_cast< bool >(val17);
25196
+ ecode18 = SWIG_AsVal_unsigned_SS_long(obj17, &val18);
25197
+ if (!SWIG_IsOK(ecode18)) {
25198
+ SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "DisplayDriver_UpdateSettings" "', argument " "18"" of type '" "unsigned long""'");
25199
+ }
25200
+ arg18 = static_cast< unsigned long >(val18);
25201
+ ecode19 = SWIG_AsVal_bool(obj18, &val19);
25202
+ if (!SWIG_IsOK(ecode19)) {
25203
+ SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "DisplayDriver_UpdateSettings" "', argument " "19"" of type '" "bool""'");
25204
+ }
25205
+ arg19 = static_cast< bool >(val19);
25206
+ ecode20 = SWIG_AsVal_unsigned_SS_long(obj19, &val20);
25207
+ if (!SWIG_IsOK(ecode20)) {
25208
+ SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "DisplayDriver_UpdateSettings" "', argument " "20"" of type '" "unsigned long""'");
25209
+ }
25210
+ arg20 = static_cast< unsigned long >(val20);
25211
+ ecode21 = SWIG_AsVal_bool(obj20, &val21);
25212
+ if (!SWIG_IsOK(ecode21)) {
25213
+ SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "DisplayDriver_UpdateSettings" "', argument " "21"" of type '" "bool""'");
25214
+ }
25215
+ arg21 = static_cast< bool >(val21);
25216
+ ecode22 = SWIG_AsVal_unsigned_SS_long(obj21, &val22);
25217
+ if (!SWIG_IsOK(ecode22)) {
25218
+ SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "DisplayDriver_UpdateSettings" "', argument " "22"" of type '" "unsigned long""'");
25219
+ }
25220
+ arg22 = static_cast< unsigned long >(val22);
25221
+ ecode23 = SWIG_AsVal_bool(obj22, &val23);
25222
+ if (!SWIG_IsOK(ecode23)) {
25223
+ SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "DisplayDriver_UpdateSettings" "', argument " "23"" of type '" "bool""'");
25224
+ }
25225
+ arg23 = static_cast< bool >(val23);
25226
+ ecode24 = SWIG_AsVal_unsigned_SS_long(obj23, &val24);
25227
+ if (!SWIG_IsOK(ecode24)) {
25228
+ SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "DisplayDriver_UpdateSettings" "', argument " "24"" of type '" "unsigned long""'");
25229
+ }
25230
+ arg24 = static_cast< unsigned long >(val24);
25231
+ ecode25 = SWIG_AsVal_bool(obj24, &val25);
25232
+ if (!SWIG_IsOK(ecode25)) {
25233
+ SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "DisplayDriver_UpdateSettings" "', argument " "25"" of type '" "bool""'");
25234
+ }
25235
+ arg25 = static_cast< bool >(val25);
25236
+ ecode26 = SWIG_AsVal_unsigned_SS_long(obj25, &val26);
25237
+ if (!SWIG_IsOK(ecode26)) {
25238
+ SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "DisplayDriver_UpdateSettings" "', argument " "26"" of type '" "unsigned long""'");
25239
+ }
25240
+ arg26 = static_cast< unsigned long >(val26);
25241
+ ecode27 = SWIG_AsVal_bool(obj26, &val27);
25242
+ if (!SWIG_IsOK(ecode27)) {
25243
+ SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "DisplayDriver_UpdateSettings" "', argument " "27"" of type '" "bool""'");
25244
+ }
25245
+ arg27 = static_cast< bool >(val27);
25246
+ ecode28 = SWIG_AsVal_unsigned_SS_long(obj27, &val28);
25247
+ if (!SWIG_IsOK(ecode28)) {
25248
+ SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "DisplayDriver_UpdateSettings" "', argument " "28"" of type '" "unsigned long""'");
25249
+ }
25250
+ arg28 = static_cast< unsigned long >(val28);
25251
+ ecode29 = SWIG_AsVal_bool(obj28, &val29);
25252
+ if (!SWIG_IsOK(ecode29)) {
25253
+ SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "DisplayDriver_UpdateSettings" "', argument " "29"" of type '" "bool""'");
25254
+ }
25255
+ arg29 = static_cast< bool >(val29);
25256
+ ecode30 = SWIG_AsVal_unsigned_SS_long(obj29, &val30);
25257
+ if (!SWIG_IsOK(ecode30)) {
25258
+ SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "DisplayDriver_UpdateSettings" "', argument " "30"" of type '" "unsigned long""'");
25259
+ }
25260
+ arg30 = static_cast< unsigned long >(val30);
25261
+ ecode31 = SWIG_AsVal_int(obj30, &val31);
25262
+ if (!SWIG_IsOK(ecode31)) {
25263
+ SWIG_exception_fail(SWIG_ArgError(ecode31), "in method '" "DisplayDriver_UpdateSettings" "', argument " "31"" of type '" "int""'");
25264
+ }
25265
+ arg31 = static_cast< int >(val31);
25266
+ ecode32 = SWIG_AsVal_int(obj31, &val32);
25267
+ if (!SWIG_IsOK(ecode32)) {
25268
+ SWIG_exception_fail(SWIG_ArgError(ecode32), "in method '" "DisplayDriver_UpdateSettings" "', argument " "32"" of type '" "int""'");
25269
+ }
25270
+ arg32 = static_cast< int >(val32);
25271
+ (arg1)->UpdateSettings(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30,arg31,arg32);
25272
+ resultobj = SWIG_Py_Void();
25273
+ return resultobj;
25274
+fail:
25275
+ return NULL;
25276
+}
25277
+
25278
+
25279
+SWIGINTERN PyObject *DisplayDriver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25280
+ PyObject *obj;
25281
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
25282
+ SWIG_TypeNewClientData(SWIGTYPE_p_DisplayDriver, SWIG_NewClientData(obj));
25283
+ return SWIG_Py_Void();
25284
+}
25285
+
25286
+SWIGINTERN PyObject *_wrap_print_error(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25287
+ PyObject *resultobj = 0;
25288
+ char *arg1 = (char *) 0 ;
25289
+ int arg2 ;
25290
+ int res1 ;
25291
+ char *buf1 = 0 ;
25292
+ int alloc1 = 0 ;
25293
+ int val2 ;
25294
+ int ecode2 = 0 ;
25295
+ PyObject * obj0 = 0 ;
25296
+ PyObject * obj1 = 0 ;
25297
+ int result;
25298
+
25299
+ if (!PyArg_ParseTuple(args,(char *)"OO:print_error",&obj0,&obj1)) SWIG_fail;
25300
+ res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
25301
+ if (!SWIG_IsOK(res1)) {
25302
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_error" "', argument " "1"" of type '" "char const *""'");
25303
+ }
25304
+ arg1 = reinterpret_cast< char * >(buf1);
25305
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
25306
+ if (!SWIG_IsOK(ecode2)) {
25307
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "print_error" "', argument " "2"" of type '" "int""'");
25308
+ }
25309
+ arg2 = static_cast< int >(val2);
25310
+ result = (int)print_error((char const *)arg1,arg2);
25311
+ resultobj = SWIG_From_int(static_cast< int >(result));
25312
+ if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25313
+ return resultobj;
25314
+fail:
25315
+ if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25316
+ return NULL;
25317
+}
25318
+
25319
+
25320
+SWIGINTERN PyObject *_wrap_new_Digit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25321
+ PyObject *resultobj = 0;
25322
+ DisplayDriver *arg1 = (DisplayDriver *) 0 ;
25323
+ wxWindow *arg2 = (wxWindow *) 0 ;
25324
+ void *argp1 = 0 ;
25325
+ int res1 = 0 ;
25326
+ void *argp2 = 0 ;
25327
+ int res2 = 0 ;
25328
+ PyObject * obj0 = 0 ;
25329
+ PyObject * obj1 = 0 ;
25330
+ Digit *result = 0 ;
25331
+
25332
+ if (!PyArg_ParseTuple(args,(char *)"OO:new_Digit",&obj0,&obj1)) SWIG_fail;
25333
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DisplayDriver, 0 | 0 );
25334
+ if (!SWIG_IsOK(res1)) {
25335
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Digit" "', argument " "1"" of type '" "DisplayDriver *""'");
25336
+ }
25337
+ arg1 = reinterpret_cast< DisplayDriver * >(argp1);
25338
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25339
+ if (!SWIG_IsOK(res2)) {
25340
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Digit" "', argument " "2"" of type '" "wxWindow *""'");
25341
+ }
25342
+ arg2 = reinterpret_cast< wxWindow * >(argp2);
25343
+ result = (Digit *)new Digit(arg1,arg2);
25344
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Digit, SWIG_POINTER_NEW | 0 );
25345
+ return resultobj;
25346
+fail:
25347
+ return NULL;
25348
+}
25349
+
25350
+
25351
+SWIGINTERN PyObject *_wrap_delete_Digit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25352
+ PyObject *resultobj = 0;
25353
+ Digit *arg1 = (Digit *) 0 ;
25354
+ void *argp1 = 0 ;
25355
+ int res1 = 0 ;
25356
+ PyObject * obj0 = 0 ;
25357
+
25358
+ if (!PyArg_ParseTuple(args,(char *)"O:delete_Digit",&obj0)) SWIG_fail;
25359
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, SWIG_POINTER_DISOWN | 0 );
25360
+ if (!SWIG_IsOK(res1)) {
25361
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Digit" "', argument " "1"" of type '" "Digit *""'");
25362
+ }
25363
+ arg1 = reinterpret_cast< Digit * >(argp1);
25364
+ delete arg1;
25365
+ resultobj = SWIG_Py_Void();
25366
+ return resultobj;
25367
+fail:
25368
+ return NULL;
25369
+}
25370
+
25371
+
25372
+SWIGINTERN PyObject *_wrap_Digit_InitCats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25373
+ PyObject *resultobj = 0;
25374
+ Digit *arg1 = (Digit *) 0 ;
25375
+ void *argp1 = 0 ;
25376
+ int res1 = 0 ;
25377
+ PyObject * obj0 = 0 ;
25378
+ int result;
25379
+
25380
+ if (!PyArg_ParseTuple(args,(char *)"O:Digit_InitCats",&obj0)) SWIG_fail;
25381
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
25382
+ if (!SWIG_IsOK(res1)) {
25383
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_InitCats" "', argument " "1"" of type '" "Digit *""'");
25384
+ }
25385
+ arg1 = reinterpret_cast< Digit * >(argp1);
25386
+ result = (int)(arg1)->InitCats();
25387
+ resultobj = SWIG_From_int(static_cast< int >(result));
25388
+ return resultobj;
25389
+fail:
25390
+ return NULL;
25391
+}
25392
+
25393
+
25394
+SWIGINTERN PyObject *_wrap_Digit_AddLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25395
+ PyObject *resultobj = 0;
25396
+ Digit *arg1 = (Digit *) 0 ;
25397
+ int arg2 ;
25398
+ std::vector< double,std::allocator< double > > arg3 ;
25399
+ int arg4 ;
25400
+ int arg5 ;
25401
+ char *arg6 = (char *) 0 ;
25402
+ int arg7 ;
25403
+ double arg8 ;
25404
+ void *argp1 = 0 ;
25405
+ int res1 = 0 ;
25406
+ int val2 ;
25407
+ int ecode2 = 0 ;
25408
+ int val4 ;
25409
+ int ecode4 = 0 ;
25410
+ int val5 ;
25411
+ int ecode5 = 0 ;
25412
+ int res6 ;
25413
+ char *buf6 = 0 ;
25414
+ int alloc6 = 0 ;
25415
+ int val7 ;
25416
+ int ecode7 = 0 ;
25417
+ double val8 ;
25418
+ int ecode8 = 0 ;
25419
+ PyObject * obj0 = 0 ;
25420
+ PyObject * obj1 = 0 ;
25421
+ PyObject * obj2 = 0 ;
25422
+ PyObject * obj3 = 0 ;
25423
+ PyObject * obj4 = 0 ;
25424
+ PyObject * obj5 = 0 ;
25425
+ PyObject * obj6 = 0 ;
25426
+ PyObject * obj7 = 0 ;
25427
+ int result;
25428
+
25429
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Digit_AddLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
25430
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
25431
+ if (!SWIG_IsOK(res1)) {
25432
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_AddLine" "', argument " "1"" of type '" "Digit *""'");
25433
+ }
25434
+ arg1 = reinterpret_cast< Digit * >(argp1);
25435
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
25436
+ if (!SWIG_IsOK(ecode2)) {
25437
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_AddLine" "', argument " "2"" of type '" "int""'");
25438
+ }
25439
+ arg2 = static_cast< int >(val2);
25440
+ {
25441
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
25442
+ int res = swig::asptr(obj2, &ptr);
25443
+ if (!SWIG_IsOK(res) || !ptr) {
25444
+ SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Digit_AddLine" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >""'");
25445
+ }
25446
+ arg3 = *ptr;
25447
+ if (SWIG_IsNewObj(res)) delete ptr;
25448
+ }
25449
+ ecode4 = SWIG_AsVal_int(obj3, &val4);
25450
+ if (!SWIG_IsOK(ecode4)) {
25451
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Digit_AddLine" "', argument " "4"" of type '" "int""'");
25452
+ }
25453
+ arg4 = static_cast< int >(val4);
25454
+ ecode5 = SWIG_AsVal_int(obj4, &val5);
25455
+ if (!SWIG_IsOK(ecode5)) {
25456
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Digit_AddLine" "', argument " "5"" of type '" "int""'");
25457
+ }
25458
+ arg5 = static_cast< int >(val5);
25459
+ res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
25460
+ if (!SWIG_IsOK(res6)) {
25461
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Digit_AddLine" "', argument " "6"" of type '" "char const *""'");
25462
+ }
25463
+ arg6 = reinterpret_cast< char * >(buf6);
25464
+ ecode7 = SWIG_AsVal_int(obj6, &val7);
25465
+ if (!SWIG_IsOK(ecode7)) {
25466
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Digit_AddLine" "', argument " "7"" of type '" "int""'");
25467
+ }
25468
+ arg7 = static_cast< int >(val7);
25469
+ ecode8 = SWIG_AsVal_double(obj7, &val8);
25470
+ if (!SWIG_IsOK(ecode8)) {
25471
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Digit_AddLine" "', argument " "8"" of type '" "double""'");
25472
+ }
25473
+ arg8 = static_cast< double >(val8);
25474
+ result = (int)(arg1)->AddLine(arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
25475
+ resultobj = SWIG_From_int(static_cast< int >(result));
25476
+ if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
25477
+ return resultobj;
25478
+fail:
25479
+ if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
25480
+ return NULL;
25481
+}
25482
+
25483
+
25484
+SWIGINTERN PyObject *_wrap_Digit_RewriteLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25485
+ PyObject *resultobj = 0;
25486
+ Digit *arg1 = (Digit *) 0 ;
25487
+ int arg2 ;
25488
+ std::vector< double,std::allocator< double > > arg3 ;
25489
+ char *arg4 = (char *) 0 ;
25490
+ int arg5 ;
25491
+ double arg6 ;
25492
+ void *argp1 = 0 ;
25493
+ int res1 = 0 ;
25494
+ int val2 ;
25495
+ int ecode2 = 0 ;
25496
+ int res4 ;
25497
+ char *buf4 = 0 ;
25498
+ int alloc4 = 0 ;
25499
+ int val5 ;
25500
+ int ecode5 = 0 ;
25501
+ double val6 ;
25502
+ int ecode6 = 0 ;
25503
+ PyObject * obj0 = 0 ;
25504
+ PyObject * obj1 = 0 ;
25505
+ PyObject * obj2 = 0 ;
25506
+ PyObject * obj3 = 0 ;
25507
+ PyObject * obj4 = 0 ;
25508
+ PyObject * obj5 = 0 ;
25509
+ int result;
25510
+
25511
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Digit_RewriteLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
25512
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
25513
+ if (!SWIG_IsOK(res1)) {
25514
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_RewriteLine" "', argument " "1"" of type '" "Digit *""'");
25515
+ }
25516
+ arg1 = reinterpret_cast< Digit * >(argp1);
25517
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
25518
+ if (!SWIG_IsOK(ecode2)) {
25519
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_RewriteLine" "', argument " "2"" of type '" "int""'");
25520
+ }
25521
+ arg2 = static_cast< int >(val2);
25522
+ {
25523
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
25524
+ int res = swig::asptr(obj2, &ptr);
25525
+ if (!SWIG_IsOK(res) || !ptr) {
25526
+ SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Digit_RewriteLine" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >""'");
25527
+ }
25528
+ arg3 = *ptr;
25529
+ if (SWIG_IsNewObj(res)) delete ptr;
25530
+ }
25531
+ res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
25532
+ if (!SWIG_IsOK(res4)) {
25533
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Digit_RewriteLine" "', argument " "4"" of type '" "char const *""'");
25534
+ }
25535
+ arg4 = reinterpret_cast< char * >(buf4);
25536
+ ecode5 = SWIG_AsVal_int(obj4, &val5);
25537
+ if (!SWIG_IsOK(ecode5)) {
25538
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Digit_RewriteLine" "', argument " "5"" of type '" "int""'");
25539
+ }
25540
+ arg5 = static_cast< int >(val5);
25541
+ ecode6 = SWIG_AsVal_double(obj5, &val6);
25542
+ if (!SWIG_IsOK(ecode6)) {
25543
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Digit_RewriteLine" "', argument " "6"" of type '" "double""'");
25544
+ }
25545
+ arg6 = static_cast< double >(val6);
25546
+ result = (int)(arg1)->RewriteLine(arg2,arg3,(char const *)arg4,arg5,arg6);
25547
+ resultobj = SWIG_From_int(static_cast< int >(result));
25548
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
25549
+ return resultobj;
25550
+fail:
25551
+ if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
25552
+ return NULL;
25553
+}
25554
+
25555
+
25556
+SWIGINTERN PyObject *_wrap_Digit_SplitLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25557
+ PyObject *resultobj = 0;
25558
+ Digit *arg1 = (Digit *) 0 ;
25559
+ double arg2 ;
25560
+ double arg3 ;
25561
+ double arg4 ;
25562
+ double arg5 ;
25563
+ void *argp1 = 0 ;
25564
+ int res1 = 0 ;
25565
+ double val2 ;
25566
+ int ecode2 = 0 ;
25567
+ double val3 ;
25568
+ int ecode3 = 0 ;
25569
+ double val4 ;
25570
+ int ecode4 = 0 ;
25571
+ double val5 ;
25572
+ int ecode5 = 0 ;
25573
+ PyObject * obj0 = 0 ;
25574
+ PyObject * obj1 = 0 ;
25575
+ PyObject * obj2 = 0 ;
25576
+ PyObject * obj3 = 0 ;
25577
+ PyObject * obj4 = 0 ;
25578
+ int result;
25579
+
25580
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:Digit_SplitLine",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25581
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
25582
+ if (!SWIG_IsOK(res1)) {
25583
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_SplitLine" "', argument " "1"" of type '" "Digit *""'");
25584
+ }
25585
+ arg1 = reinterpret_cast< Digit * >(argp1);
25586
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
25587
+ if (!SWIG_IsOK(ecode2)) {
25588
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_SplitLine" "', argument " "2"" of type '" "double""'");
25589
+ }
25590
+ arg2 = static_cast< double >(val2);
25591
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
25592
+ if (!SWIG_IsOK(ecode3)) {
25593
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Digit_SplitLine" "', argument " "3"" of type '" "double""'");
25594
+ }
25595
+ arg3 = static_cast< double >(val3);
25596
+ ecode4 = SWIG_AsVal_double(obj3, &val4);
25597
+ if (!SWIG_IsOK(ecode4)) {
25598
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Digit_SplitLine" "', argument " "4"" of type '" "double""'");
25599
+ }
25600
+ arg4 = static_cast< double >(val4);
25601
+ ecode5 = SWIG_AsVal_double(obj4, &val5);
25602
+ if (!SWIG_IsOK(ecode5)) {
25603
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Digit_SplitLine" "', argument " "5"" of type '" "double""'");
25604
+ }
25605
+ arg5 = static_cast< double >(val5);
25606
+ result = (int)(arg1)->SplitLine(arg2,arg3,arg4,arg5);
25607
+ resultobj = SWIG_From_int(static_cast< int >(result));
25608
+ return resultobj;
25609
+fail:
25610
+ return NULL;
25611
+}
25612
+
25613
+
25614
+SWIGINTERN PyObject *_wrap_Digit_DeleteLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25615
+ PyObject *resultobj = 0;
25616
+ Digit *arg1 = (Digit *) 0 ;
25617
+ bool arg2 ;
25618
+ void *argp1 = 0 ;
25619
+ int res1 = 0 ;
25620
+ bool val2 ;
25621
+ int ecode2 = 0 ;
25622
+ PyObject * obj0 = 0 ;
25623
+ PyObject * obj1 = 0 ;
25624
+ int result;
25625
+
25626
+ if (!PyArg_ParseTuple(args,(char *)"OO:Digit_DeleteLines",&obj0,&obj1)) SWIG_fail;
25627
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
25628
+ if (!SWIG_IsOK(res1)) {
25629
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_DeleteLines" "', argument " "1"" of type '" "Digit *""'");
25630
+ }
25631
+ arg1 = reinterpret_cast< Digit * >(argp1);
25632
+ ecode2 = SWIG_AsVal_bool(obj1, &val2);
25633
+ if (!SWIG_IsOK(ecode2)) {
25634
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_DeleteLines" "', argument " "2"" of type '" "bool""'");
25635
+ }
25636
+ arg2 = static_cast< bool >(val2);
25637
+ result = (int)(arg1)->DeleteLines(arg2);
25638
+ resultobj = SWIG_From_int(static_cast< int >(result));
25639
+ return resultobj;
25640
+fail:
25641
+ return NULL;
25642
+}
25643
+
25644
+
25645
+SWIGINTERN PyObject *_wrap_Digit_MoveLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25646
+ PyObject *resultobj = 0;
25647
+ Digit *arg1 = (Digit *) 0 ;
25648
+ double arg2 ;
25649
+ double arg3 ;
25650
+ double arg4 ;
25651
+ char *arg5 = (char *) 0 ;
25652
+ int arg6 ;
25653
+ double arg7 ;
25654
+ void *argp1 = 0 ;
25655
+ int res1 = 0 ;
25656
+ double val2 ;
25657
+ int ecode2 = 0 ;
25658
+ double val3 ;
25659
+ int ecode3 = 0 ;
25660
+ double val4 ;
25661
+ int ecode4 = 0 ;
25662
+ int res5 ;
25663
+ char *buf5 = 0 ;
25664
+ int alloc5 = 0 ;
25665
+ int val6 ;
25666
+ int ecode6 = 0 ;
25667
+ double val7 ;
25668
+ int ecode7 = 0 ;
25669
+ PyObject * obj0 = 0 ;
25670
+ PyObject * obj1 = 0 ;
25671
+ PyObject * obj2 = 0 ;
25672
+ PyObject * obj3 = 0 ;
25673
+ PyObject * obj4 = 0 ;
25674
+ PyObject * obj5 = 0 ;
25675
+ PyObject * obj6 = 0 ;
25676
+ int result;
25677
+
25678
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Digit_MoveLines",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
25679
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
25680
+ if (!SWIG_IsOK(res1)) {
25681
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_MoveLines" "', argument " "1"" of type '" "Digit *""'");
25682
+ }
25683
+ arg1 = reinterpret_cast< Digit * >(argp1);
25684
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
25685
+ if (!SWIG_IsOK(ecode2)) {
25686
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_MoveLines" "', argument " "2"" of type '" "double""'");
25687
+ }
25688
+ arg2 = static_cast< double >(val2);
25689
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
25690
+ if (!SWIG_IsOK(ecode3)) {
25691
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Digit_MoveLines" "', argument " "3"" of type '" "double""'");
25692
+ }
25693
+ arg3 = static_cast< double >(val3);
25694
+ ecode4 = SWIG_AsVal_double(obj3, &val4);
25695
+ if (!SWIG_IsOK(ecode4)) {
25696
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Digit_MoveLines" "', argument " "4"" of type '" "double""'");
25697
+ }
25698
+ arg4 = static_cast< double >(val4);
25699
+ res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
25700
+ if (!SWIG_IsOK(res5)) {
25701
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Digit_MoveLines" "', argument " "5"" of type '" "char const *""'");
25702
+ }
25703
+ arg5 = reinterpret_cast< char * >(buf5);
25704
+ ecode6 = SWIG_AsVal_int(obj5, &val6);
25705
+ if (!SWIG_IsOK(ecode6)) {
25706
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Digit_MoveLines" "', argument " "6"" of type '" "int""'");
25707
+ }
25708
+ arg6 = static_cast< int >(val6);
25709
+ ecode7 = SWIG_AsVal_double(obj6, &val7);
25710
+ if (!SWIG_IsOK(ecode7)) {
25711
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Digit_MoveLines" "', argument " "7"" of type '" "double""'");
25712
+ }
25713
+ arg7 = static_cast< double >(val7);
25714
+ result = (int)(arg1)->MoveLines(arg2,arg3,arg4,(char const *)arg5,arg6,arg7);
25715
+ resultobj = SWIG_From_int(static_cast< int >(result));
25716
+ if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25717
+ return resultobj;
25718
+fail:
25719
+ if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25720
+ return NULL;
25721
+}
25722
+
25723
+
25724
+SWIGINTERN PyObject *_wrap_Digit_FlipLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25725
+ PyObject *resultobj = 0;
25726
+ Digit *arg1 = (Digit *) 0 ;
25727
+ void *argp1 = 0 ;
25728
+ int res1 = 0 ;
25729
+ PyObject * obj0 = 0 ;
25730
+ int result;
25731
+
25732
+ if (!PyArg_ParseTuple(args,(char *)"O:Digit_FlipLines",&obj0)) SWIG_fail;
25733
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
25734
+ if (!SWIG_IsOK(res1)) {
25735
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_FlipLines" "', argument " "1"" of type '" "Digit *""'");
25736
+ }
25737
+ arg1 = reinterpret_cast< Digit * >(argp1);
25738
+ result = (int)(arg1)->FlipLines();
25739
+ resultobj = SWIG_From_int(static_cast< int >(result));
25740
+ return resultobj;
25741
+fail:
25742
+ return NULL;
25743
+}
25744
+
25745
+
25746
+SWIGINTERN PyObject *_wrap_Digit_MergeLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25747
+ PyObject *resultobj = 0;
25748
+ Digit *arg1 = (Digit *) 0 ;
25749
+ void *argp1 = 0 ;
25750
+ int res1 = 0 ;
25751
+ PyObject * obj0 = 0 ;
25752
+ int result;
25753
+
25754
+ if (!PyArg_ParseTuple(args,(char *)"O:Digit_MergeLines",&obj0)) SWIG_fail;
25755
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
25756
+ if (!SWIG_IsOK(res1)) {
25757
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_MergeLines" "', argument " "1"" of type '" "Digit *""'");
25758
+ }
25759
+ arg1 = reinterpret_cast< Digit * >(argp1);
25760
+ result = (int)(arg1)->MergeLines();
25761
+ resultobj = SWIG_From_int(static_cast< int >(result));
25762
+ return resultobj;
25763
+fail:
25764
+ return NULL;
25765
+}
25766
+
25767
+
25768
+SWIGINTERN PyObject *_wrap_Digit_BreakLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25769
+ PyObject *resultobj = 0;
25770
+ Digit *arg1 = (Digit *) 0 ;
25771
+ void *argp1 = 0 ;
25772
+ int res1 = 0 ;
25773
+ PyObject * obj0 = 0 ;
25774
+ int result;
25775
+
25776
+ if (!PyArg_ParseTuple(args,(char *)"O:Digit_BreakLines",&obj0)) SWIG_fail;
25777
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
25778
+ if (!SWIG_IsOK(res1)) {
25779
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_BreakLines" "', argument " "1"" of type '" "Digit *""'");
25780
+ }
25781
+ arg1 = reinterpret_cast< Digit * >(argp1);
25782
+ result = (int)(arg1)->BreakLines();
25783
+ resultobj = SWIG_From_int(static_cast< int >(result));
25784
+ return resultobj;
25785
+fail:
25786
+ return NULL;
25787
+}
25788
+
25789
+
25790
+SWIGINTERN PyObject *_wrap_Digit_SnapLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25791
+ PyObject *resultobj = 0;
25792
+ Digit *arg1 = (Digit *) 0 ;
25793
+ double arg2 ;
25794
+ void *argp1 = 0 ;
25795
+ int res1 = 0 ;
25796
+ double val2 ;
25797
+ int ecode2 = 0 ;
25798
+ PyObject * obj0 = 0 ;
25799
+ PyObject * obj1 = 0 ;
25800
+ int result;
25801
+
25802
+ if (!PyArg_ParseTuple(args,(char *)"OO:Digit_SnapLines",&obj0,&obj1)) SWIG_fail;
25803
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
25804
+ if (!SWIG_IsOK(res1)) {
25805
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_SnapLines" "', argument " "1"" of type '" "Digit *""'");
25806
+ }
25807
+ arg1 = reinterpret_cast< Digit * >(argp1);
25808
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
25809
+ if (!SWIG_IsOK(ecode2)) {
25810
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_SnapLines" "', argument " "2"" of type '" "double""'");
25811
+ }
25812
+ arg2 = static_cast< double >(val2);
25813
+ result = (int)(arg1)->SnapLines(arg2);
25814
+ resultobj = SWIG_From_int(static_cast< int >(result));
25815
+ return resultobj;
25816
+fail:
25817
+ return NULL;
25818
+}
25819
+
25820
+
25821
+SWIGINTERN PyObject *_wrap_Digit_ConnectLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25822
+ PyObject *resultobj = 0;
25823
+ Digit *arg1 = (Digit *) 0 ;
25824
+ double arg2 ;
25825
+ void *argp1 = 0 ;
25826
+ int res1 = 0 ;
25827
+ double val2 ;
25828
+ int ecode2 = 0 ;
25829
+ PyObject * obj0 = 0 ;
25830
+ PyObject * obj1 = 0 ;
25831
+ int result;
25832
+
25833
+ if (!PyArg_ParseTuple(args,(char *)"OO:Digit_ConnectLines",&obj0,&obj1)) SWIG_fail;
25834
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
25835
+ if (!SWIG_IsOK(res1)) {
25836
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_ConnectLines" "', argument " "1"" of type '" "Digit *""'");
25837
+ }
25838
+ arg1 = reinterpret_cast< Digit * >(argp1);
25839
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
25840
+ if (!SWIG_IsOK(ecode2)) {
25841
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_ConnectLines" "', argument " "2"" of type '" "double""'");
25842
+ }
25843
+ arg2 = static_cast< double >(val2);
25844
+ result = (int)(arg1)->ConnectLines(arg2);
25845
+ resultobj = SWIG_From_int(static_cast< int >(result));
25846
+ return resultobj;
25847
+fail:
25848
+ return NULL;
25849
+}
25850
+
25851
+
25852
+SWIGINTERN PyObject *_wrap_Digit_TypeConvLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25853
+ PyObject *resultobj = 0;
25854
+ Digit *arg1 = (Digit *) 0 ;
25855
+ void *argp1 = 0 ;
25856
+ int res1 = 0 ;
25857
+ PyObject * obj0 = 0 ;
25858
+ int result;
25859
+
25860
+ if (!PyArg_ParseTuple(args,(char *)"O:Digit_TypeConvLines",&obj0)) SWIG_fail;
25861
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
25862
+ if (!SWIG_IsOK(res1)) {
25863
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_TypeConvLines" "', argument " "1"" of type '" "Digit *""'");
25864
+ }
25865
+ arg1 = reinterpret_cast< Digit * >(argp1);
25866
+ result = (int)(arg1)->TypeConvLines();
25867
+ resultobj = SWIG_From_int(static_cast< int >(result));
25868
+ return resultobj;
25869
+fail:
25870
+ return NULL;
25871
+}
25872
+
25873
+
25874
+SWIGINTERN PyObject *_wrap_Digit_ZBulkLabeling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25875
+ PyObject *resultobj = 0;
25876
+ Digit *arg1 = (Digit *) 0 ;
25877
+ double arg2 ;
25878
+ double arg3 ;
25879
+ double arg4 ;
25880
+ double arg5 ;
25881
+ double arg6 ;
25882
+ double arg7 ;
25883
+ void *argp1 = 0 ;
25884
+ int res1 = 0 ;
25885
+ double val2 ;
25886
+ int ecode2 = 0 ;
25887
+ double val3 ;
25888
+ int ecode3 = 0 ;
25889
+ double val4 ;
25890
+ int ecode4 = 0 ;
25891
+ double val5 ;
25892
+ int ecode5 = 0 ;
25893
+ double val6 ;
25894
+ int ecode6 = 0 ;
25895
+ double val7 ;
25896
+ int ecode7 = 0 ;
25897
+ PyObject * obj0 = 0 ;
25898
+ PyObject * obj1 = 0 ;
25899
+ PyObject * obj2 = 0 ;
25900
+ PyObject * obj3 = 0 ;
25901
+ PyObject * obj4 = 0 ;
25902
+ PyObject * obj5 = 0 ;
25903
+ PyObject * obj6 = 0 ;
25904
+ int result;
25905
+
25906
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Digit_ZBulkLabeling",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
25907
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
25908
+ if (!SWIG_IsOK(res1)) {
25909
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_ZBulkLabeling" "', argument " "1"" of type '" "Digit *""'");
25910
+ }
25911
+ arg1 = reinterpret_cast< Digit * >(argp1);
25912
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
25913
+ if (!SWIG_IsOK(ecode2)) {
25914
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_ZBulkLabeling" "', argument " "2"" of type '" "double""'");
25915
+ }
25916
+ arg2 = static_cast< double >(val2);
25917
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
25918
+ if (!SWIG_IsOK(ecode3)) {
25919
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Digit_ZBulkLabeling" "', argument " "3"" of type '" "double""'");
25920
+ }
25921
+ arg3 = static_cast< double >(val3);
25922
+ ecode4 = SWIG_AsVal_double(obj3, &val4);
25923
+ if (!SWIG_IsOK(ecode4)) {
25924
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Digit_ZBulkLabeling" "', argument " "4"" of type '" "double""'");
25925
+ }
25926
+ arg4 = static_cast< double >(val4);
25927
+ ecode5 = SWIG_AsVal_double(obj4, &val5);
25928
+ if (!SWIG_IsOK(ecode5)) {
25929
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Digit_ZBulkLabeling" "', argument " "5"" of type '" "double""'");
25930
+ }
25931
+ arg5 = static_cast< double >(val5);
25932
+ ecode6 = SWIG_AsVal_double(obj5, &val6);
25933
+ if (!SWIG_IsOK(ecode6)) {
25934
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Digit_ZBulkLabeling" "', argument " "6"" of type '" "double""'");
25935
+ }
25936
+ arg6 = static_cast< double >(val6);
25937
+ ecode7 = SWIG_AsVal_double(obj6, &val7);
25938
+ if (!SWIG_IsOK(ecode7)) {
25939
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Digit_ZBulkLabeling" "', argument " "7"" of type '" "double""'");
25940
+ }
25941
+ arg7 = static_cast< double >(val7);
25942
+ result = (int)(arg1)->ZBulkLabeling(arg2,arg3,arg4,arg5,arg6,arg7);
25943
+ resultobj = SWIG_From_int(static_cast< int >(result));
25944
+ return resultobj;
25945
+fail:
25946
+ return NULL;
25947
+}
25948
+
25949
+
25950
+SWIGINTERN PyObject *_wrap_Digit_CopyLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25951
+ PyObject *resultobj = 0;
25952
+ Digit *arg1 = (Digit *) 0 ;
25953
+ std::vector< int,std::allocator< int > > arg2 ;
25954
+ char *arg3 = (char *) 0 ;
25955
+ void *argp1 = 0 ;
25956
+ int res1 = 0 ;
25957
+ int res3 ;
25958
+ char *buf3 = 0 ;
25959
+ int alloc3 = 0 ;
25960
+ PyObject * obj0 = 0 ;
25961
+ PyObject * obj1 = 0 ;
25962
+ PyObject * obj2 = 0 ;
25963
+ int result;
25964
+
25965
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Digit_CopyLines",&obj0,&obj1,&obj2)) SWIG_fail;
25966
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
25967
+ if (!SWIG_IsOK(res1)) {
25968
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_CopyLines" "', argument " "1"" of type '" "Digit *""'");
25969
+ }
25970
+ arg1 = reinterpret_cast< Digit * >(argp1);
25971
+ {
25972
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
25973
+ int res = swig::asptr(obj1, &ptr);
25974
+ if (!SWIG_IsOK(res) || !ptr) {
25975
+ SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Digit_CopyLines" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'");
25976
+ }
25977
+ arg2 = *ptr;
25978
+ if (SWIG_IsNewObj(res)) delete ptr;
25979
+ }
25980
+ res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
25981
+ if (!SWIG_IsOK(res3)) {
25982
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Digit_CopyLines" "', argument " "3"" of type '" "char const *""'");
25983
+ }
25984
+ arg3 = reinterpret_cast< char * >(buf3);
25985
+ result = (int)(arg1)->CopyLines(arg2,(char const *)arg3);
25986
+ resultobj = SWIG_From_int(static_cast< int >(result));
25987
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
25988
+ return resultobj;
25989
+fail:
25990
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
25991
+ return NULL;
25992
+}
25993
+
25994
+
25995
+SWIGINTERN PyObject *_wrap_Digit_MoveVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25996
+ PyObject *resultobj = 0;
25997
+ Digit *arg1 = (Digit *) 0 ;
25998
+ double arg2 ;
25999
+ double arg3 ;
26000
+ double arg4 ;
26001
+ double arg5 ;
26002
+ double arg6 ;
26003
+ double arg7 ;
26004
+ char *arg8 = (char *) 0 ;
26005
+ int arg9 ;
26006
+ double arg10 ;
26007
+ double arg11 ;
26008
+ void *argp1 = 0 ;
26009
+ int res1 = 0 ;
26010
+ double val2 ;
26011
+ int ecode2 = 0 ;
26012
+ double val3 ;
26013
+ int ecode3 = 0 ;
26014
+ double val4 ;
26015
+ int ecode4 = 0 ;
26016
+ double val5 ;
26017
+ int ecode5 = 0 ;
26018
+ double val6 ;
26019
+ int ecode6 = 0 ;
26020
+ double val7 ;
26021
+ int ecode7 = 0 ;
26022
+ int res8 ;
26023
+ char *buf8 = 0 ;
26024
+ int alloc8 = 0 ;
26025
+ int val9 ;
26026
+ int ecode9 = 0 ;
26027
+ double val10 ;
26028
+ int ecode10 = 0 ;
26029
+ double val11 ;
26030
+ int ecode11 = 0 ;
26031
+ PyObject * obj0 = 0 ;
26032
+ PyObject * obj1 = 0 ;
26033
+ PyObject * obj2 = 0 ;
26034
+ PyObject * obj3 = 0 ;
26035
+ PyObject * obj4 = 0 ;
26036
+ PyObject * obj5 = 0 ;
26037
+ PyObject * obj6 = 0 ;
26038
+ PyObject * obj7 = 0 ;
26039
+ PyObject * obj8 = 0 ;
26040
+ PyObject * obj9 = 0 ;
26041
+ PyObject * obj10 = 0 ;
26042
+ int result;
26043
+
26044
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Digit_MoveVertex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
26045
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
26046
+ if (!SWIG_IsOK(res1)) {
26047
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_MoveVertex" "', argument " "1"" of type '" "Digit *""'");
26048
+ }
26049
+ arg1 = reinterpret_cast< Digit * >(argp1);
26050
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
26051
+ if (!SWIG_IsOK(ecode2)) {
26052
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_MoveVertex" "', argument " "2"" of type '" "double""'");
26053
+ }
26054
+ arg2 = static_cast< double >(val2);
26055
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
26056
+ if (!SWIG_IsOK(ecode3)) {
26057
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Digit_MoveVertex" "', argument " "3"" of type '" "double""'");
26058
+ }
26059
+ arg3 = static_cast< double >(val3);
26060
+ ecode4 = SWIG_AsVal_double(obj3, &val4);
26061
+ if (!SWIG_IsOK(ecode4)) {
26062
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Digit_MoveVertex" "', argument " "4"" of type '" "double""'");
26063
+ }
26064
+ arg4 = static_cast< double >(val4);
26065
+ ecode5 = SWIG_AsVal_double(obj4, &val5);
26066
+ if (!SWIG_IsOK(ecode5)) {
26067
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Digit_MoveVertex" "', argument " "5"" of type '" "double""'");
26068
+ }
26069
+ arg5 = static_cast< double >(val5);
26070
+ ecode6 = SWIG_AsVal_double(obj5, &val6);
26071
+ if (!SWIG_IsOK(ecode6)) {
26072
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Digit_MoveVertex" "', argument " "6"" of type '" "double""'");
26073
+ }
26074
+ arg6 = static_cast< double >(val6);
26075
+ ecode7 = SWIG_AsVal_double(obj6, &val7);
26076
+ if (!SWIG_IsOK(ecode7)) {
26077
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Digit_MoveVertex" "', argument " "7"" of type '" "double""'");
26078
+ }
26079
+ arg7 = static_cast< double >(val7);
26080
+ res8 = SWIG_AsCharPtrAndSize(obj7, &buf8, NULL, &alloc8);
26081
+ if (!SWIG_IsOK(res8)) {
26082
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Digit_MoveVertex" "', argument " "8"" of type '" "char const *""'");
26083
+ }
26084
+ arg8 = reinterpret_cast< char * >(buf8);
26085
+ ecode9 = SWIG_AsVal_int(obj8, &val9);
26086
+ if (!SWIG_IsOK(ecode9)) {
26087
+ SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Digit_MoveVertex" "', argument " "9"" of type '" "int""'");
26088
+ }
26089
+ arg9 = static_cast< int >(val9);
26090
+ ecode10 = SWIG_AsVal_double(obj9, &val10);
26091
+ if (!SWIG_IsOK(ecode10)) {
26092
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Digit_MoveVertex" "', argument " "10"" of type '" "double""'");
26093
+ }
26094
+ arg10 = static_cast< double >(val10);
26095
+ ecode11 = SWIG_AsVal_double(obj10, &val11);
26096
+ if (!SWIG_IsOK(ecode11)) {
26097
+ SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Digit_MoveVertex" "', argument " "11"" of type '" "double""'");
26098
+ }
26099
+ arg11 = static_cast< double >(val11);
26100
+ result = (int)(arg1)->MoveVertex(arg2,arg3,arg4,arg5,arg6,arg7,(char const *)arg8,arg9,arg10,arg11);
26101
+ resultobj = SWIG_From_int(static_cast< int >(result));
26102
+ if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
26103
+ return resultobj;
26104
+fail:
26105
+ if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
26106
+ return NULL;
26107
+}
26108
+
26109
+
26110
+SWIGINTERN PyObject *_wrap_Digit_ModifyLineVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26111
+ PyObject *resultobj = 0;
26112
+ Digit *arg1 = (Digit *) 0 ;
26113
+ int arg2 ;
26114
+ double arg3 ;
26115
+ double arg4 ;
26116
+ double arg5 ;
26117
+ double arg6 ;
26118
+ void *argp1 = 0 ;
26119
+ int res1 = 0 ;
26120
+ int val2 ;
26121
+ int ecode2 = 0 ;
26122
+ double val3 ;
26123
+ int ecode3 = 0 ;
26124
+ double val4 ;
26125
+ int ecode4 = 0 ;
26126
+ double val5 ;
26127
+ int ecode5 = 0 ;
26128
+ double val6 ;
26129
+ int ecode6 = 0 ;
26130
+ PyObject * obj0 = 0 ;
26131
+ PyObject * obj1 = 0 ;
26132
+ PyObject * obj2 = 0 ;
26133
+ PyObject * obj3 = 0 ;
26134
+ PyObject * obj4 = 0 ;
26135
+ PyObject * obj5 = 0 ;
26136
+ int result;
26137
+
26138
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Digit_ModifyLineVertex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
26139
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
26140
+ if (!SWIG_IsOK(res1)) {
26141
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_ModifyLineVertex" "', argument " "1"" of type '" "Digit *""'");
26142
+ }
26143
+ arg1 = reinterpret_cast< Digit * >(argp1);
26144
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
26145
+ if (!SWIG_IsOK(ecode2)) {
26146
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_ModifyLineVertex" "', argument " "2"" of type '" "int""'");
26147
+ }
26148
+ arg2 = static_cast< int >(val2);
26149
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
26150
+ if (!SWIG_IsOK(ecode3)) {
26151
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Digit_ModifyLineVertex" "', argument " "3"" of type '" "double""'");
26152
+ }
26153
+ arg3 = static_cast< double >(val3);
26154
+ ecode4 = SWIG_AsVal_double(obj3, &val4);
26155
+ if (!SWIG_IsOK(ecode4)) {
26156
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Digit_ModifyLineVertex" "', argument " "4"" of type '" "double""'");
26157
+ }
26158
+ arg4 = static_cast< double >(val4);
26159
+ ecode5 = SWIG_AsVal_double(obj4, &val5);
26160
+ if (!SWIG_IsOK(ecode5)) {
26161
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Digit_ModifyLineVertex" "', argument " "5"" of type '" "double""'");
26162
+ }
26163
+ arg5 = static_cast< double >(val5);
26164
+ ecode6 = SWIG_AsVal_double(obj5, &val6);
26165
+ if (!SWIG_IsOK(ecode6)) {
26166
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Digit_ModifyLineVertex" "', argument " "6"" of type '" "double""'");
26167
+ }
26168
+ arg6 = static_cast< double >(val6);
26169
+ result = (int)(arg1)->ModifyLineVertex(arg2,arg3,arg4,arg5,arg6);
26170
+ resultobj = SWIG_From_int(static_cast< int >(result));
26171
+ return resultobj;
26172
+fail:
26173
+ return NULL;
26174
+}
26175
+
26176
+
26177
+SWIGINTERN PyObject *_wrap_Digit_SelectLinesByQuery(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26178
+ PyObject *resultobj = 0;
26179
+ Digit *arg1 = (Digit *) 0 ;
26180
+ double arg2 ;
26181
+ double arg3 ;
26182
+ double arg4 ;
26183
+ double arg5 ;
26184
+ double arg6 ;
26185
+ double arg7 ;
26186
+ bool arg8 ;
26187
+ int arg9 ;
26188
+ int arg10 ;
26189
+ double arg11 ;
26190
+ void *argp1 = 0 ;
26191
+ int res1 = 0 ;
26192
+ double val2 ;
26193
+ int ecode2 = 0 ;
26194
+ double val3 ;
26195
+ int ecode3 = 0 ;
26196
+ double val4 ;
26197
+ int ecode4 = 0 ;
26198
+ double val5 ;
26199
+ int ecode5 = 0 ;
26200
+ double val6 ;
26201
+ int ecode6 = 0 ;
26202
+ double val7 ;
26203
+ int ecode7 = 0 ;
26204
+ bool val8 ;
26205
+ int ecode8 = 0 ;
26206
+ int val9 ;
26207
+ int ecode9 = 0 ;
26208
+ int val10 ;
26209
+ int ecode10 = 0 ;
26210
+ double val11 ;
26211
+ int ecode11 = 0 ;
26212
+ PyObject * obj0 = 0 ;
26213
+ PyObject * obj1 = 0 ;
26214
+ PyObject * obj2 = 0 ;
26215
+ PyObject * obj3 = 0 ;
26216
+ PyObject * obj4 = 0 ;
26217
+ PyObject * obj5 = 0 ;
26218
+ PyObject * obj6 = 0 ;
26219
+ PyObject * obj7 = 0 ;
26220
+ PyObject * obj8 = 0 ;
26221
+ PyObject * obj9 = 0 ;
26222
+ PyObject * obj10 = 0 ;
26223
+ std::vector< int,std::allocator< int > > result;
26224
+
26225
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Digit_SelectLinesByQuery",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
26226
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
26227
+ if (!SWIG_IsOK(res1)) {
26228
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_SelectLinesByQuery" "', argument " "1"" of type '" "Digit *""'");
26229
+ }
26230
+ arg1 = reinterpret_cast< Digit * >(argp1);
26231
+ ecode2 = SWIG_AsVal_double(obj1, &val2);
26232
+ if (!SWIG_IsOK(ecode2)) {
26233
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_SelectLinesByQuery" "', argument " "2"" of type '" "double""'");
26234
+ }
26235
+ arg2 = static_cast< double >(val2);
26236
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
26237
+ if (!SWIG_IsOK(ecode3)) {
26238
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Digit_SelectLinesByQuery" "', argument " "3"" of type '" "double""'");
26239
+ }
26240
+ arg3 = static_cast< double >(val3);
26241
+ ecode4 = SWIG_AsVal_double(obj3, &val4);
26242
+ if (!SWIG_IsOK(ecode4)) {
26243
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Digit_SelectLinesByQuery" "', argument " "4"" of type '" "double""'");
26244
+ }
26245
+ arg4 = static_cast< double >(val4);
26246
+ ecode5 = SWIG_AsVal_double(obj4, &val5);
26247
+ if (!SWIG_IsOK(ecode5)) {
26248
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Digit_SelectLinesByQuery" "', argument " "5"" of type '" "double""'");
26249
+ }
26250
+ arg5 = static_cast< double >(val5);
26251
+ ecode6 = SWIG_AsVal_double(obj5, &val6);
26252
+ if (!SWIG_IsOK(ecode6)) {
26253
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Digit_SelectLinesByQuery" "', argument " "6"" of type '" "double""'");
26254
+ }
26255
+ arg6 = static_cast< double >(val6);
26256
+ ecode7 = SWIG_AsVal_double(obj6, &val7);
26257
+ if (!SWIG_IsOK(ecode7)) {
26258
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Digit_SelectLinesByQuery" "', argument " "7"" of type '" "double""'");
26259
+ }
26260
+ arg7 = static_cast< double >(val7);
26261
+ ecode8 = SWIG_AsVal_bool(obj7, &val8);
26262
+ if (!SWIG_IsOK(ecode8)) {
26263
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Digit_SelectLinesByQuery" "', argument " "8"" of type '" "bool""'");
26264
+ }
26265
+ arg8 = static_cast< bool >(val8);
26266
+ ecode9 = SWIG_AsVal_int(obj8, &val9);
26267
+ if (!SWIG_IsOK(ecode9)) {
26268
+ SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Digit_SelectLinesByQuery" "', argument " "9"" of type '" "int""'");
26269
+ }
26270
+ arg9 = static_cast< int >(val9);
26271
+ ecode10 = SWIG_AsVal_int(obj9, &val10);
26272
+ if (!SWIG_IsOK(ecode10)) {
26273
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Digit_SelectLinesByQuery" "', argument " "10"" of type '" "int""'");
26274
+ }
26275
+ arg10 = static_cast< int >(val10);
26276
+ ecode11 = SWIG_AsVal_double(obj10, &val11);
26277
+ if (!SWIG_IsOK(ecode11)) {
26278
+ SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Digit_SelectLinesByQuery" "', argument " "11"" of type '" "double""'");
26279
+ }
26280
+ arg11 = static_cast< double >(val11);
26281
+ result = (arg1)->SelectLinesByQuery(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
26282
+ resultobj = swig::from(static_cast< std::vector<int,std::allocator< int > > >(result));
26283
+ return resultobj;
26284
+fail:
26285
+ return NULL;
26286
+}
26287
+
26288
+
26289
+SWIGINTERN PyObject *_wrap_Digit_CopyCats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26290
+ PyObject *resultobj = 0;
26291
+ Digit *arg1 = (Digit *) 0 ;
26292
+ std::vector< int,std::allocator< int > > arg2 ;
26293
+ std::vector< int,std::allocator< int > > arg3 ;
26294
+ bool arg4 ;
26295
+ void *argp1 = 0 ;
26296
+ int res1 = 0 ;
26297
+ bool val4 ;
26298
+ int ecode4 = 0 ;
26299
+ PyObject * obj0 = 0 ;
26300
+ PyObject * obj1 = 0 ;
26301
+ PyObject * obj2 = 0 ;
26302
+ PyObject * obj3 = 0 ;
26303
+ int result;
26304
+
26305
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:Digit_CopyCats",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26306
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
26307
+ if (!SWIG_IsOK(res1)) {
26308
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_CopyCats" "', argument " "1"" of type '" "Digit *""'");
26309
+ }
26310
+ arg1 = reinterpret_cast< Digit * >(argp1);
26311
+ {
26312
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
26313
+ int res = swig::asptr(obj1, &ptr);
26314
+ if (!SWIG_IsOK(res) || !ptr) {
26315
+ SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Digit_CopyCats" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'");
26316
+ }
26317
+ arg2 = *ptr;
26318
+ if (SWIG_IsNewObj(res)) delete ptr;
26319
+ }
26320
+ {
26321
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
26322
+ int res = swig::asptr(obj2, &ptr);
26323
+ if (!SWIG_IsOK(res) || !ptr) {
26324
+ SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Digit_CopyCats" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > >""'");
26325
+ }
26326
+ arg3 = *ptr;
26327
+ if (SWIG_IsNewObj(res)) delete ptr;
26328
+ }
26329
+ ecode4 = SWIG_AsVal_bool(obj3, &val4);
26330
+ if (!SWIG_IsOK(ecode4)) {
26331
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Digit_CopyCats" "', argument " "4"" of type '" "bool""'");
26332
+ }
26333
+ arg4 = static_cast< bool >(val4);
26334
+ result = (int)(arg1)->CopyCats(arg2,arg3,arg4);
26335
+ resultobj = SWIG_From_int(static_cast< int >(result));
26336
+ return resultobj;
26337
+fail:
26338
+ return NULL;
26339
+}
26340
+
26341
+
26342
+SWIGINTERN PyObject *_wrap_Digit_GetCategory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26343
+ PyObject *resultobj = 0;
26344
+ Digit *arg1 = (Digit *) 0 ;
26345
+ int arg2 ;
26346
+ void *argp1 = 0 ;
26347
+ int res1 = 0 ;
26348
+ int val2 ;
26349
+ int ecode2 = 0 ;
26350
+ PyObject * obj0 = 0 ;
26351
+ PyObject * obj1 = 0 ;
26352
+ int result;
26353
+
26354
+ if (!PyArg_ParseTuple(args,(char *)"OO:Digit_GetCategory",&obj0,&obj1)) SWIG_fail;
26355
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
26356
+ if (!SWIG_IsOK(res1)) {
26357
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_GetCategory" "', argument " "1"" of type '" "Digit *""'");
26358
+ }
26359
+ arg1 = reinterpret_cast< Digit * >(argp1);
26360
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
26361
+ if (!SWIG_IsOK(ecode2)) {
26362
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_GetCategory" "', argument " "2"" of type '" "int""'");
26363
+ }
26364
+ arg2 = static_cast< int >(val2);
26365
+ result = (int)(arg1)->GetCategory(arg2);
26366
+ resultobj = SWIG_From_int(static_cast< int >(result));
26367
+ return resultobj;
26368
+fail:
26369
+ return NULL;
26370
+}
26371
+
26372
+
26373
+SWIGINTERN PyObject *_wrap_Digit_GetLineCats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26374
+ PyObject *resultobj = 0;
26375
+ Digit *arg1 = (Digit *) 0 ;
26376
+ int arg2 ;
26377
+ void *argp1 = 0 ;
26378
+ int res1 = 0 ;
26379
+ int val2 ;
26380
+ int ecode2 = 0 ;
26381
+ PyObject * obj0 = 0 ;
26382
+ PyObject * obj1 = 0 ;
26383
+ std::map< int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > > result;
26384
+
26385
+ if (!PyArg_ParseTuple(args,(char *)"OO:Digit_GetLineCats",&obj0,&obj1)) SWIG_fail;
26386
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
26387
+ if (!SWIG_IsOK(res1)) {
26388
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_GetLineCats" "', argument " "1"" of type '" "Digit *""'");
26389
+ }
26390
+ arg1 = reinterpret_cast< Digit * >(argp1);
26391
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
26392
+ if (!SWIG_IsOK(ecode2)) {
26393
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_GetLineCats" "', argument " "2"" of type '" "int""'");
26394
+ }
26395
+ arg2 = static_cast< int >(val2);
26396
+ result = (arg1)->GetLineCats(arg2);
26397
+ resultobj = swig::from(static_cast< std::map<int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > > >(result));
26398
+ return resultobj;
26399
+fail:
26400
+ return NULL;
26401
+}
26402
+
26403
+
26404
+SWIGINTERN PyObject *_wrap_Digit_SetLineCats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26405
+ PyObject *resultobj = 0;
26406
+ Digit *arg1 = (Digit *) 0 ;
26407
+ int arg2 ;
26408
+ int arg3 ;
26409
+ std::vector< int,std::allocator< int > > arg4 ;
26410
+ bool arg5 ;
26411
+ void *argp1 = 0 ;
26412
+ int res1 = 0 ;
26413
+ int val2 ;
26414
+ int ecode2 = 0 ;
26415
+ int val3 ;
26416
+ int ecode3 = 0 ;
26417
+ bool val5 ;
26418
+ int ecode5 = 0 ;
26419
+ PyObject * obj0 = 0 ;
26420
+ PyObject * obj1 = 0 ;
26421
+ PyObject * obj2 = 0 ;
26422
+ PyObject * obj3 = 0 ;
26423
+ PyObject * obj4 = 0 ;
26424
+ int result;
26425
+
26426
+ if (!PyArg_ParseTuple(args,(char *)"OOOOO:Digit_SetLineCats",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26427
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
26428
+ if (!SWIG_IsOK(res1)) {
26429
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_SetLineCats" "', argument " "1"" of type '" "Digit *""'");
26430
+ }
26431
+ arg1 = reinterpret_cast< Digit * >(argp1);
26432
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
26433
+ if (!SWIG_IsOK(ecode2)) {
26434
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_SetLineCats" "', argument " "2"" of type '" "int""'");
26435
+ }
26436
+ arg2 = static_cast< int >(val2);
26437
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
26438
+ if (!SWIG_IsOK(ecode3)) {
26439
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Digit_SetLineCats" "', argument " "3"" of type '" "int""'");
26440
+ }
26441
+ arg3 = static_cast< int >(val3);
26442
+ {
26443
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
26444
+ int res = swig::asptr(obj3, &ptr);
26445
+ if (!SWIG_IsOK(res) || !ptr) {
26446
+ SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Digit_SetLineCats" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > >""'");
26447
+ }
26448
+ arg4 = *ptr;
26449
+ if (SWIG_IsNewObj(res)) delete ptr;
26450
+ }
26451
+ ecode5 = SWIG_AsVal_bool(obj4, &val5);
26452
+ if (!SWIG_IsOK(ecode5)) {
26453
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Digit_SetLineCats" "', argument " "5"" of type '" "bool""'");
26454
+ }
26455
+ arg5 = static_cast< bool >(val5);
26456
+ result = (int)(arg1)->SetLineCats(arg2,arg3,arg4,arg5);
26457
+ resultobj = SWIG_From_int(static_cast< int >(result));
26458
+ return resultobj;
26459
+fail:
26460
+ return NULL;
26461
+}
26462
+
26463
+
26464
+SWIGINTERN PyObject *_wrap_Digit_GetLayers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26465
+ PyObject *resultobj = 0;
26466
+ Digit *arg1 = (Digit *) 0 ;
26467
+ void *argp1 = 0 ;
26468
+ int res1 = 0 ;
26469
+ PyObject * obj0 = 0 ;
26470
+ std::vector< int,std::allocator< int > > result;
26471
+
26472
+ if (!PyArg_ParseTuple(args,(char *)"O:Digit_GetLayers",&obj0)) SWIG_fail;
26473
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
26474
+ if (!SWIG_IsOK(res1)) {
26475
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_GetLayers" "', argument " "1"" of type '" "Digit *""'");
26476
+ }
26477
+ arg1 = reinterpret_cast< Digit * >(argp1);
26478
+ result = (arg1)->GetLayers();
26479
+ resultobj = swig::from(static_cast< std::vector<int,std::allocator< int > > >(result));
26480
+ return resultobj;
26481
+fail:
26482
+ return NULL;
26483
+}
26484
+
26485
+
26486
+SWIGINTERN PyObject *_wrap_Digit_Undo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26487
+ PyObject *resultobj = 0;
26488
+ Digit *arg1 = (Digit *) 0 ;
26489
+ int arg2 ;
26490
+ void *argp1 = 0 ;
26491
+ int res1 = 0 ;
26492
+ int val2 ;
26493
+ int ecode2 = 0 ;
26494
+ PyObject * obj0 = 0 ;
26495
+ PyObject * obj1 = 0 ;
26496
+ int result;
26497
+
26498
+ if (!PyArg_ParseTuple(args,(char *)"OO:Digit_Undo",&obj0,&obj1)) SWIG_fail;
26499
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
26500
+ if (!SWIG_IsOK(res1)) {
26501
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_Undo" "', argument " "1"" of type '" "Digit *""'");
26502
+ }
26503
+ arg1 = reinterpret_cast< Digit * >(argp1);
26504
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
26505
+ if (!SWIG_IsOK(ecode2)) {
26506
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_Undo" "', argument " "2"" of type '" "int""'");
26507
+ }
26508
+ arg2 = static_cast< int >(val2);
26509
+ result = (int)(arg1)->Undo(arg2);
26510
+ resultobj = SWIG_From_int(static_cast< int >(result));
26511
+ return resultobj;
26512
+fail:
26513
+ return NULL;
26514
+}
26515
+
26516
+
26517
+SWIGINTERN PyObject *_wrap_Digit_GetUndoLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26518
+ PyObject *resultobj = 0;
26519
+ Digit *arg1 = (Digit *) 0 ;
26520
+ void *argp1 = 0 ;
26521
+ int res1 = 0 ;
26522
+ PyObject * obj0 = 0 ;
26523
+ int result;
26524
+
26525
+ if (!PyArg_ParseTuple(args,(char *)"O:Digit_GetUndoLevel",&obj0)) SWIG_fail;
26526
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
26527
+ if (!SWIG_IsOK(res1)) {
26528
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_GetUndoLevel" "', argument " "1"" of type '" "Digit *""'");
26529
+ }
26530
+ arg1 = reinterpret_cast< Digit * >(argp1);
26531
+ result = (int)(arg1)->GetUndoLevel();
26532
+ resultobj = SWIG_From_int(static_cast< int >(result));
26533
+ return resultobj;
26534
+fail:
26535
+ return NULL;
26536
+}
26537
+
26538
+
26539
+SWIGINTERN PyObject *_wrap_Digit_UpdateSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26540
+ PyObject *resultobj = 0;
26541
+ Digit *arg1 = (Digit *) 0 ;
26542
+ bool arg2 ;
26543
+ void *argp1 = 0 ;
26544
+ int res1 = 0 ;
26545
+ bool val2 ;
26546
+ int ecode2 = 0 ;
26547
+ PyObject * obj0 = 0 ;
26548
+ PyObject * obj1 = 0 ;
26549
+
26550
+ if (!PyArg_ParseTuple(args,(char *)"OO:Digit_UpdateSettings",&obj0,&obj1)) SWIG_fail;
26551
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Digit, 0 | 0 );
26552
+ if (!SWIG_IsOK(res1)) {
26553
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Digit_UpdateSettings" "', argument " "1"" of type '" "Digit *""'");
26554
+ }
26555
+ arg1 = reinterpret_cast< Digit * >(argp1);
26556
+ ecode2 = SWIG_AsVal_bool(obj1, &val2);
26557
+ if (!SWIG_IsOK(ecode2)) {
26558
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Digit_UpdateSettings" "', argument " "2"" of type '" "bool""'");
26559
+ }
26560
+ arg2 = static_cast< bool >(val2);
26561
+ (arg1)->UpdateSettings(arg2);
26562
+ resultobj = SWIG_Py_Void();
26563
+ return resultobj;
26564
+fail:
26565
+ return NULL;
26566
+}
26567
+
26568
+
26569
+SWIGINTERN PyObject *Digit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26570
+ PyObject *obj;
26571
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
26572
+ SWIG_TypeNewClientData(SWIGTYPE_p_Digit, SWIG_NewClientData(obj));
26573
+ return SWIG_Py_Void();
26574
+}
26575
+
26576
+SWIGINTERN PyObject *_wrap_new_PseudoDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26577
+ PyObject *resultobj = 0;
26578
+ gwxPseudoDC *result = 0 ;
26579
+
26580
+ if (!PyArg_ParseTuple(args,(char *)":new_PseudoDC")) SWIG_fail;
26581
+ result = (gwxPseudoDC *)new gwxPseudoDC();
26582
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gwxPseudoDC, SWIG_POINTER_NEW | 0 );
26583
+ return resultobj;
26584
+fail:
26585
+ return NULL;
26586
+}
26587
+
26588
+
26589
+SWIGINTERN PyObject *_wrap_delete_PseudoDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26590
+ PyObject *resultobj = 0;
26591
+ gwxPseudoDC *arg1 = (gwxPseudoDC *) 0 ;
26592
+ void *argp1 = 0 ;
26593
+ int res1 = 0 ;
26594
+ PyObject * obj0 = 0 ;
26595
+
26596
+ if (!PyArg_ParseTuple(args,(char *)"O:delete_PseudoDC",&obj0)) SWIG_fail;
26597
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gwxPseudoDC, SWIG_POINTER_DISOWN | 0 );
26598
+ if (!SWIG_IsOK(res1)) {
26599
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PseudoDC" "', argument " "1"" of type '" "gwxPseudoDC *""'");
26600
+ }
26601
+ arg1 = reinterpret_cast< gwxPseudoDC * >(argp1);
26602
+ delete arg1;
26603
+ resultobj = SWIG_Py_Void();
26604
+ return resultobj;
26605
+fail:
26606
+ return NULL;
26607
+}
26608
+
26609
+
26610
+SWIGINTERN PyObject *_wrap_PseudoDC_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26611
+ PyObject *resultobj = 0;
26612
+ gwxPseudoDC *arg1 = (gwxPseudoDC *) 0 ;
26613
+ void *argp1 = 0 ;
26614
+ int res1 = 0 ;
26615
+ PyObject * obj0 = 0 ;
26616
+
26617
+ if (!PyArg_ParseTuple(args,(char *)"O:PseudoDC_Clear",&obj0)) SWIG_fail;
26618
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gwxPseudoDC, 0 | 0 );
26619
+ if (!SWIG_IsOK(res1)) {
26620
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_Clear" "', argument " "1"" of type '" "gwxPseudoDC *""'");
26621
+ }
26622
+ arg1 = reinterpret_cast< gwxPseudoDC * >(argp1);
26623
+ (arg1)->Clear();
26624
+ resultobj = SWIG_Py_Void();
26625
+ return resultobj;
26626
+fail:
26627
+ return NULL;
26628
+}
26629
+
26630
+
26631
+SWIGINTERN PyObject *_wrap_PseudoDC_RemoveAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26632
+ PyObject *resultobj = 0;
26633
+ gwxPseudoDC *arg1 = (gwxPseudoDC *) 0 ;
26634
+ void *argp1 = 0 ;
26635
+ int res1 = 0 ;
26636
+ PyObject * obj0 = 0 ;
26637
+
26638
+ if (!PyArg_ParseTuple(args,(char *)"O:PseudoDC_RemoveAll",&obj0)) SWIG_fail;
26639
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gwxPseudoDC, 0 | 0 );
26640
+ if (!SWIG_IsOK(res1)) {
26641
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_RemoveAll" "', argument " "1"" of type '" "gwxPseudoDC *""'");
26642
+ }
26643
+ arg1 = reinterpret_cast< gwxPseudoDC * >(argp1);
26644
+ (arg1)->RemoveAll();
26645
+ resultobj = SWIG_Py_Void();
26646
+ return resultobj;
26647
+fail:
26648
+ return NULL;
26649
+}
26650
+
26651
+
26652
+SWIGINTERN PyObject *_wrap_PseudoDC_RemoveId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26653
+ PyObject *resultobj = 0;
26654
+ gwxPseudoDC *arg1 = (gwxPseudoDC *) 0 ;
26655
+ int arg2 ;
26656
+ void *argp1 = 0 ;
26657
+ int res1 = 0 ;
26658
+ int val2 ;
26659
+ int ecode2 = 0 ;
26660
+ PyObject * obj0 = 0 ;
26661
+ PyObject * obj1 = 0 ;
26662
+
26663
+ if (!PyArg_ParseTuple(args,(char *)"OO:PseudoDC_RemoveId",&obj0,&obj1)) SWIG_fail;
26664
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gwxPseudoDC, 0 | 0 );
26665
+ if (!SWIG_IsOK(res1)) {
26666
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_RemoveId" "', argument " "1"" of type '" "gwxPseudoDC *""'");
26667
+ }
26668
+ arg1 = reinterpret_cast< gwxPseudoDC * >(argp1);
26669
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
26670
+ if (!SWIG_IsOK(ecode2)) {
26671
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_RemoveId" "', argument " "2"" of type '" "int""'");
26672
+ }
26673
+ arg2 = static_cast< int >(val2);
26674
+ (arg1)->RemoveId(arg2);
26675
+ resultobj = SWIG_Py_Void();
26676
+ return resultobj;
26677
+fail:
26678
+ return NULL;
26679
+}
26680
+
26681
+
26682
+SWIGINTERN PyObject *_wrap_PseudoDC_DrawToDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26683
+ PyObject *resultobj = 0;
26684
+ gwxPseudoDC *arg1 = (gwxPseudoDC *) 0 ;
26685
+ void *arg2 = (void *) 0 ;
26686
+ void *argp1 = 0 ;
26687
+ int res1 = 0 ;
26688
+ int res2 ;
26689
+ PyObject * obj0 = 0 ;
26690
+ PyObject * obj1 = 0 ;
26691
+
26692
+ if (!PyArg_ParseTuple(args,(char *)"OO:PseudoDC_DrawToDC",&obj0,&obj1)) SWIG_fail;
26693
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gwxPseudoDC, 0 | 0 );
26694
+ if (!SWIG_IsOK(res1)) {
26695
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawToDC" "', argument " "1"" of type '" "gwxPseudoDC *""'");
26696
+ }
26697
+ arg1 = reinterpret_cast< gwxPseudoDC * >(argp1);
26698
+ res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
26699
+ if (!SWIG_IsOK(res2)) {
26700
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawToDC" "', argument " "2"" of type '" "void *""'");
26701
+ }
26702
+ gwxPseudoDC_DrawToDC(arg1,arg2);
26703
+ resultobj = SWIG_Py_Void();
26704
+ return resultobj;
26705
+fail:
26706
+ return NULL;
26707
+}
26708
+
26709
+
26710
+SWIGINTERN PyObject *_wrap_PseudoDC_DrawToDCClipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26711
+ PyObject *resultobj = 0;
26712
+ gwxPseudoDC *arg1 = (gwxPseudoDC *) 0 ;
26713
+ void *arg2 = (void *) 0 ;
26714
+ wxRect *arg3 = 0 ;
26715
+ void *argp1 = 0 ;
26716
+ int res1 = 0 ;
26717
+ int res2 ;
26718
+ void *argp3 = 0 ;
26719
+ int res3 = 0 ;
26720
+ PyObject * obj0 = 0 ;
26721
+ PyObject * obj1 = 0 ;
26722
+ PyObject * obj2 = 0 ;
26723
+
26724
+ if (!PyArg_ParseTuple(args,(char *)"OOO:PseudoDC_DrawToDCClipped",&obj0,&obj1,&obj2)) SWIG_fail;
26725
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gwxPseudoDC, 0 | 0 );
26726
+ if (!SWIG_IsOK(res1)) {
26727
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawToDCClipped" "', argument " "1"" of type '" "gwxPseudoDC *""'");
26728
+ }
26729
+ arg1 = reinterpret_cast< gwxPseudoDC * >(argp1);
26730
+ res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
26731
+ if (!SWIG_IsOK(res2)) {
26732
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawToDCClipped" "', argument " "2"" of type '" "void *""'");
26733
+ }
26734
+ res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxRect, 0 | 0);
26735
+ if (!SWIG_IsOK(res3)) {
26736
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PseudoDC_DrawToDCClipped" "', argument " "3"" of type '" "wxRect const &""'");
26737
+ }
26738
+ if (!argp3) {
26739
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawToDCClipped" "', argument " "3"" of type '" "wxRect const &""'");
26740
+ }
26741
+ arg3 = reinterpret_cast< wxRect * >(argp3);
26742
+ gwxPseudoDC_DrawToDCClipped(arg1,arg2,(wxRect const &)*arg3);
26743
+ resultobj = SWIG_Py_Void();
26744
+ return resultobj;
26745
+fail:
26746
+ return NULL;
26747
+}
26748
+
26749
+
26750
+SWIGINTERN PyObject *_wrap_PseudoDC_GetIdBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26751
+ PyObject *resultobj = 0;
26752
+ gwxPseudoDC *arg1 = (gwxPseudoDC *) 0 ;
26753
+ int arg2 ;
26754
+ void *argp1 = 0 ;
26755
+ int res1 = 0 ;
26756
+ int val2 ;
26757
+ int ecode2 = 0 ;
26758
+ PyObject * obj0 = 0 ;
26759
+ PyObject * obj1 = 0 ;
26760
+ wxRect result;
26761
+
26762
+ if (!PyArg_ParseTuple(args,(char *)"OO:PseudoDC_GetIdBounds",&obj0,&obj1)) SWIG_fail;
26763
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gwxPseudoDC, 0 | 0 );
26764
+ if (!SWIG_IsOK(res1)) {
26765
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_GetIdBounds" "', argument " "1"" of type '" "gwxPseudoDC *""'");
26766
+ }
26767
+ arg1 = reinterpret_cast< gwxPseudoDC * >(argp1);
26768
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
26769
+ if (!SWIG_IsOK(ecode2)) {
26770
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_GetIdBounds" "', argument " "2"" of type '" "int""'");
26771
+ }
26772
+ arg2 = static_cast< int >(val2);
26773
+ result = gwxPseudoDC_GetIdBounds(arg1,arg2);
26774
+ {
26775
+ resultobj = Py_BuildValue("iiii", (&result)->x, (&result)->y, (&result)->width, (&result)->height);
26776
+ }
26777
+ return resultobj;
26778
+fail:
26779
+ return NULL;
26780
+}
26781
+
26782
+
26783
+SWIGINTERN PyObject *PseudoDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26784
+ PyObject *obj;
26785
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
26786
+ SWIG_TypeNewClientData(SWIGTYPE_p_gwxPseudoDC, SWIG_NewClientData(obj));
26787
+ return SWIG_Py_Void();
26788
+}
26789
+
26790
+static PyMethodDef SwigMethods[] = {
26791
+ { (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, NULL},
26792
+ { (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, NULL},
26793
+ { (char *)"PySwigIterator_incr", _wrap_PySwigIterator_incr, METH_VARARGS, NULL},
26794
+ { (char *)"PySwigIterator_decr", _wrap_PySwigIterator_decr, METH_VARARGS, NULL},
26795
+ { (char *)"PySwigIterator_distance", _wrap_PySwigIterator_distance, METH_VARARGS, NULL},
26796
+ { (char *)"PySwigIterator_equal", _wrap_PySwigIterator_equal, METH_VARARGS, NULL},
26797
+ { (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, NULL},
26798
+ { (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, NULL},
26799
+ { (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, NULL},
26800
+ { (char *)"PySwigIterator_advance", _wrap_PySwigIterator_advance, METH_VARARGS, NULL},
26801
+ { (char *)"PySwigIterator___eq__", _wrap_PySwigIterator___eq__, METH_VARARGS, NULL},
26802
+ { (char *)"PySwigIterator___ne__", _wrap_PySwigIterator___ne__, METH_VARARGS, NULL},
26803
+ { (char *)"PySwigIterator___iadd__", _wrap_PySwigIterator___iadd__, METH_VARARGS, NULL},
26804
+ { (char *)"PySwigIterator___isub__", _wrap_PySwigIterator___isub__, METH_VARARGS, NULL},
26805
+ { (char *)"PySwigIterator___add__", _wrap_PySwigIterator___add__, METH_VARARGS, NULL},
26806
+ { (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, NULL},
26807
+ { (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
26808
+ { (char *)"IntVector_iterator", _wrap_IntVector_iterator, METH_VARARGS, NULL},
26809
+ { (char *)"IntVector___nonzero__", _wrap_IntVector___nonzero__, METH_VARARGS, NULL},
26810
+ { (char *)"IntVector___len__", _wrap_IntVector___len__, METH_VARARGS, NULL},
26811
+ { (char *)"IntVector_pop", _wrap_IntVector_pop, METH_VARARGS, NULL},
26812
+ { (char *)"IntVector___getslice__", _wrap_IntVector___getslice__, METH_VARARGS, NULL},
26813
+ { (char *)"IntVector___setslice__", _wrap_IntVector___setslice__, METH_VARARGS, NULL},
26814
+ { (char *)"IntVector___delslice__", _wrap_IntVector___delslice__, METH_VARARGS, NULL},
26815
+ { (char *)"IntVector___delitem__", _wrap_IntVector___delitem__, METH_VARARGS, NULL},
26816
+ { (char *)"IntVector___getitem__", _wrap_IntVector___getitem__, METH_VARARGS, NULL},
26817
+ { (char *)"IntVector___setitem__", _wrap_IntVector___setitem__, METH_VARARGS, NULL},
26818
+ { (char *)"IntVector_append", _wrap_IntVector_append, METH_VARARGS, NULL},
26819
+ { (char *)"IntVector_empty", _wrap_IntVector_empty, METH_VARARGS, NULL},
26820
+ { (char *)"IntVector_size", _wrap_IntVector_size, METH_VARARGS, NULL},
26821
+ { (char *)"IntVector_clear", _wrap_IntVector_clear, METH_VARARGS, NULL},
26822
+ { (char *)"IntVector_swap", _wrap_IntVector_swap, METH_VARARGS, NULL},
26823
+ { (char *)"IntVector_get_allocator", _wrap_IntVector_get_allocator, METH_VARARGS, NULL},
26824
+ { (char *)"IntVector_begin", _wrap_IntVector_begin, METH_VARARGS, NULL},
26825
+ { (char *)"IntVector_end", _wrap_IntVector_end, METH_VARARGS, NULL},
26826
+ { (char *)"IntVector_rbegin", _wrap_IntVector_rbegin, METH_VARARGS, NULL},
26827
+ { (char *)"IntVector_rend", _wrap_IntVector_rend, METH_VARARGS, NULL},
26828
+ { (char *)"IntVector_pop_back", _wrap_IntVector_pop_back, METH_VARARGS, NULL},
26829
+ { (char *)"IntVector_erase", _wrap_IntVector_erase, METH_VARARGS, NULL},
26830
+ { (char *)"new_IntVector", _wrap_new_IntVector, METH_VARARGS, NULL},
26831
+ { (char *)"IntVector_push_back", _wrap_IntVector_push_back, METH_VARARGS, NULL},
26832
+ { (char *)"IntVector_front", _wrap_IntVector_front, METH_VARARGS, NULL},
26833
+ { (char *)"IntVector_back", _wrap_IntVector_back, METH_VARARGS, NULL},
26834
+ { (char *)"IntVector_assign", _wrap_IntVector_assign, METH_VARARGS, NULL},
26835
+ { (char *)"IntVector_resize", _wrap_IntVector_resize, METH_VARARGS, NULL},
26836
+ { (char *)"IntVector_insert", _wrap_IntVector_insert, METH_VARARGS, NULL},
26837
+ { (char *)"IntVector_reserve", _wrap_IntVector_reserve, METH_VARARGS, NULL},
26838
+ { (char *)"IntVector_capacity", _wrap_IntVector_capacity, METH_VARARGS, NULL},
26839
+ { (char *)"delete_IntVector", _wrap_delete_IntVector, METH_VARARGS, NULL},
26840
+ { (char *)"IntVector_swigregister", IntVector_swigregister, METH_VARARGS, NULL},
26841
+ { (char *)"DoubleVector_iterator", _wrap_DoubleVector_iterator, METH_VARARGS, NULL},
26842
+ { (char *)"DoubleVector___nonzero__", _wrap_DoubleVector___nonzero__, METH_VARARGS, NULL},
26843
+ { (char *)"DoubleVector___len__", _wrap_DoubleVector___len__, METH_VARARGS, NULL},
26844
+ { (char *)"DoubleVector_pop", _wrap_DoubleVector_pop, METH_VARARGS, NULL},
26845
+ { (char *)"DoubleVector___getslice__", _wrap_DoubleVector___getslice__, METH_VARARGS, NULL},
26846
+ { (char *)"DoubleVector___setslice__", _wrap_DoubleVector___setslice__, METH_VARARGS, NULL},
26847
+ { (char *)"DoubleVector___delslice__", _wrap_DoubleVector___delslice__, METH_VARARGS, NULL},
26848
+ { (char *)"DoubleVector___delitem__", _wrap_DoubleVector___delitem__, METH_VARARGS, NULL},
26849
+ { (char *)"DoubleVector___getitem__", _wrap_DoubleVector___getitem__, METH_VARARGS, NULL},
26850
+ { (char *)"DoubleVector___setitem__", _wrap_DoubleVector___setitem__, METH_VARARGS, NULL},
26851
+ { (char *)"DoubleVector_append", _wrap_DoubleVector_append, METH_VARARGS, NULL},
26852
+ { (char *)"DoubleVector_empty", _wrap_DoubleVector_empty, METH_VARARGS, NULL},
26853
+ { (char *)"DoubleVector_size", _wrap_DoubleVector_size, METH_VARARGS, NULL},
26854
+ { (char *)"DoubleVector_clear", _wrap_DoubleVector_clear, METH_VARARGS, NULL},
26855
+ { (char *)"DoubleVector_swap", _wrap_DoubleVector_swap, METH_VARARGS, NULL},
26856
+ { (char *)"DoubleVector_get_allocator", _wrap_DoubleVector_get_allocator, METH_VARARGS, NULL},
26857
+ { (char *)"DoubleVector_begin", _wrap_DoubleVector_begin, METH_VARARGS, NULL},
26858
+ { (char *)"DoubleVector_end", _wrap_DoubleVector_end, METH_VARARGS, NULL},
26859
+ { (char *)"DoubleVector_rbegin", _wrap_DoubleVector_rbegin, METH_VARARGS, NULL},
26860
+ { (char *)"DoubleVector_rend", _wrap_DoubleVector_rend, METH_VARARGS, NULL},
26861
+ { (char *)"DoubleVector_pop_back", _wrap_DoubleVector_pop_back, METH_VARARGS, NULL},
26862
+ { (char *)"DoubleVector_erase", _wrap_DoubleVector_erase, METH_VARARGS, NULL},
26863
+ { (char *)"new_DoubleVector", _wrap_new_DoubleVector, METH_VARARGS, NULL},
26864
+ { (char *)"DoubleVector_push_back", _wrap_DoubleVector_push_back, METH_VARARGS, NULL},
26865
+ { (char *)"DoubleVector_front", _wrap_DoubleVector_front, METH_VARARGS, NULL},
26866
+ { (char *)"DoubleVector_back", _wrap_DoubleVector_back, METH_VARARGS, NULL},
26867
+ { (char *)"DoubleVector_assign", _wrap_DoubleVector_assign, METH_VARARGS, NULL},
26868
+ { (char *)"DoubleVector_resize", _wrap_DoubleVector_resize, METH_VARARGS, NULL},
26869
+ { (char *)"DoubleVector_insert", _wrap_DoubleVector_insert, METH_VARARGS, NULL},
26870
+ { (char *)"DoubleVector_reserve", _wrap_DoubleVector_reserve, METH_VARARGS, NULL},
26871
+ { (char *)"DoubleVector_capacity", _wrap_DoubleVector_capacity, METH_VARARGS, NULL},
26872
+ { (char *)"delete_DoubleVector", _wrap_delete_DoubleVector, METH_VARARGS, NULL},
26873
+ { (char *)"DoubleVector_swigregister", DoubleVector_swigregister, METH_VARARGS, NULL},
26874
+ { (char *)"IntVecIntMap_iterator", _wrap_IntVecIntMap_iterator, METH_VARARGS, NULL},
26875
+ { (char *)"IntVecIntMap___nonzero__", _wrap_IntVecIntMap___nonzero__, METH_VARARGS, NULL},
26876
+ { (char *)"IntVecIntMap___len__", _wrap_IntVecIntMap___len__, METH_VARARGS, NULL},
26877
+ { (char *)"IntVecIntMap___getitem__", _wrap_IntVecIntMap___getitem__, METH_VARARGS, NULL},
26878
+ { (char *)"IntVecIntMap___delitem__", _wrap_IntVecIntMap___delitem__, METH_VARARGS, NULL},
26879
+ { (char *)"IntVecIntMap_has_key", _wrap_IntVecIntMap_has_key, METH_VARARGS, NULL},
26880
+ { (char *)"IntVecIntMap_keys", _wrap_IntVecIntMap_keys, METH_VARARGS, NULL},
26881
+ { (char *)"IntVecIntMap_values", _wrap_IntVecIntMap_values, METH_VARARGS, NULL},
26882
+ { (char *)"IntVecIntMap_items", _wrap_IntVecIntMap_items, METH_VARARGS, NULL},
26883
+ { (char *)"IntVecIntMap___contains__", _wrap_IntVecIntMap___contains__, METH_VARARGS, NULL},
26884
+ { (char *)"IntVecIntMap_key_iterator", _wrap_IntVecIntMap_key_iterator, METH_VARARGS, NULL},
26885
+ { (char *)"IntVecIntMap_value_iterator", _wrap_IntVecIntMap_value_iterator, METH_VARARGS, NULL},
26886
+ { (char *)"IntVecIntMap___setitem__", _wrap_IntVecIntMap___setitem__, METH_VARARGS, NULL},
26887
+ { (char *)"new_IntVecIntMap", _wrap_new_IntVecIntMap, METH_VARARGS, NULL},
26888
+ { (char *)"IntVecIntMap_empty", _wrap_IntVecIntMap_empty, METH_VARARGS, NULL},
26889
+ { (char *)"IntVecIntMap_size", _wrap_IntVecIntMap_size, METH_VARARGS, NULL},
26890
+ { (char *)"IntVecIntMap_clear", _wrap_IntVecIntMap_clear, METH_VARARGS, NULL},
26891
+ { (char *)"IntVecIntMap_swap", _wrap_IntVecIntMap_swap, METH_VARARGS, NULL},
26892
+ { (char *)"IntVecIntMap_get_allocator", _wrap_IntVecIntMap_get_allocator, METH_VARARGS, NULL},
26893
+ { (char *)"IntVecIntMap_begin", _wrap_IntVecIntMap_begin, METH_VARARGS, NULL},
26894
+ { (char *)"IntVecIntMap_end", _wrap_IntVecIntMap_end, METH_VARARGS, NULL},
26895
+ { (char *)"IntVecIntMap_rbegin", _wrap_IntVecIntMap_rbegin, METH_VARARGS, NULL},
26896
+ { (char *)"IntVecIntMap_rend", _wrap_IntVecIntMap_rend, METH_VARARGS, NULL},
26897
+ { (char *)"IntVecIntMap_count", _wrap_IntVecIntMap_count, METH_VARARGS, NULL},
26898
+ { (char *)"IntVecIntMap_erase", _wrap_IntVecIntMap_erase, METH_VARARGS, NULL},
26899
+ { (char *)"IntVecIntMap_find", _wrap_IntVecIntMap_find, METH_VARARGS, NULL},
26900
+ { (char *)"IntVecIntMap_lower_bound", _wrap_IntVecIntMap_lower_bound, METH_VARARGS, NULL},
26901
+ { (char *)"IntVecIntMap_upper_bound", _wrap_IntVecIntMap_upper_bound, METH_VARARGS, NULL},
26902
+ { (char *)"delete_IntVecIntMap", _wrap_delete_IntVecIntMap, METH_VARARGS, NULL},
26903
+ { (char *)"IntVecIntMap_swigregister", IntVecIntMap_swigregister, METH_VARARGS, NULL},
26904
+ { (char *)"DoubleVecIntMap_iterator", _wrap_DoubleVecIntMap_iterator, METH_VARARGS, NULL},
26905
+ { (char *)"DoubleVecIntMap___nonzero__", _wrap_DoubleVecIntMap___nonzero__, METH_VARARGS, NULL},
26906
+ { (char *)"DoubleVecIntMap___len__", _wrap_DoubleVecIntMap___len__, METH_VARARGS, NULL},
26907
+ { (char *)"DoubleVecIntMap___getitem__", _wrap_DoubleVecIntMap___getitem__, METH_VARARGS, NULL},
26908
+ { (char *)"DoubleVecIntMap___delitem__", _wrap_DoubleVecIntMap___delitem__, METH_VARARGS, NULL},
26909
+ { (char *)"DoubleVecIntMap_has_key", _wrap_DoubleVecIntMap_has_key, METH_VARARGS, NULL},
26910
+ { (char *)"DoubleVecIntMap_keys", _wrap_DoubleVecIntMap_keys, METH_VARARGS, NULL},
26911
+ { (char *)"DoubleVecIntMap_values", _wrap_DoubleVecIntMap_values, METH_VARARGS, NULL},
26912
+ { (char *)"DoubleVecIntMap_items", _wrap_DoubleVecIntMap_items, METH_VARARGS, NULL},
26913
+ { (char *)"DoubleVecIntMap___contains__", _wrap_DoubleVecIntMap___contains__, METH_VARARGS, NULL},
26914
+ { (char *)"DoubleVecIntMap_key_iterator", _wrap_DoubleVecIntMap_key_iterator, METH_VARARGS, NULL},
26915
+ { (char *)"DoubleVecIntMap_value_iterator", _wrap_DoubleVecIntMap_value_iterator, METH_VARARGS, NULL},
26916
+ { (char *)"DoubleVecIntMap___setitem__", _wrap_DoubleVecIntMap___setitem__, METH_VARARGS, NULL},
26917
+ { (char *)"new_DoubleVecIntMap", _wrap_new_DoubleVecIntMap, METH_VARARGS, NULL},
26918
+ { (char *)"DoubleVecIntMap_empty", _wrap_DoubleVecIntMap_empty, METH_VARARGS, NULL},
26919
+ { (char *)"DoubleVecIntMap_size", _wrap_DoubleVecIntMap_size, METH_VARARGS, NULL},
26920
+ { (char *)"DoubleVecIntMap_clear", _wrap_DoubleVecIntMap_clear, METH_VARARGS, NULL},
26921
+ { (char *)"DoubleVecIntMap_swap", _wrap_DoubleVecIntMap_swap, METH_VARARGS, NULL},
26922
+ { (char *)"DoubleVecIntMap_get_allocator", _wrap_DoubleVecIntMap_get_allocator, METH_VARARGS, NULL},
26923
+ { (char *)"DoubleVecIntMap_begin", _wrap_DoubleVecIntMap_begin, METH_VARARGS, NULL},
26924
+ { (char *)"DoubleVecIntMap_end", _wrap_DoubleVecIntMap_end, METH_VARARGS, NULL},
26925
+ { (char *)"DoubleVecIntMap_rbegin", _wrap_DoubleVecIntMap_rbegin, METH_VARARGS, NULL},
26926
+ { (char *)"DoubleVecIntMap_rend", _wrap_DoubleVecIntMap_rend, METH_VARARGS, NULL},
26927
+ { (char *)"DoubleVecIntMap_count", _wrap_DoubleVecIntMap_count, METH_VARARGS, NULL},
26928
+ { (char *)"DoubleVecIntMap_erase", _wrap_DoubleVecIntMap_erase, METH_VARARGS, NULL},
26929
+ { (char *)"DoubleVecIntMap_find", _wrap_DoubleVecIntMap_find, METH_VARARGS, NULL},
26930
+ { (char *)"DoubleVecIntMap_lower_bound", _wrap_DoubleVecIntMap_lower_bound, METH_VARARGS, NULL},
26931
+ { (char *)"DoubleVecIntMap_upper_bound", _wrap_DoubleVecIntMap_upper_bound, METH_VARARGS, NULL},
26932
+ { (char *)"delete_DoubleVecIntMap", _wrap_delete_DoubleVecIntMap, METH_VARARGS, NULL},
26933
+ { (char *)"DoubleVecIntMap_swigregister", DoubleVecIntMap_swigregister, METH_VARARGS, NULL},
26934
+ { (char *)"new_DisplayDriver", _wrap_new_DisplayDriver, METH_VARARGS, NULL},
26935
+ { (char *)"delete_DisplayDriver", _wrap_delete_DisplayDriver, METH_VARARGS, NULL},
26936
+ { (char *)"DisplayDriver_DrawMap", _wrap_DisplayDriver_DrawMap, METH_VARARGS, NULL},
26937
+ { (char *)"DisplayDriver_SelectLinesByBox", _wrap_DisplayDriver_SelectLinesByBox, METH_VARARGS, NULL},
26938
+ { (char *)"DisplayDriver_SelectLineByPoint", _wrap_DisplayDriver_SelectLineByPoint, METH_VARARGS, NULL},
26939
+ { (char *)"DisplayDriver_GetSelected", _wrap_DisplayDriver_GetSelected, METH_VARARGS, NULL},
26940
+ { (char *)"DisplayDriver_GetSelectedCoord", _wrap_DisplayDriver_GetSelectedCoord, METH_VARARGS, NULL},
26941
+ { (char *)"DisplayDriver_GetDuplicates", _wrap_DisplayDriver_GetDuplicates, METH_VARARGS, NULL},
26942
+ { (char *)"DisplayDriver_GetRegionSelected", _wrap_DisplayDriver_GetRegionSelected, METH_VARARGS, NULL},
26943
+ { (char *)"DisplayDriver_SetSelected", _wrap_DisplayDriver_SetSelected, METH_VARARGS, NULL},
26944
+ { (char *)"DisplayDriver_UnSelect", _wrap_DisplayDriver_UnSelect, METH_VARARGS, NULL},
26945
+ { (char *)"DisplayDriver_GetSelectedVertex", _wrap_DisplayDriver_GetSelectedVertex, METH_VARARGS, NULL},
26946
+ { (char *)"DisplayDriver_DrawSelected", _wrap_DisplayDriver_DrawSelected, METH_VARARGS, NULL},
26947
+ { (char *)"DisplayDriver_CloseMap", _wrap_DisplayDriver_CloseMap, METH_VARARGS, NULL},
26948
+ { (char *)"DisplayDriver_OpenMap", _wrap_DisplayDriver_OpenMap, METH_VARARGS, NULL},
26949
+ { (char *)"DisplayDriver_ReloadMap", _wrap_DisplayDriver_ReloadMap, METH_VARARGS, NULL},
26950
+ { (char *)"DisplayDriver_SetDevice", _wrap_DisplayDriver_SetDevice, METH_VARARGS, NULL},
26951
+ { (char *)"DisplayDriver_GetMapBoundingBox", _wrap_DisplayDriver_GetMapBoundingBox, METH_VARARGS, NULL},
26952
+ { (char *)"DisplayDriver_Is3D", _wrap_DisplayDriver_Is3D, METH_VARARGS, NULL},
26953
+ { (char *)"DisplayDriver_SetRegion", _wrap_DisplayDriver_SetRegion, METH_VARARGS, NULL},
26954
+ { (char *)"DisplayDriver_UpdateSettings", _wrap_DisplayDriver_UpdateSettings, METH_VARARGS, NULL},
26955
+ { (char *)"DisplayDriver_swigregister", DisplayDriver_swigregister, METH_VARARGS, NULL},
26956
+ { (char *)"print_error", _wrap_print_error, METH_VARARGS, NULL},
26957
+ { (char *)"new_Digit", _wrap_new_Digit, METH_VARARGS, NULL},
26958
+ { (char *)"delete_Digit", _wrap_delete_Digit, METH_VARARGS, NULL},
26959
+ { (char *)"Digit_InitCats", _wrap_Digit_InitCats, METH_VARARGS, NULL},
26960
+ { (char *)"Digit_AddLine", _wrap_Digit_AddLine, METH_VARARGS, NULL},
26961
+ { (char *)"Digit_RewriteLine", _wrap_Digit_RewriteLine, METH_VARARGS, NULL},
26962
+ { (char *)"Digit_SplitLine", _wrap_Digit_SplitLine, METH_VARARGS, NULL},
26963
+ { (char *)"Digit_DeleteLines", _wrap_Digit_DeleteLines, METH_VARARGS, NULL},
26964
+ { (char *)"Digit_MoveLines", _wrap_Digit_MoveLines, METH_VARARGS, NULL},
26965
+ { (char *)"Digit_FlipLines", _wrap_Digit_FlipLines, METH_VARARGS, NULL},
26966
+ { (char *)"Digit_MergeLines", _wrap_Digit_MergeLines, METH_VARARGS, NULL},
26967
+ { (char *)"Digit_BreakLines", _wrap_Digit_BreakLines, METH_VARARGS, NULL},
26968
+ { (char *)"Digit_SnapLines", _wrap_Digit_SnapLines, METH_VARARGS, NULL},
26969
+ { (char *)"Digit_ConnectLines", _wrap_Digit_ConnectLines, METH_VARARGS, NULL},
26970
+ { (char *)"Digit_TypeConvLines", _wrap_Digit_TypeConvLines, METH_VARARGS, NULL},
26971
+ { (char *)"Digit_ZBulkLabeling", _wrap_Digit_ZBulkLabeling, METH_VARARGS, NULL},
26972
+ { (char *)"Digit_CopyLines", _wrap_Digit_CopyLines, METH_VARARGS, NULL},
26973
+ { (char *)"Digit_MoveVertex", _wrap_Digit_MoveVertex, METH_VARARGS, NULL},
26974
+ { (char *)"Digit_ModifyLineVertex", _wrap_Digit_ModifyLineVertex, METH_VARARGS, NULL},
26975
+ { (char *)"Digit_SelectLinesByQuery", _wrap_Digit_SelectLinesByQuery, METH_VARARGS, NULL},
26976
+ { (char *)"Digit_CopyCats", _wrap_Digit_CopyCats, METH_VARARGS, NULL},
26977
+ { (char *)"Digit_GetCategory", _wrap_Digit_GetCategory, METH_VARARGS, NULL},
26978
+ { (char *)"Digit_GetLineCats", _wrap_Digit_GetLineCats, METH_VARARGS, NULL},
26979
+ { (char *)"Digit_SetLineCats", _wrap_Digit_SetLineCats, METH_VARARGS, NULL},
26980
+ { (char *)"Digit_GetLayers", _wrap_Digit_GetLayers, METH_VARARGS, NULL},
26981
+ { (char *)"Digit_Undo", _wrap_Digit_Undo, METH_VARARGS, NULL},
26982
+ { (char *)"Digit_GetUndoLevel", _wrap_Digit_GetUndoLevel, METH_VARARGS, NULL},
26983
+ { (char *)"Digit_UpdateSettings", _wrap_Digit_UpdateSettings, METH_VARARGS, NULL},
26984
+ { (char *)"Digit_swigregister", Digit_swigregister, METH_VARARGS, NULL},
26985
+ { (char *)"new_PseudoDC", _wrap_new_PseudoDC, METH_VARARGS, NULL},
26986
+ { (char *)"delete_PseudoDC", _wrap_delete_PseudoDC, METH_VARARGS, NULL},
26987
+ { (char *)"PseudoDC_Clear", _wrap_PseudoDC_Clear, METH_VARARGS, NULL},
26988
+ { (char *)"PseudoDC_RemoveAll", _wrap_PseudoDC_RemoveAll, METH_VARARGS, NULL},
26989
+ { (char *)"PseudoDC_RemoveId", _wrap_PseudoDC_RemoveId, METH_VARARGS, NULL},
26990
+ { (char *)"PseudoDC_DrawToDC", _wrap_PseudoDC_DrawToDC, METH_VARARGS, NULL},
26991
+ { (char *)"PseudoDC_DrawToDCClipped", _wrap_PseudoDC_DrawToDCClipped, METH_VARARGS, NULL},
26992
+ { (char *)"PseudoDC_GetIdBounds", _wrap_PseudoDC_GetIdBounds, METH_VARARGS, NULL},
26993
+ { (char *)"PseudoDC_swigregister", PseudoDC_swigregister, METH_VARARGS, NULL},
26994
+ { NULL, NULL, 0, NULL }
26995
+};
26996
+
26997
+
26998
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
26999
+
27000
+static swig_type_info _swigt__p_Digit = {"_p_Digit", "Digit *", 0, 0, (void*)0, 0};
27001
+static swig_type_info _swigt__p_DisplayDriver = {"_p_DisplayDriver", "DisplayDriver *", 0, 0, (void*)0, 0};
27002
+static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
27003
+static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
27004
+static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
27005
+static swig_type_info _swigt__p_gwxPseudoDC = {"_p_gwxPseudoDC", "gwxPseudoDC *", 0, 0, (void*)0, 0};
27006
+static swig_type_info _swigt__p_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
27007
+static swig_type_info _swigt__p_mapped_type = {"_p_mapped_type", "mapped_type *", 0, 0, (void*)0, 0};
27008
+static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
27009
+static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
27010
+static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
27011
+static swig_type_info _swigt__p_std__lessT_int_t = {"_p_std__lessT_int_t", "std::less< int > *", 0, 0, (void*)0, 0};
27012
+static swig_type_info _swigt__p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t = {"_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t", "std::map< int,std::vector< double > > *|std::map< int,std::vector< double,std::allocator< double > >,std::less< int >,std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > > *|std::map< int,std::vector< double,std::allocator< double > > > *", 0, 0, (void*)0, 0};
27013
+static swig_type_info _swigt__p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t__allocator_type = {"_p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t__allocator_type", "std::allocator< std::pair< int const,std::vector< double,std::allocator< double > > > > *|std::map< int,std::vector< double > >::allocator_type *", 0, 0, (void*)0, 0};
27014
+static swig_type_info _swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t = {"_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t", "std::map< int,std::vector< int > > *|std::map< int,std::vector< int,std::allocator< int > >,std::less< int >,std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > > *|std::map< int,std::vector< int,std::allocator< int > > > *", 0, 0, (void*)0, 0};
27015
+static swig_type_info _swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type = {"_p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type", "std::map< int,std::vector< int > >::allocator_type *|std::allocator< std::pair< int const,std::vector< int,std::allocator< int > > > > *", 0, 0, (void*)0, 0};
27016
+static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t = {"_p_std__vectorT_double_std__allocatorT_double_t_t", "std::vector< double,std::allocator< double > > *|std::vector< double > *", 0, 0, (void*)0, 0};
27017
+static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type = {"_p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type", "std::vector< double >::allocator_type *|std::allocator< double > *", 0, 0, (void*)0, 0};
27018
+static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|std::vector< int > *", 0, 0, (void*)0, 0};
27019
+static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type = {"_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type", "std::vector< int >::allocator_type *|std::allocator< int > *", 0, 0, (void*)0, 0};
27020
+static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
27021
+static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
27022
+static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
27023
+static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
27024
+
27025
+static swig_type_info *swig_type_initial[] = {
27026
+ &_swigt__p_Digit,
27027
+ &_swigt__p_DisplayDriver,
27028
+ &_swigt__p_allocator_type,
27029
+ &_swigt__p_char,
27030
+ &_swigt__p_difference_type,
27031
+ &_swigt__p_gwxPseudoDC,
27032
+ &_swigt__p_key_type,
27033
+ &_swigt__p_mapped_type,
27034
+ &_swigt__p_p_PyObject,
27035
+ &_swigt__p_size_type,
27036
+ &_swigt__p_std__invalid_argument,
27037
+ &_swigt__p_std__lessT_int_t,
27038
+ &_swigt__p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t,
27039
+ &_swigt__p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t__allocator_type,
27040
+ &_swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t,
27041
+ &_swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type,
27042
+ &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t,
27043
+ &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type,
27044
+ &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
27045
+ &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type,
27046
+ &_swigt__p_swig__PySwigIterator,
27047
+ &_swigt__p_value_type,
27048
+ &_swigt__p_wxRect,
27049
+ &_swigt__p_wxWindow,
27050
+};
27051
+
27052
+static swig_cast_info _swigc__p_Digit[] = { {&_swigt__p_Digit, 0, 0, 0},{0, 0, 0, 0}};
27053
+static swig_cast_info _swigc__p_DisplayDriver[] = { {&_swigt__p_DisplayDriver, 0, 0, 0},{0, 0, 0, 0}};
27054
+static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
27055
+static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
27056
+static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
27057
+static swig_cast_info _swigc__p_gwxPseudoDC[] = { {&_swigt__p_gwxPseudoDC, 0, 0, 0},{0, 0, 0, 0}};
27058
+static swig_cast_info _swigc__p_key_type[] = { {&_swigt__p_key_type, 0, 0, 0},{0, 0, 0, 0}};
27059
+static swig_cast_info _swigc__p_mapped_type[] = { {&_swigt__p_mapped_type, 0, 0, 0},{0, 0, 0, 0}};
27060
+static swig_cast_info _swigc__p_p_PyObject[] = { {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
27061
+static swig_cast_info _swigc__p_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
27062
+static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
27063
+static swig_cast_info _swigc__p_std__lessT_int_t[] = { {&_swigt__p_std__lessT_int_t, 0, 0, 0},{0, 0, 0, 0}};
27064
+static swig_cast_info _swigc__p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t[] = { {&_swigt__p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
27065
+static swig_cast_info _swigc__p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t__allocator_type[] = { {&_swigt__p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
27066
+static swig_cast_info _swigc__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t[] = { {&_swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
27067
+static swig_cast_info _swigc__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type[] = { {&_swigt__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
27068
+static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t[] = { {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
27069
+static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
27070
+static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = { {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
27071
+static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
27072
+static swig_cast_info _swigc__p_swig__PySwigIterator[] = { {&_swigt__p_swig__PySwigIterator, 0, 0, 0},{0, 0, 0, 0}};
27073
+static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
27074
+static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
27075
+static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxWindow, 0, 0, 0},{0, 0, 0, 0}};
27076
+
27077
+static swig_cast_info *swig_cast_initial[] = {
27078
+ _swigc__p_Digit,
27079
+ _swigc__p_DisplayDriver,
27080
+ _swigc__p_allocator_type,
27081
+ _swigc__p_char,
27082
+ _swigc__p_difference_type,
27083
+ _swigc__p_gwxPseudoDC,
27084
+ _swigc__p_key_type,
27085
+ _swigc__p_mapped_type,
27086
+ _swigc__p_p_PyObject,
27087
+ _swigc__p_size_type,
27088
+ _swigc__p_std__invalid_argument,
27089
+ _swigc__p_std__lessT_int_t,
27090
+ _swigc__p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t,
27091
+ _swigc__p_std__mapT_int_std__vectorT_double_std__allocatorT_double_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_double_std__allocatorT_double_t_t_t_t_t__allocator_type,
27092
+ _swigc__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t,
27093
+ _swigc__p_std__mapT_int_std__vectorT_int_std__allocatorT_int_t_t_std__lessT_int_t_std__allocatorT_std__pairT_int_const_std__vectorT_int_std__allocatorT_int_t_t_t_t_t__allocator_type,
27094
+ _swigc__p_std__vectorT_double_std__allocatorT_double_t_t,
27095
+ _swigc__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type,
27096
+ _swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
27097
+ _swigc__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type,
27098
+ _swigc__p_swig__PySwigIterator,
27099
+ _swigc__p_value_type,
27100
+ _swigc__p_wxRect,
27101
+ _swigc__p_wxWindow,
27102
+};
27103
+
27104
+
27105
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
27106
+
27107
+static swig_const_info swig_const_table[] = {
27108
+{0, 0, 0, 0.0, 0, 0}};
27109
+
27110
+#ifdef __cplusplus
27111
+}
27112
+#endif
27113
+/* -----------------------------------------------------------------------------
27114
+ * Type initialization:
27115
+ * This problem is tough by the requirement that no dynamic
27116
+ * memory is used. Also, since swig_type_info structures store pointers to
27117
+ * swig_cast_info structures and swig_cast_info structures store pointers back
27118
+ * to swig_type_info structures, we need some lookup code at initialization.
27119
+ * The idea is that swig generates all the structures that are needed.
27120
+ * The runtime then collects these partially filled structures.
27121
+ * The SWIG_InitializeModule function takes these initial arrays out of
27122
+ * swig_module, and does all the lookup, filling in the swig_module.types
27123
+ * array with the correct data and linking the correct swig_cast_info
27124
+ * structures together.
27125
+ *
27126
+ * The generated swig_type_info structures are assigned staticly to an initial
27127
+ * array. We just loop through that array, and handle each type individually.
27128
+ * First we lookup if this type has been already loaded, and if so, use the
27129
+ * loaded structure instead of the generated one. Then we have to fill in the
27130
+ * cast linked list. The cast data is initially stored in something like a
27131
+ * two-dimensional array. Each row corresponds to a type (there are the same
27132
+ * number of rows as there are in the swig_type_initial array). Each entry in
27133
+ * a column is one of the swig_cast_info structures for that type.
27134
+ * The cast_initial array is actually an array of arrays, because each row has
27135
+ * a variable number of columns. So to actually build the cast linked list,
27136
+ * we find the array of casts associated with the type, and loop through it
27137
+ * adding the casts to the list. The one last trick we need to do is making
27138
+ * sure the type pointer in the swig_cast_info struct is correct.
27139
+ *
27140
+ * First off, we lookup the cast->type name to see if it is already loaded.
27141
+ * There are three cases to handle:
27142
+ * 1) If the cast->type has already been loaded AND the type we are adding
27143
+ * casting info to has not been loaded (it is in this module), THEN we
27144
+ * replace the cast->type pointer with the type pointer that has already
27145
+ * been loaded.
27146
+ * 2) If BOTH types (the one we are adding casting info to, and the
27147
+ * cast->type) are loaded, THEN the cast info has already been loaded by
27148
+ * the previous module so we just ignore it.
27149
+ * 3) Finally, if cast->type has not already been loaded, then we add that
27150
+ * swig_cast_info to the linked list (because the cast->type) pointer will
27151
+ * be correct.
27152
+ * ----------------------------------------------------------------------------- */
27153
+
27154
+#ifdef __cplusplus
27155
+extern "C" {
27156
+#if 0
27157
+} /* c-mode */
27158
+#endif
27159
+#endif
27160
+
27161
+#if 0
27162
+#define SWIGRUNTIME_DEBUG
27163
+#endif
27164
+
27165
+
27166
+SWIGRUNTIME void
27167
+SWIG_InitializeModule(void *clientdata) {
27168
+ size_t i;
27169
+ swig_module_info *module_head, *iter;
27170
+ int found, init;
27171
+
27172
+ clientdata = clientdata;
27173
+
27174
+ /* check to see if the circular list has been setup, if not, set it up */
27175
+ if (swig_module.next==0) {
27176
+ /* Initialize the swig_module */
27177
+ swig_module.type_initial = swig_type_initial;
27178
+ swig_module.cast_initial = swig_cast_initial;
27179
+ swig_module.next = &swig_module;
27180
+ init = 1;
27181
+ } else {
27182
+ init = 0;
27183
+ }
27184
+
27185
+ /* Try and load any already created modules */
27186
+ module_head = SWIG_GetModule(clientdata);
27187
+ if (!module_head) {
27188
+ /* This is the first module loaded for this interpreter */
27189
+ /* so set the swig module into the interpreter */
27190
+ SWIG_SetModule(clientdata, &swig_module);
27191
+ module_head = &swig_module;
27192
+ } else {
27193
+ /* the interpreter has loaded a SWIG module, but has it loaded this one? */
27194
+ found=0;
27195
+ iter=module_head;
27196
+ do {
27197
+ if (iter==&swig_module) {
27198
+ found=1;
27199
+ break;
27200
+ }
27201
+ iter=iter->next;
27202
+ } while (iter!= module_head);
27203
+
27204
+ /* if the is found in the list, then all is done and we may leave */
27205
+ if (found) return;
27206
+ /* otherwise we must add out module into the list */
27207
+ swig_module.next = module_head->next;
27208
+ module_head->next = &swig_module;
27209
+ }
27210
+
27211
+ /* When multiple interpeters are used, a module could have already been initialized in
27212
+ a different interpreter, but not yet have a pointer in this interpreter.
27213
+ In this case, we do not want to continue adding types... everything should be
27214
+ set up already */
27215
+ if (init == 0) return;
27216
+
27217
+ /* Now work on filling in swig_module.types */
27218
+#ifdef SWIGRUNTIME_DEBUG
27219
+ printf("SWIG_InitializeModule: size %d\n", swig_module.size);
27220
+#endif
27221
+ for (i = 0; i < swig_module.size; ++i) {
27222
+ swig_type_info *type = 0;
27223
+ swig_type_info *ret;
27224
+ swig_cast_info *cast;
27225
+
27226
+#ifdef SWIGRUNTIME_DEBUG
27227
+ printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
27228
+#endif
27229
+
27230
+ /* if there is another module already loaded */
27231
+ if (swig_module.next != &swig_module) {
27232
+ type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
27233
+ }
27234
+ if (type) {
27235
+ /* Overwrite clientdata field */
27236
+#ifdef SWIGRUNTIME_DEBUG
27237
+ printf("SWIG_InitializeModule: found type %s\n", type->name);
27238
+#endif
27239
+ if (swig_module.type_initial[i]->clientdata) {
27240
+ type->clientdata = swig_module.type_initial[i]->clientdata;
27241
+#ifdef SWIGRUNTIME_DEBUG
27242
+ printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27243
+#endif
27244
+ }
27245
+ } else {
27246
+ type = swig_module.type_initial[i];
27247
+ }
27248
+
27249
+ /* Insert casting types */
27250
+ cast = swig_module.cast_initial[i];
27251
+ while (cast->type) {
27252
+ /* Don't need to add information already in the list */
27253
+ ret = 0;
27254
+#ifdef SWIGRUNTIME_DEBUG
27255
+ printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
27256
+#endif
27257
+ if (swig_module.next != &swig_module) {
27258
+ ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
27259
+#ifdef SWIGRUNTIME_DEBUG
27260
+ if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
27261
+#endif
27262
+ }
27263
+ if (ret) {
27264
+ if (type == swig_module.type_initial[i]) {
27265
+#ifdef SWIGRUNTIME_DEBUG
27266
+ printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
27267
+#endif
27268
+ cast->type = ret;
27269
+ ret = 0;
27270
+ } else {
27271
+ /* Check for casting already in the list */
27272
+ swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
27273
+#ifdef SWIGRUNTIME_DEBUG
27274
+ if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
27275
+#endif
27276
+ if (!ocast) ret = 0;
27277
+ }
27278
+ }
27279
+
27280
+ if (!ret) {
27281
+#ifdef SWIGRUNTIME_DEBUG
27282
+ printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
27283
+#endif
27284
+ if (type->cast) {
27285
+ type->cast->prev = cast;
27286
+ cast->next = type->cast;
27287
+ }
27288
+ type->cast = cast;
27289
+ }
27290
+ cast++;
27291
+ }
27292
+ /* Set entry in modules->types array equal to the type */
27293
+ swig_module.types[i] = type;
27294
+ }
27295
+ swig_module.types[i] = 0;
27296
+
27297
+#ifdef SWIGRUNTIME_DEBUG
27298
+ printf("**** SWIG_InitializeModule: Cast List ******\n");
27299
+ for (i = 0; i < swig_module.size; ++i) {
27300
+ int j = 0;
27301
+ swig_cast_info *cast = swig_module.cast_initial[i];
27302
+ printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
27303
+ while (cast->type) {
27304
+ printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
27305
+ cast++;
27306
+ ++j;
27307
+ }
27308
+ printf("---- Total casts: %d\n",j);
27309
+ }
27310
+ printf("**** SWIG_InitializeModule: Cast List ******\n");
27311
+#endif
27312
+}
27313
+
27314
+/* This function will propagate the clientdata field of type to
27315
+* any new swig_type_info structures that have been added into the list
27316
+* of equivalent types. It is like calling
27317
+* SWIG_TypeClientData(type, clientdata) a second time.
27318
+*/
27319
+SWIGRUNTIME void
27320
+SWIG_PropagateClientData(void) {
27321
+ size_t i;
27322
+ swig_cast_info *equiv;
27323
+ static int init_run = 0;
27324
+
27325
+ if (init_run) return;
27326
+ init_run = 1;
27327
+
27328
+ for (i = 0; i < swig_module.size; i++) {
27329
+ if (swig_module.types[i]->clientdata) {
27330
+ equiv = swig_module.types[i]->cast;
27331
+ while (equiv) {
27332
+ if (!equiv->converter) {
27333
+ if (equiv->type && !equiv->type->clientdata)
27334
+ SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
27335
+ }
27336
+ equiv = equiv->next;
27337
+ }
27338
+ }
27339
+ }
27340
+}
27341
+
27342
+#ifdef __cplusplus
27343
+#if 0
27344
+{
27345
+ /* c-mode */
27346
+#endif
27347
+}
27348
+#endif
27349
+
27350
+
27351
+
27352
+#ifdef __cplusplus
27353
+extern "C" {
27354
+#endif
27355
+
27356
+ /* Python-specific SWIG API */
27357
+#define SWIG_newvarlink() SWIG_Python_newvarlink()
27358
+#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
27359
+#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
27360
+
27361
+ /* -----------------------------------------------------------------------------
27362
+ * global variable support code.
27363
+ * ----------------------------------------------------------------------------- */
27364
+
27365
+ typedef struct swig_globalvar {
27366
+ char *name; /* Name of global variable */
27367
+ PyObject *(*get_attr)(void); /* Return the current value */
27368
+ int (*set_attr)(PyObject *); /* Set the value */
27369
+ struct swig_globalvar *next;
27370
+ } swig_globalvar;
27371
+
27372
+ typedef struct swig_varlinkobject {
27373
+ PyObject_HEAD
27374
+ swig_globalvar *vars;
27375
+ } swig_varlinkobject;
27376
+
27377
+ SWIGINTERN PyObject *
27378
+ swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
27379
+ return PyString_FromString("<Swig global variables>");
27380
+ }
27381
+
27382
+ SWIGINTERN PyObject *
27383
+ swig_varlink_str(swig_varlinkobject *v) {
27384
+ PyObject *str = PyString_FromString("(");
27385
+ swig_globalvar *var;
27386
+ for (var = v->vars; var; var=var->next) {
27387
+ PyString_ConcatAndDel(&str,PyString_FromString(var->name));
27388
+ if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
27389
+ }
27390
+ PyString_ConcatAndDel(&str,PyString_FromString(")"));
27391
+ return str;
27392
+ }
27393
+
27394
+ SWIGINTERN int
27395
+ swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
27396
+ PyObject *str = swig_varlink_str(v);
27397
+ fprintf(fp,"Swig global variables ");
27398
+ fprintf(fp,"%s\n", PyString_AsString(str));
27399
+ Py_DECREF(str);
27400
+ return 0;
27401
+ }
27402
+
27403
+ SWIGINTERN void
27404
+ swig_varlink_dealloc(swig_varlinkobject *v) {
27405
+ swig_globalvar *var = v->vars;
27406
+ while (var) {
27407
+ swig_globalvar *n = var->next;
27408
+ free(var->name);
27409
+ free(var);
27410
+ var = n;
27411
+ }
27412
+ }
27413
+
27414
+ SWIGINTERN PyObject *
27415
+ swig_varlink_getattr(swig_varlinkobject *v, char *n) {
27416
+ PyObject *res = NULL;
27417
+ swig_globalvar *var = v->vars;
27418
+ while (var) {
27419
+ if (strcmp(var->name,n) == 0) {
27420
+ res = (*var->get_attr)();
27421
+ break;
27422
+ }
27423
+ var = var->next;
27424
+ }
27425
+ if (res == NULL && !PyErr_Occurred()) {
27426
+ PyErr_SetString(PyExc_NameError,"Unknown C global variable");
27427
+ }
27428
+ return res;
27429
+ }
27430
+
27431
+ SWIGINTERN int
27432
+ swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
27433
+ int res = 1;
27434
+ swig_globalvar *var = v->vars;
27435
+ while (var) {
27436
+ if (strcmp(var->name,n) == 0) {
27437
+ res = (*var->set_attr)(p);
27438
+ break;
27439
+ }
27440
+ var = var->next;
27441
+ }
27442
+ if (res == 1 && !PyErr_Occurred()) {
27443
+ PyErr_SetString(PyExc_NameError,"Unknown C global variable");
27444
+ }
27445
+ return res;
27446
+ }
27447
+
27448
+ SWIGINTERN PyTypeObject*
27449
+ swig_varlink_type(void) {
27450
+ static char varlink__doc__[] = "Swig var link object";
27451
+ static PyTypeObject varlink_type;
27452
+ static int type_init = 0;
27453
+ if (!type_init) {
27454
+ const PyTypeObject tmp
27455
+ = {
27456
+ PyObject_HEAD_INIT(NULL)
27457
+ 0, /* Number of items in variable part (ob_size) */
27458
+ (char *)"swigvarlink", /* Type name (tp_name) */
27459
+ sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
27460
+ 0, /* Itemsize (tp_itemsize) */
27461
+ (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
27462
+ (printfunc) swig_varlink_print, /* Print (tp_print) */
27463
+ (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
27464
+ (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
27465
+ 0, /* tp_compare */
27466
+ (reprfunc) swig_varlink_repr, /* tp_repr */
27467
+ 0, /* tp_as_number */
27468
+ 0, /* tp_as_sequence */
27469
+ 0, /* tp_as_mapping */
27470
+ 0, /* tp_hash */
27471
+ 0, /* tp_call */
27472
+ (reprfunc)swig_varlink_str, /* tp_str */
27473
+ 0, /* tp_getattro */
27474
+ 0, /* tp_setattro */
27475
+ 0, /* tp_as_buffer */
27476
+ 0, /* tp_flags */
27477
+ varlink__doc__, /* tp_doc */
27478
+ 0, /* tp_traverse */
27479
+ 0, /* tp_clear */
27480
+ 0, /* tp_richcompare */
27481
+ 0, /* tp_weaklistoffset */
27482
+#if PY_VERSION_HEX >= 0x02020000
27483
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
27484
+#endif
27485
+#if PY_VERSION_HEX >= 0x02030000
27486
+ 0, /* tp_del */
27487
+#endif
27488
+#ifdef COUNT_ALLOCS
27489
+ 0,0,0,0 /* tp_alloc -> tp_next */
27490
+#endif
27491
+ };
27492
+ varlink_type = tmp;
27493
+ varlink_type.ob_type = &PyType_Type;
27494
+ type_init = 1;
27495
+ }
27496
+ return &varlink_type;
27497
+ }
27498
+
27499
+ /* Create a variable linking object for use later */
27500
+ SWIGINTERN PyObject *
27501
+ SWIG_Python_newvarlink(void) {
27502
+ swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
27503
+ if (result) {
27504
+ result->vars = 0;
27505
+ }
27506
+ return ((PyObject*) result);
27507
+ }
27508
+
27509
+ SWIGINTERN void
27510
+ SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
27511
+ swig_varlinkobject *v = (swig_varlinkobject *) p;
27512
+ swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
27513
+ if (gv) {
27514
+ size_t size = strlen(name)+1;
27515
+ gv->name = (char *)malloc(size);
27516
+ if (gv->name) {
27517
+ strncpy(gv->name,name,size);
27518
+ gv->get_attr = get_attr;
27519
+ gv->set_attr = set_attr;
27520
+ gv->next = v->vars;
27521
+ }
27522
+ }
27523
+ v->vars = gv;
27524
+ }
27525
+
27526
+ SWIGINTERN PyObject *
27527
+ SWIG_globals(void) {
27528
+ static PyObject *_SWIG_globals = 0;
27529
+ if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
27530
+ return _SWIG_globals;
27531
+ }
27532
+
27533
+ /* -----------------------------------------------------------------------------
27534
+ * constants/methods manipulation
27535
+ * ----------------------------------------------------------------------------- */
27536
+
27537
+ /* Install Constants */
27538
+ SWIGINTERN void
27539
+ SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
27540
+ PyObject *obj = 0;
27541
+ size_t i;
27542
+ for (i = 0; constants[i].type; ++i) {
27543
+ switch(constants[i].type) {
27544
+ case SWIG_PY_POINTER:
27545
+ obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
27546
+ break;
27547
+ case SWIG_PY_BINARY:
27548
+ obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
27549
+ break;
27550
+ default:
27551
+ obj = 0;
27552
+ break;
27553
+ }
27554
+ if (obj) {
27555
+ PyDict_SetItemString(d, constants[i].name, obj);
27556
+ Py_DECREF(obj);
27557
+ }
27558
+ }
27559
+ }
27560
+
27561
+ /* -----------------------------------------------------------------------------*/
27562
+ /* Fix SwigMethods to carry the callback ptrs when needed */
27563
+ /* -----------------------------------------------------------------------------*/
27564
+
27565
+ SWIGINTERN void
27566
+ SWIG_Python_FixMethods(PyMethodDef *methods,
27567
+ swig_const_info *const_table,
27568
+ swig_type_info **types,
27569
+ swig_type_info **types_initial) {
27570
+ size_t i;
27571
+ for (i = 0; methods[i].ml_name; ++i) {
27572
+ const char *c = methods[i].ml_doc;
27573
+ if (c && (c = strstr(c, "swig_ptr: "))) {
27574
+ int j;
27575
+ swig_const_info *ci = 0;
27576
+ const char *name = c + 10;
27577
+ for (j = 0; const_table[j].type; ++j) {
27578
+ if (strncmp(const_table[j].name, name,
27579
+ strlen(const_table[j].name)) == 0) {
27580
+ ci = &(const_table[j]);
27581
+ break;
27582
+ }
27583
+ }
27584
+ if (ci) {
27585
+ size_t shift = (ci->ptype) - types;
27586
+ swig_type_info *ty = types_initial[shift];
27587
+ size_t ldoc = (c - methods[i].ml_doc);
27588
+ size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
27589
+ char *ndoc = (char*)malloc(ldoc + lptr + 10);
27590
+ if (ndoc) {
27591
+ char *buff = ndoc;
27592
+ void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
27593
+ if (ptr) {
27594
+ strncpy(buff, methods[i].ml_doc, ldoc);
27595
+ buff += ldoc;
27596
+ strncpy(buff, "swig_ptr: ", 10);
27597
+ buff += 10;
27598
+ SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
27599
+ methods[i].ml_doc = ndoc;
27600
+ }
27601
+ }
27602
+ }
27603
+ }
27604
+ }
27605
+ }
27606
+
27607
+#ifdef __cplusplus
27608
+}
27609
+#endif
27610
+
27611
+/* -----------------------------------------------------------------------------*
27612
+ * Partial Init method
27613
+ * -----------------------------------------------------------------------------*/
27614
+
27615
+#ifdef __cplusplus
27616
+extern "C"
27617
+#endif
27618
+SWIGEXPORT void SWIG_init(void) {
27619
+ PyObject *m, *d;
27620
+
27621
+ /* Fix SwigMethods to carry the callback ptrs when needed */
27622
+ SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
27623
+
27624
+ m = Py_InitModule((char *) SWIG_name, SwigMethods);
27625
+ d = PyModule_GetDict(m);
27626
+
27627
+ SWIG_InitializeModule(0);
27628
+ SWIG_InstallConstants(d,swig_const_table);
27629
+
27630
+
27631
+ SWIG_Python_SetConstant(d, "GSQL_MAX",SWIG_From_int(static_cast< int >(4000)));
27632
+ SWIG_Python_SetConstant(d, "GV_POINT",SWIG_From_int(static_cast< int >(0x01)));
27633
+ SWIG_Python_SetConstant(d, "GV_LINE",SWIG_From_int(static_cast< int >(0x02)));
27634
+ SWIG_Python_SetConstant(d, "GV_BOUNDARY",SWIG_From_int(static_cast< int >(0x04)));
27635
+ SWIG_Python_SetConstant(d, "GV_CENTROID",SWIG_From_int(static_cast< int >(0x08)));
27636
+ SWIG_Python_SetConstant(d, "GV_FACE",SWIG_From_int(static_cast< int >(0x10)));
27637
+ SWIG_Python_SetConstant(d, "GV_KERNEL",SWIG_From_int(static_cast< int >(0x20)));
27638
+ SWIG_Python_SetConstant(d, "GV_AREA",SWIG_From_int(static_cast< int >(0x40)));
27639
+ SWIG_Python_SetConstant(d, "GV_VOLUME",SWIG_From_int(static_cast< int >(0x80)));
27640
+ SWIG_Python_SetConstant(d, "GV_POINTS",SWIG_From_int(static_cast< int >((0x01|0x08))));
27641
+ SWIG_Python_SetConstant(d, "GV_LINES",SWIG_From_int(static_cast< int >((0x02|0x04))));
27642
+ SWIG_Python_SetConstant(d, "PORT_DOUBLE_MAX",SWIG_From_double(static_cast< double >(1.7976931348623157e+308)));
27643
+ SWIG_Python_SetConstant(d, "NO_SNAP",SWIG_From_int(static_cast< int >(0)));
27644
+ SWIG_Python_SetConstant(d, "SNAP",SWIG_From_int(static_cast< int >(1)));
27645
+ SWIG_Python_SetConstant(d, "SNAPVERTEX",SWIG_From_int(static_cast< int >(2)));
27646
+ SWIG_Python_SetConstant(d, "QUERY_UNKNOWN",SWIG_From_int(static_cast< int >(-1)));
27647
+ SWIG_Python_SetConstant(d, "QUERY_LENGTH",SWIG_From_int(static_cast< int >(0)));
27648
+ SWIG_Python_SetConstant(d, "QUERY_DANGLE",SWIG_From_int(static_cast< int >(1)));
27649
+}
27650
+
27651
diff -urNad grass-6.4.0~rc5+39426~/gui/wxpython/vdigit/setup.py grass-6.4.0~rc5+39426/gui/wxpython/vdigit/setup.py
27652
--- grass-6.4.0~rc5+39426~/gui/wxpython/vdigit/setup.py 2009-10-07 10:48:15.000000000 +0200
27653
+++ grass-6.4.0~rc5+39426/gui/wxpython/vdigit/setup.py 2009-10-08 00:04:50.000000000 +0200
27654
@@ -46,7 +46,7 @@
27655
"vertex.cpp",
27656
"pseudodc.cpp",
27657
"digit.cpp",
27658
- "grass6_wxvdigit.i"],
27659
+ "grass6_wxvdigit_wrap.cpp"],
27660
swig_opts = ['-c++',
27661
'-shadow'],
27662
define_macros = macros,
Loggerhead is a web-based interface for Breezy
Version: 2.0.1