Line data Source code
1 : /* ----------------------------------------------------------------------------
2 : * This file was automatically generated by SWIG (http://www.swig.org).
3 : * Version 4.0.1
4 : *
5 : * This file is not intended to be easily readable and contains a number of
6 : * coding conventions designed to improve portability and efficiency. Do not make
7 : * changes to this file unless you know what you are doing--modify the SWIG
8 : * interface file instead.
9 : * ----------------------------------------------------------------------------- */
10 :
11 :
12 : #ifndef SWIGPYTHON
13 : #define SWIGPYTHON
14 : #define SED_HACKS
15 : #endif
16 :
17 : #define SWIG_PYTHON_THREADS
18 : #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
19 :
20 :
21 : #ifdef __cplusplus
22 : /* SwigValueWrapper is described in swig.swg */
23 : template<typename T> class SwigValueWrapper {
24 : struct SwigMovePointer {
25 : T *ptr;
26 : SwigMovePointer(T *p) : ptr(p) { }
27 : ~SwigMovePointer() { delete ptr; }
28 : SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
29 : } pointer;
30 : SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
31 : SwigValueWrapper(const SwigValueWrapper<T>& rhs);
32 : public:
33 : SwigValueWrapper() : pointer(0) { }
34 : SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
35 : operator T&() const { return *pointer.ptr; }
36 : T *operator&() { return pointer.ptr; }
37 : };
38 :
39 : template <typename T> T SwigValueInit() {
40 : return T();
41 : }
42 : #endif
43 :
44 : /* -----------------------------------------------------------------------------
45 : * This section contains generic SWIG labels for method/variable
46 : * declarations/attributes, and other compiler dependent labels.
47 : * ----------------------------------------------------------------------------- */
48 :
49 : /* template workaround for compilers that cannot correctly implement the C++ standard */
50 : #ifndef SWIGTEMPLATEDISAMBIGUATOR
51 : # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
52 : # define SWIGTEMPLATEDISAMBIGUATOR template
53 : # elif defined(__HP_aCC)
54 : /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
55 : /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
56 : # define SWIGTEMPLATEDISAMBIGUATOR template
57 : # else
58 : # define SWIGTEMPLATEDISAMBIGUATOR
59 : # endif
60 : #endif
61 :
62 : /* inline attribute */
63 : #ifndef SWIGINLINE
64 : # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
65 : # define SWIGINLINE inline
66 : # else
67 : # define SWIGINLINE
68 : # endif
69 : #endif
70 :
71 : /* attribute recognised by some compilers to avoid 'unused' warnings */
72 : #ifndef SWIGUNUSED
73 : # if defined(__GNUC__)
74 : # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
75 : # define SWIGUNUSED __attribute__ ((__unused__))
76 : # else
77 : # define SWIGUNUSED
78 : # endif
79 : # elif defined(__ICC)
80 : # define SWIGUNUSED __attribute__ ((__unused__))
81 : # else
82 : # define SWIGUNUSED
83 : # endif
84 : #endif
85 :
86 : #ifndef SWIG_MSC_UNSUPPRESS_4505
87 : # if defined(_MSC_VER)
88 : # pragma warning(disable : 4505) /* unreferenced local function has been removed */
89 : # endif
90 : #endif
91 :
92 : #ifndef SWIGUNUSEDPARM
93 : # ifdef __cplusplus
94 : # define SWIGUNUSEDPARM(p)
95 : # else
96 : # define SWIGUNUSEDPARM(p) p SWIGUNUSED
97 : # endif
98 : #endif
99 :
100 : /* internal SWIG method */
101 : #ifndef SWIGINTERN
102 : # define SWIGINTERN static SWIGUNUSED
103 : #endif
104 :
105 : /* internal inline SWIG method */
106 : #ifndef SWIGINTERNINLINE
107 : # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
108 : #endif
109 :
110 : /* exporting methods */
111 : #if defined(__GNUC__)
112 : # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
113 : # ifndef GCC_HASCLASSVISIBILITY
114 : # define GCC_HASCLASSVISIBILITY
115 : # endif
116 : # endif
117 : #endif
118 :
119 : #ifndef SWIGEXPORT
120 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
121 : # if defined(STATIC_LINKED)
122 : # define SWIGEXPORT
123 : # else
124 : # define SWIGEXPORT __declspec(dllexport)
125 : # endif
126 : # else
127 : # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
128 : # define SWIGEXPORT __attribute__ ((visibility("default")))
129 : # else
130 : # define SWIGEXPORT
131 : # endif
132 : # endif
133 : #endif
134 :
135 : /* calling conventions for Windows */
136 : #ifndef SWIGSTDCALL
137 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
138 : # define SWIGSTDCALL __stdcall
139 : # else
140 : # define SWIGSTDCALL
141 : # endif
142 : #endif
143 :
144 : /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
145 : #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
146 : # define _CRT_SECURE_NO_DEPRECATE
147 : #endif
148 :
149 : /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
150 : #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
151 : # define _SCL_SECURE_NO_DEPRECATE
152 : #endif
153 :
154 : /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
155 : #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
156 : # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
157 : #endif
158 :
159 : /* Intel's compiler complains if a variable which was never initialised is
160 : * cast to void, which is a common idiom which we use to indicate that we
161 : * are aware a variable isn't used. So we just silence that warning.
162 : * See: https://github.com/swig/swig/issues/192 for more discussion.
163 : */
164 : #ifdef __INTEL_COMPILER
165 : # pragma warning disable 592
166 : #endif
167 :
168 :
169 : #if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
170 : /* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
171 : # include <math.h>
172 : #endif
173 :
174 : #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
175 : /* Use debug wrappers with the Python release dll */
176 : # undef _DEBUG
177 : # include <Python.h>
178 : # define _DEBUG 1
179 : #else
180 : # include <Python.h>
181 : #endif
182 :
183 : /* -----------------------------------------------------------------------------
184 : * swigrun.swg
185 : *
186 : * This file contains generic C API SWIG runtime support for pointer
187 : * type checking.
188 : * ----------------------------------------------------------------------------- */
189 :
190 : /* This should only be incremented when either the layout of swig_type_info changes,
191 : or for whatever reason, the runtime changes incompatibly */
192 : #define SWIG_RUNTIME_VERSION "4"
193 :
194 : /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
195 : #ifdef SWIG_TYPE_TABLE
196 : # define SWIG_QUOTE_STRING(x) #x
197 : # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
198 : # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
199 : #else
200 : # define SWIG_TYPE_TABLE_NAME
201 : #endif
202 :
203 : /*
204 : You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
205 : creating a static or dynamic library from the SWIG runtime code.
206 : In 99.9% of the cases, SWIG just needs to declare them as 'static'.
207 :
208 : But only do this if strictly necessary, ie, if you have problems
209 : with your compiler or suchlike.
210 : */
211 :
212 : #ifndef SWIGRUNTIME
213 : # define SWIGRUNTIME SWIGINTERN
214 : #endif
215 :
216 : #ifndef SWIGRUNTIMEINLINE
217 : # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
218 : #endif
219 :
220 : /* Generic buffer size */
221 : #ifndef SWIG_BUFFER_SIZE
222 : # define SWIG_BUFFER_SIZE 1024
223 : #endif
224 :
225 : /* Flags for pointer conversions */
226 : #define SWIG_POINTER_DISOWN 0x1
227 : #define SWIG_CAST_NEW_MEMORY 0x2
228 : #define SWIG_POINTER_NO_NULL 0x4
229 :
230 : /* Flags for new pointer objects */
231 : #define SWIG_POINTER_OWN 0x1
232 :
233 :
234 : /*
235 : Flags/methods for returning states.
236 :
237 : The SWIG conversion methods, as ConvertPtr, return an integer
238 : that tells if the conversion was successful or not. And if not,
239 : an error code can be returned (see swigerrors.swg for the codes).
240 :
241 : Use the following macros/flags to set or process the returning
242 : states.
243 :
244 : In old versions of SWIG, code such as the following was usually written:
245 :
246 : if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
247 : // success code
248 : } else {
249 : //fail code
250 : }
251 :
252 : Now you can be more explicit:
253 :
254 : int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
255 : if (SWIG_IsOK(res)) {
256 : // success code
257 : } else {
258 : // fail code
259 : }
260 :
261 : which is the same really, but now you can also do
262 :
263 : Type *ptr;
264 : int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
265 : if (SWIG_IsOK(res)) {
266 : // success code
267 : if (SWIG_IsNewObj(res) {
268 : ...
269 : delete *ptr;
270 : } else {
271 : ...
272 : }
273 : } else {
274 : // fail code
275 : }
276 :
277 : I.e., now SWIG_ConvertPtr can return new objects and you can
278 : identify the case and take care of the deallocation. Of course that
279 : also requires SWIG_ConvertPtr to return new result values, such as
280 :
281 : int SWIG_ConvertPtr(obj, ptr,...) {
282 : if (<obj is ok>) {
283 : if (<need new object>) {
284 : *ptr = <ptr to new allocated object>;
285 : return SWIG_NEWOBJ;
286 : } else {
287 : *ptr = <ptr to old object>;
288 : return SWIG_OLDOBJ;
289 : }
290 : } else {
291 : return SWIG_BADOBJ;
292 : }
293 : }
294 :
295 : Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
296 : more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
297 : SWIG errors code.
298 :
299 : Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
300 : allows to return the 'cast rank', for example, if you have this
301 :
302 : int food(double)
303 : int fooi(int);
304 :
305 : and you call
306 :
307 : food(1) // cast rank '1' (1 -> 1.0)
308 : fooi(1) // cast rank '0'
309 :
310 : just use the SWIG_AddCast()/SWIG_CheckState()
311 : */
312 :
313 : #define SWIG_OK (0)
314 : #define SWIG_ERROR (-1)
315 : #define SWIG_IsOK(r) (r >= 0)
316 : #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
317 :
318 : /* The CastRankLimit says how many bits are used for the cast rank */
319 : #define SWIG_CASTRANKLIMIT (1 << 8)
320 : /* The NewMask denotes the object was created (using new/malloc) */
321 : #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
322 : /* The TmpMask is for in/out typemaps that use temporal objects */
323 : #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
324 : /* Simple returning values */
325 : #define SWIG_BADOBJ (SWIG_ERROR)
326 : #define SWIG_OLDOBJ (SWIG_OK)
327 : #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
328 : #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
329 : /* Check, add and del mask methods */
330 : #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
331 : #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
332 : #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
333 : #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
334 : #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
335 : #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
336 :
337 : /* Cast-Rank Mode */
338 : #if defined(SWIG_CASTRANK_MODE)
339 : # ifndef SWIG_TypeRank
340 : # define SWIG_TypeRank unsigned long
341 : # endif
342 : # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
343 : # define SWIG_MAXCASTRANK (2)
344 : # endif
345 : # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
346 : # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
347 : SWIGINTERNINLINE int SWIG_AddCast(int r) {
348 : return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
349 : }
350 : SWIGINTERNINLINE int SWIG_CheckState(int r) {
351 : return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
352 : }
353 : #else /* no cast-rank mode */
354 : # define SWIG_AddCast(r) (r)
355 : # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
356 : #endif
357 :
358 :
359 : #include <string.h>
360 :
361 : #ifdef __cplusplus
362 : extern "C" {
363 : #endif
364 :
365 : typedef void *(*swig_converter_func)(void *, int *);
366 : typedef struct swig_type_info *(*swig_dycast_func)(void **);
367 :
368 : /* Structure to store information on one type */
369 : typedef struct swig_type_info {
370 : const char *name; /* mangled name of this type */
371 : const char *str; /* human readable name of this type */
372 : swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
373 : struct swig_cast_info *cast; /* linked list of types that can cast into this type */
374 : void *clientdata; /* language specific type data */
375 : int owndata; /* flag if the structure owns the clientdata */
376 : } swig_type_info;
377 :
378 : /* Structure to store a type and conversion function used for casting */
379 : typedef struct swig_cast_info {
380 : swig_type_info *type; /* pointer to type that is equivalent to this type */
381 : swig_converter_func converter; /* function to cast the void pointers */
382 : struct swig_cast_info *next; /* pointer to next cast in linked list */
383 : struct swig_cast_info *prev; /* pointer to the previous cast */
384 : } swig_cast_info;
385 :
386 : /* Structure used to store module information
387 : * Each module generates one structure like this, and the runtime collects
388 : * all of these structures and stores them in a circularly linked list.*/
389 : typedef struct swig_module_info {
390 : swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
391 : size_t size; /* Number of types in this module */
392 : struct swig_module_info *next; /* Pointer to next element in circularly linked list */
393 : swig_type_info **type_initial; /* Array of initially generated type structures */
394 : swig_cast_info **cast_initial; /* Array of initially generated casting structures */
395 : void *clientdata; /* Language specific module data */
396 : } swig_module_info;
397 :
398 : /*
399 : Compare two type names skipping the space characters, therefore
400 : "char*" == "char *" and "Class<int>" == "Class<int >", etc.
401 :
402 : Return 0 when the two name types are equivalent, as in
403 : strncmp, but skipping ' '.
404 : */
405 : SWIGRUNTIME int
406 0 : SWIG_TypeNameComp(const char *f1, const char *l1,
407 : const char *f2, const char *l2) {
408 0 : for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
409 0 : while ((*f1 == ' ') && (f1 != l1)) ++f1;
410 0 : while ((*f2 == ' ') && (f2 != l2)) ++f2;
411 0 : if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
412 : }
413 0 : return (int)((l1 - f1) - (l2 - f2));
414 : }
415 :
416 : /*
417 : Check type equivalence in a name list like <name1>|<name2>|...
418 : Return 0 if equal, -1 if nb < tb, 1 if nb > tb
419 : */
420 : SWIGRUNTIME int
421 0 : SWIG_TypeCmp(const char *nb, const char *tb) {
422 0 : int equiv = 1;
423 0 : const char* te = tb + strlen(tb);
424 0 : const char* ne = nb;
425 0 : while (equiv != 0 && *ne) {
426 0 : for (nb = ne; *ne; ++ne) {
427 0 : if (*ne == '|') break;
428 : }
429 0 : equiv = SWIG_TypeNameComp(nb, ne, tb, te);
430 0 : if (*ne) ++ne;
431 : }
432 0 : return equiv;
433 : }
434 :
435 : /*
436 : Check type equivalence in a name list like <name1>|<name2>|...
437 : Return 0 if not equal, 1 if equal
438 : */
439 : SWIGRUNTIME int
440 0 : SWIG_TypeEquiv(const char *nb, const char *tb) {
441 0 : return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
442 : }
443 :
444 : /*
445 : Check the typename
446 : */
447 : SWIGRUNTIME swig_cast_info *
448 6970 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
449 6970 : if (ty) {
450 6970 : swig_cast_info *iter = ty->cast;
451 9126 : while (iter) {
452 9122 : if (strcmp(iter->type->name, c) == 0) {
453 6966 : if (iter == ty->cast)
454 : return iter;
455 : /* Move iter to the top of the linked list */
456 738 : iter->prev->next = iter->next;
457 738 : if (iter->next)
458 465 : iter->next->prev = iter->prev;
459 738 : iter->next = ty->cast;
460 738 : iter->prev = 0;
461 738 : if (ty->cast) ty->cast->prev = iter;
462 738 : ty->cast = iter;
463 738 : return iter;
464 : }
465 2156 : iter = iter->next;
466 : }
467 : }
468 : return 0;
469 : }
470 :
471 : /*
472 : Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
473 : */
474 : SWIGRUNTIME swig_cast_info *
475 : SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
476 : if (ty) {
477 : swig_cast_info *iter = ty->cast;
478 : while (iter) {
479 : if (iter->type == from) {
480 : if (iter == ty->cast)
481 : return iter;
482 : /* Move iter to the top of the linked list */
483 : iter->prev->next = iter->next;
484 : if (iter->next)
485 : iter->next->prev = iter->prev;
486 : iter->next = ty->cast;
487 : iter->prev = 0;
488 : if (ty->cast) ty->cast->prev = iter;
489 : ty->cast = iter;
490 : return iter;
491 : }
492 : iter = iter->next;
493 : }
494 : }
495 : return 0;
496 : }
497 :
498 : /*
499 : Cast a pointer up an inheritance hierarchy
500 : */
501 : SWIGRUNTIMEINLINE void *
502 959 : SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
503 959 : return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
504 : }
505 :
506 : /*
507 : Dynamic pointer casting. Down an inheritance hierarchy
508 : */
509 : SWIGRUNTIME swig_type_info *
510 : SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
511 : swig_type_info *lastty = ty;
512 : if (!ty || !ty->dcast) return ty;
513 : while (ty && (ty->dcast)) {
514 : ty = (*ty->dcast)(ptr);
515 : if (ty) lastty = ty;
516 : }
517 : return lastty;
518 : }
519 :
520 : /*
521 : Return the name associated with this type
522 : */
523 : SWIGRUNTIMEINLINE const char *
524 : SWIG_TypeName(const swig_type_info *ty) {
525 : return ty->name;
526 : }
527 :
528 : /*
529 : Return the pretty name associated with this type,
530 : that is an unmangled type name in a form presentable to the user.
531 : */
532 : SWIGRUNTIME const char *
533 29 : SWIG_TypePrettyName(const swig_type_info *type) {
534 : /* The "str" field contains the equivalent pretty names of the
535 : type, separated by vertical-bar characters. We choose
536 : to print the last name, as it is often (?) the most
537 : specific. */
538 29 : if (!type) return NULL;
539 29 : if (type->str != NULL) {
540 : const char *last_name = type->str;
541 : const char *s;
542 580 : for (s = type->str; *s; s++)
543 551 : if (*s == '|') last_name = s+1;
544 : return last_name;
545 : }
546 : else
547 0 : return type->name;
548 : }
549 :
550 : /*
551 : Set the clientdata field for a type
552 : */
553 : SWIGRUNTIME void
554 : SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
555 : swig_cast_info *cast = ti->cast;
556 : /* if (ti->clientdata == clientdata) return; */
557 : ti->clientdata = clientdata;
558 :
559 : while (cast) {
560 : if (!cast->converter) {
561 : swig_type_info *tc = cast->type;
562 : if (!tc->clientdata) {
563 : SWIG_TypeClientData(tc, clientdata);
564 : }
565 : }
566 : cast = cast->next;
567 : }
568 : }
569 : SWIGRUNTIME void
570 4095 : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
571 4095 : SWIG_TypeClientData(ti, clientdata);
572 4095 : ti->owndata = 1;
573 : }
574 :
575 : /*
576 : Search for a swig_type_info structure only by mangled name
577 : Search is a O(log #types)
578 :
579 : We start searching at module start, and finish searching when start == end.
580 : Note: if start == end at the beginning of the function, we go all the way around
581 : the circular list.
582 : */
583 : SWIGRUNTIME swig_type_info *
584 19406 : SWIG_MangledTypeQueryModule(swig_module_info *start,
585 : swig_module_info *end,
586 : const char *name) {
587 19406 : swig_module_info *iter = start;
588 38229 : do {
589 38229 : if (iter->size) {
590 38229 : size_t l = 0;
591 38229 : size_t r = iter->size - 1;
592 133229 : do {
593 : /* since l+r >= 0, we can (>> 1) instead (/ 2) */
594 133229 : size_t i = (l + r) >> 1;
595 133229 : const char *iname = iter->types[i]->name;
596 133229 : if (iname) {
597 133229 : int compare = strcmp(name, iname);
598 133229 : if (compare == 0) {
599 11764 : return iter->types[i];
600 121465 : } else if (compare < 0) {
601 59393 : if (i) {
602 44953 : r = i - 1;
603 : } else {
604 : break;
605 : }
606 62072 : } else if (compare > 0) {
607 62072 : l = i + 1;
608 : }
609 : } else {
610 : break; /* should never happen */
611 : }
612 107025 : } while (l <= r);
613 : }
614 26465 : iter = iter->next;
615 26465 : } while (iter != end);
616 : return 0;
617 : }
618 :
619 : /*
620 : Search for a swig_type_info structure for either a mangled name or a human readable name.
621 : It first searches the mangled names of the types, which is a O(log #types)
622 : If a type is not found it then searches the human readable names, which is O(#types).
623 :
624 : We start searching at module start, and finish searching when start == end.
625 : Note: if start == end at the beginning of the function, we go all the way around
626 : the circular list.
627 : */
628 : SWIGRUNTIME swig_type_info *
629 23 : SWIG_TypeQueryModule(swig_module_info *start,
630 : swig_module_info *end,
631 : const char *name) {
632 : /* STEP 1: Search the name field using binary search */
633 23 : swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
634 23 : if (ret) {
635 : return ret;
636 : } else {
637 : /* STEP 2: If the type hasn't been found, do a complete search
638 : of the str field (the human readable name) */
639 : swig_module_info *iter = start;
640 0 : do {
641 0 : size_t i = 0;
642 0 : for (; i < iter->size; ++i) {
643 0 : if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
644 0 : return iter->types[i];
645 : }
646 0 : iter = iter->next;
647 0 : } while (iter != end);
648 : }
649 :
650 : /* neither found a match */
651 : return 0;
652 : }
653 :
654 : /*
655 : Pack binary data into a string
656 : */
657 : SWIGRUNTIME char *
658 0 : SWIG_PackData(char *c, void *ptr, size_t sz) {
659 0 : static const char hex[17] = "0123456789abcdef";
660 0 : const unsigned char *u = (unsigned char *) ptr;
661 0 : const unsigned char *eu = u + sz;
662 0 : for (; u != eu; ++u) {
663 0 : unsigned char uu = *u;
664 0 : *(c++) = hex[(uu & 0xf0) >> 4];
665 0 : *(c++) = hex[uu & 0xf];
666 : }
667 0 : return c;
668 : }
669 :
670 : /*
671 : Unpack binary data from a string
672 : */
673 : SWIGRUNTIME const char *
674 : SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
675 : unsigned char *u = (unsigned char *) ptr;
676 : const unsigned char *eu = u + sz;
677 : for (; u != eu; ++u) {
678 : char d = *(c++);
679 : unsigned char uu;
680 : if ((d >= '0') && (d <= '9'))
681 : uu = (unsigned char)((d - '0') << 4);
682 : else if ((d >= 'a') && (d <= 'f'))
683 : uu = (unsigned char)((d - ('a'-10)) << 4);
684 : else
685 : return (char *) 0;
686 : d = *(c++);
687 : if ((d >= '0') && (d <= '9'))
688 : uu |= (unsigned char)(d - '0');
689 : else if ((d >= 'a') && (d <= 'f'))
690 : uu |= (unsigned char)(d - ('a'-10));
691 : else
692 : return (char *) 0;
693 : *u = uu;
694 : }
695 : return c;
696 : }
697 :
698 : /*
699 : Pack 'void *' into a string buffer.
700 : */
701 : SWIGRUNTIME char *
702 0 : SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
703 0 : char *r = buff;
704 0 : if ((2*sizeof(void *) + 2) > bsz) return 0;
705 0 : *(r++) = '_';
706 0 : r = SWIG_PackData(r,&ptr,sizeof(void *));
707 0 : if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
708 0 : strcpy(r,name);
709 0 : return buff;
710 : }
711 :
712 : SWIGRUNTIME const char *
713 : SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
714 : if (*c != '_') {
715 : if (strcmp(c,"NULL") == 0) {
716 : *ptr = (void *) 0;
717 : return name;
718 : } else {
719 : return 0;
720 : }
721 : }
722 : return SWIG_UnpackData(++c,ptr,sizeof(void *));
723 : }
724 :
725 : SWIGRUNTIME char *
726 0 : SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
727 0 : char *r = buff;
728 0 : size_t lname = (name ? strlen(name) : 0);
729 0 : if ((2*sz + 2 + lname) > bsz) return 0;
730 0 : *(r++) = '_';
731 0 : r = SWIG_PackData(r,ptr,sz);
732 0 : if (lname) {
733 0 : strncpy(r,name,lname+1);
734 : } else {
735 0 : *r = 0;
736 : }
737 : return buff;
738 : }
739 :
740 : SWIGRUNTIME const char *
741 : SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
742 : if (*c != '_') {
743 : if (strcmp(c,"NULL") == 0) {
744 : memset(ptr,0,sz);
745 : return name;
746 : } else {
747 : return 0;
748 : }
749 : }
750 : return SWIG_UnpackData(++c,ptr,sz);
751 : }
752 :
753 : #ifdef __cplusplus
754 : }
755 : #endif
756 :
757 : /* Errors in SWIG */
758 : #define SWIG_UnknownError -1
759 : #define SWIG_IOError -2
760 : #define SWIG_RuntimeError -3
761 : #define SWIG_IndexError -4
762 : #define SWIG_TypeError -5
763 : #define SWIG_DivisionByZero -6
764 : #define SWIG_OverflowError -7
765 : #define SWIG_SyntaxError -8
766 : #define SWIG_ValueError -9
767 : #define SWIG_SystemError -10
768 : #define SWIG_AttributeError -11
769 : #define SWIG_MemoryError -12
770 : #define SWIG_NullReferenceError -13
771 :
772 :
773 :
774 : /* Compatibility macros for Python 3 */
775 : #if PY_VERSION_HEX >= 0x03000000
776 :
777 : #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
778 : #define PyInt_Check(x) PyLong_Check(x)
779 : #define PyInt_AsLong(x) PyLong_AsLong(x)
780 : #define PyInt_FromLong(x) PyLong_FromLong(x)
781 : #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
782 : #define PyString_Check(name) PyBytes_Check(name)
783 : #define PyString_FromString(x) PyUnicode_FromString(x)
784 : #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
785 : #define PyString_AsString(str) PyBytes_AsString(str)
786 : #define PyString_Size(str) PyBytes_Size(str)
787 : #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
788 : #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
789 : #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
790 : #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
791 :
792 : #endif
793 :
794 : #ifndef Py_TYPE
795 : # define Py_TYPE(op) ((op)->ob_type)
796 : #endif
797 :
798 : /* SWIG APIs for compatibility of both Python 2 & 3 */
799 :
800 : #if PY_VERSION_HEX >= 0x03000000
801 : # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
802 : #else
803 : # define SWIG_Python_str_FromFormat PyString_FromFormat
804 : #endif
805 :
806 :
807 : /* Warning: This function will allocate a new string in Python 3,
808 : * so please call SWIG_Python_str_DelForPy3(x) to free the space.
809 : */
810 : SWIGINTERN char*
811 : SWIG_Python_str_AsChar(PyObject *str)
812 : {
813 : #if PY_VERSION_HEX >= 0x03000000
814 : char *newstr = 0;
815 : str = PyUnicode_AsUTF8String(str);
816 : if (str) {
817 : char *cstr;
818 : Py_ssize_t len;
819 : PyBytes_AsStringAndSize(str, &cstr, &len);
820 : newstr = (char *) malloc(len+1);
821 : memcpy(newstr, cstr, len+1);
822 : Py_XDECREF(str);
823 : }
824 : return newstr;
825 : #else
826 : return PyString_AsString(str);
827 : #endif
828 : }
829 :
830 : #if PY_VERSION_HEX >= 0x03000000
831 : # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
832 : #else
833 : # define SWIG_Python_str_DelForPy3(x)
834 : #endif
835 :
836 :
837 : SWIGINTERN PyObject*
838 296 : SWIG_Python_str_FromChar(const char *c)
839 : {
840 : #if PY_VERSION_HEX >= 0x03000000
841 296 : return PyUnicode_FromString(c);
842 : #else
843 : return PyString_FromString(c);
844 : #endif
845 : }
846 :
847 : #ifndef PyObject_DEL
848 : # define PyObject_DEL PyObject_Del
849 : #endif
850 :
851 : // SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user
852 : // interface files check for it.
853 : # define SWIGPY_USE_CAPSULE
854 : # define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
855 :
856 : #if PY_VERSION_HEX < 0x03020000
857 : #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
858 : #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
859 : #define Py_hash_t long
860 : #endif
861 :
862 : /* -----------------------------------------------------------------------------
863 : * error manipulation
864 : * ----------------------------------------------------------------------------- */
865 :
866 : SWIGRUNTIME PyObject*
867 238 : SWIG_Python_ErrorType(int code) {
868 238 : PyObject* type = 0;
869 22 : switch(code) {
870 0 : case SWIG_MemoryError:
871 0 : type = PyExc_MemoryError;
872 0 : break;
873 0 : case SWIG_IOError:
874 0 : type = PyExc_IOError;
875 0 : break;
876 210 : case SWIG_RuntimeError:
877 210 : type = PyExc_RuntimeError;
878 0 : break;
879 0 : case SWIG_IndexError:
880 0 : type = PyExc_IndexError;
881 0 : break;
882 22 : case SWIG_TypeError:
883 22 : type = PyExc_TypeError;
884 22 : break;
885 0 : case SWIG_DivisionByZero:
886 0 : type = PyExc_ZeroDivisionError;
887 0 : break;
888 0 : case SWIG_OverflowError:
889 0 : type = PyExc_OverflowError;
890 0 : break;
891 0 : case SWIG_SyntaxError:
892 0 : type = PyExc_SyntaxError;
893 0 : break;
894 6 : case SWIG_ValueError:
895 6 : type = PyExc_ValueError;
896 0 : break;
897 0 : case SWIG_SystemError:
898 0 : type = PyExc_SystemError;
899 0 : break;
900 0 : case SWIG_AttributeError:
901 0 : type = PyExc_AttributeError;
902 0 : break;
903 0 : default:
904 0 : type = PyExc_RuntimeError;
905 : }
906 210 : return type;
907 : }
908 :
909 :
910 : SWIGRUNTIME void
911 : SWIG_Python_AddErrorMsg(const char* mesg)
912 : {
913 : PyObject *type = 0;
914 : PyObject *value = 0;
915 : PyObject *traceback = 0;
916 :
917 : if (PyErr_Occurred())
918 : PyErr_Fetch(&type, &value, &traceback);
919 : if (value) {
920 : PyObject *old_str = PyObject_Str(value);
921 : const char *tmp = SWIG_Python_str_AsChar(old_str);
922 : PyErr_Clear();
923 : Py_XINCREF(type);
924 : if (tmp)
925 : PyErr_Format(type, "%s %s", tmp, mesg);
926 : else
927 : PyErr_Format(type, "%s", mesg);
928 : SWIG_Python_str_DelForPy3(tmp);
929 : Py_DECREF(old_str);
930 : Py_DECREF(value);
931 : } else {
932 : PyErr_SetString(PyExc_RuntimeError, mesg);
933 : }
934 : }
935 :
936 : SWIGRUNTIME int
937 0 : SWIG_Python_TypeErrorOccurred(PyObject *obj)
938 : {
939 0 : PyObject *error;
940 0 : if (obj)
941 : return 0;
942 0 : error = PyErr_Occurred();
943 0 : return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
944 : }
945 :
946 : SWIGRUNTIME void
947 0 : SWIG_Python_RaiseOrModifyTypeError(const char *message)
948 : {
949 0 : if (SWIG_Python_TypeErrorOccurred(NULL)) {
950 : /* Use existing TypeError to preserve stacktrace and enhance with given message */
951 0 : PyObject *newvalue;
952 0 : PyObject *type = NULL, *value = NULL, *traceback = NULL;
953 0 : PyErr_Fetch(&type, &value, &traceback);
954 : #if PY_VERSION_HEX >= 0x03000000
955 0 : newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
956 : #else
957 : newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
958 : #endif
959 0 : Py_XDECREF(value);
960 0 : PyErr_Restore(type, newvalue, traceback);
961 : } else {
962 : /* Raise TypeError using given message */
963 0 : PyErr_SetString(PyExc_TypeError, message);
964 : }
965 0 : }
966 :
967 : #if defined(SWIG_PYTHON_NO_THREADS)
968 : # if defined(SWIG_PYTHON_THREADS)
969 : # undef SWIG_PYTHON_THREADS
970 : # endif
971 : #endif
972 : #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
973 : # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
974 : # define SWIG_PYTHON_USE_GIL
975 : # endif
976 : # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
977 : # ifndef SWIG_PYTHON_INITIALIZE_THREADS
978 : # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
979 : # endif
980 : # ifdef __cplusplus /* C++ code */
981 : class SWIG_Python_Thread_Block {
982 : bool status;
983 : PyGILState_STATE state;
984 : public:
985 600 : void end() { if (status) { PyGILState_Release(state); status = false;} }
986 576 : SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
987 24 : ~SWIG_Python_Thread_Block() { end(); }
988 : };
989 : class SWIG_Python_Thread_Allow {
990 : bool status;
991 : PyThreadState *save;
992 : public:
993 7153610 : void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
994 7153610 : SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
995 0 : ~SWIG_Python_Thread_Allow() { end(); }
996 : };
997 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
998 : # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
999 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1000 : # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1001 : # else /* C code */
1002 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1003 : # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1004 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1005 : # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1006 : # endif
1007 : # else /* Old thread way, not implemented, user must provide it */
1008 : # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1009 : # define SWIG_PYTHON_INITIALIZE_THREADS
1010 : # endif
1011 : # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1012 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1013 : # endif
1014 : # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1015 : # define SWIG_PYTHON_THREAD_END_BLOCK
1016 : # endif
1017 : # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1018 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1019 : # endif
1020 : # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1021 : # define SWIG_PYTHON_THREAD_END_ALLOW
1022 : # endif
1023 : # endif
1024 : #else /* No thread support */
1025 : # define SWIG_PYTHON_INITIALIZE_THREADS
1026 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1027 : # define SWIG_PYTHON_THREAD_END_BLOCK
1028 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1029 : # define SWIG_PYTHON_THREAD_END_ALLOW
1030 : #endif
1031 :
1032 : /* -----------------------------------------------------------------------------
1033 : * Python API portion that goes into the runtime
1034 : * ----------------------------------------------------------------------------- */
1035 :
1036 : #ifdef __cplusplus
1037 : extern "C" {
1038 : #endif
1039 :
1040 : /* -----------------------------------------------------------------------------
1041 : * Constant declarations
1042 : * ----------------------------------------------------------------------------- */
1043 :
1044 : /* Constant Types */
1045 : #define SWIG_PY_POINTER 4
1046 : #define SWIG_PY_BINARY 5
1047 :
1048 : /* Constant information structure */
1049 : typedef struct swig_const_info {
1050 : int type;
1051 : const char *name;
1052 : long lvalue;
1053 : double dvalue;
1054 : void *pvalue;
1055 : swig_type_info **ptype;
1056 : } swig_const_info;
1057 :
1058 : #ifdef __cplusplus
1059 : }
1060 : #endif
1061 :
1062 :
1063 : /* -----------------------------------------------------------------------------
1064 : * pyrun.swg
1065 : *
1066 : * This file contains the runtime support for Python modules
1067 : * and includes code for managing global variables and pointer
1068 : * type checking.
1069 : *
1070 : * ----------------------------------------------------------------------------- */
1071 :
1072 : #if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
1073 : # error "This version of SWIG only supports Python >= 2.7"
1074 : #endif
1075 :
1076 : #if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000
1077 : # error "This version of SWIG only supports Python 3 >= 3.2"
1078 : #endif
1079 :
1080 : /* Common SWIG API */
1081 :
1082 : /* for raw pointers */
1083 : #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1084 : #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1085 : #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1086 :
1087 : #ifdef SWIGPYTHON_BUILTIN
1088 : #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1089 : #else
1090 : #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1091 : #endif
1092 :
1093 : #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1094 :
1095 : #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1096 : #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1097 : #define swig_owntype int
1098 :
1099 : /* for raw packed data */
1100 : #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1101 : #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1102 :
1103 : /* for class or struct pointers */
1104 : #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1105 : #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1106 :
1107 : /* for C or C++ function pointers */
1108 : #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1109 : #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1110 :
1111 : /* for C++ member pointers, ie, member methods */
1112 : #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1113 : #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1114 :
1115 :
1116 : /* Runtime API */
1117 :
1118 : #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1119 : #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1120 : #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1121 :
1122 : #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1123 : #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1124 : #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1125 : #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1126 : #define SWIG_fail goto fail
1127 :
1128 :
1129 : /* Runtime API implementation */
1130 :
1131 : /* Error manipulation */
1132 :
1133 : SWIGINTERN void
1134 : SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1135 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1136 : PyErr_SetObject(errtype, obj);
1137 : Py_DECREF(obj);
1138 : SWIG_PYTHON_THREAD_END_BLOCK;
1139 : }
1140 :
1141 : SWIGINTERN void
1142 248 : SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1143 248 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1144 248 : PyErr_SetString(errtype, msg);
1145 248 : SWIG_PYTHON_THREAD_END_BLOCK;
1146 248 : }
1147 :
1148 : #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1149 :
1150 : /* Set a constant value */
1151 :
1152 : #if defined(SWIGPYTHON_BUILTIN)
1153 :
1154 : SWIGINTERN void
1155 : SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1156 : PyObject *s = PyString_InternFromString(key);
1157 : PyList_Append(seq, s);
1158 : Py_DECREF(s);
1159 : }
1160 :
1161 : SWIGINTERN void
1162 : SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1163 : PyDict_SetItemString(d, name, obj);
1164 : Py_DECREF(obj);
1165 : if (public_interface)
1166 : SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1167 : }
1168 :
1169 : #else
1170 :
1171 : SWIGINTERN void
1172 52143 : SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1173 52143 : PyDict_SetItemString(d, name, obj);
1174 52143 : Py_DECREF(obj);
1175 52143 : }
1176 :
1177 : #endif
1178 :
1179 : /* Append a value to the result obj */
1180 :
1181 : SWIGINTERN PyObject*
1182 22222 : SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1183 22222 : if (!result) {
1184 : result = obj;
1185 14412 : } else if (result == Py_None) {
1186 13890 : Py_DECREF(result);
1187 : result = obj;
1188 : } else {
1189 522 : if (!PyList_Check(result)) {
1190 87 : PyObject *o2 = result;
1191 87 : result = PyList_New(1);
1192 87 : PyList_SetItem(result, 0, o2);
1193 : }
1194 522 : PyList_Append(result,obj);
1195 522 : Py_DECREF(obj);
1196 : }
1197 22222 : return result;
1198 : }
1199 :
1200 : /* Unpack the argument tuple */
1201 :
1202 : SWIGINTERN Py_ssize_t
1203 2015120 : SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1204 : {
1205 2015120 : if (!args) {
1206 33268 : if (!min && !max) {
1207 : return 1;
1208 : } else {
1209 0 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1210 : name, (min == max ? "" : "at least "), (int)min);
1211 0 : return 0;
1212 : }
1213 : }
1214 1981850 : if (!PyTuple_Check(args)) {
1215 4095 : if (min <= 1 && max >= 1) {
1216 4095 : Py_ssize_t i;
1217 4095 : objs[0] = args;
1218 4095 : for (i = 1; i < max; ++i) {
1219 0 : objs[i] = 0;
1220 : }
1221 : return 2;
1222 : }
1223 0 : PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1224 0 : return 0;
1225 : } else {
1226 1977760 : Py_ssize_t l = PyTuple_GET_SIZE(args);
1227 1977760 : if (l < min) {
1228 1 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1229 : name, (min == max ? "" : "at least "), (int)min, (int)l);
1230 1 : return 0;
1231 1977760 : } else if (l > max) {
1232 0 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1233 : name, (min == max ? "" : "at most "), (int)max, (int)l);
1234 0 : return 0;
1235 : } else {
1236 : Py_ssize_t i;
1237 6177570 : for (i = 0; i < l; ++i) {
1238 4199810 : objs[i] = PyTuple_GET_ITEM(args, i);
1239 : }
1240 2038230 : for (; l < max; ++l) {
1241 60477 : objs[l] = 0;
1242 : }
1243 1977760 : return i + 1;
1244 : }
1245 : }
1246 : }
1247 :
1248 : /* A functor is a function object with one single object argument */
1249 : #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1250 :
1251 : /*
1252 : Helper for static pointer initialization for both C and C++ code, for example
1253 : static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1254 : */
1255 : #ifdef __cplusplus
1256 : #define SWIG_STATIC_POINTER(var) var
1257 : #else
1258 : #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1259 : #endif
1260 :
1261 : /* -----------------------------------------------------------------------------
1262 : * Pointer declarations
1263 : * ----------------------------------------------------------------------------- */
1264 :
1265 : /* Flags for new pointer objects */
1266 : #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1267 : #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1268 :
1269 : #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1270 :
1271 : #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1272 : #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1273 :
1274 : #ifdef __cplusplus
1275 : extern "C" {
1276 : #endif
1277 :
1278 : /* The python void return value */
1279 :
1280 : SWIGRUNTIMEINLINE PyObject *
1281 1381830 : SWIG_Py_Void(void)
1282 : {
1283 1381830 : PyObject *none = Py_None;
1284 0 : Py_INCREF(none);
1285 375478 : return none;
1286 : }
1287 :
1288 : /* SwigPyClientData */
1289 :
1290 : typedef struct {
1291 : PyObject *klass;
1292 : PyObject *newraw;
1293 : PyObject *newargs;
1294 : PyObject *destroy;
1295 : int delargs;
1296 : int implicitconv;
1297 : PyTypeObject *pytype;
1298 : } SwigPyClientData;
1299 :
1300 : SWIGRUNTIMEINLINE int
1301 : SWIG_Python_CheckImplicit(swig_type_info *ty)
1302 : {
1303 : SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1304 : int fail = data ? data->implicitconv : 0;
1305 : if (fail)
1306 : PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
1307 : return fail;
1308 : }
1309 :
1310 : SWIGRUNTIMEINLINE PyObject *
1311 : SWIG_Python_ExceptionType(swig_type_info *desc) {
1312 : SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1313 : PyObject *klass = data ? data->klass : 0;
1314 : return (klass ? klass : PyExc_RuntimeError);
1315 : }
1316 :
1317 :
1318 : SWIGRUNTIME SwigPyClientData *
1319 4095 : SwigPyClientData_New(PyObject* obj)
1320 : {
1321 4095 : if (!obj) {
1322 : return 0;
1323 : } else {
1324 4095 : SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1325 : /* the klass element */
1326 4095 : data->klass = obj;
1327 4095 : Py_INCREF(data->klass);
1328 : /* the newraw method and newargs arguments used to create a new raw instance */
1329 4095 : if (PyClass_Check(obj)) {
1330 4095 : data->newraw = 0;
1331 4095 : data->newargs = obj;
1332 4095 : Py_INCREF(obj);
1333 : } else {
1334 0 : data->newraw = PyObject_GetAttrString(data->klass, "__new__");
1335 0 : if (data->newraw) {
1336 0 : Py_INCREF(data->newraw);
1337 0 : data->newargs = PyTuple_New(1);
1338 0 : PyTuple_SetItem(data->newargs, 0, obj);
1339 : } else {
1340 0 : data->newargs = obj;
1341 : }
1342 0 : Py_INCREF(data->newargs);
1343 : }
1344 : /* the destroy method, aka as the C++ delete method */
1345 4095 : data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
1346 4095 : if (PyErr_Occurred()) {
1347 546 : PyErr_Clear();
1348 546 : data->destroy = 0;
1349 : }
1350 4095 : if (data->destroy) {
1351 3549 : int flags;
1352 3549 : Py_INCREF(data->destroy);
1353 3549 : flags = PyCFunction_GET_FLAGS(data->destroy);
1354 3549 : data->delargs = !(flags & (METH_O));
1355 : } else {
1356 546 : data->delargs = 0;
1357 : }
1358 4095 : data->implicitconv = 0;
1359 4095 : data->pytype = 0;
1360 4095 : return data;
1361 : }
1362 : }
1363 :
1364 : SWIGRUNTIME void
1365 0 : SwigPyClientData_Del(SwigPyClientData *data) {
1366 0 : Py_XDECREF(data->newraw);
1367 0 : Py_XDECREF(data->newargs);
1368 0 : Py_XDECREF(data->destroy);
1369 0 : }
1370 :
1371 : /* =============== SwigPyObject =====================*/
1372 :
1373 : typedef struct {
1374 : PyObject_HEAD
1375 : void *ptr;
1376 : swig_type_info *ty;
1377 : int own;
1378 : PyObject *next;
1379 : #ifdef SWIGPYTHON_BUILTIN
1380 : PyObject *dict;
1381 : #endif
1382 : } SwigPyObject;
1383 :
1384 :
1385 : #ifdef SWIGPYTHON_BUILTIN
1386 :
1387 : SWIGRUNTIME PyObject *
1388 : SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1389 : {
1390 : SwigPyObject *sobj = (SwigPyObject *)v;
1391 :
1392 : if (!sobj->dict)
1393 : sobj->dict = PyDict_New();
1394 :
1395 : Py_INCREF(sobj->dict);
1396 : return sobj->dict;
1397 : }
1398 :
1399 : #endif
1400 :
1401 : SWIGRUNTIME PyObject *
1402 0 : SwigPyObject_long(SwigPyObject *v)
1403 : {
1404 0 : return PyLong_FromVoidPtr(v->ptr);
1405 : }
1406 :
1407 : SWIGRUNTIME PyObject *
1408 : SwigPyObject_format(const char* fmt, SwigPyObject *v)
1409 : {
1410 : PyObject *res = NULL;
1411 : PyObject *args = PyTuple_New(1);
1412 : if (args) {
1413 : if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1414 : PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1415 : if (ofmt) {
1416 : #if PY_VERSION_HEX >= 0x03000000
1417 : res = PyUnicode_Format(ofmt,args);
1418 : #else
1419 : res = PyString_Format(ofmt,args);
1420 : #endif
1421 : Py_DECREF(ofmt);
1422 : }
1423 : Py_DECREF(args);
1424 : }
1425 : }
1426 : return res;
1427 : }
1428 :
1429 : SWIGRUNTIME PyObject *
1430 : SwigPyObject_oct(SwigPyObject *v)
1431 : {
1432 : return SwigPyObject_format("%o",v);
1433 : }
1434 :
1435 : SWIGRUNTIME PyObject *
1436 : SwigPyObject_hex(SwigPyObject *v)
1437 : {
1438 : return SwigPyObject_format("%x",v);
1439 : }
1440 :
1441 : SWIGRUNTIME PyObject *
1442 29 : SwigPyObject_repr(SwigPyObject *v)
1443 : {
1444 29 : const char *name = SWIG_TypePrettyName(v->ty);
1445 29 : PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1446 29 : if (v->next) {
1447 0 : PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1448 : # if PY_VERSION_HEX >= 0x03000000
1449 0 : PyObject *joined = PyUnicode_Concat(repr, nrep);
1450 0 : Py_DecRef(repr);
1451 0 : Py_DecRef(nrep);
1452 0 : repr = joined;
1453 : # else
1454 : PyString_ConcatAndDel(&repr,nrep);
1455 : # endif
1456 : }
1457 29 : return repr;
1458 : }
1459 :
1460 : /* We need a version taking two PyObject* parameters so it's a valid
1461 : * PyCFunction to use in swigobject_methods[]. */
1462 : SWIGRUNTIME PyObject *
1463 0 : SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1464 : {
1465 0 : return SwigPyObject_repr((SwigPyObject*)v);
1466 : }
1467 :
1468 : SWIGRUNTIME int
1469 1 : SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1470 : {
1471 1 : void *i = v->ptr;
1472 1 : void *j = w->ptr;
1473 1 : return (i < j) ? -1 : ((i > j) ? 1 : 0);
1474 : }
1475 :
1476 : /* Added for Python 3.x, would it also be useful for Python 2.x? */
1477 : SWIGRUNTIME PyObject*
1478 1 : SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1479 : {
1480 1 : PyObject* res;
1481 1 : if( op != Py_EQ && op != Py_NE ) {
1482 0 : Py_INCREF(Py_NotImplemented);
1483 0 : return Py_NotImplemented;
1484 : }
1485 2 : res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1486 1 : return res;
1487 : }
1488 :
1489 :
1490 : SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1491 :
1492 : #ifdef SWIGPYTHON_BUILTIN
1493 : static swig_type_info *SwigPyObject_stype = 0;
1494 : SWIGRUNTIME PyTypeObject*
1495 : SwigPyObject_type(void) {
1496 : SwigPyClientData *cd;
1497 : assert(SwigPyObject_stype);
1498 : cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1499 : assert(cd);
1500 : assert(cd->pytype);
1501 : return cd->pytype;
1502 : }
1503 : #else
1504 : SWIGRUNTIME PyTypeObject*
1505 11795100 : SwigPyObject_type(void) {
1506 11795100 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1507 11795100 : return type;
1508 : }
1509 : #endif
1510 :
1511 : SWIGRUNTIMEINLINE int
1512 : SwigPyObject_Check(PyObject *op) {
1513 : #ifdef SWIGPYTHON_BUILTIN
1514 : PyTypeObject *target_tp = SwigPyObject_type();
1515 : if (PyType_IsSubtype(op->ob_type, target_tp))
1516 : return 1;
1517 : return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1518 : #else
1519 : return (Py_TYPE(op) == SwigPyObject_type())
1520 : || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1521 : #endif
1522 : }
1523 :
1524 : SWIGRUNTIME PyObject *
1525 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1526 :
1527 : SWIGRUNTIME void
1528 1113070 : SwigPyObject_dealloc(PyObject *v)
1529 : {
1530 1113070 : SwigPyObject *sobj = (SwigPyObject *) v;
1531 1113070 : PyObject *next = sobj->next;
1532 1113070 : if (sobj->own == SWIG_POINTER_OWN) {
1533 700090 : swig_type_info *ty = sobj->ty;
1534 700090 : SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1535 700090 : PyObject *destroy = data ? data->destroy : 0;
1536 700090 : if (destroy) {
1537 : /* destroy is always a VARARGS method */
1538 700090 : PyObject *res;
1539 :
1540 : /* PyObject_CallFunction() has the potential to silently drop
1541 : the active exception. In cases of unnamed temporary
1542 : variable or where we just finished iterating over a generator
1543 : StopIteration will be active right now, and this needs to
1544 : remain true upon return from SwigPyObject_dealloc. So save
1545 : and restore. */
1546 :
1547 700090 : PyObject *type = NULL, *value = NULL, *traceback = NULL;
1548 700090 : PyErr_Fetch(&type, &value, &traceback);
1549 :
1550 700090 : if (data->delargs) {
1551 : /* we need to create a temporary object to carry the destroy operation */
1552 0 : PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1553 0 : res = SWIG_Python_CallFunctor(destroy, tmp);
1554 0 : Py_DECREF(tmp);
1555 : } else {
1556 700090 : PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1557 700090 : PyObject *mself = PyCFunction_GET_SELF(destroy);
1558 700090 : res = ((*meth)(mself, v));
1559 : }
1560 700090 : if (!res)
1561 0 : PyErr_WriteUnraisable(destroy);
1562 :
1563 700090 : PyErr_Restore(type, value, traceback);
1564 :
1565 1400180 : Py_XDECREF(res);
1566 : }
1567 : #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1568 : else {
1569 : const char *name = SWIG_TypePrettyName(ty);
1570 : printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1571 : }
1572 : #endif
1573 : }
1574 1113070 : Py_XDECREF(next);
1575 1113070 : PyObject_DEL(v);
1576 1113070 : }
1577 :
1578 : SWIGRUNTIME PyObject*
1579 0 : SwigPyObject_append(PyObject* v, PyObject* next)
1580 : {
1581 0 : SwigPyObject *sobj = (SwigPyObject *) v;
1582 0 : if (!SwigPyObject_Check(next)) {
1583 0 : PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1584 0 : return NULL;
1585 : }
1586 0 : sobj->next = next;
1587 0 : Py_INCREF(next);
1588 0 : return SWIG_Py_Void();
1589 : }
1590 :
1591 : SWIGRUNTIME PyObject*
1592 0 : SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1593 : {
1594 0 : SwigPyObject *sobj = (SwigPyObject *) v;
1595 0 : if (sobj->next) {
1596 0 : Py_INCREF(sobj->next);
1597 0 : return sobj->next;
1598 : } else {
1599 0 : return SWIG_Py_Void();
1600 : }
1601 : }
1602 :
1603 : SWIGINTERN PyObject*
1604 322 : SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1605 : {
1606 322 : SwigPyObject *sobj = (SwigPyObject *)v;
1607 322 : sobj->own = 0;
1608 322 : return SWIG_Py_Void();
1609 : }
1610 :
1611 : SWIGINTERN PyObject*
1612 0 : SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1613 : {
1614 0 : SwigPyObject *sobj = (SwigPyObject *)v;
1615 0 : sobj->own = SWIG_POINTER_OWN;
1616 0 : return SWIG_Py_Void();
1617 : }
1618 :
1619 : SWIGINTERN PyObject*
1620 322 : SwigPyObject_own(PyObject *v, PyObject *args)
1621 : {
1622 322 : PyObject *val = 0;
1623 322 : if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
1624 : return NULL;
1625 : } else {
1626 322 : SwigPyObject *sobj = (SwigPyObject *)v;
1627 322 : PyObject *obj = PyBool_FromLong(sobj->own);
1628 322 : if (val) {
1629 322 : if (PyObject_IsTrue(val)) {
1630 0 : SwigPyObject_acquire(v,args);
1631 : } else {
1632 322 : SwigPyObject_disown(v,args);
1633 : }
1634 : }
1635 322 : return obj;
1636 : }
1637 : }
1638 :
1639 : static PyMethodDef
1640 : swigobject_methods[] = {
1641 : {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
1642 : {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
1643 : {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
1644 : {"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
1645 : {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
1646 : {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
1647 : {0, 0, 0, 0}
1648 : };
1649 :
1650 : SWIGRUNTIME PyTypeObject*
1651 273 : SwigPyObject_TypeOnce(void) {
1652 273 : static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1653 :
1654 273 : static PyNumberMethods SwigPyObject_as_number = {
1655 : (binaryfunc)0, /*nb_add*/
1656 : (binaryfunc)0, /*nb_subtract*/
1657 : (binaryfunc)0, /*nb_multiply*/
1658 : /* nb_divide removed in Python 3 */
1659 : #if PY_VERSION_HEX < 0x03000000
1660 : (binaryfunc)0, /*nb_divide*/
1661 : #endif
1662 : (binaryfunc)0, /*nb_remainder*/
1663 : (binaryfunc)0, /*nb_divmod*/
1664 : (ternaryfunc)0,/*nb_power*/
1665 : (unaryfunc)0, /*nb_negative*/
1666 : (unaryfunc)0, /*nb_positive*/
1667 : (unaryfunc)0, /*nb_absolute*/
1668 : (inquiry)0, /*nb_nonzero*/
1669 : 0, /*nb_invert*/
1670 : 0, /*nb_lshift*/
1671 : 0, /*nb_rshift*/
1672 : 0, /*nb_and*/
1673 : 0, /*nb_xor*/
1674 : 0, /*nb_or*/
1675 : #if PY_VERSION_HEX < 0x03000000
1676 : 0, /*nb_coerce*/
1677 : #endif
1678 : (unaryfunc)SwigPyObject_long, /*nb_int*/
1679 : #if PY_VERSION_HEX < 0x03000000
1680 : (unaryfunc)SwigPyObject_long, /*nb_long*/
1681 : #else
1682 : 0, /*nb_reserved*/
1683 : #endif
1684 : (unaryfunc)0, /*nb_float*/
1685 : #if PY_VERSION_HEX < 0x03000000
1686 : (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1687 : (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1688 : #endif
1689 : #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1690 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1691 : #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1692 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1693 : #else
1694 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1695 : #endif
1696 : };
1697 :
1698 273 : static PyTypeObject swigpyobject_type;
1699 273 : static int type_init = 0;
1700 273 : if (!type_init) {
1701 273 : const PyTypeObject tmp = {
1702 : #if PY_VERSION_HEX >= 0x03000000
1703 : PyVarObject_HEAD_INIT(NULL, 0)
1704 : #else
1705 : PyObject_HEAD_INIT(NULL)
1706 : 0, /* ob_size */
1707 : #endif
1708 : "SwigPyObject", /* tp_name */
1709 : sizeof(SwigPyObject), /* tp_basicsize */
1710 : 0, /* tp_itemsize */
1711 : (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1712 : 0, /* tp_print */
1713 : (getattrfunc)0, /* tp_getattr */
1714 : (setattrfunc)0, /* tp_setattr */
1715 : #if PY_VERSION_HEX >= 0x03000000
1716 : 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1717 : #else
1718 : (cmpfunc)SwigPyObject_compare, /* tp_compare */
1719 : #endif
1720 : (reprfunc)SwigPyObject_repr, /* tp_repr */
1721 : &SwigPyObject_as_number, /* tp_as_number */
1722 : 0, /* tp_as_sequence */
1723 : 0, /* tp_as_mapping */
1724 : (hashfunc)0, /* tp_hash */
1725 : (ternaryfunc)0, /* tp_call */
1726 : 0, /* tp_str */
1727 : PyObject_GenericGetAttr, /* tp_getattro */
1728 : 0, /* tp_setattro */
1729 : 0, /* tp_as_buffer */
1730 : Py_TPFLAGS_DEFAULT, /* tp_flags */
1731 : swigobject_doc, /* tp_doc */
1732 : 0, /* tp_traverse */
1733 : 0, /* tp_clear */
1734 : (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1735 : 0, /* tp_weaklistoffset */
1736 : 0, /* tp_iter */
1737 : 0, /* tp_iternext */
1738 : swigobject_methods, /* tp_methods */
1739 : 0, /* tp_members */
1740 : 0, /* tp_getset */
1741 : 0, /* tp_base */
1742 : 0, /* tp_dict */
1743 : 0, /* tp_descr_get */
1744 : 0, /* tp_descr_set */
1745 : 0, /* tp_dictoffset */
1746 : 0, /* tp_init */
1747 : 0, /* tp_alloc */
1748 : 0, /* tp_new */
1749 : 0, /* tp_free */
1750 : 0, /* tp_is_gc */
1751 : 0, /* tp_bases */
1752 : 0, /* tp_mro */
1753 : 0, /* tp_cache */
1754 : 0, /* tp_subclasses */
1755 : 0, /* tp_weaklist */
1756 : 0, /* tp_del */
1757 : 0, /* tp_version_tag */
1758 : #if PY_VERSION_HEX >= 0x03040000
1759 : 0, /* tp_finalize */
1760 : #endif
1761 : #ifdef COUNT_ALLOCS
1762 : 0, /* tp_allocs */
1763 : 0, /* tp_frees */
1764 : 0, /* tp_maxalloc */
1765 : 0, /* tp_prev */
1766 : 0 /* tp_next */
1767 : #endif
1768 : };
1769 273 : swigpyobject_type = tmp;
1770 273 : type_init = 1;
1771 273 : if (PyType_Ready(&swigpyobject_type) < 0)
1772 0 : return NULL;
1773 : }
1774 : return &swigpyobject_type;
1775 : }
1776 :
1777 : SWIGRUNTIME PyObject *
1778 1113240 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1779 : {
1780 1113240 : SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1781 1113240 : if (sobj) {
1782 1113240 : sobj->ptr = ptr;
1783 1113240 : sobj->ty = ty;
1784 1113240 : sobj->own = own;
1785 1113240 : sobj->next = 0;
1786 : }
1787 1113240 : return (PyObject *)sobj;
1788 : }
1789 :
1790 : /* -----------------------------------------------------------------------------
1791 : * Implements a simple Swig Packed type, and use it instead of string
1792 : * ----------------------------------------------------------------------------- */
1793 :
1794 : typedef struct {
1795 : PyObject_HEAD
1796 : void *pack;
1797 : swig_type_info *ty;
1798 : size_t size;
1799 : } SwigPyPacked;
1800 :
1801 : SWIGRUNTIME PyObject *
1802 0 : SwigPyPacked_repr(SwigPyPacked *v)
1803 : {
1804 0 : char result[SWIG_BUFFER_SIZE];
1805 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1806 0 : return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1807 : } else {
1808 0 : return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1809 : }
1810 : }
1811 :
1812 : SWIGRUNTIME PyObject *
1813 0 : SwigPyPacked_str(SwigPyPacked *v)
1814 : {
1815 0 : char result[SWIG_BUFFER_SIZE];
1816 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1817 0 : return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1818 : } else {
1819 0 : return SWIG_Python_str_FromChar(v->ty->name);
1820 : }
1821 : }
1822 :
1823 : SWIGRUNTIME int
1824 : SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
1825 : {
1826 : size_t i = v->size;
1827 : size_t j = w->size;
1828 : int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1829 : return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
1830 : }
1831 :
1832 : SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
1833 :
1834 : SWIGRUNTIME PyTypeObject*
1835 273 : SwigPyPacked_type(void) {
1836 273 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
1837 273 : return type;
1838 : }
1839 :
1840 : SWIGRUNTIMEINLINE int
1841 : SwigPyPacked_Check(PyObject *op) {
1842 : return ((op)->ob_type == SwigPyPacked_TypeOnce())
1843 : || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
1844 : }
1845 :
1846 : SWIGRUNTIME void
1847 0 : SwigPyPacked_dealloc(PyObject *v)
1848 : {
1849 0 : if (SwigPyPacked_Check(v)) {
1850 0 : SwigPyPacked *sobj = (SwigPyPacked *) v;
1851 0 : free(sobj->pack);
1852 : }
1853 0 : PyObject_DEL(v);
1854 0 : }
1855 :
1856 : SWIGRUNTIME PyTypeObject*
1857 273 : SwigPyPacked_TypeOnce(void) {
1858 273 : static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1859 273 : static PyTypeObject swigpypacked_type;
1860 273 : static int type_init = 0;
1861 273 : if (!type_init) {
1862 273 : const PyTypeObject tmp = {
1863 : #if PY_VERSION_HEX>=0x03000000
1864 : PyVarObject_HEAD_INIT(NULL, 0)
1865 : #else
1866 : PyObject_HEAD_INIT(NULL)
1867 : 0, /* ob_size */
1868 : #endif
1869 : "SwigPyPacked", /* tp_name */
1870 : sizeof(SwigPyPacked), /* tp_basicsize */
1871 : 0, /* tp_itemsize */
1872 : (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
1873 : 0, /* tp_print */
1874 : (getattrfunc)0, /* tp_getattr */
1875 : (setattrfunc)0, /* tp_setattr */
1876 : #if PY_VERSION_HEX>=0x03000000
1877 : 0, /* tp_reserved in 3.0.1 */
1878 : #else
1879 : (cmpfunc)SwigPyPacked_compare, /* tp_compare */
1880 : #endif
1881 : (reprfunc)SwigPyPacked_repr, /* tp_repr */
1882 : 0, /* tp_as_number */
1883 : 0, /* tp_as_sequence */
1884 : 0, /* tp_as_mapping */
1885 : (hashfunc)0, /* tp_hash */
1886 : (ternaryfunc)0, /* tp_call */
1887 : (reprfunc)SwigPyPacked_str, /* tp_str */
1888 : PyObject_GenericGetAttr, /* tp_getattro */
1889 : 0, /* tp_setattro */
1890 : 0, /* tp_as_buffer */
1891 : Py_TPFLAGS_DEFAULT, /* tp_flags */
1892 : swigpacked_doc, /* tp_doc */
1893 : 0, /* tp_traverse */
1894 : 0, /* tp_clear */
1895 : 0, /* tp_richcompare */
1896 : 0, /* tp_weaklistoffset */
1897 : 0, /* tp_iter */
1898 : 0, /* tp_iternext */
1899 : 0, /* tp_methods */
1900 : 0, /* tp_members */
1901 : 0, /* tp_getset */
1902 : 0, /* tp_base */
1903 : 0, /* tp_dict */
1904 : 0, /* tp_descr_get */
1905 : 0, /* tp_descr_set */
1906 : 0, /* tp_dictoffset */
1907 : 0, /* tp_init */
1908 : 0, /* tp_alloc */
1909 : 0, /* tp_new */
1910 : 0, /* tp_free */
1911 : 0, /* tp_is_gc */
1912 : 0, /* tp_bases */
1913 : 0, /* tp_mro */
1914 : 0, /* tp_cache */
1915 : 0, /* tp_subclasses */
1916 : 0, /* tp_weaklist */
1917 : 0, /* tp_del */
1918 : 0, /* tp_version_tag */
1919 : #if PY_VERSION_HEX >= 0x03040000
1920 : 0, /* tp_finalize */
1921 : #endif
1922 : #ifdef COUNT_ALLOCS
1923 : 0, /* tp_allocs */
1924 : 0, /* tp_frees */
1925 : 0, /* tp_maxalloc */
1926 : 0, /* tp_prev */
1927 : 0 /* tp_next */
1928 : #endif
1929 : };
1930 273 : swigpypacked_type = tmp;
1931 273 : type_init = 1;
1932 273 : if (PyType_Ready(&swigpypacked_type) < 0)
1933 0 : return NULL;
1934 : }
1935 : return &swigpypacked_type;
1936 : }
1937 :
1938 : SWIGRUNTIME PyObject *
1939 0 : SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
1940 : {
1941 0 : SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
1942 0 : if (sobj) {
1943 0 : void *pack = malloc(size);
1944 0 : if (pack) {
1945 0 : memcpy(pack, ptr, size);
1946 0 : sobj->pack = pack;
1947 0 : sobj->ty = ty;
1948 0 : sobj->size = size;
1949 : } else {
1950 0 : PyObject_DEL((PyObject *) sobj);
1951 0 : sobj = 0;
1952 : }
1953 : }
1954 0 : return (PyObject *) sobj;
1955 : }
1956 :
1957 : SWIGRUNTIME swig_type_info *
1958 : SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1959 : {
1960 : if (SwigPyPacked_Check(obj)) {
1961 : SwigPyPacked *sobj = (SwigPyPacked *)obj;
1962 : if (sobj->size != size) return 0;
1963 : memcpy(ptr, sobj->pack, size);
1964 : return sobj->ty;
1965 : } else {
1966 : return 0;
1967 : }
1968 : }
1969 :
1970 : /* -----------------------------------------------------------------------------
1971 : * pointers/data manipulation
1972 : * ----------------------------------------------------------------------------- */
1973 :
1974 : static PyObject *Swig_This_global = NULL;
1975 :
1976 : SWIGRUNTIME PyObject *
1977 4976490 : SWIG_This(void)
1978 : {
1979 4976490 : if (Swig_This_global == NULL)
1980 273 : Swig_This_global = SWIG_Python_str_FromChar("this");
1981 4976490 : return Swig_This_global;
1982 : }
1983 :
1984 : /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1985 :
1986 : /* TODO: I don't know how to implement the fast getset in Python 3 right now */
1987 : #if PY_VERSION_HEX>=0x03000000
1988 : #define SWIG_PYTHON_SLOW_GETSET_THIS
1989 : #endif
1990 :
1991 : SWIGRUNTIME SwigPyObject *
1992 5311240 : SWIG_Python_GetSwigThis(PyObject *pyobj)
1993 : {
1994 5311260 : PyObject *obj;
1995 :
1996 5311260 : if (SwigPyObject_Check(pyobj))
1997 : return (SwigPyObject *) pyobj;
1998 :
1999 : #ifdef SWIGPYTHON_BUILTIN
2000 : (void)obj;
2001 : # ifdef PyWeakref_CheckProxy
2002 : if (PyWeakref_CheckProxy(pyobj)) {
2003 : pyobj = PyWeakref_GET_OBJECT(pyobj);
2004 : if (pyobj && SwigPyObject_Check(pyobj))
2005 : return (SwigPyObject*) pyobj;
2006 : }
2007 : # endif
2008 : return NULL;
2009 : #else
2010 :
2011 4616700 : obj = 0;
2012 :
2013 : #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2014 : if (PyInstance_Check(pyobj)) {
2015 : obj = _PyInstance_Lookup(pyobj, SWIG_This());
2016 : } else {
2017 : PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2018 : if (dictptr != NULL) {
2019 : PyObject *dict = *dictptr;
2020 : obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2021 : } else {
2022 : #ifdef PyWeakref_CheckProxy
2023 : if (PyWeakref_CheckProxy(pyobj)) {
2024 : PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2025 : return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2026 : }
2027 : #endif
2028 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2029 : if (obj) {
2030 : Py_DECREF(obj);
2031 : } else {
2032 : if (PyErr_Occurred()) PyErr_Clear();
2033 : return 0;
2034 : }
2035 : }
2036 : }
2037 : #else
2038 4616700 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2039 4616700 : if (obj) {
2040 4257120 : Py_DECREF(obj);
2041 : } else {
2042 359587 : if (PyErr_Occurred()) PyErr_Clear();
2043 359587 : return 0;
2044 : }
2045 : #endif
2046 4257120 : if (obj && !SwigPyObject_Check(obj)) {
2047 : /* a PyObject is called 'this', try to get the 'real this'
2048 : SwigPyObject from it */
2049 : return SWIG_Python_GetSwigThis(obj);
2050 : }
2051 : return (SwigPyObject *)obj;
2052 : #endif
2053 : }
2054 :
2055 : /* Acquire a pointer value */
2056 :
2057 : SWIGRUNTIME int
2058 : SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2059 : if (own == SWIG_POINTER_OWN) {
2060 : SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2061 : if (sobj) {
2062 : int oldown = sobj->own;
2063 : sobj->own = own;
2064 : return oldown;
2065 : }
2066 : }
2067 : return 0;
2068 : }
2069 :
2070 : /* Convert a pointer value */
2071 :
2072 : SWIGRUNTIME int
2073 4952740 : SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2074 4952740 : int res;
2075 4952740 : SwigPyObject *sobj;
2076 4952740 : int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2077 :
2078 4952740 : if (!obj)
2079 : return SWIG_ERROR;
2080 4952740 : if (obj == Py_None && !implicit_conv) {
2081 1012 : if (ptr)
2082 1012 : *ptr = 0;
2083 2024 : return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
2084 : }
2085 :
2086 4951730 : res = SWIG_ERROR;
2087 :
2088 4951730 : sobj = SWIG_Python_GetSwigThis(obj);
2089 4951730 : if (own)
2090 0 : *own = 0;
2091 4951740 : while (sobj) {
2092 4951650 : void *vptr = sobj->ptr;
2093 4951650 : if (ty) {
2094 4951650 : swig_type_info *to = sobj->ty;
2095 4951650 : if (to == ty) {
2096 : /* no type cast needed */
2097 4950690 : if (ptr) *ptr = vptr;
2098 : break;
2099 : } else {
2100 963 : swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2101 963 : if (!tc) {
2102 4 : sobj = (SwigPyObject *)sobj->next;
2103 : } else {
2104 959 : if (ptr) {
2105 959 : int newmemory = 0;
2106 959 : *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2107 959 : if (newmemory == SWIG_CAST_NEW_MEMORY) {
2108 0 : assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2109 0 : if (own)
2110 0 : *own = *own | SWIG_CAST_NEW_MEMORY;
2111 : }
2112 : }
2113 : break;
2114 : }
2115 : }
2116 : } else {
2117 0 : if (ptr) *ptr = vptr;
2118 : break;
2119 : }
2120 : }
2121 4951730 : if (sobj) {
2122 4951650 : if (own)
2123 0 : *own = *own | sobj->own;
2124 4951650 : if (flags & SWIG_POINTER_DISOWN) {
2125 728523 : sobj->own = 0;
2126 : }
2127 : res = SWIG_OK;
2128 : } else {
2129 82 : if (implicit_conv) {
2130 0 : SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2131 0 : if (data && !data->implicitconv) {
2132 0 : PyObject *klass = data->klass;
2133 0 : if (klass) {
2134 0 : PyObject *impconv;
2135 0 : data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2136 0 : impconv = SWIG_Python_CallFunctor(klass, obj);
2137 0 : data->implicitconv = 0;
2138 0 : if (PyErr_Occurred()) {
2139 0 : PyErr_Clear();
2140 0 : impconv = 0;
2141 : }
2142 0 : if (impconv) {
2143 0 : SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2144 0 : if (iobj) {
2145 0 : void *vptr;
2146 0 : res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2147 0 : if (SWIG_IsOK(res)) {
2148 0 : if (ptr) {
2149 0 : *ptr = vptr;
2150 : /* transfer the ownership to 'ptr' */
2151 0 : iobj->own = 0;
2152 0 : res = SWIG_AddCast(res);
2153 0 : res = SWIG_AddNewMask(res);
2154 : } else {
2155 : res = SWIG_AddCast(res);
2156 : }
2157 : }
2158 : }
2159 0 : Py_DECREF(impconv);
2160 : }
2161 : }
2162 : }
2163 0 : if (!SWIG_IsOK(res) && obj == Py_None) {
2164 0 : if (ptr)
2165 0 : *ptr = 0;
2166 0 : if (PyErr_Occurred())
2167 0 : PyErr_Clear();
2168 : res = SWIG_OK;
2169 : }
2170 : }
2171 : }
2172 : return res;
2173 : }
2174 :
2175 : /* Convert a function ptr value */
2176 :
2177 : SWIGRUNTIME int
2178 : SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2179 : if (!PyCFunction_Check(obj)) {
2180 : return SWIG_ConvertPtr(obj, ptr, ty, 0);
2181 : } else {
2182 : void *vptr = 0;
2183 : swig_cast_info *tc;
2184 :
2185 : /* here we get the method pointer for callbacks */
2186 : const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2187 : const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2188 : if (desc)
2189 : desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2190 : if (!desc)
2191 : return SWIG_ERROR;
2192 : tc = SWIG_TypeCheck(desc,ty);
2193 : if (tc) {
2194 : int newmemory = 0;
2195 : *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2196 : assert(!newmemory); /* newmemory handling not yet implemented */
2197 : } else {
2198 : return SWIG_ERROR;
2199 : }
2200 : return SWIG_OK;
2201 : }
2202 : }
2203 :
2204 : /* Convert a packed pointer value */
2205 :
2206 : SWIGRUNTIME int
2207 : SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2208 : swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2209 : if (!to) return SWIG_ERROR;
2210 : if (ty) {
2211 : if (to != ty) {
2212 : /* check type cast? */
2213 : swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2214 : if (!tc) return SWIG_ERROR;
2215 : }
2216 : }
2217 : return SWIG_OK;
2218 : }
2219 :
2220 : /* -----------------------------------------------------------------------------
2221 : * Create a new pointer object
2222 : * ----------------------------------------------------------------------------- */
2223 :
2224 : /*
2225 : Create a new instance object, without calling __init__, and set the
2226 : 'this' attribute.
2227 : */
2228 :
2229 : SWIGRUNTIME PyObject*
2230 : SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2231 : {
2232 : PyObject *inst = 0;
2233 : PyObject *newraw = data->newraw;
2234 : if (newraw) {
2235 : inst = PyObject_Call(newraw, data->newargs, NULL);
2236 : if (inst) {
2237 : #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2238 : PyObject **dictptr = _PyObject_GetDictPtr(inst);
2239 : if (dictptr != NULL) {
2240 : PyObject *dict = *dictptr;
2241 : if (dict == NULL) {
2242 : dict = PyDict_New();
2243 : *dictptr = dict;
2244 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2245 : }
2246 : }
2247 : #else
2248 : PyObject *key = SWIG_This();
2249 : PyObject_SetAttr(inst, key, swig_this);
2250 : #endif
2251 : }
2252 : } else {
2253 : #if PY_VERSION_HEX >= 0x03000000
2254 : PyObject *empty_args = PyTuple_New(0);
2255 : if (empty_args) {
2256 : PyObject *empty_kwargs = PyDict_New();
2257 : if (empty_kwargs) {
2258 : inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
2259 : Py_DECREF(empty_kwargs);
2260 : if (inst) {
2261 : PyObject_SetAttr(inst, SWIG_This(), swig_this);
2262 : Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2263 : }
2264 : }
2265 : Py_DECREF(empty_args);
2266 : }
2267 : #else
2268 : PyObject *dict = PyDict_New();
2269 : if (dict) {
2270 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2271 : inst = PyInstance_NewRaw(data->newargs, dict);
2272 : Py_DECREF(dict);
2273 : }
2274 : #endif
2275 : }
2276 : return inst;
2277 : }
2278 :
2279 : SWIGRUNTIME void
2280 359509 : SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2281 : {
2282 359509 : PyObject *dict;
2283 : #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2284 : PyObject **dictptr = _PyObject_GetDictPtr(inst);
2285 : if (dictptr != NULL) {
2286 : dict = *dictptr;
2287 : if (dict == NULL) {
2288 : dict = PyDict_New();
2289 : *dictptr = dict;
2290 : }
2291 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2292 : return;
2293 : }
2294 : #endif
2295 359509 : dict = PyObject_GetAttrString(inst, "__dict__");
2296 359509 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2297 359509 : Py_DECREF(dict);
2298 359509 : }
2299 :
2300 :
2301 : SWIGINTERN PyObject *
2302 359509 : SWIG_Python_InitShadowInstance(PyObject *args) {
2303 359509 : PyObject *obj[2];
2304 359509 : if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2305 : return NULL;
2306 : } else {
2307 359509 : SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2308 359509 : if (sthis) {
2309 0 : SwigPyObject_append((PyObject*) sthis, obj[1]);
2310 : } else {
2311 359509 : SWIG_Python_SetSwigThis(obj[0], obj[1]);
2312 : }
2313 359509 : return SWIG_Py_Void();
2314 : }
2315 : }
2316 :
2317 : /* Create a new pointer object */
2318 :
2319 : SWIGRUNTIME PyObject *
2320 1124680 : SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2321 1124680 : SwigPyClientData *clientdata;
2322 1124680 : PyObject * robj;
2323 1124680 : int own;
2324 :
2325 1124680 : if (!ptr)
2326 11433 : return SWIG_Py_Void();
2327 :
2328 1113240 : clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2329 1113240 : own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2330 1113240 : if (clientdata && clientdata->pytype) {
2331 0 : SwigPyObject *newobj;
2332 0 : if (flags & SWIG_BUILTIN_TP_INIT) {
2333 0 : newobj = (SwigPyObject*) self;
2334 0 : if (newobj->ptr) {
2335 0 : PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2336 0 : while (newobj->next)
2337 : newobj = (SwigPyObject *) newobj->next;
2338 0 : newobj->next = next_self;
2339 0 : newobj = (SwigPyObject *)next_self;
2340 : #ifdef SWIGPYTHON_BUILTIN
2341 : newobj->dict = 0;
2342 : #endif
2343 : }
2344 : } else {
2345 0 : newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2346 : #ifdef SWIGPYTHON_BUILTIN
2347 : newobj->dict = 0;
2348 : #endif
2349 : }
2350 0 : if (newobj) {
2351 0 : newobj->ptr = ptr;
2352 0 : newobj->ty = type;
2353 0 : newobj->own = own;
2354 0 : newobj->next = 0;
2355 0 : return (PyObject*) newobj;
2356 : }
2357 0 : return SWIG_Py_Void();
2358 : }
2359 :
2360 1113240 : assert(!(flags & SWIG_BUILTIN_TP_INIT));
2361 :
2362 1113240 : robj = SwigPyObject_New(ptr, type, own);
2363 1113240 : if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2364 753462 : PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2365 753462 : Py_DECREF(robj);
2366 : robj = inst;
2367 : }
2368 : return robj;
2369 : }
2370 :
2371 : /* Create a new packed object */
2372 :
2373 : SWIGRUNTIMEINLINE PyObject *
2374 0 : SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2375 0 : return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2376 : }
2377 :
2378 : /* -----------------------------------------------------------------------------*
2379 : * Get type list
2380 : * -----------------------------------------------------------------------------*/
2381 :
2382 : #ifdef SWIG_LINK_RUNTIME
2383 : void *SWIG_ReturnGlobalTypeList(void *);
2384 : #endif
2385 :
2386 : SWIGRUNTIME swig_module_info *
2387 : SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2388 : static void *type_pointer = (void *)0;
2389 : /* first check if module already created */
2390 : if (!type_pointer) {
2391 : #ifdef SWIG_LINK_RUNTIME
2392 : type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2393 : #else
2394 : type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2395 : if (PyErr_Occurred()) {
2396 : PyErr_Clear();
2397 : type_pointer = (void *)0;
2398 : }
2399 : #endif
2400 : }
2401 : return (swig_module_info *) type_pointer;
2402 : }
2403 :
2404 : SWIGRUNTIME void
2405 0 : SWIG_Python_DestroyModule(PyObject *obj)
2406 : {
2407 0 : swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2408 0 : swig_type_info **types = swig_module->types;
2409 0 : size_t i;
2410 0 : for (i =0; i < swig_module->size; ++i) {
2411 0 : swig_type_info *ty = types[i];
2412 0 : if (ty->owndata) {
2413 0 : SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2414 0 : if (data) SwigPyClientData_Del(data);
2415 : }
2416 : }
2417 0 : Py_DECREF(SWIG_This());
2418 0 : Swig_This_global = NULL;
2419 0 : }
2420 :
2421 : SWIGRUNTIME void
2422 0 : SWIG_Python_SetModule(swig_module_info *swig_module) {
2423 : #if PY_VERSION_HEX >= 0x03000000
2424 : /* Add a dummy module object into sys.modules */
2425 0 : PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
2426 : #else
2427 : static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2428 : PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2429 : #endif
2430 0 : PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2431 0 : if (pointer && module) {
2432 0 : PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2433 : } else {
2434 0 : Py_XDECREF(pointer);
2435 : }
2436 0 : }
2437 :
2438 : /* The python cached type query */
2439 : SWIGRUNTIME PyObject *
2440 296 : SWIG_Python_TypeCache(void) {
2441 296 : static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2442 296 : return cache;
2443 : }
2444 :
2445 : SWIGRUNTIME swig_type_info *
2446 23 : SWIG_Python_TypeQuery(const char *type)
2447 : {
2448 23 : PyObject *cache = SWIG_Python_TypeCache();
2449 23 : PyObject *key = SWIG_Python_str_FromChar(type);
2450 23 : PyObject *obj = PyDict_GetItem(cache, key);
2451 23 : swig_type_info *descriptor;
2452 23 : if (obj) {
2453 0 : descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2454 : } else {
2455 23 : swig_module_info *swig_module = SWIG_GetModule(0);
2456 23 : descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2457 23 : if (descriptor) {
2458 23 : obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2459 23 : PyDict_SetItem(cache, key, obj);
2460 23 : Py_DECREF(obj);
2461 : }
2462 : }
2463 23 : Py_DECREF(key);
2464 23 : return descriptor;
2465 : }
2466 :
2467 : /*
2468 : For backward compatibility only
2469 : */
2470 : #define SWIG_POINTER_EXCEPTION 0
2471 : #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2472 : #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2473 :
2474 : SWIGRUNTIME int
2475 : SWIG_Python_AddErrMesg(const char* mesg, int infront)
2476 : {
2477 : if (PyErr_Occurred()) {
2478 : PyObject *type = 0;
2479 : PyObject *value = 0;
2480 : PyObject *traceback = 0;
2481 : PyErr_Fetch(&type, &value, &traceback);
2482 : if (value) {
2483 : PyObject *old_str = PyObject_Str(value);
2484 : const char *tmp = SWIG_Python_str_AsChar(old_str);
2485 : const char *errmesg = tmp ? tmp : "Invalid error message";
2486 : Py_XINCREF(type);
2487 : PyErr_Clear();
2488 : if (infront) {
2489 : PyErr_Format(type, "%s %s", mesg, errmesg);
2490 : } else {
2491 : PyErr_Format(type, "%s %s", errmesg, mesg);
2492 : }
2493 : SWIG_Python_str_DelForPy3(tmp);
2494 : Py_DECREF(old_str);
2495 : }
2496 : return 1;
2497 : } else {
2498 : return 0;
2499 : }
2500 : }
2501 :
2502 : SWIGRUNTIME int
2503 : SWIG_Python_ArgFail(int argnum)
2504 : {
2505 : if (PyErr_Occurred()) {
2506 : /* add information about failing argument */
2507 : char mesg[256];
2508 : PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2509 : return SWIG_Python_AddErrMesg(mesg, 1);
2510 : } else {
2511 : return 0;
2512 : }
2513 : }
2514 :
2515 : SWIGRUNTIMEINLINE const char *
2516 : SwigPyObject_GetDesc(PyObject *self)
2517 : {
2518 : SwigPyObject *v = (SwigPyObject *)self;
2519 : swig_type_info *ty = v ? v->ty : 0;
2520 : return ty ? ty->str : "";
2521 : }
2522 :
2523 : SWIGRUNTIME void
2524 : SWIG_Python_TypeError(const char *type, PyObject *obj)
2525 : {
2526 : if (type) {
2527 : #if defined(SWIG_COBJECT_TYPES)
2528 : if (obj && SwigPyObject_Check(obj)) {
2529 : const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2530 : if (otype) {
2531 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2532 : type, otype);
2533 : return;
2534 : }
2535 : } else
2536 : #endif
2537 : {
2538 : const char *otype = (obj ? obj->ob_type->tp_name : 0);
2539 : if (otype) {
2540 : PyObject *str = PyObject_Str(obj);
2541 : const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2542 : if (cstr) {
2543 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2544 : type, otype, cstr);
2545 : SWIG_Python_str_DelForPy3(cstr);
2546 : } else {
2547 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2548 : type, otype);
2549 : }
2550 : Py_XDECREF(str);
2551 : return;
2552 : }
2553 : }
2554 : PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2555 : } else {
2556 : PyErr_Format(PyExc_TypeError, "unexpected type is received");
2557 : }
2558 : }
2559 :
2560 :
2561 : /* Convert a pointer value, signal an exception on a type mismatch */
2562 : SWIGRUNTIME void *
2563 : SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2564 : void *result;
2565 : if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2566 : PyErr_Clear();
2567 : #if SWIG_POINTER_EXCEPTION
2568 : if (flags) {
2569 : SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2570 : SWIG_Python_ArgFail(argnum);
2571 : }
2572 : #endif
2573 : }
2574 : return result;
2575 : }
2576 :
2577 : #ifdef SWIGPYTHON_BUILTIN
2578 : SWIGRUNTIME int
2579 : SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2580 : PyTypeObject *tp = obj->ob_type;
2581 : PyObject *descr;
2582 : PyObject *encoded_name;
2583 : descrsetfunc f;
2584 : int res = -1;
2585 :
2586 : # ifdef Py_USING_UNICODE
2587 : if (PyString_Check(name)) {
2588 : name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2589 : if (!name)
2590 : return -1;
2591 : } else if (!PyUnicode_Check(name))
2592 : # else
2593 : if (!PyString_Check(name))
2594 : # endif
2595 : {
2596 : PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2597 : return -1;
2598 : } else {
2599 : Py_INCREF(name);
2600 : }
2601 :
2602 : if (!tp->tp_dict) {
2603 : if (PyType_Ready(tp) < 0)
2604 : goto done;
2605 : }
2606 :
2607 : descr = _PyType_Lookup(tp, name);
2608 : f = NULL;
2609 : if (descr != NULL)
2610 : f = descr->ob_type->tp_descr_set;
2611 : if (!f) {
2612 : if (PyString_Check(name)) {
2613 : encoded_name = name;
2614 : Py_INCREF(name);
2615 : } else {
2616 : encoded_name = PyUnicode_AsUTF8String(name);
2617 : if (!encoded_name)
2618 : return -1;
2619 : }
2620 : PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2621 : Py_DECREF(encoded_name);
2622 : } else {
2623 : res = f(descr, obj, value);
2624 : }
2625 :
2626 : done:
2627 : Py_DECREF(name);
2628 : return res;
2629 : }
2630 : #endif
2631 :
2632 :
2633 : #ifdef __cplusplus
2634 : }
2635 : #endif
2636 :
2637 :
2638 :
2639 : #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2640 :
2641 : #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2642 :
2643 :
2644 :
2645 : #ifdef __cplusplus
2646 : extern "C" {
2647 : #endif
2648 :
2649 : /* Method creation and docstring support functions */
2650 :
2651 : SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name);
2652 : SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
2653 : SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
2654 :
2655 : #ifdef __cplusplus
2656 : }
2657 : #endif
2658 :
2659 :
2660 : #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
2661 :
2662 :
2663 : /* -------- TYPES TABLE (BEGIN) -------- */
2664 :
2665 : #define SWIGTYPE_p_ArrowArray swig_types[0]
2666 : #define SWIGTYPE_p_ArrowArrayStream swig_types[1]
2667 : #define SWIGTYPE_p_ArrowSchema swig_types[2]
2668 : #define SWIGTYPE_p_GDALDatasetShadow swig_types[3]
2669 : #define SWIGTYPE_p_GDALDriverShadow swig_types[4]
2670 : #define SWIGTYPE_p_GDALMajorObjectShadow swig_types[5]
2671 : #define SWIGTYPE_p_GDALProgressFunc swig_types[6]
2672 : #define SWIGTYPE_p_GIntBig swig_types[7]
2673 : #define SWIGTYPE_p_OGRCodedValue swig_types[8]
2674 : #define SWIGTYPE_p_OGRFeatureDefnShadow swig_types[9]
2675 : #define SWIGTYPE_p_OGRFeatureShadow swig_types[10]
2676 : #define SWIGTYPE_p_OGRFieldDefnShadow swig_types[11]
2677 : #define SWIGTYPE_p_OGRFieldDomainShadow swig_types[12]
2678 : #define SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow swig_types[13]
2679 : #define SWIGTYPE_p_OGRGeomFieldDefnShadow swig_types[14]
2680 : #define SWIGTYPE_p_OGRGeomTransformerShadow swig_types[15]
2681 : #define SWIGTYPE_p_OGRGeometryShadow swig_types[16]
2682 : #define SWIGTYPE_p_OGRLayerShadow swig_types[17]
2683 : #define SWIGTYPE_p_OGRPreparedGeometryShadow swig_types[18]
2684 : #define SWIGTYPE_p_OGRStyleTableShadow swig_types[19]
2685 : #define SWIGTYPE_p_OSRCoordinateTransformationShadow swig_types[20]
2686 : #define SWIGTYPE_p_OSRSpatialReferenceShadow swig_types[21]
2687 : #define SWIGTYPE_p_bool swig_types[22]
2688 : #define SWIGTYPE_p_char swig_types[23]
2689 : #define SWIGTYPE_p_double swig_types[24]
2690 : #define SWIGTYPE_p_f_double_p_q_const__char_p_void__int swig_types[25]
2691 : #define SWIGTYPE_p_float swig_types[26]
2692 : #define SWIGTYPE_p_int swig_types[27]
2693 : #define SWIGTYPE_p_p_GIntBig swig_types[28]
2694 : #define SWIGTYPE_p_p_OGRGeometryTypeCounter swig_types[29]
2695 : #define SWIGTYPE_p_p_OGRSpatialReferenceH swig_types[30]
2696 : #define SWIGTYPE_p_p_char swig_types[31]
2697 : #define SWIGTYPE_p_p_double swig_types[32]
2698 : #define SWIGTYPE_p_p_int swig_types[33]
2699 : #define SWIGTYPE_p_size_t swig_types[34]
2700 : static swig_type_info *swig_types[36];
2701 : static swig_module_info swig_module = {swig_types, 35, 0, 0, 0, 0};
2702 : #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2703 : #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2704 :
2705 : /* -------- TYPES TABLE (END) -------- */
2706 :
2707 : #ifdef SWIG_TypeQuery
2708 : # undef SWIG_TypeQuery
2709 : #endif
2710 : #define SWIG_TypeQuery SWIG_Python_TypeQuery
2711 :
2712 : /*-----------------------------------------------
2713 : @(target):= _ogr.so
2714 : ------------------------------------------------*/
2715 : #if PY_VERSION_HEX >= 0x03000000
2716 : # define SWIG_init PyInit__ogr
2717 :
2718 : #else
2719 : # define SWIG_init init_ogr
2720 :
2721 : #endif
2722 : #define SWIG_name "_ogr"
2723 :
2724 : #define SWIGVERSION 0x040001
2725 : #define SWIG_VERSION SWIGVERSION
2726 :
2727 :
2728 : #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2729 : #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2730 :
2731 :
2732 : #include <stdexcept>
2733 :
2734 :
2735 : namespace swig {
2736 : class SwigPtr_PyObject {
2737 : protected:
2738 : PyObject *_obj;
2739 :
2740 : public:
2741 : SwigPtr_PyObject() :_obj(0)
2742 : {
2743 : }
2744 :
2745 : SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
2746 : {
2747 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
2748 : Py_XINCREF(_obj);
2749 : SWIG_PYTHON_THREAD_END_BLOCK;
2750 : }
2751 :
2752 : SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
2753 : {
2754 : if (initial_ref) {
2755 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
2756 : Py_XINCREF(_obj);
2757 : SWIG_PYTHON_THREAD_END_BLOCK;
2758 : }
2759 : }
2760 :
2761 : SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
2762 : {
2763 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
2764 : Py_XINCREF(item._obj);
2765 : Py_XDECREF(_obj);
2766 : _obj = item._obj;
2767 : SWIG_PYTHON_THREAD_END_BLOCK;
2768 : return *this;
2769 : }
2770 :
2771 : ~SwigPtr_PyObject()
2772 : {
2773 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
2774 : Py_XDECREF(_obj);
2775 : SWIG_PYTHON_THREAD_END_BLOCK;
2776 : }
2777 :
2778 : operator PyObject *() const
2779 : {
2780 : return _obj;
2781 : }
2782 :
2783 : PyObject *operator->() const
2784 : {
2785 : return _obj;
2786 : }
2787 : };
2788 : }
2789 :
2790 :
2791 : namespace swig {
2792 : struct SwigVar_PyObject : SwigPtr_PyObject {
2793 : SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
2794 :
2795 : SwigVar_PyObject & operator = (PyObject* obj)
2796 : {
2797 : Py_XDECREF(_obj);
2798 : _obj = obj;
2799 : return *this;
2800 : }
2801 : };
2802 : }
2803 :
2804 :
2805 : typedef void* VoidPtrAsLong;
2806 :
2807 :
2808 : typedef char retStringAndCPLFree;
2809 :
2810 :
2811 : #include <iostream>
2812 : using namespace std;
2813 :
2814 : #define CPL_SUPRESS_CPLUSPLUS
2815 :
2816 : #include "gdal.h"
2817 : #include "ogr_api.h"
2818 : #include "ogr_core.h"
2819 : #include "cpl_port.h"
2820 : #include "cpl_string.h"
2821 : #include "ogr_srs_api.h"
2822 : #include "ogr_recordbatch.h"
2823 : #include "ogr_p.h"
2824 :
2825 : #define FIELD_INDEX_ERROR_TMPL "Invalid field index: '%i'"
2826 : #define FIELD_NAME_ERROR_TMPL "Invalid field name: '%s'"
2827 :
2828 : typedef void GDALMajorObjectShadow;
2829 : typedef void GDALDatasetShadow;
2830 :
2831 : #ifdef DEBUG
2832 : typedef struct OGRSpatialReferenceHS OSRSpatialReferenceShadow;
2833 : typedef struct OGRDriverHS OGRDriverShadow;
2834 : typedef struct OGRDataSourceHS OGRDataSourceShadow;
2835 : typedef struct OGRLayerHS OGRLayerShadow;
2836 : typedef struct OGRFeatureHS OGRFeatureShadow;
2837 : typedef struct OGRFeatureDefnHS OGRFeatureDefnShadow;
2838 : typedef struct OGRGeometryHS OGRGeometryShadow;
2839 : typedef struct OGRCoordinateTransformationHS OSRCoordinateTransformationShadow;
2840 : typedef struct OGRFieldDefnHS OGRFieldDefnShadow;
2841 : #else
2842 : typedef void OSRSpatialReferenceShadow;
2843 : typedef void OGRDriverShadow;
2844 : typedef void OGRDataSourceShadow;
2845 : typedef void OGRLayerShadow;
2846 : typedef void OGRFeatureShadow;
2847 : typedef void OGRFeatureDefnShadow;
2848 : typedef void OGRGeometryShadow;
2849 : typedef void OSRCoordinateTransformationShadow;
2850 : typedef void OGRFieldDefnShadow;
2851 : #endif
2852 :
2853 : typedef struct OGRStyleTableHS OGRStyleTableShadow;
2854 : typedef struct OGRGeomFieldDefnHS OGRGeomFieldDefnShadow;
2855 : typedef struct OGRGeomTransformer OGRGeomTransformerShadow;
2856 : typedef struct _OGRPreparedGeometry OGRPreparedGeometryShadow;
2857 : typedef struct OGRFieldDomainHS OGRFieldDomainShadow;
2858 : typedef struct OGRGeomCoordinatePrecision OGRGeomCoordinatePrecisionShadow;
2859 :
2860 :
2861 : SWIGINTERNINLINE PyObject*
2862 434838 : SWIG_From_int (int value)
2863 : {
2864 434838 : return PyInt_FromLong((long) value);
2865 : }
2866 :
2867 :
2868 : SWIGINTERN swig_type_info*
2869 246 : SWIG_pchar_descriptor(void)
2870 : {
2871 246 : static int init = 0;
2872 246 : static swig_type_info* info = 0;
2873 246 : if (!init) {
2874 23 : info = SWIG_TypeQuery("_p_char");
2875 23 : init = 1;
2876 : }
2877 246 : return info;
2878 : }
2879 :
2880 :
2881 : SWIGINTERNINLINE PyObject *
2882 240608 : SWIG_FromCharPtrAndSize(const char* carray, size_t size)
2883 : {
2884 240608 : if (carray) {
2885 240489 : if (size > INT_MAX) {
2886 0 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2887 0 : return pchar_descriptor ?
2888 0 : SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
2889 : } else {
2890 : #if PY_VERSION_HEX >= 0x03000000
2891 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
2892 : return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
2893 : #else
2894 240489 : return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
2895 : #endif
2896 : #else
2897 : return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
2898 : #endif
2899 : }
2900 : } else {
2901 119 : return SWIG_Py_Void();
2902 : }
2903 : }
2904 :
2905 :
2906 : SWIGINTERNINLINE PyObject *
2907 240608 : SWIG_FromCharPtr(const char *cptr)
2908 : {
2909 229142 : return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
2910 : }
2911 :
2912 :
2913 : #define MODULE_NAME "ogr"
2914 :
2915 :
2916 : #include "cpl_string.h"
2917 : #include "cpl_conv.h"
2918 :
2919 : static int bUseExceptions=0;
2920 : static int bUserHasSpecifiedIfUsingExceptions = FALSE;
2921 : static thread_local int bUseExceptionsLocal = -1;
2922 :
2923 2909940 : struct PythonBindingErrorHandlerContext
2924 : {
2925 : std::string osInitialMsg{};
2926 : std::string osFailureMsg{};
2927 : CPLErrorNum nLastCode = CPLE_None;
2928 : bool bMemoryError = false;
2929 : };
2930 :
2931 : static void CPL_STDCALL
2932 654 : PythonBindingErrorHandler(CPLErr eclass, CPLErrorNum err_no, const char *msg )
2933 : {
2934 654 : PythonBindingErrorHandlerContext* ctxt = static_cast<
2935 654 : PythonBindingErrorHandlerContext*>(CPLGetErrorHandlerUserData());
2936 :
2937 : /*
2938 : ** Generally we want to suppress error reporting if we have exceptions
2939 : ** enabled as the error message will be in the exception thrown in
2940 : ** Python.
2941 : */
2942 :
2943 : /* If the error class is CE_Fatal, we want to have a message issued
2944 : because the CPL support code does an abort() before any exception
2945 : can be generated */
2946 654 : if (eclass == CE_Fatal ) {
2947 0 : CPLCallPreviousHandler(eclass, err_no, msg );
2948 : }
2949 :
2950 : /*
2951 : ** We do not want to interfere with non-failure messages since
2952 : ** they won't be translated into exceptions.
2953 : */
2954 654 : else if (eclass != CE_Failure ) {
2955 167 : CPLCallPreviousHandler(eclass, err_no, msg );
2956 : }
2957 : else {
2958 487 : ctxt->nLastCode = err_no;
2959 487 : try
2960 : {
2961 487 : if( ctxt->osFailureMsg.empty() ) {
2962 318 : ctxt->osFailureMsg = msg;
2963 318 : ctxt->osInitialMsg = ctxt->osFailureMsg;
2964 : } else {
2965 169 : if( ctxt->osFailureMsg.size() < 10000 ) {
2966 338 : std::string osTmp(msg);
2967 169 : osTmp += "\nMay be caused by: ";
2968 169 : osTmp += ctxt->osFailureMsg;
2969 169 : ctxt->osFailureMsg = std::move(osTmp);
2970 169 : ctxt->osInitialMsg = ctxt->osFailureMsg;
2971 : }
2972 : else
2973 : {
2974 0 : std::string osTmp(msg);
2975 0 : osTmp += "\n[...]\nMay be caused by: ";
2976 0 : osTmp += ctxt->osInitialMsg;
2977 0 : ctxt->osFailureMsg = std::move(osTmp);
2978 : }
2979 : }
2980 : }
2981 0 : catch( const std::exception& )
2982 : {
2983 0 : ctxt->bMemoryError = true;
2984 : }
2985 : }
2986 654 : }
2987 :
2988 :
2989 :
2990 :
2991 : static
2992 7237400 : int GetUseExceptions() {
2993 4621530 : return bUseExceptionsLocal >= 0 ? bUseExceptionsLocal : bUseExceptions;
2994 : }
2995 :
2996 9296 : static int _GetExceptionsLocal()
2997 : {
2998 9296 : return bUseExceptionsLocal;
2999 : }
3000 :
3001 18592 : static void _SetExceptionsLocal(int bVal)
3002 : {
3003 18592 : bUseExceptionsLocal = bVal;
3004 : }
3005 :
3006 : static
3007 27 : void _UseExceptions() {
3008 27 : CPLErrorReset();
3009 27 : bUserHasSpecifiedIfUsingExceptions = TRUE;
3010 27 : if( !bUseExceptions )
3011 : {
3012 25 : bUseExceptions = 1;
3013 : }
3014 : }
3015 :
3016 : static
3017 5 : void _DontUseExceptions() {
3018 5 : CPLErrorReset();
3019 5 : bUserHasSpecifiedIfUsingExceptions = TRUE;
3020 5 : if( bUseExceptions )
3021 : {
3022 0 : bUseExceptions = 0;
3023 : }
3024 : }
3025 :
3026 18751 : static int _UserHasSpecifiedIfUsingExceptions()
3027 : {
3028 1716 : return bUserHasSpecifiedIfUsingExceptions || bUseExceptionsLocal >= 0;
3029 : }
3030 :
3031 :
3032 :
3033 : #include <limits.h>
3034 : #if !defined(SWIG_NO_LLONG_MAX)
3035 : # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3036 : # define LLONG_MAX __LONG_LONG_MAX__
3037 : # define LLONG_MIN (-LLONG_MAX - 1LL)
3038 : # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3039 : # endif
3040 : #endif
3041 :
3042 :
3043 : SWIGINTERN int
3044 709024 : SWIG_AsVal_double (PyObject *obj, double *val)
3045 : {
3046 709024 : int res = SWIG_TypeError;
3047 709024 : if (PyFloat_Check(obj)) {
3048 384361 : if (val) *val = PyFloat_AsDouble(obj);
3049 384361 : return SWIG_OK;
3050 : #if PY_VERSION_HEX < 0x03000000
3051 : } else if (PyInt_Check(obj)) {
3052 : if (val) *val = (double) PyInt_AsLong(obj);
3053 : return SWIG_OK;
3054 : #endif
3055 324663 : } else if (PyLong_Check(obj)) {
3056 324663 : double v = PyLong_AsDouble(obj);
3057 324663 : if (!PyErr_Occurred()) {
3058 324663 : if (val) *val = v;
3059 324663 : return SWIG_OK;
3060 : } else {
3061 0 : PyErr_Clear();
3062 : }
3063 : }
3064 : #ifdef SWIG_PYTHON_CAST_MODE
3065 : {
3066 : int dispatch = 0;
3067 : double d = PyFloat_AsDouble(obj);
3068 : if (!PyErr_Occurred()) {
3069 : if (val) *val = d;
3070 : return SWIG_AddCast(SWIG_OK);
3071 : } else {
3072 : PyErr_Clear();
3073 : }
3074 : if (!dispatch) {
3075 : long v = PyLong_AsLong(obj);
3076 : if (!PyErr_Occurred()) {
3077 : if (val) *val = v;
3078 : return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3079 : } else {
3080 : PyErr_Clear();
3081 : }
3082 : }
3083 : }
3084 : #endif
3085 : return res;
3086 : }
3087 :
3088 :
3089 : #include <float.h>
3090 :
3091 :
3092 : #include <math.h>
3093 :
3094 :
3095 : SWIGINTERNINLINE int
3096 : SWIG_CanCastAsInteger(double *d, double min, double max) {
3097 : double x = *d;
3098 : if ((min <= x && x <= max)) {
3099 : double fx = floor(x);
3100 : double cx = ceil(x);
3101 : double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3102 : if ((errno == EDOM) || (errno == ERANGE)) {
3103 : errno = 0;
3104 : } else {
3105 : double summ, reps, diff;
3106 : if (rd < x) {
3107 : diff = x - rd;
3108 : } else if (rd > x) {
3109 : diff = rd - x;
3110 : } else {
3111 : return 1;
3112 : }
3113 : summ = rd + x;
3114 : reps = diff/summ;
3115 : if (reps < 8*DBL_EPSILON) {
3116 : *d = rd;
3117 : return 1;
3118 : }
3119 : }
3120 : }
3121 : return 0;
3122 : }
3123 :
3124 :
3125 : SWIGINTERN int
3126 1802900 : SWIG_AsVal_long (PyObject *obj, long* val)
3127 : {
3128 : #if PY_VERSION_HEX < 0x03000000
3129 : if (PyInt_Check(obj)) {
3130 : if (val) *val = PyInt_AsLong(obj);
3131 : return SWIG_OK;
3132 : } else
3133 : #endif
3134 1802900 : if (PyLong_Check(obj)) {
3135 1798690 : long v = PyLong_AsLong(obj);
3136 1798690 : if (!PyErr_Occurred()) {
3137 1798690 : if (val) *val = v;
3138 1798690 : return SWIG_OK;
3139 : } else {
3140 0 : PyErr_Clear();
3141 0 : return SWIG_OverflowError;
3142 : }
3143 : }
3144 : #ifdef SWIG_PYTHON_CAST_MODE
3145 : {
3146 : int dispatch = 0;
3147 : long v = PyInt_AsLong(obj);
3148 : if (!PyErr_Occurred()) {
3149 : if (val) *val = v;
3150 : return SWIG_AddCast(SWIG_OK);
3151 : } else {
3152 : PyErr_Clear();
3153 : }
3154 : if (!dispatch) {
3155 : double d;
3156 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3157 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3158 : if (val) *val = (long)(d);
3159 : return res;
3160 : }
3161 : }
3162 : }
3163 : #endif
3164 : return SWIG_TypeError;
3165 : }
3166 :
3167 :
3168 : SWIGINTERN int
3169 1308210 : SWIG_AsVal_int (PyObject * obj, int *val)
3170 : {
3171 1308210 : long v;
3172 2616430 : int res = SWIG_AsVal_long (obj, &v);
3173 1308210 : if (SWIG_IsOK(res)) {
3174 1304000 : if ((v < INT_MIN || v > INT_MAX)) {
3175 : return SWIG_OverflowError;
3176 : } else {
3177 809314 : if (val) *val = static_cast< int >(v);
3178 : }
3179 : }
3180 : return res;
3181 : }
3182 :
3183 :
3184 : /* Completely unrelated: just to avoid Coverity warnings */
3185 :
3186 : static int bReturnSame = 1;
3187 :
3188 0 : void NeverCallMePlease() {
3189 0 : bReturnSame = 0;
3190 0 : }
3191 :
3192 : /* Some SWIG code generates dead code, which Coverity warns about */
3193 4672460 : template<class T> static T ReturnSame(T x)
3194 : {
3195 18483 : if( bReturnSame )
3196 : return x;
3197 : return 0;
3198 : }
3199 :
3200 2909940 : static void pushErrorHandler()
3201 : {
3202 2909940 : CPLErrorReset();
3203 2909940 : PythonBindingErrorHandlerContext* ctxt = new PythonBindingErrorHandlerContext();
3204 2909940 : CPLPushErrorHandlerEx(PythonBindingErrorHandler, ctxt);
3205 2909940 : }
3206 :
3207 2909940 : static void popErrorHandler()
3208 : {
3209 2909940 : PythonBindingErrorHandlerContext* ctxt = static_cast<
3210 2909940 : PythonBindingErrorHandlerContext*>(CPLGetErrorHandlerUserData());
3211 2909940 : CPLPopErrorHandler();
3212 2909940 : if( ctxt->bMemoryError )
3213 : {
3214 0 : CPLErrorSetState(
3215 : CE_Failure, CPLE_OutOfMemory, "Out of memory");
3216 : }
3217 2909940 : else if( !ctxt->osFailureMsg.empty() )
3218 : {
3219 346 : CPLErrorSetState(
3220 318 : CPLGetLastErrorType() == CE_Failure ? CE_Failure: CE_Warning,
3221 : ctxt->nLastCode, ctxt->osFailureMsg.c_str());
3222 : }
3223 2909940 : delete ctxt;
3224 2909940 : }
3225 :
3226 :
3227 :
3228 :
3229 : /* Return a PyObject* from a NULL terminated C String */
3230 : static PyObject* GDALPythonObjectFromCStr(const char *pszStr) CPL_UNUSED;
3231 9482 : static PyObject* GDALPythonObjectFromCStr(const char *pszStr)
3232 : {
3233 9482 : const unsigned char* pszIter = (const unsigned char*) pszStr;
3234 428995 : while(*pszIter != 0)
3235 : {
3236 419513 : if (*pszIter > 127)
3237 : {
3238 0 : PyObject* pyObj = PyUnicode_DecodeUTF8(pszStr, strlen(pszStr), "strict");
3239 0 : if (pyObj != NULL && !PyErr_Occurred())
3240 : return pyObj;
3241 0 : PyErr_Clear();
3242 0 : return PyBytes_FromString(pszStr);
3243 : }
3244 419513 : pszIter ++;
3245 : }
3246 9482 : return PyUnicode_FromString(pszStr);
3247 : }
3248 :
3249 : /* Return a NULL terminated c String from a PyObject */
3250 : /* Result must be freed with GDALPythonFreeCStr */
3251 : static char* GDALPythonObjectToCStr(PyObject* pyObject, int* pbToFree) CPL_UNUSED;
3252 24293 : static char* GDALPythonObjectToCStr(PyObject* pyObject, int* pbToFree)
3253 : {
3254 24293 : *pbToFree = 0;
3255 24293 : if (PyUnicode_Check(pyObject))
3256 : {
3257 24293 : char *pszStr;
3258 24293 : char *pszNewStr;
3259 24293 : Py_ssize_t nLen;
3260 24293 : PyObject* pyUTF8Str = PyUnicode_AsUTF8String(pyObject);
3261 24293 : if( pyUTF8Str == NULL )
3262 : return NULL;
3263 24291 : PyBytes_AsStringAndSize(pyUTF8Str, &pszStr, &nLen);
3264 24291 : pszNewStr = (char *) malloc(nLen+1);
3265 24291 : if( pszNewStr == NULL )
3266 : {
3267 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Failed to allocate %llu bytes",
3268 : (unsigned long long)(nLen + 1));
3269 0 : Py_XDECREF(pyUTF8Str);
3270 0 : return NULL;
3271 : }
3272 24291 : memcpy(pszNewStr, pszStr, nLen+1);
3273 24291 : Py_XDECREF(pyUTF8Str);
3274 24291 : *pbToFree = 1;
3275 24291 : return pszNewStr;
3276 : }
3277 0 : else if( PyBytes_Check(pyObject) )
3278 : {
3279 0 : char* ret = PyBytes_AsString(pyObject);
3280 :
3281 : // Check if there are \0 bytes inside the string
3282 0 : const Py_ssize_t size = PyBytes_Size(pyObject);
3283 0 : for( Py_ssize_t i = 0; i < size; i++ )
3284 : {
3285 0 : if( ret[i] == 0 )
3286 : {
3287 0 : CPLError(CE_Failure, CPLE_AppDefined,
3288 : "bytes object cast as string contains a zero-byte.");
3289 0 : return NULL;
3290 : }
3291 : }
3292 :
3293 : return ret;
3294 : }
3295 : else
3296 : {
3297 0 : CPLError(CE_Failure, CPLE_AppDefined,
3298 : "Passed object is neither of type string nor bytes");
3299 0 : return NULL;
3300 : }
3301 : }
3302 :
3303 : static char * GDALPythonPathToCStr(PyObject* pyObject, int* pbToFree) CPL_UNUSED;
3304 3180 : static char * GDALPythonPathToCStr(PyObject* pyObject, int* pbToFree)
3305 : {
3306 3180 : PyObject* os = PyImport_ImportModule("os");
3307 3180 : if (os == NULL)
3308 : {
3309 : return NULL;
3310 : }
3311 :
3312 3180 : PyObject* pathLike = PyObject_GetAttrString(os, "PathLike");
3313 3180 : if (pathLike == NULL)
3314 : {
3315 0 : Py_DECREF(os);
3316 0 : return NULL;
3317 : }
3318 :
3319 3180 : if (!PyObject_IsInstance(pyObject, pathLike))
3320 : {
3321 0 : Py_DECREF(pathLike);
3322 0 : Py_DECREF(os);
3323 0 : return NULL;
3324 : }
3325 :
3326 3180 : PyObject* str = PyObject_Str(pyObject);
3327 3180 : char* ret = NULL;
3328 3180 : if (str != NULL)
3329 : {
3330 3180 : ret = GDALPythonObjectToCStr(str, pbToFree);
3331 3180 : Py_DECREF(str);
3332 : }
3333 :
3334 3180 : Py_DECREF(pathLike);
3335 3180 : Py_DECREF(os);
3336 :
3337 : return ret;
3338 : }
3339 :
3340 :
3341 : static void GDALPythonFreeCStr(void* ptr, int bToFree) CPL_UNUSED;
3342 21373 : static void GDALPythonFreeCStr(void* ptr, int bToFree)
3343 : {
3344 21373 : if (bToFree)
3345 21371 : free(ptr);
3346 : }
3347 :
3348 :
3349 :
3350 :
3351 : typedef struct {
3352 : PyObject *psPyCallback;
3353 : PyObject *psPyCallbackData;
3354 : int nLastReported;
3355 : } PyProgressData;
3356 :
3357 : /************************************************************************/
3358 : /* PyProgressProxy() */
3359 : /************************************************************************/
3360 :
3361 :
3362 : static int CPL_STDCALL
3363 : PyProgressProxy( double dfComplete, const char *pszMessage, void *pData ) CPL_UNUSED;
3364 :
3365 : static int CPL_STDCALL
3366 24 : PyProgressProxy( double dfComplete, const char *pszMessage, void *pData )
3367 :
3368 : {
3369 24 : PyProgressData *psInfo = (PyProgressData *) pData;
3370 24 : PyObject *psArgs, *psResult;
3371 24 : int bContinue = TRUE;
3372 :
3373 24 : if( dfComplete > 0 && psInfo->nLastReported == (int) (100.0 * dfComplete) )
3374 : return TRUE;
3375 :
3376 24 : if( psInfo->psPyCallback == NULL || psInfo->psPyCallback == Py_None )
3377 : return TRUE;
3378 :
3379 24 : psInfo->nLastReported = (int) (100.0 * dfComplete);
3380 :
3381 24 : if( pszMessage == NULL )
3382 0 : pszMessage = "";
3383 :
3384 48 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3385 :
3386 24 : if( psInfo->psPyCallbackData == NULL )
3387 24 : psArgs = Py_BuildValue("(dsO)", dfComplete, pszMessage, Py_None );
3388 : else
3389 0 : psArgs = Py_BuildValue("(dsO)", dfComplete, pszMessage,
3390 : psInfo->psPyCallbackData );
3391 :
3392 24 : psResult = PyObject_CallObject( psInfo->psPyCallback, psArgs);
3393 24 : Py_XDECREF(psArgs);
3394 :
3395 24 : if( PyErr_Occurred() != NULL )
3396 : {
3397 0 : PyErr_Print();
3398 0 : PyErr_Clear();
3399 0 : SWIG_PYTHON_THREAD_END_BLOCK;
3400 : return FALSE;
3401 : }
3402 :
3403 24 : if( psResult == NULL )
3404 : {
3405 0 : SWIG_PYTHON_THREAD_END_BLOCK;
3406 : return TRUE;
3407 : }
3408 :
3409 24 : if( psResult == Py_None )
3410 : {
3411 0 : SWIG_PYTHON_THREAD_END_BLOCK;
3412 : return TRUE;
3413 : }
3414 :
3415 24 : if( !PyArg_Parse( psResult, "i", &bContinue ) )
3416 : {
3417 0 : PyErr_Clear();
3418 0 : CPLError(CE_Failure, CPLE_AppDefined, "bad progress return value");
3419 0 : Py_XDECREF(psResult);
3420 0 : SWIG_PYTHON_THREAD_END_BLOCK;
3421 : return FALSE;
3422 : }
3423 :
3424 24 : Py_XDECREF(psResult);
3425 24 : SWIG_PYTHON_THREAD_END_BLOCK;
3426 :
3427 24 : return bContinue;
3428 : }
3429 :
3430 :
3431 : #include "gdal.h"
3432 :
3433 20 : SWIGINTERN char const *GDALMajorObjectShadow_GetDescription(GDALMajorObjectShadow *self){
3434 20 : return GDALGetDescription( self );
3435 : }
3436 :
3437 : SWIGINTERN int
3438 88217 : SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3439 : {
3440 : #if PY_VERSION_HEX>=0x03000000
3441 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3442 : if (PyBytes_Check(obj))
3443 : #else
3444 88217 : if (PyUnicode_Check(obj))
3445 : #endif
3446 : #else
3447 : if (PyString_Check(obj))
3448 : #endif
3449 : {
3450 87971 : char *cstr; Py_ssize_t len;
3451 87971 : int ret = SWIG_OK;
3452 : #if PY_VERSION_HEX>=0x03000000
3453 : #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3454 87971 : if (!alloc && cptr) {
3455 : /* We can't allow converting without allocation, since the internal
3456 : representation of string in Python 3 is UCS-2/UCS-4 but we require
3457 : a UTF-8 representation.
3458 : TODO(bhy) More detailed explanation */
3459 : return SWIG_RuntimeError;
3460 : }
3461 87971 : obj = PyUnicode_AsUTF8String(obj); if (!obj) return SWIG_TypeError;
3462 87971 : if (!obj)
3463 : return SWIG_TypeError;
3464 87971 : if (alloc)
3465 85041 : *alloc = SWIG_NEWOBJ;
3466 : #endif
3467 87971 : PyBytes_AsStringAndSize(obj, &cstr, &len);
3468 : #else
3469 : PyString_AsStringAndSize(obj, &cstr, &len);
3470 : #endif
3471 87971 : if (cptr) {
3472 85041 : if (alloc) {
3473 85041 : if (*alloc == SWIG_NEWOBJ) {
3474 85041 : *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
3475 85041 : *alloc = SWIG_NEWOBJ;
3476 : } else {
3477 0 : *cptr = cstr;
3478 0 : *alloc = SWIG_OLDOBJ;
3479 : }
3480 : } else {
3481 : #if PY_VERSION_HEX>=0x03000000
3482 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3483 : *cptr = PyBytes_AsString(obj);
3484 : #else
3485 : assert(0); /* Should never reach here with Unicode strings in Python 3 */
3486 : #endif
3487 : #else
3488 : *cptr = SWIG_Python_str_AsChar(obj);
3489 : if (!*cptr)
3490 : ret = SWIG_TypeError;
3491 : #endif
3492 : }
3493 : }
3494 87971 : if (psize) *psize = len + 1;
3495 : #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3496 87971 : Py_XDECREF(obj);
3497 : #endif
3498 87971 : return ret;
3499 : } else {
3500 : #if defined(SWIG_PYTHON_2_UNICODE)
3501 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3502 : #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3503 : #endif
3504 : #if PY_VERSION_HEX<0x03000000
3505 : if (PyUnicode_Check(obj)) {
3506 : char *cstr; Py_ssize_t len;
3507 : if (!alloc && cptr) {
3508 : return SWIG_RuntimeError;
3509 : }
3510 : obj = PyUnicode_AsUTF8String(obj); if (!obj) return SWIG_TypeError;
3511 : if (!obj)
3512 : return SWIG_TypeError;
3513 : if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3514 : if (cptr) {
3515 : if (alloc) *alloc = SWIG_NEWOBJ;
3516 : *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
3517 : }
3518 : if (psize) *psize = len + 1;
3519 :
3520 : Py_XDECREF(obj);
3521 : return SWIG_OK;
3522 : } else {
3523 : Py_XDECREF(obj);
3524 : }
3525 : }
3526 : #endif
3527 : #endif
3528 :
3529 246 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3530 246 : if (pchar_descriptor) {
3531 246 : void* vptr = 0;
3532 246 : if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3533 203 : if (cptr) *cptr = (char *) vptr;
3534 203 : if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3535 203 : if (alloc) *alloc = SWIG_OLDOBJ;
3536 203 : return SWIG_OK;
3537 : }
3538 : }
3539 : }
3540 : return SWIG_TypeError;
3541 : }
3542 :
3543 :
3544 :
3545 :
3546 0 : SWIGINTERN void GDALMajorObjectShadow_SetDescription(GDALMajorObjectShadow *self,char const *pszNewDesc){
3547 0 : GDALSetDescription( self, pszNewDesc );
3548 0 : }
3549 8 : SWIGINTERN char **GDALMajorObjectShadow_GetMetadataDomainList(GDALMajorObjectShadow *self){
3550 8 : return GDALGetMetadataDomainList( self );
3551 : }
3552 :
3553 420 : static PyObject* CSLToList( char** stringarray, bool *pbErr )
3554 : {
3555 420 : PyObject* res;
3556 420 : if ( stringarray == NULL ) {
3557 45 : res = Py_None;
3558 45 : Py_INCREF( res );
3559 : }
3560 : else {
3561 375 : int len = CSLCount( stringarray );
3562 375 : res = PyList_New( len );
3563 375 : if( !res ) {
3564 0 : *pbErr = true;
3565 0 : return res;
3566 : }
3567 1308 : for ( int i = 0; i < len; ++i ) {
3568 933 : PyObject *o = GDALPythonObjectFromCStr( stringarray[i] );
3569 933 : PyList_SetItem(res, i, o );
3570 : }
3571 : }
3572 420 : *pbErr = false;
3573 420 : return res;
3574 : }
3575 :
3576 75 : SWIGINTERN char **GDALMajorObjectShadow_GetMetadata_Dict(GDALMajorObjectShadow *self,char const *pszDomain=""){
3577 75 : return GDALGetMetadata( self, pszDomain );
3578 : }
3579 :
3580 : /* Return a PyObject* from a C String */
3581 398 : static PyObject* GDALPythonObjectFromCStrAndSize(const char *pszStr, size_t nLen)
3582 : {
3583 398 : const unsigned char* pszIter = (const unsigned char*) pszStr;
3584 3662 : for( size_t i = 0; i < nLen; ++i)
3585 : {
3586 3264 : if (pszIter[i] > 127)
3587 : {
3588 0 : PyObject* pyObj = PyUnicode_DecodeUTF8(pszStr, nLen, "strict");
3589 0 : if (pyObj != NULL && !PyErr_Occurred())
3590 : return pyObj;
3591 0 : PyErr_Clear();
3592 0 : return PyBytes_FromStringAndSize(pszStr, nLen);
3593 : }
3594 : }
3595 398 : return PyUnicode_FromStringAndSize(pszStr, nLen);
3596 : }
3597 :
3598 :
3599 : static PyObject*
3600 80 : GetCSLStringAsPyDict( char **stringarray, bool bFreeCSL ) {
3601 80 : PyObject* dict = PyDict_New();
3602 80 : if ( stringarray != NULL ) {
3603 462 : for (char** iter = stringarray; *iter; ++iter ) {
3604 398 : const char* pszSep = strchr( *iter, '=' );
3605 398 : if ( pszSep != NULL) {
3606 398 : const char* keyptr = *iter;
3607 398 : const char* valptr = pszSep + 1;
3608 398 : PyObject *nm = GDALPythonObjectFromCStrAndSize( keyptr, (size_t)(pszSep - keyptr) );
3609 398 : PyObject *val = GDALPythonObjectFromCStr( valptr );
3610 398 : PyDict_SetItem(dict, nm, val );
3611 398 : Py_DECREF(nm);
3612 398 : Py_DECREF(val);
3613 : }
3614 : }
3615 : }
3616 80 : if( bFreeCSL )
3617 0 : CSLDestroy(stringarray);
3618 80 : return dict;
3619 : }
3620 :
3621 9 : SWIGINTERN char **GDALMajorObjectShadow_GetMetadata_List(GDALMajorObjectShadow *self,char const *pszDomain=""){
3622 9 : return GDALGetMetadata( self, pszDomain );
3623 : }
3624 :
3625 : /************************************************************************/
3626 : /* CSLFromPySequence() */
3627 : /************************************************************************/
3628 955 : static char **CSLFromPySequence( PyObject *pySeq, int *pbErr )
3629 :
3630 : {
3631 955 : *pbErr = FALSE;
3632 : /* Check if is a list (and reject strings, that are seen as sequence of characters) */
3633 955 : if ( ! PySequence_Check(pySeq) || PyUnicode_Check(pySeq) ) {
3634 0 : PyErr_SetString(PyExc_TypeError,"not a sequence");
3635 0 : *pbErr = TRUE;
3636 0 : return NULL;
3637 : }
3638 :
3639 955 : Py_ssize_t size = PySequence_Size(pySeq);
3640 955 : if( size > (Py_ssize_t)(INT_MAX - 1) ) {
3641 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
3642 0 : *pbErr = TRUE;
3643 0 : return NULL;
3644 : }
3645 955 : if( size == 0 ) {
3646 : return NULL;
3647 : }
3648 695 : char** papszRet = (char**) VSICalloc((int)size + 1, sizeof(char*));
3649 695 : if( !papszRet ) {
3650 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
3651 0 : *pbErr = TRUE;
3652 0 : return NULL;
3653 : }
3654 2993 : for (int i = 0; i < (int)size; i++) {
3655 2298 : PyObject* pyObj = PySequence_GetItem(pySeq,i);
3656 2298 : if (PyUnicode_Check(pyObj))
3657 : {
3658 2298 : char *pszStr;
3659 2298 : Py_ssize_t nLen;
3660 2298 : PyObject* pyUTF8Str = PyUnicode_AsUTF8String(pyObj);
3661 2298 : if( !pyUTF8Str )
3662 : {
3663 0 : Py_DECREF(pyObj);
3664 0 : PyErr_SetString(PyExc_TypeError,"invalid Unicode sequence");
3665 0 : CSLDestroy(papszRet);
3666 0 : *pbErr = TRUE;
3667 0 : return NULL;
3668 : }
3669 2298 : PyBytes_AsStringAndSize(pyUTF8Str, &pszStr, &nLen);
3670 2298 : papszRet[i] = VSIStrdup(pszStr);
3671 4572 : Py_XDECREF(pyUTF8Str);
3672 : }
3673 0 : else if (PyBytes_Check(pyObj))
3674 0 : papszRet[i] = VSIStrdup(PyBytes_AsString(pyObj));
3675 : else
3676 : {
3677 0 : Py_DECREF(pyObj);
3678 0 : PyErr_SetString(PyExc_TypeError,"sequence must contain strings");
3679 0 : CSLDestroy(papszRet);
3680 0 : *pbErr = TRUE;
3681 0 : return NULL;
3682 : }
3683 2298 : Py_DECREF(pyObj);
3684 2298 : if( !papszRet[i] )
3685 : {
3686 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
3687 0 : CSLDestroy(papszRet);
3688 0 : *pbErr = TRUE;
3689 0 : return NULL;
3690 : }
3691 : }
3692 : return papszRet;
3693 : }
3694 :
3695 :
3696 55 : static char **CSLFromPyMapping( PyObject *pyObj, int *pbErr )
3697 :
3698 : {
3699 55 : char** retCSL = NULL;
3700 55 : Py_ssize_t size = PyMapping_Length( pyObj );
3701 55 : if ( size > 0 && size == (int)size) {
3702 55 : PyObject *item_list = PyMapping_Items( pyObj );
3703 116 : for( int i=0; i<(int)size; i++ ) {
3704 61 : PyObject *it = PySequence_GetItem( item_list, i );
3705 :
3706 61 : PyObject *k, *v;
3707 61 : if ( ! PyArg_ParseTuple( it, "OO", &k, &v ) ) {
3708 0 : Py_DECREF(it);
3709 0 : Py_DECREF(item_list);
3710 0 : PyErr_SetString(PyExc_TypeError,"Cannot retrieve key/value");
3711 0 : CSLDestroy(retCSL);
3712 0 : *pbErr = TRUE;
3713 0 : return NULL;
3714 : }
3715 :
3716 61 : PyObject* kStr = PyObject_Str(k);
3717 61 : if( PyErr_Occurred() )
3718 : {
3719 0 : Py_DECREF(it);
3720 0 : Py_DECREF(item_list);
3721 0 : CSLDestroy(retCSL);
3722 0 : *pbErr = TRUE;
3723 0 : return NULL;
3724 : }
3725 :
3726 61 : PyObject* vStr;
3727 61 : if( PyBytes_Check(v) )
3728 : {
3729 0 : vStr = v;
3730 0 : Py_INCREF(vStr);
3731 : }
3732 : else
3733 : {
3734 61 : vStr = PyObject_Str(v);
3735 61 : if( PyErr_Occurred() )
3736 : {
3737 0 : Py_DECREF(it);
3738 0 : Py_DECREF(kStr);
3739 0 : Py_DECREF(item_list);
3740 0 : CSLDestroy(retCSL);
3741 0 : *pbErr = TRUE;
3742 0 : return NULL;
3743 : }
3744 : }
3745 :
3746 61 : int bFreeK, bFreeV;
3747 61 : char* pszK = GDALPythonObjectToCStr(kStr, &bFreeK);
3748 61 : char* pszV = GDALPythonObjectToCStr(vStr, &bFreeV);
3749 61 : if( pszK == NULL || pszV == NULL )
3750 : {
3751 0 : GDALPythonFreeCStr(pszK, bFreeK);
3752 0 : GDALPythonFreeCStr(pszV, bFreeV);
3753 0 : Py_DECREF(kStr);
3754 0 : Py_DECREF(vStr);
3755 0 : Py_DECREF(it);
3756 0 : Py_DECREF(item_list);
3757 0 : PyErr_SetString(PyExc_TypeError,"Cannot get key/value as string");
3758 0 : CSLDestroy(retCSL);
3759 0 : *pbErr = TRUE;
3760 0 : return NULL;
3761 : }
3762 61 : retCSL = CSLAddNameValue( retCSL, pszK, pszV );
3763 :
3764 61 : GDALPythonFreeCStr(pszK, bFreeK);
3765 61 : GDALPythonFreeCStr(pszV, bFreeV);
3766 61 : Py_DECREF(kStr);
3767 61 : Py_DECREF(vStr);
3768 61 : Py_DECREF(it);
3769 : }
3770 55 : Py_DECREF(item_list);
3771 : }
3772 55 : *pbErr = FALSE;
3773 55 : return retCSL;
3774 : }
3775 :
3776 : SWIGINTERN CPLErr GDALMajorObjectShadow_SetMetadata__SWIG_0(GDALMajorObjectShadow *self,char **papszMetadata,char const *pszDomain=""){
3777 : return GDALSetMetadata( self, papszMetadata, pszDomain );
3778 : }
3779 : SWIGINTERN CPLErr GDALMajorObjectShadow_SetMetadata__SWIG_1(GDALMajorObjectShadow *self,char *pszMetadataString,char const *pszDomain=""){
3780 : char *tmpList[2];
3781 : tmpList[0] = pszMetadataString;
3782 : tmpList[1] = 0;
3783 : return GDALSetMetadata( self, tmpList, pszDomain );
3784 : }
3785 478 : SWIGINTERN char const *GDALMajorObjectShadow_GetMetadataItem(GDALMajorObjectShadow *self,char const *pszName,char const *pszDomain=""){
3786 478 : return GDALGetMetadataItem( self, pszName, pszDomain);
3787 : }
3788 295 : SWIGINTERN CPLErr GDALMajorObjectShadow_SetMetadataItem(GDALMajorObjectShadow *self,char const *pszName,char const *pszValue,char const *pszDomain=""){
3789 295 : return GDALSetMetadataItem( self, pszName, pszValue, pszDomain);
3790 : }
3791 :
3792 4532 : int GetGEOSVersionMajor() {
3793 4532 : int num;
3794 4532 : OGRGetGEOSVersion(&num, NULL, NULL);
3795 4532 : return num;
3796 : }
3797 :
3798 250 : int GetGEOSVersionMinor() {
3799 250 : int num;
3800 250 : OGRGetGEOSVersion(NULL, &num, NULL);
3801 250 : return num;
3802 : }
3803 :
3804 250 : int GetGEOSVersionMicro() {
3805 250 : int num;
3806 250 : OGRGetGEOSVersion(NULL, NULL, &num);
3807 250 : return num;
3808 : }
3809 :
3810 4 : SWIGINTERN OGRStyleTableShadow *new_OGRStyleTableShadow(){
3811 4 : return (OGRStyleTableShadow*) OGR_STBL_Create();
3812 : }
3813 4 : SWIGINTERN void delete_OGRStyleTableShadow(OGRStyleTableShadow *self){
3814 4 : OGR_STBL_Destroy( (OGRStyleTableH) self );
3815 4 : }
3816 5 : SWIGINTERN int OGRStyleTableShadow_AddStyle(OGRStyleTableShadow *self,char const *pszName,char const *pszStyleString){
3817 5 : return OGR_STBL_AddStyle( (OGRStyleTableH) self, pszName, pszStyleString);
3818 : }
3819 2 : SWIGINTERN int OGRStyleTableShadow_LoadStyleTable(OGRStyleTableShadow *self,char const *utf8_path){
3820 2 : return OGR_STBL_LoadStyleTable( (OGRStyleTableH) self, utf8_path );
3821 : }
3822 2 : SWIGINTERN int OGRStyleTableShadow_SaveStyleTable(OGRStyleTableShadow *self,char const *utf8_path){
3823 2 : return OGR_STBL_SaveStyleTable( (OGRStyleTableH) self, utf8_path );
3824 : }
3825 2 : SWIGINTERN char const *OGRStyleTableShadow_Find(OGRStyleTableShadow *self,char const *pszName){
3826 2 : return OGR_STBL_Find( (OGRStyleTableH) self, pszName );
3827 : }
3828 1 : SWIGINTERN void OGRStyleTableShadow_ResetStyleStringReading(OGRStyleTableShadow *self){
3829 1 : OGR_STBL_ResetStyleStringReading( (OGRStyleTableH) self );
3830 1 : }
3831 5 : SWIGINTERN char const *OGRStyleTableShadow_GetNextStyle(OGRStyleTableShadow *self){
3832 5 : return OGR_STBL_GetNextStyle( (OGRStyleTableH) self );
3833 : }
3834 1 : SWIGINTERN char const *OGRStyleTableShadow_GetLastStyleName(OGRStyleTableShadow *self){
3835 1 : return OGR_STBL_GetLastStyleName( (OGRStyleTableH) self );
3836 : }
3837 4 : SWIGINTERN ArrowArray *new_ArrowArray(){
3838 4 : return (struct ArrowArray* )calloc(1, sizeof(struct ArrowArray));
3839 : }
3840 571 : SWIGINTERN void delete_ArrowArray(ArrowArray *self){
3841 571 : if( self->release )
3842 514 : self->release(self);
3843 571 : free(self);
3844 : }
3845 527 : SWIGINTERN VoidPtrAsLong ArrowArray__getPtr(ArrowArray *self){
3846 527 : return self;
3847 : }
3848 1 : SWIGINTERN GIntBig ArrowArray_GetChildrenCount(ArrowArray *self){
3849 1 : return self->n_children;
3850 : }
3851 0 : SWIGINTERN GIntBig ArrowArray_GetLength(ArrowArray *self){
3852 0 : return self->length;
3853 : }
3854 126 : SWIGINTERN ArrowSchema *new_ArrowSchema(){
3855 126 : return (struct ArrowSchema* )calloc(1, sizeof(struct ArrowSchema));
3856 : }
3857 506 : SWIGINTERN void delete_ArrowSchema(ArrowSchema *self){
3858 506 : if( self->release )
3859 425 : self->release(self);
3860 506 : free(self);
3861 : }
3862 682 : SWIGINTERN VoidPtrAsLong ArrowSchema__getPtr(ArrowSchema *self){
3863 682 : return self;
3864 : }
3865 426 : SWIGINTERN char const *ArrowSchema_GetName(ArrowSchema *self){
3866 426 : return self->name;
3867 : }
3868 26 : SWIGINTERN GIntBig ArrowSchema_GetChildrenCount(ArrowSchema *self){
3869 26 : return self->n_children;
3870 : }
3871 833 : SWIGINTERN ArrowSchema const *ArrowSchema_GetChild(ArrowSchema *self,int iChild){
3872 833 : if( iChild < 0 || iChild >= self->n_children )
3873 : {
3874 0 : CPLError(CE_Failure, CPLE_AppDefined, "Wrong index");
3875 0 : return NULL;
3876 : }
3877 833 : return self->children[iChild];
3878 : }
3879 350 : SWIGINTERN void delete_ArrowArrayStream(ArrowArrayStream *self){
3880 350 : if( self->release )
3881 350 : self->release(self);
3882 350 : free(self);
3883 : }
3884 380 : SWIGINTERN ArrowSchema *ArrowArrayStream_GetSchema(ArrowArrayStream *self){
3885 380 : struct ArrowSchema* schema = (struct ArrowSchema* )malloc(sizeof(struct ArrowSchema));
3886 380 : if( self->get_schema(self, schema) == 0 )
3887 : {
3888 : return schema;
3889 : }
3890 : else
3891 : {
3892 0 : free(schema);
3893 0 : return NULL;
3894 : }
3895 : }
3896 : SWIGINTERN ArrowArray *ArrowArrayStream_GetNextRecordBatch(ArrowArrayStream *self,char **options=NULL){
3897 : struct ArrowArray* array = (struct ArrowArray* )malloc(sizeof(struct ArrowArray));
3898 : if( self->get_next(self, array) == 0 && array->release != NULL )
3899 : {
3900 : return array;
3901 : }
3902 : else
3903 : {
3904 : free(array);
3905 : return NULL;
3906 : }
3907 : }
3908 :
3909 15 : static void ReleaseArrowArrayStreamPyCapsule(PyObject* capsule) {
3910 15 : struct ArrowArrayStream* stream =
3911 15 : (struct ArrowArrayStream*)PyCapsule_GetPointer(capsule, "arrow_array_stream");
3912 15 : if (stream->release != NULL) {
3913 3 : stream->release(stream);
3914 : }
3915 15 : CPLFree(stream);
3916 15 : }
3917 :
3918 11 : static char** ParseArrowMetadata(const char *pabyMetadata)
3919 : {
3920 11 : char** ret = NULL;
3921 11 : int32_t nKVP;
3922 11 : memcpy(&nKVP, pabyMetadata, sizeof(int32_t));
3923 11 : pabyMetadata += sizeof(int32_t);
3924 22 : for (int i = 0; i < nKVP; ++i)
3925 : {
3926 11 : int32_t nSizeKey;
3927 11 : memcpy(&nSizeKey, pabyMetadata, sizeof(int32_t));
3928 11 : pabyMetadata += sizeof(int32_t);
3929 22 : std::string osKey;
3930 11 : osKey.assign(pabyMetadata, nSizeKey);
3931 11 : pabyMetadata += nSizeKey;
3932 :
3933 11 : int32_t nSizeValue;
3934 11 : memcpy(&nSizeValue, pabyMetadata, sizeof(int32_t));
3935 11 : pabyMetadata += sizeof(int32_t);
3936 22 : std::string osValue;
3937 11 : osValue.assign(pabyMetadata, nSizeValue);
3938 11 : pabyMetadata += nSizeValue;
3939 :
3940 11 : ret = CSLSetNameValue(ret, osKey.c_str(), osValue.c_str());
3941 : }
3942 :
3943 11 : return ret;
3944 : }
3945 :
3946 : // Create output fields using CreateFieldFromArrowSchema()
3947 : static bool CreateFieldsFromArrowSchema(OGRLayerH hDstLayer,
3948 : const struct ArrowSchema* schemaSrc,
3949 : char** options)
3950 : {
3951 : for (int i = 0; i < schemaSrc->n_children; ++i)
3952 : {
3953 : const char *metadata =
3954 : schemaSrc->children[i]->metadata;
3955 : if( metadata )
3956 : {
3957 : char** keyValues = ParseArrowMetadata(metadata);
3958 : const char *ARROW_EXTENSION_NAME_KEY = "ARROW:extension:name";
3959 : const char *EXTENSION_NAME_OGC_WKB = "ogc.wkb";
3960 : const char *EXTENSION_NAME_GEOARROW_WKB = "geoarrow.wkb";
3961 : const char* value = CSLFetchNameValue(keyValues, ARROW_EXTENSION_NAME_KEY);
3962 : const bool bSkip = ( value && (EQUAL(value, EXTENSION_NAME_OGC_WKB) || EQUAL(value, EXTENSION_NAME_GEOARROW_WKB)) );
3963 : CSLDestroy(keyValues);
3964 : if( bSkip )
3965 : continue;
3966 : }
3967 :
3968 : const char *pszFieldName =
3969 : schemaSrc->children[i]->name;
3970 : if (!EQUAL(pszFieldName, "OGC_FID") &&
3971 : !EQUAL(pszFieldName, "wkb_geometry") &&
3972 : !OGR_L_CreateFieldFromArrowSchema(
3973 : hDstLayer, schemaSrc->children[i], options))
3974 : {
3975 : CPLError(CE_Failure, CPLE_AppDefined,
3976 : "Cannot create field %s",
3977 : pszFieldName);
3978 : return false;
3979 : }
3980 : }
3981 : return true;
3982 : }
3983 :
3984 :
3985 264 : SWIGINTERN GDALDatasetShadow *OGRLayerShadow_GetDataset(OGRLayerShadow *self){
3986 264 : return OGR_L_GetDataset(self);
3987 : }
3988 29 : SWIGINTERN OGRErr OGRLayerShadow_Rename(OGRLayerShadow *self,char const *new_name){
3989 29 : return OGR_L_Rename( self, new_name);
3990 : }
3991 :
3992 :
3993 : #include "ogr_core.h"
3994 : static char const *
3995 5718 : OGRErrMessages( int rc ) {
3996 5718 : switch( rc ) {
3997 : case OGRERR_NONE:
3998 : return "OGR Error: None";
3999 2172 : case OGRERR_NOT_ENOUGH_DATA:
4000 2172 : return "OGR Error: Not enough data to deserialize";
4001 0 : case OGRERR_NOT_ENOUGH_MEMORY:
4002 0 : return "OGR Error: Not enough memory";
4003 1098 : case OGRERR_UNSUPPORTED_GEOMETRY_TYPE:
4004 1098 : return "OGR Error: Unsupported geometry type";
4005 0 : case OGRERR_UNSUPPORTED_OPERATION:
4006 0 : return "OGR Error: Unsupported operation";
4007 2372 : case OGRERR_CORRUPT_DATA:
4008 2372 : return "OGR Error: Corrupt data";
4009 71 : case OGRERR_FAILURE:
4010 71 : return "OGR Error: General Error";
4011 0 : case OGRERR_UNSUPPORTED_SRS:
4012 0 : return "OGR Error: Unsupported SRS";
4013 0 : case OGRERR_INVALID_HANDLE:
4014 0 : return "OGR Error: Invalid handle";
4015 5 : case OGRERR_NON_EXISTING_FEATURE:
4016 5 : return "OGR Error: Non existing feature";
4017 0 : default:
4018 0 : return "OGR Error: Unknown";
4019 : }
4020 : }
4021 :
4022 0 : SWIGINTERN int OGRLayerShadow_GetRefCount(OGRLayerShadow *self){
4023 0 : return OGR_L_GetRefCount(self);
4024 : }
4025 : SWIGINTERN void OGRLayerShadow_SetSpatialFilter__SWIG_0(OGRLayerShadow *self,OGRGeometryShadow *filter){
4026 : OGR_L_SetSpatialFilter (self, filter);
4027 : }
4028 : SWIGINTERN void OGRLayerShadow_SetSpatialFilterRect__SWIG_0(OGRLayerShadow *self,double minx,double miny,double maxx,double maxy){
4029 : OGR_L_SetSpatialFilterRect(self, minx, miny, maxx, maxy);
4030 : }
4031 : SWIGINTERN void OGRLayerShadow_SetSpatialFilter__SWIG_1(OGRLayerShadow *self,int iGeomField,OGRGeometryShadow *filter){
4032 : OGR_L_SetSpatialFilterEx (self, iGeomField, filter);
4033 : }
4034 : SWIGINTERN void OGRLayerShadow_SetSpatialFilterRect__SWIG_1(OGRLayerShadow *self,int iGeomField,double minx,double miny,double maxx,double maxy){
4035 : OGR_L_SetSpatialFilterRectEx(self, iGeomField, minx, miny, maxx, maxy);
4036 : }
4037 5 : SWIGINTERN OGRGeometryShadow *OGRLayerShadow_GetSpatialFilter(OGRLayerShadow *self){
4038 5 : return (OGRGeometryShadow *) OGR_L_GetSpatialFilter(self);
4039 : }
4040 1443 : SWIGINTERN OGRErr OGRLayerShadow_SetAttributeFilter(OGRLayerShadow *self,char *filter_string){
4041 1443 : return OGR_L_SetAttributeFilter((OGRLayerShadow*)self, filter_string);
4042 : }
4043 17639 : SWIGINTERN void OGRLayerShadow_ResetReading(OGRLayerShadow *self){
4044 17639 : OGR_L_ResetReading(self);
4045 17639 : }
4046 1221 : SWIGINTERN char const *OGRLayerShadow_GetName(OGRLayerShadow *self){
4047 1221 : return OGR_L_GetName(self);
4048 : }
4049 1102 : SWIGINTERN OGRwkbGeometryType OGRLayerShadow_GetGeomType(OGRLayerShadow *self){
4050 1102 : return (OGRwkbGeometryType) OGR_L_GetGeomType(self);
4051 : }
4052 688 : SWIGINTERN char const *OGRLayerShadow_GetGeometryColumn(OGRLayerShadow *self){
4053 688 : return OGR_L_GetGeometryColumn(self);
4054 : }
4055 385 : SWIGINTERN char const *OGRLayerShadow_GetFIDColumn(OGRLayerShadow *self){
4056 385 : return OGR_L_GetFIDColumn(self);
4057 : }
4058 2528 : SWIGINTERN OGRFeatureShadow *OGRLayerShadow_GetFeature(OGRLayerShadow *self,GIntBig fid){
4059 2528 : return (OGRFeatureShadow*) OGR_L_GetFeature(self, fid);
4060 : }
4061 79097 : SWIGINTERN OGRFeatureShadow *OGRLayerShadow_GetNextFeature(OGRLayerShadow *self){
4062 79097 : return (OGRFeatureShadow*) OGR_L_GetNextFeature(self);
4063 : }
4064 39 : SWIGINTERN OGRErr OGRLayerShadow_SetNextByIndex(OGRLayerShadow *self,GIntBig new_index){
4065 39 : return OGR_L_SetNextByIndex(self, new_index);
4066 : }
4067 2478 : SWIGINTERN OGRErr OGRLayerShadow_SetFeature(OGRLayerShadow *self,OGRFeatureShadow *feature){
4068 2478 : return OGR_L_SetFeature(self, feature);
4069 : }
4070 281907 : SWIGINTERN OGRErr OGRLayerShadow_CreateFeature(OGRLayerShadow *self,OGRFeatureShadow *feature){
4071 281907 : return OGR_L_CreateFeature(self, feature);
4072 : }
4073 31 : SWIGINTERN OGRErr OGRLayerShadow_UpsertFeature(OGRLayerShadow *self,OGRFeatureShadow *feature){
4074 31 : return OGR_L_UpsertFeature(self, feature);
4075 : }
4076 :
4077 : static int*
4078 114 : CreateCIntListFromSequence( PyObject* pySeq, int* pnSize ) {
4079 : /* check if is List */
4080 114 : if ( !PySequence_Check(pySeq) ) {
4081 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
4082 0 : *pnSize = -1;
4083 0 : return NULL;
4084 : }
4085 114 : Py_ssize_t size = PySequence_Size(pySeq);
4086 114 : if( size > (Py_ssize_t)INT_MAX ) {
4087 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
4088 0 : *pnSize = -1;
4089 0 : return NULL;
4090 : }
4091 114 : if( (size_t)size > SIZE_MAX / sizeof(int) ) {
4092 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
4093 0 : *pnSize = -1;
4094 0 : return NULL;
4095 : }
4096 114 : *pnSize = (int)size;
4097 114 : int* ret = (int*) malloc((*pnSize)*sizeof(int));
4098 114 : if( !ret ) {
4099 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
4100 0 : *pnSize = -1;
4101 0 : return NULL;
4102 : }
4103 241 : for( int i = 0; i<*pnSize; i++ ) {
4104 127 : PyObject *o = PySequence_GetItem(pySeq,i);
4105 127 : if ( !PyArg_Parse(o,"i",&ret[i]) ) {
4106 0 : PyErr_SetString(PyExc_TypeError, "not an integer");
4107 0 : Py_DECREF(o);
4108 0 : free(ret);
4109 0 : *pnSize = -1;
4110 0 : return NULL;
4111 : }
4112 127 : Py_DECREF(o);
4113 : }
4114 : return ret;
4115 : }
4116 :
4117 :
4118 : SWIGINTERN int
4119 46 : SWIG_AsVal_bool (PyObject *obj, bool *val)
4120 : {
4121 46 : int r;
4122 46 : if (!PyBool_Check(obj))
4123 : return SWIG_ERROR;
4124 46 : r = PyObject_IsTrue(obj);
4125 46 : if (r == -1)
4126 : return SWIG_ERROR;
4127 46 : if (val) *val = r ? true : false;
4128 : return SWIG_OK;
4129 : }
4130 :
4131 31 : SWIGINTERN OGRErr OGRLayerShadow_UpdateFeature(OGRLayerShadow *self,OGRFeatureShadow *feature,int nUpdatedFieldsCount,int const *panUpdatedFieldsIdx,int nUpdatedGeomFieldsCount,int const *panUpdatedGeomFieldsIdx,bool bUpdateStyleString){
4132 31 : return OGR_L_UpdateFeature(self, feature,
4133 : nUpdatedFieldsCount,
4134 : panUpdatedFieldsIdx,
4135 : nUpdatedGeomFieldsCount,
4136 : panUpdatedGeomFieldsIdx,
4137 : bUpdateStyleString);
4138 : }
4139 3355 : SWIGINTERN OGRErr OGRLayerShadow_DeleteFeature(OGRLayerShadow *self,GIntBig fid){
4140 3355 : return OGR_L_DeleteFeature(self, fid);
4141 : }
4142 251 : SWIGINTERN OGRErr OGRLayerShadow_SyncToDisk(OGRLayerShadow *self){
4143 251 : return OGR_L_SyncToDisk(self);
4144 : }
4145 126733 : SWIGINTERN OGRFeatureDefnShadow *OGRLayerShadow_GetLayerDefn(OGRLayerShadow *self){
4146 253466 : auto defn = (OGRFeatureDefnShadow*) OGR_L_GetLayerDefn(self);
4147 126733 : if (defn)
4148 126733 : OGR_FD_Reference(defn);
4149 126733 : return defn;
4150 : }
4151 36757 : SWIGINTERN GIntBig OGRLayerShadow_GetFeatureCount(OGRLayerShadow *self,int force=1){
4152 36757 : return OGR_L_GetFeatureCount(self, force);
4153 : }
4154 :
4155 : static PyObject *
4156 13793 : CreateTupleFromDoubleArray( const double *first, size_t size ) {
4157 13793 : PyObject *out = PyTuple_New( size );
4158 68880 : for( unsigned int i=0; i<size; i++ ) {
4159 55087 : PyObject *val = PyFloat_FromDouble( *first );
4160 55087 : ++first;
4161 55087 : PyTuple_SetItem( out, i, val );
4162 : }
4163 13793 : return out;
4164 : }
4165 :
4166 372 : SWIGINTERN void OGRLayerShadow_GetExtent(OGRLayerShadow *self,double argout[4],int *isvalid=NULL,int force=1,int can_return_null=0,int geom_field=0){
4167 744 : OGRErr eErr = OGR_L_GetExtentEx(self, geom_field, (OGREnvelope*)argout, force);
4168 372 : if (can_return_null)
4169 36 : *isvalid = (eErr == 0);
4170 : else
4171 : *isvalid = TRUE;
4172 372 : return;
4173 : }
4174 60 : SWIGINTERN void OGRLayerShadow_GetExtent3D(OGRLayerShadow *self,double argout[6],int *isvalid=NULL,int force=1,int can_return_null=0,int geom_field=0){
4175 120 : OGRErr eErr = OGR_L_GetExtent3D(self, geom_field, (OGREnvelope3D*)argout, force);
4176 60 : if (can_return_null)
4177 1 : *isvalid = (eErr == 0);
4178 : else
4179 : *isvalid = TRUE;
4180 60 : return;
4181 : }
4182 753 : SWIGINTERN bool OGRLayerShadow_TestCapability(OGRLayerShadow *self,char const *cap){
4183 1506 : return (OGR_L_TestCapability(self, cap) > 0);
4184 : }
4185 :
4186 : SWIGINTERNINLINE PyObject*
4187 37457 : SWIG_From_bool (bool value)
4188 : {
4189 37457 : return PyBool_FromLong(value ? 1 : 0);
4190 : }
4191 :
4192 77219 : SWIGINTERN OGRErr OGRLayerShadow_CreateField(OGRLayerShadow *self,OGRFieldDefnShadow *field_def,int approx_ok=1){
4193 77219 : return OGR_L_CreateField(self, field_def, approx_ok);
4194 : }
4195 372 : SWIGINTERN OGRErr OGRLayerShadow_DeleteField(OGRLayerShadow *self,int iField){
4196 372 : return OGR_L_DeleteField(self, iField);
4197 : }
4198 34 : SWIGINTERN OGRErr OGRLayerShadow_ReorderField(OGRLayerShadow *self,int iOldFieldPos,int iNewFieldPos){
4199 34 : return OGR_L_ReorderField(self, iOldFieldPos, iNewFieldPos);
4200 : }
4201 43 : SWIGINTERN OGRErr OGRLayerShadow_ReorderFields(OGRLayerShadow *self,int nList,int *pList){
4202 43 : if (nList != OGR_FD_GetFieldCount(OGR_L_GetLayerDefn(self)))
4203 : {
4204 0 : CPLError(CE_Failure, CPLE_IllegalArg,
4205 : "List should have %d elements",
4206 : OGR_FD_GetFieldCount(OGR_L_GetLayerDefn(self)));
4207 0 : return 6;
4208 : }
4209 43 : return OGR_L_ReorderFields(self, pList);
4210 : }
4211 126 : SWIGINTERN OGRErr OGRLayerShadow_AlterFieldDefn(OGRLayerShadow *self,int iField,OGRFieldDefnShadow *field_def,int nFlags){
4212 126 : return OGR_L_AlterFieldDefn(self, iField, field_def, nFlags);
4213 : }
4214 33 : SWIGINTERN OGRErr OGRLayerShadow_AlterGeomFieldDefn(OGRLayerShadow *self,int iGeomField,OGRGeomFieldDefnShadow const *field_def,int nFlags){
4215 33 : return OGR_L_AlterGeomFieldDefn(self, iGeomField, const_cast<OGRGeomFieldDefnShadow*>(field_def), nFlags);
4216 : }
4217 120 : SWIGINTERN OGRErr OGRLayerShadow_CreateGeomField(OGRLayerShadow *self,OGRGeomFieldDefnShadow *field_def,int approx_ok=1){
4218 120 : return OGR_L_CreateGeomField(self, field_def, approx_ok);
4219 : }
4220 149 : SWIGINTERN OGRErr OGRLayerShadow_StartTransaction(OGRLayerShadow *self){
4221 149 : return OGR_L_StartTransaction(self);
4222 : }
4223 129 : SWIGINTERN OGRErr OGRLayerShadow_CommitTransaction(OGRLayerShadow *self){
4224 129 : return OGR_L_CommitTransaction(self);
4225 : }
4226 26 : SWIGINTERN OGRErr OGRLayerShadow_RollbackTransaction(OGRLayerShadow *self){
4227 26 : return OGR_L_RollbackTransaction(self);
4228 : }
4229 2 : SWIGINTERN int OGRLayerShadow_FindFieldIndex(OGRLayerShadow *self,char const *pszFieldName,int bExactMatch){
4230 2 : return OGR_L_FindFieldIndex(self, pszFieldName, bExactMatch );
4231 : }
4232 908 : SWIGINTERN OSRSpatialReferenceShadow *OGRLayerShadow_GetSpatialRef(OGRLayerShadow *self){
4233 1816 : OGRSpatialReferenceH ref = OGR_L_GetSpatialRef(self);
4234 908 : if( ref )
4235 788 : OSRReference(ref);
4236 908 : return (OSRSpatialReferenceShadow*) ref;
4237 : }
4238 0 : SWIGINTERN GIntBig OGRLayerShadow_GetFeaturesRead(OGRLayerShadow *self){
4239 0 : return OGR_L_GetFeaturesRead(self);
4240 : }
4241 265 : SWIGINTERN OGRErr OGRLayerShadow_SetIgnoredFields(OGRLayerShadow *self,char const **options){
4242 265 : return OGR_L_SetIgnoredFields( self, options );
4243 : }
4244 7 : SWIGINTERN OGRErr OGRLayerShadow_Intersection(OGRLayerShadow *self,OGRLayerShadow *method_layer,OGRLayerShadow *result_layer,char **options=NULL,GDALProgressFunc callback=NULL,void *callback_data=NULL){
4245 7 : return OGR_L_Intersection( self, method_layer, result_layer, options, callback, callback_data );
4246 : }
4247 7 : SWIGINTERN OGRErr OGRLayerShadow_Union(OGRLayerShadow *self,OGRLayerShadow *method_layer,OGRLayerShadow *result_layer,char **options=NULL,GDALProgressFunc callback=NULL,void *callback_data=NULL){
4248 7 : return OGR_L_Union( self, method_layer, result_layer, options, callback, callback_data );
4249 : }
4250 4 : SWIGINTERN OGRErr OGRLayerShadow_SymDifference(OGRLayerShadow *self,OGRLayerShadow *method_layer,OGRLayerShadow *result_layer,char **options=NULL,GDALProgressFunc callback=NULL,void *callback_data=NULL){
4251 4 : return OGR_L_SymDifference( self, method_layer, result_layer, options, callback, callback_data );
4252 : }
4253 6 : SWIGINTERN OGRErr OGRLayerShadow_Identity(OGRLayerShadow *self,OGRLayerShadow *method_layer,OGRLayerShadow *result_layer,char **options=NULL,GDALProgressFunc callback=NULL,void *callback_data=NULL){
4254 6 : return OGR_L_Identity( self, method_layer, result_layer, options, callback, callback_data );
4255 : }
4256 5 : SWIGINTERN OGRErr OGRLayerShadow_Update(OGRLayerShadow *self,OGRLayerShadow *method_layer,OGRLayerShadow *result_layer,char **options=NULL,GDALProgressFunc callback=NULL,void *callback_data=NULL){
4257 5 : return OGR_L_Update( self, method_layer, result_layer, options, callback, callback_data );
4258 : }
4259 3 : SWIGINTERN OGRErr OGRLayerShadow_Clip(OGRLayerShadow *self,OGRLayerShadow *method_layer,OGRLayerShadow *result_layer,char **options=NULL,GDALProgressFunc callback=NULL,void *callback_data=NULL){
4260 3 : return OGR_L_Clip( self, method_layer, result_layer, options, callback, callback_data );
4261 : }
4262 6 : SWIGINTERN OGRErr OGRLayerShadow_Erase(OGRLayerShadow *self,OGRLayerShadow *method_layer,OGRLayerShadow *result_layer,char **options=NULL,GDALProgressFunc callback=NULL,void *callback_data=NULL){
4263 6 : return OGR_L_Erase( self, method_layer, result_layer, options, callback, callback_data );
4264 : }
4265 3 : SWIGINTERN OGRStyleTableShadow *OGRLayerShadow_GetStyleTable(OGRLayerShadow *self){
4266 3 : return (OGRStyleTableShadow*) OGR_L_GetStyleTable(self);
4267 : }
4268 2 : SWIGINTERN void OGRLayerShadow_SetStyleTable(OGRLayerShadow *self,OGRStyleTableShadow *table){
4269 2 : if( table != NULL )
4270 1 : OGR_L_SetStyleTable(self, (OGRStyleTableH) table);
4271 : }
4272 16 : SWIGINTERN PyObject *OGRLayerShadow_ExportArrowArrayStreamPyCapsule(OGRLayerShadow *self,char **options=NULL){
4273 16 : struct ArrowArrayStream* stream =
4274 16 : (struct ArrowArrayStream*)CPLMalloc(sizeof(struct ArrowArrayStream));
4275 :
4276 16 : const int success = OGR_L_GetArrowStream(self, stream, options);
4277 :
4278 16 : PyObject* ret;
4279 16 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4280 16 : if( success )
4281 : {
4282 15 : ret = PyCapsule_New(stream, "arrow_array_stream", ReleaseArrowArrayStreamPyCapsule);
4283 : }
4284 : else
4285 : {
4286 1 : CPLFree(stream);
4287 1 : Py_INCREF(Py_None);
4288 1 : ret = Py_None;
4289 : }
4290 :
4291 16 : SWIG_PYTHON_THREAD_END_BLOCK;
4292 :
4293 16 : return ret;
4294 : }
4295 352 : SWIGINTERN ArrowArrayStream *OGRLayerShadow_GetArrowStream(OGRLayerShadow *self,char **options=NULL){
4296 352 : struct ArrowArrayStream* stream = (struct ArrowArrayStream* )malloc(sizeof(struct ArrowArrayStream));
4297 352 : if( OGR_L_GetArrowStream(self, stream, options) )
4298 : return stream;
4299 : else
4300 : {
4301 2 : free(stream);
4302 2 : return NULL;
4303 : }
4304 : }
4305 19 : SWIGINTERN void OGRLayerShadow_IsArrowSchemaSupported(OGRLayerShadow *self,ArrowSchema const *schema,bool *pbRet,char **errorMsg,char **options=NULL){
4306 38 : *pbRet = OGR_L_IsArrowSchemaSupported(self, schema, options, errorMsg);
4307 : }
4308 526 : SWIGINTERN OGRErr OGRLayerShadow_CreateFieldFromArrowSchema(OGRLayerShadow *self,ArrowSchema const *schema,char **options=NULL){
4309 526 : return OGR_L_CreateFieldFromArrowSchema(self, schema, options) ? 0 : 6;
4310 : }
4311 47 : SWIGINTERN OGRErr OGRLayerShadow_WriteArrowBatch(OGRLayerShadow *self,ArrowSchema const *schema,ArrowArray *array,char **options=NULL){
4312 47 : return OGR_L_WriteArrowBatch(self, schema, array, options) ? 0 : 6;
4313 : }
4314 12 : SWIGINTERN OGRErr OGRLayerShadow_WriteArrowStreamCapsule(OGRLayerShadow *self,PyObject *capsule,int createFieldsFromSchema,char **options=NULL){
4315 12 : ArrowArrayStream* stream = (ArrowArrayStream*)PyCapsule_GetPointer(capsule, "arrow_array_stream");
4316 12 : if( !stream )
4317 : {
4318 0 : CPLError(CE_Failure, CPLE_AppDefined, "PyCapsule_GetPointer(capsule, \"arrow_array_stream\") failed");
4319 0 : return 6;
4320 : }
4321 12 : if( stream->release == NULL )
4322 : {
4323 0 : CPLError(CE_Failure, CPLE_AppDefined, "stream->release == NULL");
4324 0 : return 6;
4325 : }
4326 :
4327 12 : ArrowSchema schema;
4328 12 : if( stream->get_schema(stream, &schema) != 0 )
4329 : {
4330 0 : stream->release(stream);
4331 0 : return 6;
4332 : }
4333 :
4334 12 : if( createFieldsFromSchema == TRUE ||
4335 12 : (createFieldsFromSchema == -1 && OGR_FD_GetFieldCount(OGR_L_GetLayerDefn(self)) == 0) )
4336 : {
4337 12 : if( !CreateFieldsFromArrowSchema(self, &schema, options) )
4338 : {
4339 0 : schema.release(&schema);
4340 0 : stream->release(stream);
4341 0 : return 6;
4342 : }
4343 : }
4344 :
4345 36 : while( true )
4346 : {
4347 24 : ArrowArray array;
4348 24 : if( stream->get_next(stream, &array) == 0 )
4349 : {
4350 24 : if( array.release == NULL )
4351 : break;
4352 12 : if( !OGR_L_WriteArrowBatch(self, &schema, &array, options) )
4353 : {
4354 0 : if( array.release )
4355 0 : array.release(&array);
4356 0 : schema.release(&schema);
4357 0 : stream->release(stream);
4358 0 : return 6;
4359 : }
4360 12 : if( array.release )
4361 12 : array.release(&array);
4362 : }
4363 : else
4364 : {
4365 0 : CPLError(CE_Failure, CPLE_AppDefined, "stream->get_next(stream, &array) failed");
4366 0 : schema.release(&schema);
4367 0 : stream->release(stream);
4368 0 : return 6;
4369 : }
4370 12 : }
4371 12 : schema.release(&schema);
4372 12 : stream->release(stream);
4373 : return 0;
4374 : }
4375 0 : SWIGINTERN OGRErr OGRLayerShadow_WriteArrowSchemaAndArrowArrayCapsule(OGRLayerShadow *self,PyObject *schemaCapsule,PyObject *arrayCapsule,int createFieldsFromSchema,char **options=NULL){
4376 0 : ArrowSchema* schema = (ArrowSchema*)PyCapsule_GetPointer(schemaCapsule, "arrow_schema");
4377 0 : if( !schema )
4378 : {
4379 0 : CPLError(CE_Failure, CPLE_AppDefined, "PyCapsule_GetPointer(schemaCapsule, \"arrow_schema\") failed");
4380 0 : return 6;
4381 : }
4382 0 : if( schema->release == NULL )
4383 : {
4384 0 : CPLError(CE_Failure, CPLE_AppDefined, "schema->release == NULL");
4385 0 : return 6;
4386 : }
4387 :
4388 0 : if( createFieldsFromSchema == TRUE ||
4389 0 : (createFieldsFromSchema == -1 && OGR_FD_GetFieldCount(OGR_L_GetLayerDefn(self)) == 0) )
4390 : {
4391 0 : if( !CreateFieldsFromArrowSchema(self, schema, options) )
4392 : {
4393 0 : schema->release(schema);
4394 0 : return 6;
4395 : }
4396 : }
4397 :
4398 0 : ArrowArray* array = (ArrowArray*)PyCapsule_GetPointer(arrayCapsule, "arrow_array");
4399 0 : if( !array )
4400 : {
4401 0 : CPLError(CE_Failure, CPLE_AppDefined, "PyCapsule_GetPointer(arrayCapsule, \"arrow_array\") failed");
4402 0 : schema->release(schema);
4403 0 : return 6;
4404 : }
4405 0 : if( array->release == NULL )
4406 : {
4407 0 : CPLError(CE_Failure, CPLE_AppDefined, "array->release == NULL");
4408 0 : schema->release(schema);
4409 0 : return 6;
4410 : }
4411 :
4412 0 : OGRErr eErr = 0;
4413 0 : if( !OGR_L_WriteArrowBatch(self, schema, array, options) )
4414 : {
4415 0 : eErr = 6;
4416 : }
4417 :
4418 0 : if( schema->release )
4419 0 : schema->release(schema);
4420 0 : if( array->release )
4421 0 : array->release(array);
4422 : return eErr;
4423 : }
4424 54 : SWIGINTERN void OGRLayerShadow_GetGeometryTypes(OGRLayerShadow *self,OGRGeometryTypeCounter **ppRet,int *pnEntryCount,int geom_field=0,int flags=0,GDALProgressFunc callback=NULL,void *callback_data=NULL){
4425 108 : *ppRet = OGR_L_GetGeometryTypes(self, geom_field, flags, pnEntryCount, callback, callback_data);
4426 : }
4427 4 : SWIGINTERN void OGRLayerShadow_GetSupportedSRSList(OGRLayerShadow *self,OGRSpatialReferenceH **ppRet,int *pnEntryCount,int geom_field=0){
4428 8 : *ppRet = OGR_L_GetSupportedSRSList(self, geom_field, pnEntryCount);
4429 : }
4430 9 : SWIGINTERN OGRErr OGRLayerShadow_SetActiveSRS(OGRLayerShadow *self,int geom_field,OSRSpatialReferenceShadow *srs){
4431 9 : return OGR_L_SetActiveSRS(self, geom_field, srs);
4432 : }
4433 201094 : SWIGINTERN void delete_OGRFeatureShadow(OGRFeatureShadow *self){
4434 201094 : OGR_F_Destroy(self);
4435 201094 : }
4436 120637 : SWIGINTERN OGRFeatureShadow *new_OGRFeatureShadow(OGRFeatureDefnShadow *feature_def){
4437 120637 : return (OGRFeatureShadow*) OGR_F_Create( feature_def );
4438 : }
4439 44858 : SWIGINTERN OGRFeatureDefnShadow *OGRFeatureShadow_GetDefnRef(OGRFeatureShadow *self){
4440 44858 : return (OGRFeatureDefnShadow*) OGR_F_GetDefnRef(self);
4441 : }
4442 235394 : SWIGINTERN OGRErr OGRFeatureShadow_SetGeometry(OGRFeatureShadow *self,OGRGeometryShadow *geom){
4443 235394 : return OGR_F_SetGeometry(self, geom);
4444 : }
4445 33924 : SWIGINTERN OGRErr OGRFeatureShadow_SetGeometryDirectly(OGRFeatureShadow *self,OGRGeometryShadow *geom){
4446 33924 : return OGR_F_SetGeometryDirectly(self, geom);
4447 : }
4448 38230 : SWIGINTERN OGRGeometryShadow *OGRFeatureShadow_GetGeometryRef(OGRFeatureShadow *self){
4449 38230 : return (OGRGeometryShadow*) OGR_F_GetGeometryRef(self);
4450 : }
4451 : SWIGINTERN OGRErr OGRFeatureShadow_SetGeomField__SWIG_0(OGRFeatureShadow *self,int iField,OGRGeometryShadow *geom){
4452 : return OGR_F_SetGeomField(self, iField, geom);
4453 : }
4454 1 : SWIGINTERN OGRErr OGRFeatureShadow_SetGeomField__SWIG_1(OGRFeatureShadow *self,char const *field_name,OGRGeometryShadow *geom){
4455 1 : int iField = OGR_F_GetGeomFieldIndex(self, field_name);
4456 1 : if (iField == -1)
4457 : {
4458 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4459 0 : return 6;
4460 : }
4461 : else
4462 1 : return OGR_F_SetGeomField(self, iField, geom);
4463 : }
4464 : SWIGINTERN OGRErr OGRFeatureShadow_SetGeomFieldDirectly__SWIG_0(OGRFeatureShadow *self,int iField,OGRGeometryShadow *geom){
4465 : return OGR_F_SetGeomFieldDirectly(self, iField, geom);
4466 : }
4467 16 : SWIGINTERN OGRErr OGRFeatureShadow_SetGeomFieldDirectly__SWIG_1(OGRFeatureShadow *self,char const *field_name,OGRGeometryShadow *geom){
4468 16 : int iField = OGR_F_GetGeomFieldIndex(self, field_name);
4469 16 : if (iField == -1)
4470 : {
4471 1 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4472 1 : return 6;
4473 : }
4474 : else
4475 15 : return OGR_F_SetGeomFieldDirectly(self, iField, geom);
4476 : }
4477 : SWIGINTERN OGRGeometryShadow *OGRFeatureShadow_GetGeomFieldRef__SWIG_0(OGRFeatureShadow *self,int iField){
4478 : return (OGRGeometryShadow*) OGR_F_GetGeomFieldRef(self, iField);
4479 : }
4480 56 : SWIGINTERN OGRGeometryShadow *OGRFeatureShadow_GetGeomFieldRef__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4481 56 : int i = OGR_F_GetGeomFieldIndex(self, field_name);
4482 56 : if (i == -1)
4483 : {
4484 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4485 0 : return NULL;
4486 : }
4487 : else
4488 56 : return (OGRGeometryShadow*) OGR_F_GetGeomFieldRef(self, i);
4489 : }
4490 49 : SWIGINTERN OGRFeatureShadow *OGRFeatureShadow_Clone(OGRFeatureShadow *self){
4491 49 : return (OGRFeatureShadow*) OGR_F_Clone(self);
4492 : }
4493 109 : SWIGINTERN bool OGRFeatureShadow_Equal(OGRFeatureShadow *self,OGRFeatureShadow *feature){
4494 218 : return (OGR_F_Equal(self, feature) > 0);
4495 : }
4496 109884 : SWIGINTERN int OGRFeatureShadow_GetFieldCount(OGRFeatureShadow *self){
4497 109884 : return OGR_F_GetFieldCount(self);
4498 : }
4499 : SWIGINTERN OGRFieldDefnShadow *OGRFeatureShadow_GetFieldDefnRef__SWIG_0(OGRFeatureShadow *self,int id){
4500 : return (OGRFieldDefnShadow *) OGR_F_GetFieldDefnRef(self, id);
4501 : }
4502 14 : SWIGINTERN OGRFieldDefnShadow *OGRFeatureShadow_GetFieldDefnRef__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4503 14 : int i = OGR_F_GetFieldIndex(self, field_name);
4504 14 : if (i == -1)
4505 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4506 : else
4507 14 : return (OGRFieldDefnShadow *) OGR_F_GetFieldDefnRef(self, i);
4508 0 : return NULL;
4509 : }
4510 121 : SWIGINTERN int OGRFeatureShadow_GetGeomFieldCount(OGRFeatureShadow *self){
4511 121 : return OGR_F_GetGeomFieldCount(self);
4512 : }
4513 : SWIGINTERN OGRGeomFieldDefnShadow *OGRFeatureShadow_GetGeomFieldDefnRef__SWIG_0(OGRFeatureShadow *self,int id){
4514 : return (OGRGeomFieldDefnShadow *) OGR_F_GetGeomFieldDefnRef(self, id);
4515 : }
4516 0 : SWIGINTERN OGRGeomFieldDefnShadow *OGRFeatureShadow_GetGeomFieldDefnRef__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4517 0 : int i = OGR_F_GetGeomFieldIndex(self, field_name);
4518 0 : if (i == -1)
4519 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4520 : else
4521 0 : return (OGRGeomFieldDefnShadow *) OGR_F_GetGeomFieldDefnRef(self, i);
4522 0 : return NULL;
4523 : }
4524 : SWIGINTERN char const *OGRFeatureShadow_GetFieldAsString__SWIG_0(OGRFeatureShadow *self,int id){
4525 : return OGR_F_GetFieldAsString(self, id);
4526 : }
4527 845 : SWIGINTERN char const *OGRFeatureShadow_GetFieldAsString__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4528 845 : int i = OGR_F_GetFieldIndex(self, field_name);
4529 845 : if (i == -1)
4530 : {
4531 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4532 0 : return NULL;
4533 : }
4534 : else
4535 : {
4536 845 : return OGR_F_GetFieldAsString(self, i);
4537 : }
4538 : }
4539 : SWIGINTERN char const *OGRFeatureShadow_GetFieldAsISO8601DateTime__SWIG_0(OGRFeatureShadow *self,int id,char **options=0){
4540 : return OGR_F_GetFieldAsISO8601DateTime(self, id, options);
4541 : }
4542 6 : SWIGINTERN char const *OGRFeatureShadow_GetFieldAsISO8601DateTime__SWIG_1(OGRFeatureShadow *self,char const *field_name,char **options=0){
4543 6 : int i = OGR_F_GetFieldIndex(self, field_name);
4544 6 : if (i == -1)
4545 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4546 : else
4547 6 : return OGR_F_GetFieldAsISO8601DateTime(self, i, options);
4548 0 : return NULL;
4549 : }
4550 : SWIGINTERN int OGRFeatureShadow_GetFieldAsInteger__SWIG_0(OGRFeatureShadow *self,int id){
4551 : return OGR_F_GetFieldAsInteger(self, id);
4552 : }
4553 217 : SWIGINTERN int OGRFeatureShadow_GetFieldAsInteger__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4554 217 : int i = OGR_F_GetFieldIndex(self, field_name);
4555 217 : if (i == -1)
4556 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4557 : else
4558 217 : return OGR_F_GetFieldAsInteger(self, i);
4559 0 : return 0;
4560 : }
4561 : SWIGINTERN GIntBig OGRFeatureShadow_GetFieldAsInteger64__SWIG_0(OGRFeatureShadow *self,int id){
4562 : return OGR_F_GetFieldAsInteger64(self, id);
4563 : }
4564 0 : SWIGINTERN GIntBig OGRFeatureShadow_GetFieldAsInteger64__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4565 0 : int i = OGR_F_GetFieldIndex(self, field_name);
4566 0 : if (i == -1)
4567 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4568 : else
4569 0 : return OGR_F_GetFieldAsInteger64(self, i);
4570 0 : return 0;
4571 : }
4572 : SWIGINTERN double OGRFeatureShadow_GetFieldAsDouble__SWIG_0(OGRFeatureShadow *self,int id){
4573 : return OGR_F_GetFieldAsDouble(self, id);
4574 : }
4575 :
4576 : #define SWIG_From_double PyFloat_FromDouble
4577 :
4578 52 : SWIGINTERN double OGRFeatureShadow_GetFieldAsDouble__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4579 52 : int i = OGR_F_GetFieldIndex(self, field_name);
4580 52 : if (i == -1)
4581 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4582 : else
4583 52 : return OGR_F_GetFieldAsDouble(self, i);
4584 0 : return 0;
4585 : }
4586 :
4587 : SWIGINTERNINLINE PyObject *
4588 : SWIG_From_float (float value)
4589 : {
4590 : return SWIG_From_double (value);
4591 : }
4592 :
4593 : SWIGINTERN void OGRFeatureShadow_GetFieldAsDateTime__SWIG_0(OGRFeatureShadow *self,int id,int *pnYear,int *pnMonth,int *pnDay,int *pnHour,int *pnMinute,float *pfSecond,int *pnTZFlag){
4594 : OGR_F_GetFieldAsDateTimeEx(self, id, pnYear, pnMonth, pnDay,
4595 : pnHour, pnMinute, pfSecond,
4596 : pnTZFlag);
4597 : }
4598 1 : SWIGINTERN void OGRFeatureShadow_GetFieldAsDateTime__SWIG_1(OGRFeatureShadow *self,char const *field_name,int *pnYear,int *pnMonth,int *pnDay,int *pnHour,int *pnMinute,float *pfSecond,int *pnTZFlag){
4599 1 : int id = OGR_F_GetFieldIndex(self, field_name);
4600 1 : if (id == -1)
4601 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4602 : else
4603 1 : OGR_F_GetFieldAsDateTimeEx(self, id, pnYear, pnMonth, pnDay,
4604 : pnHour, pnMinute, pfSecond,
4605 : pnTZFlag);
4606 1 : }
4607 : SWIGINTERN void OGRFeatureShadow_GetFieldAsIntegerList__SWIG_0(OGRFeatureShadow *self,int id,int *nLen,int const **pList){
4608 : *pList = OGR_F_GetFieldAsIntegerList(self, id, nLen);
4609 : }
4610 0 : SWIGINTERN void OGRFeatureShadow_GetFieldAsIntegerList__SWIG_1(OGRFeatureShadow *self,char const *field_name,int *nLen,int const **pList){
4611 0 : int id = OGR_F_GetFieldIndex(self, field_name);
4612 0 : if (id == -1)
4613 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4614 : else
4615 0 : *pList = OGR_F_GetFieldAsIntegerList(self, id, nLen);
4616 0 : }
4617 331 : SWIGINTERN void OGRFeatureShadow_GetFieldAsInteger64List(OGRFeatureShadow *self,int id,int *nLen,GIntBig const **pList){
4618 662 : *pList = OGR_F_GetFieldAsInteger64List(self, id, nLen);
4619 : }
4620 : SWIGINTERN void OGRFeatureShadow_GetFieldAsDoubleList__SWIG_0(OGRFeatureShadow *self,int id,int *nLen,double const **pList){
4621 : *pList = OGR_F_GetFieldAsDoubleList(self, id, nLen);
4622 : }
4623 0 : SWIGINTERN void OGRFeatureShadow_GetFieldAsDoubleList__SWIG_1(OGRFeatureShadow *self,char const *field_name,int *nLen,double const **pList){
4624 0 : int id = OGR_F_GetFieldIndex(self, field_name);
4625 0 : if (id == -1)
4626 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4627 : else
4628 0 : *pList = OGR_F_GetFieldAsDoubleList(self, id, nLen);
4629 0 : }
4630 340 : SWIGINTERN char **OGRFeatureShadow_GetFieldAsStringList(OGRFeatureShadow *self,int id){
4631 340 : return OGR_F_GetFieldAsStringList(self, id);
4632 : }
4633 39 : SWIGINTERN OGRErr OGRFeatureShadow_GetFieldAsBinary__SWIG_0(OGRFeatureShadow *self,int id,int *nLen,char **pBuf){
4634 39 : GByte* pabyBlob = OGR_F_GetFieldAsBinary(self, id, nLen);
4635 39 : *pBuf = (char*)VSIMalloc(*nLen);
4636 39 : memcpy(*pBuf, pabyBlob, *nLen);
4637 39 : return 0;
4638 : }
4639 68 : SWIGINTERN OGRErr OGRFeatureShadow_GetFieldAsBinary__SWIG_1(OGRFeatureShadow *self,char const *field_name,int *nLen,char **pBuf){
4640 68 : int id = OGR_F_GetFieldIndex(self, field_name);
4641 68 : if (id == -1)
4642 : {
4643 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4644 0 : return 6;
4645 : }
4646 : else
4647 : {
4648 68 : GByte* pabyBlob = OGR_F_GetFieldAsBinary(self, id, nLen);
4649 68 : *pBuf = (char*)VSIMalloc(*nLen);
4650 68 : memcpy(*pBuf, pabyBlob, *nLen);
4651 68 : return 0;
4652 : }
4653 : }
4654 : SWIGINTERN bool OGRFeatureShadow_IsFieldSet__SWIG_0(OGRFeatureShadow *self,int id){
4655 : return (OGR_F_IsFieldSet(self, id) > 0);
4656 : }
4657 210 : SWIGINTERN bool OGRFeatureShadow_IsFieldSet__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4658 210 : int i = OGR_F_GetFieldIndex(self, field_name);
4659 210 : if (i == -1)
4660 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4661 : else
4662 210 : return (OGR_F_IsFieldSet(self, i) > 0);
4663 0 : return false;
4664 : }
4665 : SWIGINTERN bool OGRFeatureShadow_IsFieldNull__SWIG_0(OGRFeatureShadow *self,int id){
4666 : return (OGR_F_IsFieldNull(self, id) > 0);
4667 : }
4668 55 : SWIGINTERN bool OGRFeatureShadow_IsFieldNull__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4669 55 : int i = OGR_F_GetFieldIndex(self, field_name);
4670 55 : if (i == -1)
4671 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4672 : else
4673 55 : return (OGR_F_IsFieldNull(self, i) > 0);
4674 0 : return false;
4675 : }
4676 : SWIGINTERN bool OGRFeatureShadow_IsFieldSetAndNotNull__SWIG_0(OGRFeatureShadow *self,int id){
4677 : return (OGR_F_IsFieldSetAndNotNull(self, id) > 0);
4678 : }
4679 52 : SWIGINTERN bool OGRFeatureShadow_IsFieldSetAndNotNull__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4680 52 : int i = OGR_F_GetFieldIndex(self, field_name);
4681 52 : if (i == -1)
4682 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4683 : else
4684 52 : return (OGR_F_IsFieldSetAndNotNull(self, i) > 0);
4685 0 : return false;
4686 : }
4687 302 : SWIGINTERN int OGRFeatureShadow_GetFieldIndex(OGRFeatureShadow *self,char const *field_name){
4688 : // Do not issue an error if the field doesn't exist. It is intended to be silent
4689 302 : return OGR_F_GetFieldIndex(self, field_name);
4690 : }
4691 73 : SWIGINTERN int OGRFeatureShadow_GetGeomFieldIndex(OGRFeatureShadow *self,char const *field_name){
4692 : // Do not issue an error if the field doesn't exist. It is intended to be silent
4693 73 : return OGR_F_GetGeomFieldIndex(self, field_name);
4694 : }
4695 5217 : SWIGINTERN GIntBig OGRFeatureShadow_GetFID(OGRFeatureShadow *self){
4696 5217 : return OGR_F_GetFID(self);
4697 : }
4698 160519 : SWIGINTERN OGRErr OGRFeatureShadow_SetFID(OGRFeatureShadow *self,GIntBig fid){
4699 160519 : return OGR_F_SetFID(self, fid);
4700 : }
4701 0 : SWIGINTERN void OGRFeatureShadow_DumpReadable(OGRFeatureShadow *self){
4702 0 : OGR_F_DumpReadable(self, NULL);
4703 0 : }
4704 92 : SWIGINTERN retStringAndCPLFree *OGRFeatureShadow_DumpReadableAsString(OGRFeatureShadow *self,char **options=NULL){
4705 92 : return OGR_F_DumpReadableAsString(self, options);
4706 : }
4707 : SWIGINTERN void OGRFeatureShadow_UnsetField__SWIG_0(OGRFeatureShadow *self,int id){
4708 : OGR_F_UnsetField(self, id);
4709 : }
4710 4 : SWIGINTERN void OGRFeatureShadow_UnsetField__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4711 4 : int i = OGR_F_GetFieldIndex(self, field_name);
4712 4 : if (i == -1)
4713 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4714 : else
4715 4 : OGR_F_UnsetField(self, i);
4716 4 : }
4717 : SWIGINTERN void OGRFeatureShadow_SetFieldNull__SWIG_0(OGRFeatureShadow *self,int id){
4718 : OGR_F_SetFieldNull(self, id);
4719 : }
4720 19 : SWIGINTERN void OGRFeatureShadow_SetFieldNull__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4721 19 : int i = OGR_F_GetFieldIndex(self, field_name);
4722 19 : if (i == -1)
4723 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4724 : else
4725 19 : OGR_F_SetFieldNull(self, i);
4726 19 : }
4727 : SWIGINTERN void OGRFeatureShadow_SetField__SWIG_0(OGRFeatureShadow *self,int id,char const *value){
4728 : OGR_F_SetFieldString(self, id, value);
4729 : }
4730 0 : SWIGINTERN void OGRFeatureShadow_SetField__SWIG_1(OGRFeatureShadow *self,char const *field_name,char const *value){
4731 0 : int i = OGR_F_GetFieldIndex(self, field_name);
4732 0 : if (i == -1)
4733 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4734 : else
4735 0 : OGR_F_SetFieldString(self, i, value);
4736 0 : }
4737 84445 : SWIGINTERN void OGRFeatureShadow_SetFieldInteger64(OGRFeatureShadow *self,int id,GIntBig value){
4738 84445 : OGR_F_SetFieldInteger64(self, id, value);
4739 84445 : }
4740 : SWIGINTERN void OGRFeatureShadow_SetField__SWIG_2(OGRFeatureShadow *self,int id,double value){
4741 : OGR_F_SetFieldDouble(self, id, value);
4742 : }
4743 1282 : SWIGINTERN void OGRFeatureShadow_SetField__SWIG_3(OGRFeatureShadow *self,char const *field_name,double value){
4744 1282 : int i = OGR_F_GetFieldIndex(self, field_name);
4745 1282 : if (i == -1)
4746 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4747 : else
4748 1282 : OGR_F_SetFieldDouble(self, i, value);
4749 1282 : }
4750 :
4751 : /* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
4752 : #ifndef SWIG_isfinite
4753 : /* isfinite() is a macro for C99 */
4754 : # if defined(isfinite)
4755 : # define SWIG_isfinite(X) (isfinite(X))
4756 : # elif defined(__cplusplus) && __cplusplus >= 201103L
4757 : /* Use a template so that this works whether isfinite() is std::isfinite() or
4758 : * in the global namespace. The reality seems to vary between compiler
4759 : * versions.
4760 : *
4761 : * Make sure namespace std exists to avoid compiler warnings.
4762 : *
4763 : * extern "C++" is required as this fragment can end up inside an extern "C" { } block
4764 : */
4765 : namespace std { }
4766 : extern "C++" template<typename T>
4767 0 : inline int SWIG_isfinite_func(T x) {
4768 : using namespace std;
4769 0 : return isfinite(x);
4770 : }
4771 : # define SWIG_isfinite(X) (SWIG_isfinite_func(X))
4772 : # elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
4773 : # define SWIG_isfinite(X) (__builtin_isfinite(X))
4774 : # elif defined(__clang__) && defined(__has_builtin)
4775 : # if __has_builtin(__builtin_isfinite)
4776 : # define SWIG_isfinite(X) (__builtin_isfinite(X))
4777 : # endif
4778 : # elif defined(_MSC_VER)
4779 : # define SWIG_isfinite(X) (_finite(X))
4780 : # elif defined(__sun) && defined(__SVR4)
4781 : # include <ieeefp.h>
4782 : # define SWIG_isfinite(X) (finite(X))
4783 : # endif
4784 : #endif
4785 :
4786 :
4787 : /* Accept infinite as a valid float value unless we are unable to check if a value is finite */
4788 : #ifdef SWIG_isfinite
4789 : # define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
4790 : #else
4791 : # define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
4792 : #endif
4793 :
4794 :
4795 : SWIGINTERN int
4796 88 : SWIG_AsVal_float (PyObject * obj, float *val)
4797 : {
4798 88 : double v;
4799 88 : int res = SWIG_AsVal_double (obj, &v);
4800 88 : if (SWIG_IsOK(res)) {
4801 88 : if (SWIG_Float_Overflow_Check(v)) {
4802 : return SWIG_OverflowError;
4803 : } else {
4804 88 : if (val) *val = static_cast< float >(v);
4805 : }
4806 : }
4807 : return res;
4808 : }
4809 :
4810 : SWIGINTERN void OGRFeatureShadow_SetField__SWIG_4(OGRFeatureShadow *self,int id,int year,int month,int day,int hour,int minute,float second,int tzflag){
4811 : OGR_F_SetFieldDateTimeEx(self, id, year, month, day,
4812 : hour, minute, second,
4813 : tzflag);
4814 : }
4815 20 : SWIGINTERN void OGRFeatureShadow_SetField__SWIG_5(OGRFeatureShadow *self,char const *field_name,int year,int month,int day,int hour,int minute,float second,int tzflag){
4816 20 : int i = OGR_F_GetFieldIndex(self, field_name);
4817 20 : if (i == -1)
4818 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4819 : else
4820 20 : OGR_F_SetFieldDateTimeEx(self, i, year, month, day,
4821 : hour, minute, second,
4822 : tzflag);
4823 20 : }
4824 9 : SWIGINTERN void OGRFeatureShadow_SetFieldIntegerList(OGRFeatureShadow *self,int id,int nList,int *pList){
4825 9 : OGR_F_SetFieldIntegerList(self, id, nList, pList);
4826 9 : }
4827 :
4828 : static GIntBig*
4829 122 : CreateCGIntBigListFromSequence( PyObject* pySeq, int* pnSize ) {
4830 : /* check if is List */
4831 122 : if ( !PySequence_Check(pySeq) ) {
4832 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
4833 0 : *pnSize = -1;
4834 0 : return NULL;
4835 : }
4836 122 : Py_ssize_t size = PySequence_Size(pySeq);
4837 122 : if( size > (Py_ssize_t)INT_MAX ) {
4838 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
4839 0 : *pnSize = -1;
4840 0 : return NULL;
4841 : }
4842 122 : if( (size_t)size > SIZE_MAX / sizeof(GIntBig) ) {
4843 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
4844 0 : *pnSize = -1;
4845 0 : return NULL;
4846 : }
4847 122 : *pnSize = (int)size;
4848 122 : GIntBig* ret = (GIntBig*) malloc((*pnSize)*sizeof(GIntBig));
4849 122 : if( !ret ) {
4850 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
4851 0 : *pnSize = -1;
4852 0 : return NULL;
4853 : }
4854 712 : for( int i = 0; i<*pnSize; i++ ) {
4855 590 : PyObject *o = PySequence_GetItem(pySeq,i);
4856 590 : if ( !PyArg_Parse(o,"L",&ret[i]) ) {
4857 0 : PyErr_SetString(PyExc_TypeError, "not an integer");
4858 0 : Py_DECREF(o);
4859 0 : free(ret);
4860 0 : *pnSize = -1;
4861 0 : return NULL;
4862 : }
4863 590 : Py_DECREF(o);
4864 : }
4865 : return ret;
4866 : }
4867 :
4868 122 : SWIGINTERN void OGRFeatureShadow_SetFieldInteger64List(OGRFeatureShadow *self,int id,int nList,GIntBig *pList){
4869 122 : OGR_F_SetFieldInteger64List(self, id, nList, pList);
4870 122 : }
4871 :
4872 : static double*
4873 90 : CreateCDoubleListFromSequence( PyObject* pySeq, int* pnSize ) {
4874 : /* check if is List */
4875 90 : if ( !PySequence_Check(pySeq) ) {
4876 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
4877 0 : *pnSize = -1;
4878 0 : return NULL;
4879 : }
4880 90 : Py_ssize_t size = PySequence_Size(pySeq);
4881 90 : if( size > (Py_ssize_t)INT_MAX ) {
4882 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
4883 0 : *pnSize = -1;
4884 0 : return NULL;
4885 : }
4886 90 : if( (size_t)size > SIZE_MAX / sizeof(double) ) {
4887 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
4888 0 : *pnSize = -1;
4889 0 : return NULL;
4890 : }
4891 90 : *pnSize = (int)size;
4892 90 : double* ret = (double*) malloc((*pnSize)*sizeof(double));
4893 90 : if( !ret ) {
4894 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
4895 0 : *pnSize = -1;
4896 0 : return NULL;
4897 : }
4898 291 : for( int i = 0; i<*pnSize; i++ ) {
4899 201 : PyObject *o = PySequence_GetItem(pySeq,i);
4900 201 : if ( !PyArg_Parse(o,"d",&ret[i]) ) {
4901 0 : PyErr_SetString(PyExc_TypeError, "not an number");
4902 0 : Py_DECREF(o);
4903 0 : free(ret);
4904 0 : *pnSize = -1;
4905 0 : return NULL;
4906 : }
4907 201 : Py_DECREF(o);
4908 : }
4909 : return ret;
4910 : }
4911 :
4912 90 : SWIGINTERN void OGRFeatureShadow_SetFieldDoubleList(OGRFeatureShadow *self,int id,int nList,double *pList){
4913 90 : OGR_F_SetFieldDoubleList(self, id, nList, pList);
4914 90 : }
4915 42 : SWIGINTERN void OGRFeatureShadow_SetFieldStringList(OGRFeatureShadow *self,int id,char **pList){
4916 42 : OGR_F_SetFieldStringList(self, id, pList);
4917 42 : }
4918 :
4919 : static bool
4920 515 : GetBufferAsCharPtrIntSize( PyObject* input, int *nLen, char **pBuf, int *alloc, bool *viewIsValid, Py_buffer *view ) {
4921 515 : {
4922 515 : if (PyObject_GetBuffer(input, view, PyBUF_SIMPLE) == 0)
4923 : {
4924 515 : if( view->len > INT_MAX ) {
4925 0 : PyBuffer_Release(view);
4926 0 : PyErr_SetString(PyExc_RuntimeError, "too large buffer (>2GB)" );
4927 0 : return false;
4928 : }
4929 515 : *viewIsValid = true;
4930 515 : *nLen = (int) view->len;
4931 515 : *pBuf = (char*) view->buf;
4932 515 : return true;
4933 : }
4934 : else
4935 : {
4936 0 : PyErr_Clear();
4937 : }
4938 : }
4939 0 : if (PyUnicode_Check(input))
4940 : {
4941 0 : size_t safeLen = 0;
4942 0 : int ret;
4943 0 : try {
4944 0 : ret = SWIG_AsCharPtrAndSize(input, pBuf, &safeLen, alloc);
4945 : }
4946 0 : catch( const std::exception& )
4947 : {
4948 0 : PyErr_SetString(PyExc_MemoryError, "out of memory");
4949 0 : return false;
4950 : }
4951 0 : if (!SWIG_IsOK(ret)) {
4952 0 : PyErr_SetString(PyExc_RuntimeError, "invalid Unicode string" );
4953 0 : return false;
4954 : }
4955 :
4956 0 : if (safeLen) safeLen--;
4957 0 : if( safeLen > INT_MAX ) {
4958 0 : PyErr_SetString(PyExc_RuntimeError, "too large buffer (>2GB)" );
4959 0 : return false;
4960 : }
4961 0 : *nLen = (int) safeLen;
4962 0 : return true;
4963 : }
4964 : else
4965 : {
4966 0 : PyErr_SetString(PyExc_RuntimeError, "not a unicode string, bytes, bytearray or memoryview");
4967 0 : return false;
4968 : }
4969 : }
4970 :
4971 515 : SWIGINTERN void OGRFeatureShadow__SetFieldBinary(OGRFeatureShadow *self,int id,int nLen,char *pBuf){
4972 515 : OGR_F_SetFieldBinary(self, id, nLen, pBuf);
4973 515 : }
4974 4 : SWIGINTERN void OGRFeatureShadow_SetFieldBinaryFromHexString__SWIG_0(OGRFeatureShadow *self,int id,char const *pszValue){
4975 4 : int nBytes;
4976 4 : GByte* pabyBuf = CPLHexToBinary(pszValue, &nBytes );
4977 4 : OGR_F_SetFieldBinary(self, id, nBytes, pabyBuf);
4978 4 : CPLFree(pabyBuf);
4979 4 : }
4980 2 : SWIGINTERN void OGRFeatureShadow_SetFieldBinaryFromHexString__SWIG_1(OGRFeatureShadow *self,char const *field_name,char const *pszValue){
4981 2 : int i = OGR_F_GetFieldIndex(self, field_name);
4982 2 : if (i == -1)
4983 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4984 : else
4985 : {
4986 2 : int nBytes;
4987 2 : GByte* pabyBuf = CPLHexToBinary(pszValue, &nBytes );
4988 2 : OGR_F_SetFieldBinary(self, i, nBytes, pabyBuf);
4989 2 : CPLFree(pabyBuf);
4990 : }
4991 2 : }
4992 1734 : SWIGINTERN OGRErr OGRFeatureShadow_SetFrom(OGRFeatureShadow *self,OGRFeatureShadow *other,int forgiving=1){
4993 1734 : return OGR_F_SetFrom(self, other, forgiving);
4994 : }
4995 0 : SWIGINTERN OGRErr OGRFeatureShadow_SetFromWithMap(OGRFeatureShadow *self,OGRFeatureShadow *other,int forgiving,int nList,int *pList){
4996 0 : if (nList != OGR_F_GetFieldCount(other))
4997 : {
4998 0 : CPLError(CE_Failure, CPLE_AppDefined,
4999 : "The size of map doesn't match with the field count of the source feature");
5000 0 : return 6;
5001 : }
5002 0 : return OGR_F_SetFromWithMap(self, other, forgiving, pList);
5003 : }
5004 746 : SWIGINTERN char const *OGRFeatureShadow_GetStyleString(OGRFeatureShadow *self){
5005 746 : return (const char*) OGR_F_GetStyleString(self);
5006 : }
5007 104 : SWIGINTERN void OGRFeatureShadow_SetStyleString(OGRFeatureShadow *self,char const *the_string){
5008 104 : OGR_F_SetStyleString(self, the_string);
5009 104 : }
5010 100648 : SWIGINTERN OGRFieldType OGRFeatureShadow_GetFieldType__SWIG_0(OGRFeatureShadow *self,int id){
5011 100648 : OGRFieldDefnH fd = OGR_F_GetFieldDefnRef( self, id );
5012 100648 : if (fd)
5013 100648 : return (OGRFieldType) OGR_Fld_GetType( fd );
5014 : else
5015 : return (OGRFieldType)0;
5016 : }
5017 0 : SWIGINTERN OGRFieldType OGRFeatureShadow_GetFieldType__SWIG_1(OGRFeatureShadow *self,char const *field_name){
5018 0 : int i = OGR_F_GetFieldIndex(self, field_name);
5019 0 : if (i == -1) {
5020 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
5021 0 : return (OGRFieldType)0;
5022 : } else
5023 0 : return (OGRFieldType) OGR_Fld_GetType( OGR_F_GetFieldDefnRef( self, i ) );
5024 : }
5025 10 : SWIGINTERN int OGRFeatureShadow_Validate(OGRFeatureShadow *self,int flags=OGR_F_VAL_ALL,int bEmitError=TRUE){
5026 10 : return OGR_F_Validate(self, flags, bEmitError);
5027 : }
5028 2 : SWIGINTERN void OGRFeatureShadow_FillUnsetWithDefault(OGRFeatureShadow *self,int bNotNullableOnly=FALSE,char **options=NULL){
5029 2 : OGR_F_FillUnsetWithDefault(self, bNotNullableOnly, options );
5030 2 : }
5031 9 : SWIGINTERN char const *OGRFeatureShadow_GetNativeData(OGRFeatureShadow *self){
5032 9 : return OGR_F_GetNativeData(self);
5033 : }
5034 9 : SWIGINTERN char const *OGRFeatureShadow_GetNativeMediaType(OGRFeatureShadow *self){
5035 9 : return OGR_F_GetNativeMediaType(self);
5036 : }
5037 4 : SWIGINTERN void OGRFeatureShadow_SetNativeData(OGRFeatureShadow *self,char const *nativeData){
5038 4 : OGR_F_SetNativeData(self, nativeData);
5039 4 : }
5040 4 : SWIGINTERN void OGRFeatureShadow_SetNativeMediaType(OGRFeatureShadow *self,char const *nativeMediaType){
5041 4 : OGR_F_SetNativeMediaType(self, nativeMediaType);
5042 4 : }
5043 11974 : SWIGINTERN void OGRFeatureShadow_SetFieldString(OGRFeatureShadow *self,int id,char const *value){
5044 11974 : OGR_F_SetFieldString(self, id, value);
5045 : }
5046 :
5047 185 : static int ValidateOGRGeometryType(OGRwkbGeometryType field_type)
5048 : {
5049 185 : switch(field_type)
5050 : {
5051 : case wkbUnknown:
5052 : case wkbPoint:
5053 : case wkbLineString:
5054 : case wkbPolygon:
5055 : case wkbMultiPoint:
5056 : case wkbMultiLineString:
5057 : case wkbMultiPolygon:
5058 : case wkbGeometryCollection:
5059 : case wkbCircularString:
5060 : case wkbCompoundCurve:
5061 : case wkbCurvePolygon:
5062 : case wkbMultiCurve:
5063 : case wkbMultiSurface:
5064 : case wkbCurve:
5065 : case wkbSurface:
5066 : case wkbTriangle:
5067 : case wkbTIN:
5068 : case wkbPolyhedralSurface:
5069 : case wkbNone:
5070 : /*case wkbLinearRing:*/
5071 : case wkbCircularStringZ:
5072 : case wkbCompoundCurveZ:
5073 : case wkbCurvePolygonZ:
5074 : case wkbMultiCurveZ:
5075 : case wkbMultiSurfaceZ:
5076 : case wkbCurveZ:
5077 : case wkbSurfaceZ:
5078 : case wkbTriangleZ:
5079 : case wkbTINZ:
5080 : case wkbPolyhedralSurfaceZ:
5081 : case wkbPoint25D:
5082 : case wkbLineString25D:
5083 : case wkbPolygon25D:
5084 : case wkbMultiPoint25D:
5085 : case wkbMultiLineString25D:
5086 : case wkbMultiPolygon25D:
5087 : case wkbGeometryCollection25D:
5088 : case wkbPointM:
5089 : case wkbLineStringM:
5090 : case wkbPolygonM:
5091 : case wkbMultiPointM:
5092 : case wkbMultiLineStringM:
5093 : case wkbMultiPolygonM:
5094 : case wkbGeometryCollectionM:
5095 : case wkbCircularStringM:
5096 : case wkbCompoundCurveM:
5097 : case wkbCurvePolygonM:
5098 : case wkbMultiCurveM:
5099 : case wkbMultiSurfaceM:
5100 : case wkbCurveM:
5101 : case wkbSurfaceM:
5102 : case wkbTriangleM:
5103 : case wkbTINM:
5104 : case wkbPolyhedralSurfaceM:
5105 : case wkbPointZM:
5106 : case wkbLineStringZM:
5107 : case wkbPolygonZM:
5108 : case wkbMultiPointZM:
5109 : case wkbMultiLineStringZM:
5110 : case wkbMultiPolygonZM:
5111 : case wkbGeometryCollectionZM:
5112 : case wkbCircularStringZM:
5113 : case wkbCompoundCurveZM:
5114 : case wkbCurvePolygonZM:
5115 : case wkbMultiCurveZM:
5116 : case wkbMultiSurfaceZM:
5117 : case wkbCurveZM:
5118 : case wkbSurfaceZM:
5119 : case wkbTriangleZM:
5120 : case wkbTINZM:
5121 : case wkbPolyhedralSurfaceZM:
5122 : return TRUE;
5123 2 : default:
5124 2 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal geometry type value");
5125 2 : return FALSE;
5126 : }
5127 : }
5128 :
5129 126843 : SWIGINTERN void delete_OGRFeatureDefnShadow(OGRFeatureDefnShadow *self){
5130 : /*OGR_FD_Destroy(self);*/
5131 126843 : OGR_FD_Release( OGRFeatureDefnH(self) );
5132 126843 : }
5133 110 : SWIGINTERN OGRFeatureDefnShadow *new_OGRFeatureDefnShadow(char const *name_null_ok=NULL){
5134 220 : OGRFeatureDefnH h = OGR_FD_Create(name_null_ok);
5135 110 : OGR_FD_Reference(h);
5136 110 : return (OGRFeatureDefnShadow* )h;
5137 : }
5138 103 : SWIGINTERN char const *OGRFeatureDefnShadow_GetName(OGRFeatureDefnShadow *self){
5139 103 : return OGR_FD_GetName(self);
5140 : }
5141 46237 : SWIGINTERN int OGRFeatureDefnShadow_GetFieldCount(OGRFeatureDefnShadow *self){
5142 46237 : return OGR_FD_GetFieldCount(self);
5143 : }
5144 202332 : SWIGINTERN OGRFieldDefnShadow *OGRFeatureDefnShadow_GetFieldDefn(OGRFeatureDefnShadow *self,int i){
5145 202332 : return (OGRFieldDefnShadow*) OGR_FD_GetFieldDefn(self, i);
5146 : }
5147 1732 : SWIGINTERN int OGRFeatureDefnShadow_GetFieldIndex(OGRFeatureDefnShadow *self,char const *field_name){
5148 : // Do not issue an error if the field doesn't exist. It is intended to be silent
5149 1732 : return OGR_FD_GetFieldIndex(self, field_name);
5150 : }
5151 397 : SWIGINTERN void OGRFeatureDefnShadow_AddFieldDefn(OGRFeatureDefnShadow *self,OGRFieldDefnShadow *defn){
5152 397 : OGR_FD_AddFieldDefn(self, defn);
5153 397 : }
5154 408 : SWIGINTERN int OGRFeatureDefnShadow_GetGeomFieldCount(OGRFeatureDefnShadow *self){
5155 408 : return OGR_FD_GetGeomFieldCount(self);
5156 : }
5157 577 : SWIGINTERN OGRGeomFieldDefnShadow *OGRFeatureDefnShadow_GetGeomFieldDefn(OGRFeatureDefnShadow *self,int i){
5158 577 : return (OGRGeomFieldDefnShadow*) OGR_FD_GetGeomFieldDefn(self, i);
5159 : }
5160 37 : SWIGINTERN int OGRFeatureDefnShadow_GetGeomFieldIndex(OGRFeatureDefnShadow *self,char const *field_name){
5161 : // Do not issue an error if the field doesn't exist. It is intended to be silent
5162 37 : return OGR_FD_GetGeomFieldIndex(self, field_name);
5163 : }
5164 11 : SWIGINTERN void OGRFeatureDefnShadow_AddGeomFieldDefn(OGRFeatureDefnShadow *self,OGRGeomFieldDefnShadow *defn){
5165 11 : OGR_FD_AddGeomFieldDefn(self, defn);
5166 11 : }
5167 4 : SWIGINTERN OGRErr OGRFeatureDefnShadow_DeleteGeomFieldDefn(OGRFeatureDefnShadow *self,int idx){
5168 4 : return OGR_FD_DeleteGeomFieldDefn(self, idx);
5169 : }
5170 91 : SWIGINTERN OGRwkbGeometryType OGRFeatureDefnShadow_GetGeomType(OGRFeatureDefnShadow *self){
5171 91 : return (OGRwkbGeometryType) OGR_FD_GetGeomType(self);
5172 : }
5173 12 : SWIGINTERN void OGRFeatureDefnShadow_SetGeomType(OGRFeatureDefnShadow *self,OGRwkbGeometryType geom_type){
5174 12 : if( ValidateOGRGeometryType(geom_type) )
5175 11 : OGR_FD_SetGeomType(self, geom_type);
5176 12 : }
5177 3 : SWIGINTERN int OGRFeatureDefnShadow_GetReferenceCount(OGRFeatureDefnShadow *self){
5178 3 : return OGR_FD_GetReferenceCount(self);
5179 : }
5180 6 : SWIGINTERN int OGRFeatureDefnShadow_IsGeometryIgnored(OGRFeatureDefnShadow *self){
5181 6 : return OGR_FD_IsGeometryIgnored(self);
5182 : }
5183 3 : SWIGINTERN void OGRFeatureDefnShadow_SetGeometryIgnored(OGRFeatureDefnShadow *self,int bIgnored){
5184 3 : return OGR_FD_SetGeometryIgnored(self,bIgnored);
5185 : }
5186 2 : SWIGINTERN int OGRFeatureDefnShadow_IsStyleIgnored(OGRFeatureDefnShadow *self){
5187 2 : return OGR_FD_IsStyleIgnored(self);
5188 : }
5189 0 : SWIGINTERN void OGRFeatureDefnShadow_SetStyleIgnored(OGRFeatureDefnShadow *self,int bIgnored){
5190 0 : return OGR_FD_SetStyleIgnored(self,bIgnored);
5191 : }
5192 11 : SWIGINTERN int OGRFeatureDefnShadow_IsSame(OGRFeatureDefnShadow *self,OGRFeatureDefnShadow *other_defn){
5193 11 : return OGR_FD_IsSame(self, other_defn);
5194 : }
5195 :
5196 77497 : static int ValidateOGRFieldType(OGRFieldType field_type)
5197 : {
5198 77497 : switch(field_type)
5199 : {
5200 : case OFTInteger:
5201 : case OFTIntegerList:
5202 : case OFTReal:
5203 : case OFTRealList:
5204 : case OFTString:
5205 : case OFTStringList:
5206 : case OFTBinary:
5207 : case OFTDate:
5208 : case OFTTime:
5209 : case OFTDateTime:
5210 : case OFTInteger64:
5211 : case OFTInteger64List:
5212 : return TRUE;
5213 0 : default:
5214 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal field type value");
5215 0 : return FALSE;
5216 : }
5217 : }
5218 :
5219 :
5220 419 : static int ValidateOGRFieldSubType(OGRFieldSubType field_subtype)
5221 : {
5222 419 : switch(field_subtype)
5223 : {
5224 : case OFSTNone:
5225 : case OFSTBoolean:
5226 : case OFSTInt16:
5227 : case OFSTFloat32:
5228 : case OFSTJSON:
5229 : case OFSTUUID:
5230 : return TRUE;
5231 0 : default:
5232 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal field subtype value");
5233 0 : return FALSE;
5234 : }
5235 : }
5236 :
5237 77484 : SWIGINTERN void delete_OGRFieldDefnShadow(OGRFieldDefnShadow *self){
5238 77484 : OGR_Fld_Destroy(self);
5239 77484 : }
5240 77497 : SWIGINTERN OGRFieldDefnShadow *new_OGRFieldDefnShadow(char const *name_null_ok="unnamed",OGRFieldType field_type=OFTString){
5241 77497 : if (ValidateOGRFieldType(field_type))
5242 77497 : return (OGRFieldDefnShadow*) OGR_Fld_Create(name_null_ok, field_type);
5243 : else
5244 0 : return NULL;
5245 : }
5246 192754 : SWIGINTERN char const *OGRFieldDefnShadow_GetName(OGRFieldDefnShadow *self){
5247 192754 : return OGR_Fld_GetNameRef(self);
5248 : }
5249 1537 : SWIGINTERN char const *OGRFieldDefnShadow_GetNameRef(OGRFieldDefnShadow *self){
5250 1537 : return OGR_Fld_GetNameRef(self);
5251 : }
5252 2 : SWIGINTERN void OGRFieldDefnShadow_SetName(OGRFieldDefnShadow *self,char const *name){
5253 2 : OGR_Fld_SetName(self, name);
5254 2 : }
5255 47 : SWIGINTERN char const *OGRFieldDefnShadow_GetAlternativeName(OGRFieldDefnShadow *self){
5256 47 : return OGR_Fld_GetAlternativeNameRef(self);
5257 : }
5258 9 : SWIGINTERN char const *OGRFieldDefnShadow_GetAlternativeNameRef(OGRFieldDefnShadow *self){
5259 9 : return OGR_Fld_GetAlternativeNameRef(self);
5260 : }
5261 17 : SWIGINTERN void OGRFieldDefnShadow_SetAlternativeName(OGRFieldDefnShadow *self,char const *alternativeName){
5262 17 : OGR_Fld_SetAlternativeName(self, alternativeName);
5263 17 : }
5264 4218 : SWIGINTERN OGRFieldType OGRFieldDefnShadow_GetType(OGRFieldDefnShadow *self){
5265 4218 : return OGR_Fld_GetType(self);
5266 : }
5267 0 : SWIGINTERN void OGRFieldDefnShadow_SetType(OGRFieldDefnShadow *self,OGRFieldType type){
5268 0 : if (ValidateOGRFieldType(type))
5269 0 : OGR_Fld_SetType(self, type);
5270 0 : }
5271 88534 : SWIGINTERN OGRFieldSubType OGRFieldDefnShadow_GetSubType(OGRFieldDefnShadow *self){
5272 88534 : return OGR_Fld_GetSubType(self);
5273 : }
5274 419 : SWIGINTERN void OGRFieldDefnShadow_SetSubType(OGRFieldDefnShadow *self,OGRFieldSubType type){
5275 419 : if (ValidateOGRFieldSubType(type))
5276 419 : OGR_Fld_SetSubType(self, type);
5277 419 : }
5278 0 : SWIGINTERN OGRJustification OGRFieldDefnShadow_GetJustify(OGRFieldDefnShadow *self){
5279 0 : return OGR_Fld_GetJustify(self);
5280 : }
5281 0 : SWIGINTERN void OGRFieldDefnShadow_SetJustify(OGRFieldDefnShadow *self,OGRJustification justify){
5282 0 : OGR_Fld_SetJustify(self, justify);
5283 0 : }
5284 2732 : SWIGINTERN int OGRFieldDefnShadow_GetWidth(OGRFieldDefnShadow *self){
5285 2732 : return OGR_Fld_GetWidth(self);
5286 : }
5287 320 : SWIGINTERN void OGRFieldDefnShadow_SetWidth(OGRFieldDefnShadow *self,int width){
5288 320 : OGR_Fld_SetWidth(self, width);
5289 320 : }
5290 1608 : SWIGINTERN int OGRFieldDefnShadow_GetPrecision(OGRFieldDefnShadow *self){
5291 1608 : return OGR_Fld_GetPrecision(self);
5292 : }
5293 24 : SWIGINTERN void OGRFieldDefnShadow_SetPrecision(OGRFieldDefnShadow *self,int precision){
5294 24 : OGR_Fld_SetPrecision(self, precision);
5295 24 : }
5296 0 : SWIGINTERN int OGRFieldDefnShadow_GetTZFlag(OGRFieldDefnShadow *self){
5297 0 : return OGR_Fld_GetTZFlag(self);
5298 : }
5299 6 : SWIGINTERN void OGRFieldDefnShadow_SetTZFlag(OGRFieldDefnShadow *self,int tzflag){
5300 6 : OGR_Fld_SetTZFlag(self, tzflag);
5301 6 : }
5302 13 : SWIGINTERN char const *OGRFieldDefnShadow_GetTypeName(OGRFieldDefnShadow *self){
5303 13 : return OGR_GetFieldTypeName(OGR_Fld_GetType(self));
5304 : }
5305 36 : SWIGINTERN char const *OGRFieldDefnShadow_GetFieldTypeName(OGRFieldDefnShadow *self,OGRFieldType type){
5306 36 : return OGR_GetFieldTypeName(type);
5307 : }
5308 6 : SWIGINTERN int OGRFieldDefnShadow_IsIgnored(OGRFieldDefnShadow *self){
5309 6 : return OGR_Fld_IsIgnored( self );
5310 : }
5311 0 : SWIGINTERN void OGRFieldDefnShadow_SetIgnored(OGRFieldDefnShadow *self,int bIgnored){
5312 0 : OGR_Fld_SetIgnored( self, bIgnored );
5313 0 : }
5314 80 : SWIGINTERN int OGRFieldDefnShadow_IsNullable(OGRFieldDefnShadow *self){
5315 80 : return OGR_Fld_IsNullable( self );
5316 : }
5317 190 : SWIGINTERN void OGRFieldDefnShadow_SetNullable(OGRFieldDefnShadow *self,int bNullable){
5318 190 : OGR_Fld_SetNullable( self, bNullable );
5319 190 : }
5320 80 : SWIGINTERN int OGRFieldDefnShadow_IsUnique(OGRFieldDefnShadow *self){
5321 80 : return OGR_Fld_IsUnique( self );
5322 : }
5323 28 : SWIGINTERN void OGRFieldDefnShadow_SetUnique(OGRFieldDefnShadow *self,int bUnique){
5324 28 : OGR_Fld_SetUnique( self, bUnique );
5325 28 : }
5326 4 : SWIGINTERN int OGRFieldDefnShadow_IsGenerated(OGRFieldDefnShadow *self){
5327 4 : return OGR_Fld_IsGenerated( self );
5328 : }
5329 0 : SWIGINTERN void OGRFieldDefnShadow_SetGenerated(OGRFieldDefnShadow *self,int bGenerated){
5330 0 : OGR_Fld_SetGenerated( self, bGenerated );
5331 0 : }
5332 137 : SWIGINTERN char const *OGRFieldDefnShadow_GetDefault(OGRFieldDefnShadow *self){
5333 137 : return OGR_Fld_GetDefault( self );
5334 : }
5335 149 : SWIGINTERN void OGRFieldDefnShadow_SetDefault(OGRFieldDefnShadow *self,char const *pszValue){
5336 149 : OGR_Fld_SetDefault( self, pszValue );
5337 149 : }
5338 3 : SWIGINTERN int OGRFieldDefnShadow_IsDefaultDriverSpecific(OGRFieldDefnShadow *self){
5339 3 : return OGR_Fld_IsDefaultDriverSpecific( self );
5340 : }
5341 32 : SWIGINTERN char const *OGRFieldDefnShadow_GetDomainName(OGRFieldDefnShadow *self){
5342 32 : return OGR_Fld_GetDomainName(self);
5343 : }
5344 21 : SWIGINTERN void OGRFieldDefnShadow_SetDomainName(OGRFieldDefnShadow *self,char const *name){
5345 21 : OGR_Fld_SetDomainName( self, name );
5346 21 : }
5347 58 : SWIGINTERN char const *OGRFieldDefnShadow_GetComment(OGRFieldDefnShadow *self){
5348 58 : return OGR_Fld_GetComment(self);
5349 : }
5350 32 : SWIGINTERN void OGRFieldDefnShadow_SetComment(OGRFieldDefnShadow *self,char const *comment){
5351 32 : OGR_Fld_SetComment( self, comment );
5352 32 : }
5353 171 : SWIGINTERN void delete_OGRGeomFieldDefnShadow(OGRGeomFieldDefnShadow *self){
5354 171 : OGR_GFld_Destroy(self);
5355 171 : }
5356 171 : SWIGINTERN OGRGeomFieldDefnShadow *new_OGRGeomFieldDefnShadow(char const *name_null_ok="",OGRwkbGeometryType field_type=wkbUnknown){
5357 171 : if( ValidateOGRGeometryType(field_type) )
5358 171 : return (OGRGeomFieldDefnShadow*) OGR_GFld_Create(name_null_ok, field_type);
5359 : else
5360 : return NULL;
5361 : }
5362 229 : SWIGINTERN char const *OGRGeomFieldDefnShadow_GetName(OGRGeomFieldDefnShadow *self){
5363 229 : return OGR_GFld_GetNameRef(self);
5364 : }
5365 82 : SWIGINTERN char const *OGRGeomFieldDefnShadow_GetNameRef(OGRGeomFieldDefnShadow *self){
5366 82 : return OGR_GFld_GetNameRef(self);
5367 : }
5368 4 : SWIGINTERN void OGRGeomFieldDefnShadow_SetName(OGRGeomFieldDefnShadow *self,char const *name){
5369 4 : OGR_GFld_SetName(self, name);
5370 4 : }
5371 85 : SWIGINTERN OGRwkbGeometryType OGRGeomFieldDefnShadow_GetType(OGRGeomFieldDefnShadow *self){
5372 85 : return OGR_GFld_GetType(self);
5373 : }
5374 2 : SWIGINTERN void OGRGeomFieldDefnShadow_SetType(OGRGeomFieldDefnShadow *self,OGRwkbGeometryType type){
5375 2 : if( ValidateOGRGeometryType(type) )
5376 1 : OGR_GFld_SetType(self, type);
5377 2 : }
5378 81 : SWIGINTERN OSRSpatialReferenceShadow *OGRGeomFieldDefnShadow_GetSpatialRef(OGRGeomFieldDefnShadow *self){
5379 162 : OGRSpatialReferenceH ref = OGR_GFld_GetSpatialRef(self);
5380 81 : if( ref )
5381 70 : OSRReference(ref);
5382 81 : return (OSRSpatialReferenceShadow*) ref;
5383 : }
5384 48 : SWIGINTERN void OGRGeomFieldDefnShadow_SetSpatialRef(OGRGeomFieldDefnShadow *self,OSRSpatialReferenceShadow *srs){
5385 48 : OGR_GFld_SetSpatialRef( self, (OGRSpatialReferenceH)srs );
5386 48 : }
5387 6 : SWIGINTERN int OGRGeomFieldDefnShadow_IsIgnored(OGRGeomFieldDefnShadow *self){
5388 6 : return OGR_GFld_IsIgnored( self );
5389 : }
5390 1 : SWIGINTERN void OGRGeomFieldDefnShadow_SetIgnored(OGRGeomFieldDefnShadow *self,int bIgnored){
5391 1 : OGR_GFld_SetIgnored( self, bIgnored );
5392 1 : }
5393 85 : SWIGINTERN int OGRGeomFieldDefnShadow_IsNullable(OGRGeomFieldDefnShadow *self){
5394 85 : return OGR_GFld_IsNullable( self );
5395 : }
5396 23 : SWIGINTERN void OGRGeomFieldDefnShadow_SetNullable(OGRGeomFieldDefnShadow *self,int bNullable){
5397 23 : return OGR_GFld_SetNullable( self, bNullable );
5398 : }
5399 42 : SWIGINTERN OGRGeomCoordinatePrecisionShadow *OGRGeomFieldDefnShadow_GetCoordinatePrecision(OGRGeomFieldDefnShadow *self){
5400 42 : return OGR_GFld_GetCoordinatePrecision(self);
5401 : }
5402 18 : SWIGINTERN void OGRGeomFieldDefnShadow_SetCoordinatePrecision(OGRGeomFieldDefnShadow *self,OGRGeomCoordinatePrecisionShadow *coordPrec){
5403 18 : OGR_GFld_SetCoordinatePrecision(self, coordPrec);
5404 18 : }
5405 :
5406 31028 : OGRGeometryShadow* CreateGeometryFromWkb( size_t len, char *bin_string,
5407 : OSRSpatialReferenceShadow *reference=NULL ) {
5408 31028 : OGRGeometryH geom = NULL;
5409 31028 : OGRErr err = OGR_G_CreateFromWkbEx( (unsigned char *) bin_string,
5410 : reference,
5411 : &geom,
5412 : len );
5413 31028 : if (err != 0 ) {
5414 5472 : CPLError(CE_Failure, err, "%s", OGRErrMessages(err));
5415 5472 : return NULL;
5416 : }
5417 25556 : return (OGRGeometryShadow*) geom;
5418 : }
5419 :
5420 :
5421 :
5422 : static bool
5423 31028 : GetBufferAsCharPtrSizetSize( PyObject* input, size_t *nLen, char **pBuf, int *alloc, bool *viewIsValid, Py_buffer *view ) {
5424 31028 : {
5425 31028 : if (PyObject_GetBuffer(input, view, PyBUF_SIMPLE) == 0)
5426 : {
5427 31021 : *viewIsValid = true;
5428 31021 : *nLen = view->len;
5429 31021 : *pBuf = (char*) view->buf;
5430 31021 : return true;
5431 : }
5432 : else
5433 : {
5434 7 : PyErr_Clear();
5435 : }
5436 : }
5437 7 : if (PyUnicode_Check(input))
5438 : {
5439 7 : size_t safeLen = 0;
5440 7 : int ret;
5441 7 : try {
5442 7 : ret = SWIG_AsCharPtrAndSize(input, pBuf, &safeLen, alloc);
5443 : }
5444 0 : catch( const std::exception& )
5445 : {
5446 0 : PyErr_SetString(PyExc_MemoryError, "out of memory");
5447 0 : return false;
5448 : }
5449 7 : if (!SWIG_IsOK(ret)) {
5450 0 : PyErr_SetString(PyExc_RuntimeError, "invalid Unicode string" );
5451 0 : return false;
5452 : }
5453 :
5454 7 : if (safeLen) safeLen--;
5455 7 : *nLen = safeLen;
5456 7 : return true;
5457 : }
5458 : else
5459 : {
5460 0 : PyErr_SetString(PyExc_RuntimeError, "not a unicode string, bytes, bytearray or memoryview");
5461 0 : return false;
5462 : }
5463 : }
5464 :
5465 :
5466 : SWIGINTERN int
5467 : SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
5468 : {
5469 : #if PY_VERSION_HEX < 0x03000000
5470 : if (PyInt_Check(obj)) {
5471 : long v = PyInt_AsLong(obj);
5472 : if (v >= 0) {
5473 : if (val) *val = v;
5474 : return SWIG_OK;
5475 : } else {
5476 : return SWIG_OverflowError;
5477 : }
5478 : } else
5479 : #endif
5480 : if (PyLong_Check(obj)) {
5481 : unsigned long v = PyLong_AsUnsignedLong(obj);
5482 : if (!PyErr_Occurred()) {
5483 : if (val) *val = v;
5484 : return SWIG_OK;
5485 : } else {
5486 : PyErr_Clear();
5487 : return SWIG_OverflowError;
5488 : }
5489 : }
5490 : #ifdef SWIG_PYTHON_CAST_MODE
5491 : {
5492 : int dispatch = 0;
5493 : unsigned long v = PyLong_AsUnsignedLong(obj);
5494 : if (!PyErr_Occurred()) {
5495 : if (val) *val = v;
5496 : return SWIG_AddCast(SWIG_OK);
5497 : } else {
5498 : PyErr_Clear();
5499 : }
5500 : if (!dispatch) {
5501 : double d;
5502 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
5503 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
5504 : if (val) *val = (unsigned long)(d);
5505 : return res;
5506 : }
5507 : }
5508 : }
5509 : #endif
5510 : return SWIG_TypeError;
5511 : }
5512 :
5513 :
5514 : #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
5515 : # define SWIG_LONG_LONG_AVAILABLE
5516 : #endif
5517 :
5518 :
5519 : #ifdef SWIG_LONG_LONG_AVAILABLE
5520 : SWIGINTERN int
5521 : SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
5522 : {
5523 : int res = SWIG_TypeError;
5524 : if (PyLong_Check(obj)) {
5525 : unsigned long long v = PyLong_AsUnsignedLongLong(obj);
5526 : if (!PyErr_Occurred()) {
5527 : if (val) *val = v;
5528 : return SWIG_OK;
5529 : } else {
5530 : PyErr_Clear();
5531 : res = SWIG_OverflowError;
5532 : }
5533 : } else {
5534 : unsigned long v;
5535 : res = SWIG_AsVal_unsigned_SS_long (obj,&v);
5536 : if (SWIG_IsOK(res)) {
5537 : if (val) *val = v;
5538 : return res;
5539 : }
5540 : }
5541 : #ifdef SWIG_PYTHON_CAST_MODE
5542 : {
5543 : const double mant_max = 1LL << DBL_MANT_DIG;
5544 : double d;
5545 : res = SWIG_AsVal_double (obj,&d);
5546 : if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
5547 : return SWIG_OverflowError;
5548 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
5549 : if (val) *val = (unsigned long long)(d);
5550 : return SWIG_AddCast(res);
5551 : }
5552 : res = SWIG_TypeError;
5553 : }
5554 : #endif
5555 : return res;
5556 : }
5557 : #endif
5558 :
5559 :
5560 : SWIGINTERNINLINE int
5561 : SWIG_AsVal_size_t (PyObject * obj, size_t *val)
5562 : {
5563 : int res = SWIG_TypeError;
5564 : #ifdef SWIG_LONG_LONG_AVAILABLE
5565 : if (sizeof(size_t) <= sizeof(unsigned long)) {
5566 : #endif
5567 : unsigned long v;
5568 : res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
5569 : if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
5570 : #ifdef SWIG_LONG_LONG_AVAILABLE
5571 : } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
5572 : unsigned long long v;
5573 : res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
5574 : if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
5575 : }
5576 : #endif
5577 : return res;
5578 : }
5579 :
5580 :
5581 115323 : OGRGeometryShadow* CreateGeometryFromWkt( char **val,
5582 : OSRSpatialReferenceShadow *reference=NULL ) {
5583 115323 : OGRGeometryH geom = NULL;
5584 115323 : OGRErr err = OGR_G_CreateFromWkt(val,
5585 : reference,
5586 : &geom);
5587 115323 : if (err != 0 ) {
5588 237 : CPLError(CE_Failure, err, "%s", OGRErrMessages(err));
5589 237 : return NULL;
5590 : }
5591 115086 : return (OGRGeometryShadow*) geom;
5592 : }
5593 :
5594 :
5595 :
5596 287 : OGRGeometryShadow *CreateGeometryFromGML( const char * input_string ) {
5597 287 : OGRGeometryShadow* geom = (OGRGeometryShadow*)OGR_G_CreateFromGML(input_string);
5598 287 : return geom;
5599 : }
5600 :
5601 :
5602 :
5603 42 : OGRGeometryShadow *CreateGeometryFromJson( const char * input_string ) {
5604 42 : OGRGeometryShadow* geom = (OGRGeometryShadow*)OGR_G_CreateGeometryFromJson(input_string);
5605 42 : return geom;
5606 : }
5607 :
5608 :
5609 :
5610 2 : OGRGeometryShadow *CreateGeometryFromEsriJson( const char * input_string ) {
5611 2 : OGRGeometryShadow* geom = (OGRGeometryShadow*)OGR_G_CreateGeometryFromEsriJson(input_string);
5612 2 : return geom;
5613 : }
5614 :
5615 :
5616 :
5617 5 : OGRGeometryShadow* BuildPolygonFromEdges( OGRGeometryShadow* hLineCollection,
5618 : int bBestEffort = 0,
5619 : int bAutoClose = 0,
5620 : double dfTolerance=0) {
5621 :
5622 5 : OGRGeometryH hPolygon = NULL;
5623 :
5624 5 : OGRErr eErr;
5625 :
5626 5 : hPolygon = OGRBuildPolygonFromEdges( hLineCollection, bBestEffort,
5627 : bAutoClose, dfTolerance, &eErr );
5628 :
5629 5 : if (eErr != OGRERR_NONE ) {
5630 2 : CPLError(CE_Failure, eErr, "%s", OGRErrMessages(eErr));
5631 2 : return NULL;
5632 : }
5633 :
5634 : return (OGRGeometryShadow* )hPolygon;
5635 : }
5636 :
5637 :
5638 1 : OGRGeometryShadow* ApproximateArcAngles(
5639 : double dfCenterX, double dfCenterY, double dfZ,
5640 : double dfPrimaryRadius, double dfSecondaryAxis, double dfRotation,
5641 : double dfStartAngle, double dfEndAngle,
5642 : double dfMaxAngleStepSizeDegrees ) {
5643 :
5644 1 : return (OGRGeometryShadow* )OGR_G_ApproximateArcAngles(
5645 : dfCenterX, dfCenterY, dfZ,
5646 : dfPrimaryRadius, dfSecondaryAxis, dfRotation,
5647 1 : dfStartAngle, dfEndAngle, dfMaxAngleStepSizeDegrees );
5648 : }
5649 :
5650 :
5651 46 : OGRGeometryShadow* ForceToPolygon( OGRGeometryShadow *geom_in ) {
5652 46 : if (geom_in == NULL)
5653 : return NULL;
5654 45 : return (OGRGeometryShadow* )OGR_G_ForceToPolygon( OGR_G_Clone(geom_in) );
5655 : }
5656 :
5657 :
5658 60 : OGRGeometryShadow* ForceToLineString( OGRGeometryShadow *geom_in ) {
5659 60 : if (geom_in == NULL)
5660 : return NULL;
5661 59 : return (OGRGeometryShadow* )OGR_G_ForceToLineString( OGR_G_Clone(geom_in) );
5662 : }
5663 :
5664 :
5665 47 : OGRGeometryShadow* ForceToMultiPolygon( OGRGeometryShadow *geom_in ) {
5666 47 : if (geom_in == NULL)
5667 : return NULL;
5668 46 : return (OGRGeometryShadow* )OGR_G_ForceToMultiPolygon( OGR_G_Clone(geom_in) );
5669 : }
5670 :
5671 :
5672 42 : OGRGeometryShadow* ForceToMultiPoint( OGRGeometryShadow *geom_in ) {
5673 42 : if (geom_in == NULL)
5674 : return NULL;
5675 41 : return (OGRGeometryShadow* )OGR_G_ForceToMultiPoint( OGR_G_Clone(geom_in) );
5676 : }
5677 :
5678 :
5679 50 : OGRGeometryShadow* ForceToMultiLineString( OGRGeometryShadow *geom_in ) {
5680 50 : if (geom_in == NULL)
5681 : return NULL;
5682 49 : return (OGRGeometryShadow* )OGR_G_ForceToMultiLineString( OGR_G_Clone(geom_in) );
5683 : }
5684 :
5685 :
5686 831 : OGRGeometryShadow* ForceTo( OGRGeometryShadow *geom_in, OGRwkbGeometryType eTargetType, char** options = NULL ) {
5687 831 : if (geom_in == NULL)
5688 : return NULL;
5689 819 : return (OGRGeometryShadow* )OGR_G_ForceTo( OGR_G_Clone(geom_in), eTargetType, options );
5690 : }
5691 :
5692 287469 : SWIGINTERN void delete_OGRGeometryShadow(OGRGeometryShadow *self){
5693 287469 : OGR_G_DestroyGeometry( self );
5694 287469 : }
5695 160954 : SWIGINTERN OGRGeometryShadow *new_OGRGeometryShadow(OGRwkbGeometryType type=wkbUnknown,char *wkt=0,int wkb=0,char *wkb_buf=0,char *gml=0){
5696 160954 : if (type != wkbUnknown ) {
5697 160791 : return (OGRGeometryShadow*) OGR_G_CreateGeometry( type );
5698 : }
5699 163 : else if ( wkt != 0 ) {
5700 162 : return CreateGeometryFromWkt( &wkt );
5701 : }
5702 1 : else if ( wkb != 0 ) {
5703 0 : return CreateGeometryFromWkb( wkb, wkb_buf );
5704 : }
5705 1 : else if ( gml != 0 ) {
5706 0 : return CreateGeometryFromGML( gml );
5707 : }
5708 : // throw?
5709 : else {
5710 1 : CPLError(CE_Failure, 1, "Empty geometries cannot be constructed");
5711 1 : return NULL;}
5712 :
5713 : }
5714 2403 : SWIGINTERN OGRErr OGRGeometryShadow_ExportToWkt(OGRGeometryShadow *self,char **argout){
5715 2403 : return OGR_G_ExportToWkt(self, argout);
5716 : }
5717 5407 : SWIGINTERN OGRErr OGRGeometryShadow_ExportToIsoWkt(OGRGeometryShadow *self,char **argout){
5718 5407 : return OGR_G_ExportToIsoWkt(self, argout);
5719 : }
5720 103 : SWIGINTERN OGRErr OGRGeometryShadow_ExportToWkb(OGRGeometryShadow *self,size_t *nLen,char **pBuf,OGRwkbByteOrder byte_order=wkbNDR){
5721 103 : *nLen = OGR_G_WkbSizeEx( self );
5722 103 : *pBuf = (char *) VSI_MALLOC_VERBOSE( *nLen );
5723 103 : if( *pBuf == NULL )
5724 : return 6;
5725 103 : return OGR_G_ExportToWkb(self, byte_order, (unsigned char*) *pBuf );
5726 : }
5727 10570 : SWIGINTERN OGRErr OGRGeometryShadow_ExportToIsoWkb(OGRGeometryShadow *self,size_t *nLen,char **pBuf,OGRwkbByteOrder byte_order=wkbNDR){
5728 10570 : *nLen = OGR_G_WkbSizeEx( self );
5729 10570 : *pBuf = (char *) VSI_MALLOC_VERBOSE( *nLen );
5730 10570 : if( *pBuf == NULL )
5731 : return 6;
5732 10570 : return OGR_G_ExportToIsoWkb(self, byte_order, (unsigned char*) *pBuf );
5733 : }
5734 66 : SWIGINTERN retStringAndCPLFree *OGRGeometryShadow_ExportToGML(OGRGeometryShadow *self,char **options=0){
5735 66 : return (retStringAndCPLFree*) OGR_G_ExportToGMLEx(self, options);
5736 : }
5737 0 : SWIGINTERN retStringAndCPLFree *OGRGeometryShadow_ExportToKML(OGRGeometryShadow *self,char const *altitude_mode=NULL){
5738 0 : return (retStringAndCPLFree *) OGR_G_ExportToKML(self, altitude_mode);
5739 : }
5740 88 : SWIGINTERN retStringAndCPLFree *OGRGeometryShadow_ExportToJson(OGRGeometryShadow *self,char **options=0){
5741 88 : return (retStringAndCPLFree *) OGR_G_ExportToJsonEx(self, options);
5742 : }
5743 254 : SWIGINTERN void OGRGeometryShadow_AddPoint(OGRGeometryShadow *self,double x,double y,double z=0){
5744 254 : OGR_G_AddPoint( self, x, y, z );
5745 254 : }
5746 0 : SWIGINTERN void OGRGeometryShadow_AddPointM(OGRGeometryShadow *self,double x,double y,double m){
5747 0 : OGR_G_AddPointM( self, x, y, m );
5748 0 : }
5749 0 : SWIGINTERN void OGRGeometryShadow_AddPointZM(OGRGeometryShadow *self,double x,double y,double z,double m){
5750 0 : OGR_G_AddPointZM( self, x, y, z, m );
5751 0 : }
5752 1249 : SWIGINTERN void OGRGeometryShadow_AddPoint_2D(OGRGeometryShadow *self,double x,double y){
5753 1249 : OGR_G_AddPoint_2D( self, x, y );
5754 1249 : }
5755 9 : SWIGINTERN OGRErr OGRGeometryShadow_AddGeometryDirectly(OGRGeometryShadow *self,OGRGeometryShadow *other_disown){
5756 9 : return OGR_G_AddGeometryDirectly( self, other_disown );
5757 : }
5758 104 : SWIGINTERN OGRErr OGRGeometryShadow_AddGeometry(OGRGeometryShadow *self,OGRGeometryShadow *other){
5759 104 : return OGR_G_AddGeometry( self, other );
5760 : }
5761 87 : SWIGINTERN OGRErr OGRGeometryShadow_RemoveGeometry(OGRGeometryShadow *self,int iSubGeom){
5762 87 : return OGR_G_RemoveGeometry( self, iSubGeom, TRUE );
5763 : }
5764 12445 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Clone(OGRGeometryShadow *self){
5765 12445 : return (OGRGeometryShadow*) OGR_G_Clone(self);
5766 : }
5767 3879 : SWIGINTERN OGRwkbGeometryType OGRGeometryShadow_GetGeometryType(OGRGeometryShadow *self){
5768 3879 : return (OGRwkbGeometryType) OGR_G_GetGeometryType(self);
5769 : }
5770 16093 : SWIGINTERN char const *OGRGeometryShadow_GetGeometryName(OGRGeometryShadow *self){
5771 16093 : return (const char *) OGR_G_GetGeometryName(self);
5772 : }
5773 28 : SWIGINTERN double OGRGeometryShadow_Length(OGRGeometryShadow *self){
5774 28 : return OGR_G_Length(self);
5775 : }
5776 21 : SWIGINTERN double OGRGeometryShadow_Area(OGRGeometryShadow *self){
5777 21 : return OGR_G_Area(self);
5778 : }
5779 25 : SWIGINTERN double OGRGeometryShadow_GeodesicLength(OGRGeometryShadow *self){
5780 25 : return OGR_G_GeodesicLength(self);
5781 : }
5782 24 : SWIGINTERN double OGRGeometryShadow_GeodesicArea(OGRGeometryShadow *self){
5783 24 : return OGR_G_GeodesicArea(self);
5784 : }
5785 33 : SWIGINTERN bool OGRGeometryShadow_IsClockwise(OGRGeometryShadow *self){
5786 33 : return OGR_G_IsClockwise(self);
5787 : }
5788 1386 : SWIGINTERN double OGRGeometryShadow_GetArea(OGRGeometryShadow *self){
5789 1386 : return OGR_G_Area(self);
5790 : }
5791 12843 : SWIGINTERN int OGRGeometryShadow_GetPointCount(OGRGeometryShadow *self){
5792 12843 : return OGR_G_GetPointCount(self);
5793 : }
5794 11 : SWIGINTERN void OGRGeometryShadow_GetPoints(OGRGeometryShadow *self,int *pnCount,double **ppadfXY,double **ppadfZ,int nCoordDimension=0){
5795 11 : int nPoints = OGR_G_GetPointCount(self);
5796 11 : *pnCount = nPoints;
5797 11 : if (nPoints == 0)
5798 : {
5799 1 : *ppadfXY = NULL;
5800 1 : *ppadfZ = NULL;
5801 : }
5802 11 : *ppadfXY = (double*)VSIMalloc(2 * sizeof(double) * nPoints);
5803 11 : if (*ppadfXY == NULL)
5804 : {
5805 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Cannot allocate resulting array");
5806 0 : *pnCount = 0;
5807 0 : return;
5808 : }
5809 11 : if (nCoordDimension <= 0)
5810 7 : nCoordDimension = OGR_G_GetCoordinateDimension(self);
5811 11 : *ppadfZ = (nCoordDimension == 3) ? (double*)VSIMalloc(sizeof(double) * nPoints) : NULL;
5812 11 : OGR_G_GetPoints(self,
5813 : *ppadfXY, 2 * sizeof(double),
5814 11 : (*ppadfXY) + 1, 2 * sizeof(double),
5815 : *ppadfZ, sizeof(double));
5816 : }
5817 32008 : SWIGINTERN double OGRGeometryShadow_GetX(OGRGeometryShadow *self,int point=0){
5818 32008 : return OGR_G_GetX(self, point);
5819 : }
5820 30799 : SWIGINTERN double OGRGeometryShadow_GetY(OGRGeometryShadow *self,int point=0){
5821 30799 : return OGR_G_GetY(self, point);
5822 : }
5823 15322 : SWIGINTERN double OGRGeometryShadow_GetZ(OGRGeometryShadow *self,int point=0){
5824 15322 : return OGR_G_GetZ(self, point);
5825 : }
5826 2264 : SWIGINTERN double OGRGeometryShadow_GetM(OGRGeometryShadow *self,int point=0){
5827 2264 : return OGR_G_GetM(self, point);
5828 : }
5829 217 : SWIGINTERN void OGRGeometryShadow_GetPoint(OGRGeometryShadow *self,int iPoint=0,double argout[3]=NULL){
5830 :
5831 217 : OGR_G_GetPoint( self, iPoint, argout+0, argout+1, argout+2 );
5832 217 : }
5833 1 : SWIGINTERN void OGRGeometryShadow_GetPointZM(OGRGeometryShadow *self,int iPoint=0,double argout[4]=NULL){
5834 :
5835 1 : OGR_G_GetPointZM( self, iPoint, argout+0, argout+1, argout+2, argout+3 );
5836 1 : }
5837 3 : SWIGINTERN void OGRGeometryShadow_GetPoint_2D(OGRGeometryShadow *self,int iPoint=0,double argout[2]=NULL){
5838 :
5839 3 : OGR_G_GetPoint( self, iPoint, argout+0, argout+1, NULL );
5840 3 : }
5841 12106 : SWIGINTERN int OGRGeometryShadow_GetGeometryCount(OGRGeometryShadow *self){
5842 12106 : return OGR_G_GetGeometryCount(self);
5843 : }
5844 168 : SWIGINTERN void OGRGeometryShadow_SetPoint(OGRGeometryShadow *self,int point,double x,double y,double z=0){
5845 168 : OGR_G_SetPoint(self, point, x, y, z);
5846 168 : }
5847 0 : SWIGINTERN void OGRGeometryShadow_SetPointM(OGRGeometryShadow *self,int point,double x,double y,double m){
5848 0 : OGR_G_SetPointM(self, point, x, y, m);
5849 0 : }
5850 0 : SWIGINTERN void OGRGeometryShadow_SetPointZM(OGRGeometryShadow *self,int point,double x,double y,double z,double m){
5851 0 : OGR_G_SetPointZM(self, point, x, y, z, m);
5852 0 : }
5853 160062 : SWIGINTERN void OGRGeometryShadow_SetPoint_2D(OGRGeometryShadow *self,int point,double x,double y){
5854 160062 : OGR_G_SetPoint_2D(self, point, x, y);
5855 160062 : }
5856 2 : SWIGINTERN void OGRGeometryShadow_SwapXY(OGRGeometryShadow *self){
5857 2 : OGR_G_SwapXY(self);
5858 2 : }
5859 2943 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_GetGeometryRef(OGRGeometryShadow *self,int geom){
5860 2943 : return (OGRGeometryShadow*) OGR_G_GetGeometryRef(self, geom);
5861 : }
5862 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Simplify(OGRGeometryShadow *self,double tolerance){
5863 1 : return (OGRGeometryShadow*) OGR_G_Simplify(self, tolerance);
5864 : }
5865 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_SimplifyPreserveTopology(OGRGeometryShadow *self,double tolerance){
5866 1 : return (OGRGeometryShadow*) OGR_G_SimplifyPreserveTopology(self, tolerance);
5867 : }
5868 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_DelaunayTriangulation(OGRGeometryShadow *self,double dfTolerance=0.0,int bOnlyEdges=FALSE){
5869 1 : return (OGRGeometryShadow*) OGR_G_DelaunayTriangulation(self, dfTolerance, bOnlyEdges);
5870 : }
5871 3 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Polygonize(OGRGeometryShadow *self){
5872 3 : return (OGRGeometryShadow*) OGR_G_Polygonize(self);
5873 : }
5874 0 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_BuildArea(OGRGeometryShadow *self){
5875 0 : return (OGRGeometryShadow*) OGR_G_BuildArea(self);
5876 : }
5877 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Boundary(OGRGeometryShadow *self){
5878 1 : return (OGRGeometryShadow*) OGR_G_Boundary(self);
5879 : }
5880 5 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_GetBoundary(OGRGeometryShadow *self){
5881 5 : return (OGRGeometryShadow*) OGR_G_Boundary(self);
5882 : }
5883 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_ConvexHull(OGRGeometryShadow *self){
5884 1 : return (OGRGeometryShadow*) OGR_G_ConvexHull(self);
5885 : }
5886 2 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_ConcaveHull(OGRGeometryShadow *self,double ratio,bool allowHoles){
5887 2 : return (OGRGeometryShadow*) OGR_G_ConcaveHull(self, ratio, allowHoles);
5888 : }
5889 11 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_MakeValid(OGRGeometryShadow *self,char **options=NULL){
5890 11 : return (OGRGeometryShadow*) OGR_G_MakeValidEx(self, options);
5891 : }
5892 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_SetPrecision(OGRGeometryShadow *self,double gridSize,int flags=0){
5893 1 : return (OGRGeometryShadow*) OGR_G_SetPrecision(self, gridSize, flags);
5894 : }
5895 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Normalize(OGRGeometryShadow *self){
5896 1 : return (OGRGeometryShadow*) OGR_G_Normalize(self);
5897 : }
5898 18 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_RemoveLowerDimensionSubGeoms(OGRGeometryShadow *self){
5899 18 : return (OGRGeometryShadow*) OGR_G_RemoveLowerDimensionSubGeoms(self);
5900 : }
5901 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Buffer__SWIG_0(OGRGeometryShadow *self,double distance,int quadsecs=30){
5902 : return (OGRGeometryShadow*) OGR_G_Buffer( self, distance, quadsecs );
5903 : }
5904 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Buffer__SWIG_1(OGRGeometryShadow *self,double distance,char **options){
5905 : return (OGRGeometryShadow*) OGR_G_BufferEx( self, distance, options );
5906 : }
5907 11 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Intersection(OGRGeometryShadow *self,OGRGeometryShadow *other){
5908 11 : return (OGRGeometryShadow*) OGR_G_Intersection( self, other );
5909 : }
5910 7 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Union(OGRGeometryShadow *self,OGRGeometryShadow *other){
5911 7 : return (OGRGeometryShadow*) OGR_G_Union( self, other );
5912 : }
5913 2 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_UnionCascaded(OGRGeometryShadow *self){
5914 2 : return (OGRGeometryShadow*) OGR_G_UnionCascaded( self );
5915 : }
5916 2 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_UnaryUnion(OGRGeometryShadow *self){
5917 2 : return (OGRGeometryShadow*) OGR_G_UnaryUnion( self );
5918 : }
5919 5 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Difference(OGRGeometryShadow *self,OGRGeometryShadow *other){
5920 5 : return (OGRGeometryShadow*) OGR_G_Difference( self, other );
5921 : }
5922 5 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_SymDifference(OGRGeometryShadow *self,OGRGeometryShadow *other){
5923 5 : return (OGRGeometryShadow*) OGR_G_SymDifference( self, other );
5924 : }
5925 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_SymmetricDifference(OGRGeometryShadow *self,OGRGeometryShadow *other){
5926 1 : return (OGRGeometryShadow*) OGR_G_SymDifference( self, other );
5927 : }
5928 1 : SWIGINTERN double OGRGeometryShadow_Distance(OGRGeometryShadow *self,OGRGeometryShadow *other){
5929 1 : return OGR_G_Distance(self, other);
5930 : }
5931 1 : SWIGINTERN double OGRGeometryShadow_Distance3D(OGRGeometryShadow *self,OGRGeometryShadow *other){
5932 1 : return OGR_G_Distance3D(self, other);
5933 : }
5934 4 : SWIGINTERN void OGRGeometryShadow_Empty(OGRGeometryShadow *self){
5935 4 : OGR_G_Empty(self);
5936 4 : }
5937 2128 : SWIGINTERN bool OGRGeometryShadow_IsEmpty(OGRGeometryShadow *self){
5938 4256 : return (OGR_G_IsEmpty(self) > 0);
5939 : }
5940 19 : SWIGINTERN bool OGRGeometryShadow_IsValid(OGRGeometryShadow *self){
5941 38 : return (OGR_G_IsValid(self) > 0);
5942 : }
5943 5 : SWIGINTERN bool OGRGeometryShadow_IsSimple(OGRGeometryShadow *self){
5944 10 : return (OGR_G_IsSimple(self) > 0);
5945 : }
5946 1 : SWIGINTERN bool OGRGeometryShadow_IsRing(OGRGeometryShadow *self){
5947 2 : return (OGR_G_IsRing(self) > 0);
5948 : }
5949 7 : SWIGINTERN bool OGRGeometryShadow_Intersects(OGRGeometryShadow *self,OGRGeometryShadow *other){
5950 14 : return (OGR_G_Intersects(self, other) > 0);
5951 : }
5952 2 : SWIGINTERN bool OGRGeometryShadow_Intersect(OGRGeometryShadow *self,OGRGeometryShadow *other){
5953 4 : return (OGR_G_Intersects(self, other) > 0);
5954 : }
5955 27981 : SWIGINTERN bool OGRGeometryShadow_Equals(OGRGeometryShadow *self,OGRGeometryShadow *other){
5956 55962 : return (OGR_G_Equals(self, other) > 0);
5957 : }
5958 170 : SWIGINTERN bool OGRGeometryShadow_Equal(OGRGeometryShadow *self,OGRGeometryShadow *other){
5959 340 : return (OGR_G_Equals(self, other) > 0);
5960 : }
5961 6 : SWIGINTERN bool OGRGeometryShadow_Disjoint(OGRGeometryShadow *self,OGRGeometryShadow *other){
5962 12 : return (OGR_G_Disjoint(self, other) > 0);
5963 : }
5964 6 : SWIGINTERN bool OGRGeometryShadow_Touches(OGRGeometryShadow *self,OGRGeometryShadow *other){
5965 12 : return (OGR_G_Touches(self, other) > 0);
5966 : }
5967 6 : SWIGINTERN bool OGRGeometryShadow_Crosses(OGRGeometryShadow *self,OGRGeometryShadow *other){
5968 12 : return (OGR_G_Crosses(self, other) > 0);
5969 : }
5970 6196 : SWIGINTERN bool OGRGeometryShadow_Within(OGRGeometryShadow *self,OGRGeometryShadow *other){
5971 12392 : return (OGR_G_Within(self, other) > 0);
5972 : }
5973 9 : SWIGINTERN bool OGRGeometryShadow_Contains(OGRGeometryShadow *self,OGRGeometryShadow *other){
5974 18 : return (OGR_G_Contains(self, other) > 0);
5975 : }
5976 6 : SWIGINTERN bool OGRGeometryShadow_Overlaps(OGRGeometryShadow *self,OGRGeometryShadow *other){
5977 12 : return (OGR_G_Overlaps(self, other) > 0);
5978 : }
5979 9 : SWIGINTERN OGRErr OGRGeometryShadow_TransformTo(OGRGeometryShadow *self,OSRSpatialReferenceShadow *reference){
5980 9 : return OGR_G_TransformTo(self, reference);
5981 : }
5982 : SWIGINTERN OGRErr OGRGeometryShadow_Transform__SWIG_0(OGRGeometryShadow *self,OSRCoordinateTransformationShadow *trans){
5983 : return OGR_G_Transform(self, trans);
5984 : }
5985 48 : SWIGINTERN OSRSpatialReferenceShadow *OGRGeometryShadow_GetSpatialReference(OGRGeometryShadow *self){
5986 96 : OGRSpatialReferenceH ref = OGR_G_GetSpatialReference(self);
5987 48 : if( ref )
5988 47 : OSRReference(ref);
5989 48 : return (OSRSpatialReferenceShadow*) ref;
5990 : }
5991 74 : SWIGINTERN void OGRGeometryShadow_AssignSpatialReference(OGRGeometryShadow *self,OSRSpatialReferenceShadow *reference){
5992 74 : OGR_G_AssignSpatialReference(self, reference);
5993 74 : }
5994 6 : SWIGINTERN void OGRGeometryShadow_CloseRings(OGRGeometryShadow *self){
5995 6 : OGR_G_CloseRings(self);
5996 6 : }
5997 31 : SWIGINTERN void OGRGeometryShadow_FlattenTo2D(OGRGeometryShadow *self){
5998 31 : OGR_G_FlattenTo2D(self);
5999 31 : }
6000 21 : SWIGINTERN void OGRGeometryShadow_Segmentize(OGRGeometryShadow *self,double dfMaxLength){
6001 21 : OGR_G_Segmentize(self, dfMaxLength);
6002 21 : }
6003 13140 : SWIGINTERN void OGRGeometryShadow_GetEnvelope(OGRGeometryShadow *self,double argout[4]){
6004 13140 : OGR_G_GetEnvelope(self, (OGREnvelope*)argout);
6005 13140 : }
6006 10 : SWIGINTERN void OGRGeometryShadow_GetEnvelope3D(OGRGeometryShadow *self,double argout[6]){
6007 10 : OGR_G_GetEnvelope3D(self, (OGREnvelope3D*)argout);
6008 10 : }
6009 5 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Centroid(OGRGeometryShadow *self){
6010 10 : OGRGeometryShadow *pt = (OGRGeometryShadow*) OGR_G_CreateGeometry( wkbPoint );
6011 5 : OGR_G_Centroid( self, pt );
6012 5 : return pt;
6013 : }
6014 4 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_PointOnSurface(OGRGeometryShadow *self){
6015 4 : return (OGRGeometryShadow*) OGR_G_PointOnSurface( self );
6016 : }
6017 2 : SWIGINTERN size_t OGRGeometryShadow_WkbSize(OGRGeometryShadow *self){
6018 2 : return OGR_G_WkbSizeEx(self);
6019 : }
6020 :
6021 : #define SWIG_From_long PyInt_FromLong
6022 :
6023 :
6024 : SWIGINTERNINLINE PyObject*
6025 2 : SWIG_From_unsigned_SS_long (unsigned long value)
6026 : {
6027 2 : return (value > LONG_MAX) ?
6028 2 : PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
6029 : }
6030 :
6031 :
6032 : #ifdef SWIG_LONG_LONG_AVAILABLE
6033 : SWIGINTERNINLINE PyObject*
6034 : SWIG_From_unsigned_SS_long_SS_long (unsigned long long value)
6035 : {
6036 : return (value > LONG_MAX) ?
6037 : PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
6038 : }
6039 : #endif
6040 :
6041 :
6042 : SWIGINTERNINLINE PyObject *
6043 2 : SWIG_From_size_t (size_t value)
6044 : {
6045 : #ifdef SWIG_LONG_LONG_AVAILABLE
6046 2 : if (sizeof(size_t) <= sizeof(unsigned long)) {
6047 : #endif
6048 2 : return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
6049 : #ifdef SWIG_LONG_LONG_AVAILABLE
6050 : } else {
6051 : /* assume sizeof(size_t) <= sizeof(unsigned long long) */
6052 : return SWIG_From_unsigned_SS_long_SS_long (static_cast< unsigned long long >(value));
6053 : }
6054 : #endif
6055 : }
6056 :
6057 77 : SWIGINTERN int OGRGeometryShadow_GetCoordinateDimension(OGRGeometryShadow *self){
6058 77 : return OGR_G_GetCoordinateDimension(self);
6059 : }
6060 4 : SWIGINTERN int OGRGeometryShadow_CoordinateDimension(OGRGeometryShadow *self){
6061 4 : return OGR_G_CoordinateDimension(self);
6062 : }
6063 34403 : SWIGINTERN int OGRGeometryShadow_Is3D(OGRGeometryShadow *self){
6064 34403 : return OGR_G_Is3D(self);
6065 : }
6066 37494 : SWIGINTERN int OGRGeometryShadow_IsMeasured(OGRGeometryShadow *self){
6067 37494 : return OGR_G_IsMeasured(self);
6068 : }
6069 56 : SWIGINTERN void OGRGeometryShadow_SetCoordinateDimension(OGRGeometryShadow *self,int dimension){
6070 56 : OGR_G_SetCoordinateDimension(self, dimension);
6071 56 : }
6072 154 : SWIGINTERN void OGRGeometryShadow_Set3D(OGRGeometryShadow *self,int b3D){
6073 154 : OGR_G_Set3D(self, b3D);
6074 154 : }
6075 154 : SWIGINTERN void OGRGeometryShadow_SetMeasured(OGRGeometryShadow *self,int bMeasured){
6076 154 : OGR_G_SetMeasured(self, bMeasured);
6077 154 : }
6078 21 : SWIGINTERN int OGRGeometryShadow_GetDimension(OGRGeometryShadow *self){
6079 21 : return OGR_G_GetDimension(self);
6080 : }
6081 29 : SWIGINTERN int OGRGeometryShadow_HasCurveGeometry(OGRGeometryShadow *self,int bLookForCircular=FALSE){
6082 29 : return OGR_G_HasCurveGeometry(self, bLookForCircular);
6083 : }
6084 3086 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_GetLinearGeometry(OGRGeometryShadow *self,double dfMaxAngleStepSizeDegrees=0.0,char **options=NULL){
6085 3086 : return (OGRGeometryShadow* )OGR_G_GetLinearGeometry(self, dfMaxAngleStepSizeDegrees, options);
6086 : }
6087 3067 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_GetCurveGeometry(OGRGeometryShadow *self,char **options=NULL){
6088 3067 : return (OGRGeometryShadow* )OGR_G_GetCurveGeometry(self, options);
6089 : }
6090 22 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Value(OGRGeometryShadow *self,double dfDistance){
6091 22 : return (OGRGeometryShadow*)OGR_G_Value(self, dfDistance);
6092 : }
6093 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Transform__SWIG_1(OGRGeometryShadow *self,OGRGeomTransformerShadow *transformer){
6094 : return (OGRGeometryShadow*)OGR_GeomTransformer_Transform(transformer, self);
6095 : }
6096 1 : SWIGINTERN OGRPreparedGeometryShadow *OGRGeometryShadow_CreatePreparedGeometry(OGRGeometryShadow *self){
6097 1 : return (OGRPreparedGeometryShadow*)OGRCreatePreparedGeometry(self);
6098 : }
6099 1 : SWIGINTERN void delete_OGRPreparedGeometryShadow(OGRPreparedGeometryShadow *self){
6100 1 : OGRDestroyPreparedGeometry( self );
6101 1 : }
6102 3 : SWIGINTERN bool OGRPreparedGeometryShadow_Intersects(OGRPreparedGeometryShadow *self,OGRGeometryShadow const *otherGeom){
6103 6 : return OGRPreparedGeometryIntersects(self, (OGRGeometryH)otherGeom);
6104 : }
6105 3 : SWIGINTERN bool OGRPreparedGeometryShadow_Contains(OGRPreparedGeometryShadow *self,OGRGeometryShadow const *otherGeom){
6106 6 : return OGRPreparedGeometryContains(self, (OGRGeometryH)otherGeom);
6107 : }
6108 6 : SWIGINTERN OGRGeomTransformerShadow *new_OGRGeomTransformerShadow(OSRCoordinateTransformationShadow *ct,char **options=NULL){
6109 6 : return OGR_GeomTransformer_Create(ct, options);
6110 : }
6111 6 : SWIGINTERN void delete_OGRGeomTransformerShadow(OGRGeomTransformerShadow *self){
6112 6 : OGR_GeomTransformer_Destroy( self );
6113 6 : }
6114 2 : SWIGINTERN OGRGeometryShadow *OGRGeomTransformerShadow_Transform(OGRGeomTransformerShadow *self,OGRGeometryShadow *src_geom){
6115 2 : return (OGRGeometryShadow*)OGR_GeomTransformer_Transform(self, src_geom);
6116 : }
6117 42 : SWIGINTERN void delete_OGRFieldDomainShadow(OGRFieldDomainShadow *self){
6118 42 : OGR_FldDomain_Destroy(self);
6119 42 : }
6120 55 : SWIGINTERN char const *OGRFieldDomainShadow_GetName(OGRFieldDomainShadow *self){
6121 55 : return OGR_FldDomain_GetName(self);
6122 : }
6123 58 : SWIGINTERN char const *OGRFieldDomainShadow_GetDescription(OGRFieldDomainShadow *self){
6124 58 : return OGR_FldDomain_GetDescription(self);
6125 : }
6126 58 : SWIGINTERN OGRFieldType OGRFieldDomainShadow_GetFieldType(OGRFieldDomainShadow *self){
6127 58 : return OGR_FldDomain_GetFieldType(self);
6128 : }
6129 38 : SWIGINTERN OGRFieldSubType OGRFieldDomainShadow_GetFieldSubType(OGRFieldDomainShadow *self){
6130 38 : return OGR_FldDomain_GetFieldSubType(self);
6131 : }
6132 52 : SWIGINTERN OGRFieldDomainType OGRFieldDomainShadow_GetDomainType(OGRFieldDomainShadow *self){
6133 52 : return OGR_FldDomain_GetDomainType(self);
6134 : }
6135 2 : SWIGINTERN OGRFieldDomainSplitPolicy OGRFieldDomainShadow_GetSplitPolicy(OGRFieldDomainShadow *self){
6136 2 : return OGR_FldDomain_GetSplitPolicy(self);
6137 : }
6138 1 : SWIGINTERN void OGRFieldDomainShadow_SetSplitPolicy(OGRFieldDomainShadow *self,OGRFieldDomainSplitPolicy policy){
6139 1 : OGR_FldDomain_SetSplitPolicy(self, policy);
6140 1 : }
6141 2 : SWIGINTERN OGRFieldDomainMergePolicy OGRFieldDomainShadow_GetMergePolicy(OGRFieldDomainShadow *self){
6142 2 : return OGR_FldDomain_GetMergePolicy(self);
6143 : }
6144 1 : SWIGINTERN void OGRFieldDomainShadow_SetMergePolicy(OGRFieldDomainShadow *self,OGRFieldDomainMergePolicy policy){
6145 1 : OGR_FldDomain_SetMergePolicy(self, policy);
6146 1 : }
6147 37 : SWIGINTERN OGRCodedValue const *OGRFieldDomainShadow_GetEnumeration(OGRFieldDomainShadow *self){
6148 37 : return OGR_CodedFldDomain_GetEnumeration(self);
6149 : }
6150 11 : SWIGINTERN double OGRFieldDomainShadow_GetMinAsDouble(OGRFieldDomainShadow *self){
6151 11 : const OGRField* psVal = OGR_RangeFldDomain_GetMin(self, NULL);
6152 11 : if( psVal == NULL || OGR_RawField_IsUnset(psVal) )
6153 2 : return CPLAtof("-inf");
6154 9 : const OGRFieldType eType = OGR_FldDomain_GetFieldType(self);
6155 9 : if( eType == OFTInteger )
6156 5 : return psVal->Integer;
6157 4 : if( eType == OFTInteger64 )
6158 2 : return (double)psVal->Integer64;
6159 2 : if( eType == OFTReal )
6160 2 : return psVal->Real;
6161 0 : return CPLAtof("-inf");
6162 : }
6163 2 : SWIGINTERN char const *OGRFieldDomainShadow_GetMinAsString(OGRFieldDomainShadow *self){
6164 2 : const OGRField* psVal = OGR_RangeFldDomain_GetMin(self, NULL);
6165 2 : if( psVal == NULL || OGR_RawField_IsUnset(psVal) )
6166 0 : return NULL;
6167 2 : const OGRFieldType eType = OGR_FldDomain_GetFieldType(self);
6168 2 : if( eType == OFTInteger )
6169 0 : return CPLSPrintf("%d", psVal->Integer);
6170 2 : if( eType == OFTInteger64 )
6171 0 : return CPLSPrintf(CPL_FRMT_GIB, psVal->Integer64);
6172 2 : if( eType == OFTReal )
6173 0 : return CPLSPrintf("%.18g", psVal->Real);
6174 2 : if( eType == OFTDateTime )
6175 2 : return CPLSPrintf("%04d-%02d-%02dT%02d:%02d:%02d",
6176 2 : psVal->Date.Year,
6177 2 : psVal->Date.Month,
6178 2 : psVal->Date.Day,
6179 2 : psVal->Date.Hour,
6180 2 : psVal->Date.Minute,
6181 2 : static_cast<int>(psVal->Date.Second + 0.5));
6182 : return NULL;
6183 : }
6184 7 : SWIGINTERN bool OGRFieldDomainShadow_IsMinInclusive(OGRFieldDomainShadow *self){
6185 7 : bool isInclusive = false;
6186 7 : (void)OGR_RangeFldDomain_GetMin(self, &isInclusive);
6187 7 : return isInclusive;
6188 : }
6189 11 : SWIGINTERN double OGRFieldDomainShadow_GetMaxAsDouble(OGRFieldDomainShadow *self){
6190 11 : const OGRField* psVal = OGR_RangeFldDomain_GetMax(self, NULL);
6191 11 : if( psVal == NULL || OGR_RawField_IsUnset(psVal) )
6192 2 : return CPLAtof("inf");
6193 9 : const OGRFieldType eType = OGR_FldDomain_GetFieldType(self);
6194 9 : if( eType == OFTInteger )
6195 5 : return psVal->Integer;
6196 4 : if( eType == OFTInteger64 )
6197 2 : return (double)psVal->Integer64;
6198 2 : if( eType == OFTReal )
6199 2 : return psVal->Real;
6200 0 : return CPLAtof("inf");
6201 : }
6202 2 : SWIGINTERN char const *OGRFieldDomainShadow_GetMaxAsString(OGRFieldDomainShadow *self){
6203 2 : const OGRField* psVal = OGR_RangeFldDomain_GetMax(self, NULL);
6204 2 : if( psVal == NULL || OGR_RawField_IsUnset(psVal) )
6205 0 : return NULL;
6206 2 : const OGRFieldType eType = OGR_FldDomain_GetFieldType(self);
6207 2 : if( eType == OFTInteger )
6208 0 : return CPLSPrintf("%d", psVal->Integer);
6209 2 : if( eType == OFTInteger64 )
6210 0 : return CPLSPrintf(CPL_FRMT_GIB, psVal->Integer64);
6211 2 : if( eType == OFTReal )
6212 0 : return CPLSPrintf("%.18g", psVal->Real);
6213 2 : if( eType == OFTDateTime )
6214 2 : return CPLSPrintf("%04d-%02d-%02dT%02d:%02d:%02d",
6215 2 : psVal->Date.Year,
6216 2 : psVal->Date.Month,
6217 2 : psVal->Date.Day,
6218 2 : psVal->Date.Hour,
6219 2 : psVal->Date.Minute,
6220 2 : static_cast<int>(psVal->Date.Second + 0.5));
6221 : return NULL;
6222 : }
6223 7 : SWIGINTERN bool OGRFieldDomainShadow_IsMaxInclusive(OGRFieldDomainShadow *self){
6224 7 : bool isInclusive = false;
6225 7 : (void)OGR_RangeFldDomain_GetMax(self, &isInclusive);
6226 7 : return isInclusive;
6227 : }
6228 9 : SWIGINTERN char const *OGRFieldDomainShadow_GetGlob(OGRFieldDomainShadow *self){
6229 9 : return OGR_GlobFldDomain_GetGlob(self);
6230 : }
6231 :
6232 : static
6233 19 : OGRFieldDomainShadow* CreateCodedFieldDomain( const char *name,
6234 : const char* description,
6235 : OGRFieldType type,
6236 : OGRFieldSubType subtype,
6237 : const OGRCodedValue* enumeration) {
6238 19 : return (OGRFieldDomainShadow*) OGR_CodedFldDomain_Create( name,
6239 : description,
6240 : type,
6241 : subtype,
6242 : enumeration );
6243 : }
6244 :
6245 :
6246 : static
6247 10 : OGRFieldDomainShadow* CreateRangeFieldDomain( const char *name,
6248 : const char* description,
6249 : OGRFieldType type,
6250 : OGRFieldSubType subtype,
6251 : double min,
6252 : bool minIsInclusive,
6253 : double max,
6254 : double maxIsInclusive) {
6255 10 : OGRField sMin;
6256 10 : if( type == OFTInteger )
6257 4 : sMin.Integer = static_cast<int>(min);
6258 6 : else if( type == OFTInteger64 )
6259 2 : sMin.Integer64 = static_cast<GIntBig>(min);
6260 4 : else if( type == OFTReal )
6261 3 : sMin.Real = min;
6262 : else
6263 : return NULL;
6264 9 : OGRField sMax;
6265 9 : if( type == OFTInteger )
6266 4 : sMax.Integer = static_cast<int>(max);
6267 5 : else if( type == OFTInteger64 )
6268 2 : sMax.Integer64 = static_cast<GIntBig>(max);
6269 3 : else if( type == OFTReal )
6270 3 : sMax.Real = max;
6271 : else
6272 : return NULL;
6273 9 : return (OGRFieldDomainShadow*) OGR_RangeFldDomain_Create( name,
6274 : description,
6275 : type,
6276 : subtype,
6277 : &sMin,
6278 : minIsInclusive,
6279 : &sMax,
6280 : maxIsInclusive );
6281 : }
6282 :
6283 :
6284 : static
6285 2 : OGRFieldDomainShadow* CreateRangeFieldDomainDateTime( const char *name,
6286 : const char* description,
6287 : const char* min,
6288 : bool minIsInclusive,
6289 : const char* max,
6290 : double maxIsInclusive) {
6291 2 : OGRField sMin;
6292 2 : OGRField sMax;
6293 2 : if( !OGRParseXMLDateTime(min, &sMin))
6294 : {
6295 0 : CPLError(CE_Failure, CPLE_AppDefined,
6296 : "Invalid min: %s",
6297 : min);
6298 0 : return NULL;
6299 : }
6300 2 : if( !OGRParseXMLDateTime(max, &sMax))
6301 : {
6302 0 : CPLError(CE_Failure, CPLE_AppDefined,
6303 : "Invalid max: %s",
6304 : max);
6305 0 : return NULL;
6306 : }
6307 2 : return (OGRFieldDomainShadow*) OGR_RangeFldDomain_Create( name,
6308 : description,
6309 : OFTDateTime,
6310 : OFSTNone,
6311 : &sMin,
6312 : minIsInclusive,
6313 : &sMax,
6314 : maxIsInclusive );
6315 : }
6316 :
6317 :
6318 : static
6319 14 : OGRFieldDomainShadow* CreateGlobFieldDomain( const char *name,
6320 : const char* description,
6321 : OGRFieldType type,
6322 : OGRFieldSubType subtype,
6323 : const char* glob ) {
6324 14 : return (OGRFieldDomainShadow*) OGR_GlobFldDomain_Create( name,
6325 : description,
6326 : type,
6327 : subtype,
6328 : glob );
6329 : }
6330 :
6331 19 : SWIGINTERN void delete_OGRGeomCoordinatePrecisionShadow(OGRGeomCoordinatePrecisionShadow *self){
6332 19 : OGRGeomCoordinatePrecisionDestroy(self);
6333 19 : }
6334 19 : SWIGINTERN void OGRGeomCoordinatePrecisionShadow_Set(OGRGeomCoordinatePrecisionShadow *self,double xyResolution,double zResolution,double mResolution){
6335 19 : OGRGeomCoordinatePrecisionSet(self, xyResolution, zResolution, mResolution);
6336 19 : }
6337 3 : SWIGINTERN void OGRGeomCoordinatePrecisionShadow_SetFromMeter(OGRGeomCoordinatePrecisionShadow *self,OSRSpatialReferenceShadow *srs,double xyMeterResolution,double zMeterResolution,double mResolution){
6338 3 : OGRGeomCoordinatePrecisionSetFromMeter(self, srs, xyMeterResolution, zMeterResolution, mResolution);
6339 3 : }
6340 45 : SWIGINTERN double OGRGeomCoordinatePrecisionShadow_GetXYResolution(OGRGeomCoordinatePrecisionShadow *self){
6341 45 : return OGRGeomCoordinatePrecisionGetXYResolution(self);
6342 : }
6343 42 : SWIGINTERN double OGRGeomCoordinatePrecisionShadow_GetZResolution(OGRGeomCoordinatePrecisionShadow *self){
6344 42 : return OGRGeomCoordinatePrecisionGetZResolution(self);
6345 : }
6346 27 : SWIGINTERN double OGRGeomCoordinatePrecisionShadow_GetMResolution(OGRGeomCoordinatePrecisionShadow *self){
6347 27 : return OGRGeomCoordinatePrecisionGetMResolution(self);
6348 : }
6349 4 : SWIGINTERN char **OGRGeomCoordinatePrecisionShadow_GetFormats(OGRGeomCoordinatePrecisionShadow *self){
6350 4 : return OGRGeomCoordinatePrecisionGetFormats(self);
6351 : }
6352 5 : SWIGINTERN char **OGRGeomCoordinatePrecisionShadow_GetFormatSpecificOptions(OGRGeomCoordinatePrecisionShadow *self,char const *formatName){
6353 5 : return OGRGeomCoordinatePrecisionGetFormatSpecificOptions(self, formatName);
6354 : }
6355 1 : SWIGINTERN void OGRGeomCoordinatePrecisionShadow_SetFormatSpecificOptions(OGRGeomCoordinatePrecisionShadow *self,char const *formatName,char **formatSpecificOptions){
6356 1 : OGRGeomCoordinatePrecisionSetFormatSpecificOptions(self, formatName, formatSpecificOptions);
6357 1 : }
6358 :
6359 : static
6360 19 : OGRGeomCoordinatePrecisionShadow* CreateGeomCoordinatePrecision() {
6361 19 : return OGRGeomCoordinatePrecisionCreate();
6362 : }
6363 :
6364 :
6365 0 : char const *OGRDriverShadow_get_name( OGRDriverShadow *h ) {
6366 0 : return OGR_Dr_GetName( h );
6367 : }
6368 :
6369 0 : char const *OGRDataSourceShadow_get_name( OGRDataSourceShadow *h ) {
6370 0 : return OGR_DS_GetName( h );
6371 : }
6372 :
6373 0 : char const *OGRDriverShadow_name_get( OGRDriverShadow *h ) {
6374 0 : return OGR_Dr_GetName( h );
6375 : }
6376 :
6377 0 : char const *OGRDataSourceShadow_name_get( OGRDataSourceShadow *h ) {
6378 0 : return OGR_DS_GetName( h );
6379 : }
6380 :
6381 :
6382 18 : OGRwkbGeometryType GT_SetModifier( OGRwkbGeometryType eType, int bSetZ, int bSetM = FALSE)
6383 : {
6384 18 : return OGR_GT_SetModifier(eType, bSetZ, bSetM);
6385 : }
6386 :
6387 :
6388 1 : OGRDataSourceShadow* GetOpenDS(int ds_number) {
6389 1 : OGRDataSourceShadow* layer = (OGRDataSourceShadow*) OGRGetOpenDS(ds_number);
6390 1 : return layer;
6391 : }
6392 :
6393 :
6394 7035 : OGRDataSourceShadow* Open( const char *utf8_path, int update =0 ) {
6395 7035 : CPLErrorReset();
6396 7035 : int nOpenFlags = GDAL_OF_VECTOR;
6397 7035 : if( update )
6398 1629 : nOpenFlags |= GDAL_OF_UPDATE;
6399 : #ifdef SWIGPYTHON
6400 9105 : if( GetUseExceptions() )
6401 2639 : nOpenFlags |= GDAL_OF_VERBOSE_ERROR;
6402 : #endif
6403 7035 : OGRDataSourceShadow* ds = (OGRDataSourceShadow*)GDALOpenEx( utf8_path, nOpenFlags, NULL,
6404 : NULL, NULL );
6405 : #ifndef SWIGPYTHON
6406 : if( CPLGetLastErrorType() == CE_Failure && ds != NULL )
6407 : {
6408 : CPLDebug( "SWIG",
6409 : "OGROpen() succeeded, but an error is posted, so we destroy"
6410 : " the datasource and fail at swig level." );
6411 : OGRReleaseDataSource(ds);
6412 : ds = NULL;
6413 : }
6414 : #endif
6415 7035 : return ds;
6416 : }
6417 :
6418 :
6419 23 : OGRDataSourceShadow* OpenShared( const char *utf8_path, int update =0 ) {
6420 23 : CPLErrorReset();
6421 23 : int nOpenFlags = GDAL_OF_VECTOR | GDAL_OF_SHARED;
6422 23 : if( update )
6423 12 : nOpenFlags |= GDAL_OF_UPDATE;
6424 : #ifdef SWIGPYTHON
6425 37 : if( GetUseExceptions() )
6426 14 : nOpenFlags |= GDAL_OF_VERBOSE_ERROR;
6427 : #endif
6428 23 : OGRDataSourceShadow* ds = (OGRDataSourceShadow*)GDALOpenEx( utf8_path, nOpenFlags, NULL,
6429 : NULL, NULL );
6430 : #ifndef SWIGPYTHON
6431 : if( CPLGetLastErrorType() == CE_Failure && ds != NULL )
6432 : {
6433 : OGRReleaseDataSource(ds);
6434 : ds = NULL;
6435 : }
6436 : #endif
6437 23 : return ds;
6438 : }
6439 :
6440 :
6441 : static
6442 2702 : OGRDriverShadow* GetDriverByName( char const *name ) {
6443 2702 : return (OGRDriverShadow*) OGRGetDriverByName( name );
6444 : }
6445 :
6446 : static
6447 0 : OGRDriverShadow* GetDriver(int driver_number) {
6448 0 : return (OGRDriverShadow*) OGRGetDriver(driver_number);
6449 : }
6450 :
6451 :
6452 59 : char **GeneralCmdLineProcessor( char **papszArgv, int nOptions = 0 ) {
6453 59 : int nResArgCount;
6454 :
6455 59 : if( papszArgv == NULL )
6456 : return NULL;
6457 :
6458 118 : bool bReloadDrivers = ( CSLFindString(papszArgv, "GDAL_SKIP") >= 0 ||
6459 59 : CSLFindString(papszArgv, "OGR_SKIP") >= 0 );
6460 :
6461 59 : nResArgCount =
6462 59 : GDALGeneralCmdLineProcessor( CSLCount(papszArgv), &papszArgv, GDAL_OF_VECTOR | nOptions );
6463 :
6464 59 : if( bReloadDrivers )
6465 : {
6466 0 : GDALAllRegister();
6467 : }
6468 :
6469 59 : if( nResArgCount <= 0 )
6470 : return NULL;
6471 : else
6472 57 : return papszArgv;
6473 : }
6474 :
6475 :
6476 : static
6477 11 : int GDALTermProgress_nocb( double dfProgress, const char * pszMessage=NULL, void *pData=NULL ) {
6478 11 : return GDALTermProgress( dfProgress, pszMessage, pData);
6479 : }
6480 :
6481 : #ifdef __cplusplus
6482 : extern "C" {
6483 : #endif
6484 0 : SWIGINTERN PyObject *_wrap_GetUseExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6485 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6486 0 : int result;
6487 :
6488 0 : if (!SWIG_Python_UnpackTuple(args, "GetUseExceptions", 0, 0, 0)) SWIG_fail;
6489 0 : {
6490 : #ifdef SED_HACKS
6491 0 : if( ReturnSame(TRUE) ) bLocalUseExceptionsCode = FALSE;
6492 : #endif
6493 0 : result = GetUseExceptions();
6494 : }
6495 0 : resultobj = SWIG_From_int(static_cast< int >(result));
6496 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
6497 : return resultobj;
6498 0 : fail:
6499 0 : return NULL;
6500 : }
6501 :
6502 :
6503 9296 : SWIGINTERN PyObject *_wrap__GetExceptionsLocal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6504 9296 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6505 9296 : int result;
6506 :
6507 9296 : if (!SWIG_Python_UnpackTuple(args, "_GetExceptionsLocal", 0, 0, 0)) SWIG_fail;
6508 9296 : {
6509 : #ifdef SED_HACKS
6510 9296 : if( ReturnSame(TRUE) ) bLocalUseExceptionsCode = FALSE;
6511 : #endif
6512 9296 : result = (int)_GetExceptionsLocal();
6513 : }
6514 9296 : resultobj = SWIG_From_int(static_cast< int >(result));
6515 9296 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
6516 : return resultobj;
6517 0 : fail:
6518 0 : return NULL;
6519 : }
6520 :
6521 :
6522 18592 : SWIGINTERN PyObject *_wrap__SetExceptionsLocal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6523 18592 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6524 18592 : int arg1 ;
6525 18592 : int val1 ;
6526 18592 : int ecode1 = 0 ;
6527 18592 : PyObject *swig_obj[1] ;
6528 :
6529 18592 : if (!args) SWIG_fail;
6530 18592 : swig_obj[0] = args;
6531 18592 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6532 18592 : if (!SWIG_IsOK(ecode1)) {
6533 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_SetExceptionsLocal" "', argument " "1"" of type '" "int""'");
6534 : }
6535 18592 : arg1 = static_cast< int >(val1);
6536 18592 : {
6537 : #ifdef SED_HACKS
6538 18592 : if( ReturnSame(TRUE) ) bLocalUseExceptionsCode = FALSE;
6539 : #endif
6540 18592 : _SetExceptionsLocal(arg1);
6541 : }
6542 18592 : resultobj = SWIG_Py_Void();
6543 18592 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
6544 : return resultobj;
6545 : fail:
6546 : return NULL;
6547 : }
6548 :
6549 :
6550 27 : SWIGINTERN PyObject *_wrap__UseExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6551 27 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6552 :
6553 27 : if (!SWIG_Python_UnpackTuple(args, "_UseExceptions", 0, 0, 0)) SWIG_fail;
6554 27 : _UseExceptions();
6555 27 : resultobj = SWIG_Py_Void();
6556 27 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
6557 : return resultobj;
6558 0 : fail:
6559 0 : return NULL;
6560 : }
6561 :
6562 :
6563 5 : SWIGINTERN PyObject *_wrap__DontUseExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6564 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6565 :
6566 5 : if (!SWIG_Python_UnpackTuple(args, "_DontUseExceptions", 0, 0, 0)) SWIG_fail;
6567 5 : _DontUseExceptions();
6568 5 : resultobj = SWIG_Py_Void();
6569 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
6570 : return resultobj;
6571 0 : fail:
6572 0 : return NULL;
6573 : }
6574 :
6575 :
6576 18751 : SWIGINTERN PyObject *_wrap__UserHasSpecifiedIfUsingExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6577 18751 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6578 18751 : int result;
6579 :
6580 18751 : if (!SWIG_Python_UnpackTuple(args, "_UserHasSpecifiedIfUsingExceptions", 0, 0, 0)) SWIG_fail;
6581 18751 : {
6582 : #ifdef SED_HACKS
6583 18751 : if( ReturnSame(TRUE) ) bLocalUseExceptionsCode = FALSE;
6584 : #endif
6585 18751 : result = (int)_UserHasSpecifiedIfUsingExceptions();
6586 : }
6587 18751 : resultobj = SWIG_From_int(static_cast< int >(result));
6588 18751 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
6589 : return resultobj;
6590 0 : fail:
6591 0 : return NULL;
6592 : }
6593 :
6594 :
6595 20 : SWIGINTERN PyObject *_wrap_MajorObject_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6596 20 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6597 20 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
6598 20 : void *argp1 = 0 ;
6599 20 : int res1 = 0 ;
6600 20 : PyObject *swig_obj[1] ;
6601 20 : char *result = 0 ;
6602 :
6603 20 : if (!args) SWIG_fail;
6604 20 : swig_obj[0] = args;
6605 20 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
6606 20 : if (!SWIG_IsOK(res1)) {
6607 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetDescription" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
6608 : }
6609 20 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
6610 20 : {
6611 20 : const int bLocalUseExceptions = GetUseExceptions();
6612 20 : if ( bLocalUseExceptions ) {
6613 7 : pushErrorHandler();
6614 : }
6615 20 : {
6616 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6617 20 : result = (char *)GDALMajorObjectShadow_GetDescription(arg1);
6618 20 : SWIG_PYTHON_THREAD_END_ALLOW;
6619 : }
6620 20 : if ( bLocalUseExceptions ) {
6621 7 : popErrorHandler();
6622 : }
6623 : #ifndef SED_HACKS
6624 : if ( bLocalUseExceptions ) {
6625 : CPLErr eclass = CPLGetLastErrorType();
6626 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6627 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6628 : }
6629 : }
6630 : #endif
6631 : }
6632 20 : resultobj = SWIG_FromCharPtr((const char *)result);
6633 20 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
6634 : return resultobj;
6635 : fail:
6636 : return NULL;
6637 : }
6638 :
6639 :
6640 0 : SWIGINTERN PyObject *_wrap_MajorObject_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6641 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6642 0 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
6643 0 : char *arg2 = (char *) 0 ;
6644 0 : void *argp1 = 0 ;
6645 0 : int res1 = 0 ;
6646 0 : int res2 ;
6647 0 : char *buf2 = 0 ;
6648 0 : int alloc2 = 0 ;
6649 0 : PyObject *swig_obj[2] ;
6650 :
6651 0 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_SetDescription", 2, 2, swig_obj)) SWIG_fail;
6652 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
6653 0 : if (!SWIG_IsOK(res1)) {
6654 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_SetDescription" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
6655 : }
6656 0 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
6657 0 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
6658 0 : if (!SWIG_IsOK(res2)) {
6659 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_SetDescription" "', argument " "2"" of type '" "char const *""'");
6660 : }
6661 0 : arg2 = reinterpret_cast< char * >(buf2);
6662 0 : {
6663 0 : if (!arg2) {
6664 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
6665 : }
6666 : }
6667 0 : {
6668 0 : const int bLocalUseExceptions = GetUseExceptions();
6669 0 : if ( bLocalUseExceptions ) {
6670 0 : pushErrorHandler();
6671 : }
6672 0 : {
6673 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6674 0 : GDALMajorObjectShadow_SetDescription(arg1,(char const *)arg2);
6675 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6676 : }
6677 0 : if ( bLocalUseExceptions ) {
6678 0 : popErrorHandler();
6679 : }
6680 : #ifndef SED_HACKS
6681 : if ( bLocalUseExceptions ) {
6682 : CPLErr eclass = CPLGetLastErrorType();
6683 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6684 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6685 : }
6686 : }
6687 : #endif
6688 : }
6689 0 : resultobj = SWIG_Py_Void();
6690 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6691 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
6692 : return resultobj;
6693 0 : fail:
6694 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6695 : return NULL;
6696 : }
6697 :
6698 :
6699 8 : SWIGINTERN PyObject *_wrap_MajorObject_GetMetadataDomainList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6700 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6701 8 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
6702 8 : void *argp1 = 0 ;
6703 8 : int res1 = 0 ;
6704 8 : PyObject *swig_obj[1] ;
6705 8 : char **result = 0 ;
6706 :
6707 8 : if (!args) SWIG_fail;
6708 8 : swig_obj[0] = args;
6709 8 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
6710 8 : if (!SWIG_IsOK(res1)) {
6711 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetMetadataDomainList" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
6712 : }
6713 8 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
6714 8 : {
6715 8 : const int bLocalUseExceptions = GetUseExceptions();
6716 8 : if ( bLocalUseExceptions ) {
6717 0 : pushErrorHandler();
6718 : }
6719 8 : {
6720 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6721 8 : result = (char **)GDALMajorObjectShadow_GetMetadataDomainList(arg1);
6722 8 : SWIG_PYTHON_THREAD_END_ALLOW;
6723 : }
6724 8 : if ( bLocalUseExceptions ) {
6725 0 : popErrorHandler();
6726 : }
6727 : #ifndef SED_HACKS
6728 : if ( bLocalUseExceptions ) {
6729 : CPLErr eclass = CPLGetLastErrorType();
6730 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6731 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6732 : }
6733 : }
6734 : #endif
6735 : }
6736 8 : {
6737 : /* %typemap(out) char **CSL -> ( string ) */
6738 8 : bool bErr = false;
6739 8 : resultobj = CSLToList(result, &bErr);
6740 8 : CSLDestroy(result);
6741 8 : if( bErr ) {
6742 0 : SWIG_fail;
6743 : }
6744 : }
6745 8 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
6746 : return resultobj;
6747 : fail:
6748 : return NULL;
6749 : }
6750 :
6751 :
6752 75 : SWIGINTERN PyObject *_wrap_MajorObject_GetMetadata_Dict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6753 75 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6754 75 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
6755 75 : char *arg2 = (char *) "" ;
6756 75 : void *argp1 = 0 ;
6757 75 : int res1 = 0 ;
6758 75 : int res2 ;
6759 75 : char *buf2 = 0 ;
6760 75 : int alloc2 = 0 ;
6761 75 : PyObject *swig_obj[2] ;
6762 75 : char **result = 0 ;
6763 :
6764 75 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_GetMetadata_Dict", 1, 2, swig_obj)) SWIG_fail;
6765 75 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
6766 75 : if (!SWIG_IsOK(res1)) {
6767 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetMetadata_Dict" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
6768 : }
6769 75 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
6770 75 : if (swig_obj[1]) {
6771 62 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
6772 62 : if (!SWIG_IsOK(res2)) {
6773 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_GetMetadata_Dict" "', argument " "2"" of type '" "char const *""'");
6774 : }
6775 62 : arg2 = reinterpret_cast< char * >(buf2);
6776 : }
6777 75 : {
6778 75 : const int bLocalUseExceptions = GetUseExceptions();
6779 75 : if ( bLocalUseExceptions ) {
6780 44 : pushErrorHandler();
6781 : }
6782 75 : {
6783 75 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6784 75 : result = (char **)GDALMajorObjectShadow_GetMetadata_Dict(arg1,(char const *)arg2);
6785 75 : SWIG_PYTHON_THREAD_END_ALLOW;
6786 : }
6787 75 : if ( bLocalUseExceptions ) {
6788 44 : popErrorHandler();
6789 : }
6790 : #ifndef SED_HACKS
6791 : if ( bLocalUseExceptions ) {
6792 : CPLErr eclass = CPLGetLastErrorType();
6793 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6794 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6795 : }
6796 : }
6797 : #endif
6798 : }
6799 75 : {
6800 : /* %typemap(out) char **dict */
6801 75 : resultobj = GetCSLStringAsPyDict(result, false);
6802 : }
6803 75 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6804 75 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
6805 : return resultobj;
6806 0 : fail:
6807 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6808 : return NULL;
6809 : }
6810 :
6811 :
6812 9 : SWIGINTERN PyObject *_wrap_MajorObject_GetMetadata_List(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6813 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6814 9 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
6815 9 : char *arg2 = (char *) "" ;
6816 9 : void *argp1 = 0 ;
6817 9 : int res1 = 0 ;
6818 9 : int res2 ;
6819 9 : char *buf2 = 0 ;
6820 9 : int alloc2 = 0 ;
6821 9 : PyObject *swig_obj[2] ;
6822 9 : char **result = 0 ;
6823 :
6824 9 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_GetMetadata_List", 1, 2, swig_obj)) SWIG_fail;
6825 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
6826 9 : if (!SWIG_IsOK(res1)) {
6827 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetMetadata_List" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
6828 : }
6829 9 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
6830 9 : if (swig_obj[1]) {
6831 5 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
6832 5 : if (!SWIG_IsOK(res2)) {
6833 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_GetMetadata_List" "', argument " "2"" of type '" "char const *""'");
6834 : }
6835 5 : arg2 = reinterpret_cast< char * >(buf2);
6836 : }
6837 9 : {
6838 9 : const int bLocalUseExceptions = GetUseExceptions();
6839 9 : if ( bLocalUseExceptions ) {
6840 5 : pushErrorHandler();
6841 : }
6842 9 : {
6843 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6844 9 : result = (char **)GDALMajorObjectShadow_GetMetadata_List(arg1,(char const *)arg2);
6845 9 : SWIG_PYTHON_THREAD_END_ALLOW;
6846 : }
6847 9 : if ( bLocalUseExceptions ) {
6848 5 : popErrorHandler();
6849 : }
6850 : #ifndef SED_HACKS
6851 : if ( bLocalUseExceptions ) {
6852 : CPLErr eclass = CPLGetLastErrorType();
6853 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6854 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6855 : }
6856 : }
6857 : #endif
6858 : }
6859 9 : {
6860 : /* %typemap(out) char **options -> ( string ) */
6861 9 : bool bErr = false;
6862 9 : resultobj = CSLToList(result, &bErr);
6863 9 : if( bErr ) {
6864 0 : SWIG_fail;
6865 : }
6866 : }
6867 9 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6868 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
6869 : return resultobj;
6870 0 : fail:
6871 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6872 : return NULL;
6873 : }
6874 :
6875 :
6876 : SWIGINTERN PyObject *_wrap_MajorObject_SetMetadata__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
6877 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6878 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
6879 : char **arg2 = (char **) 0 ;
6880 : char *arg3 = (char *) "" ;
6881 : void *argp1 = 0 ;
6882 : int res1 = 0 ;
6883 : int res3 ;
6884 : char *buf3 = 0 ;
6885 : int alloc3 = 0 ;
6886 : CPLErr result;
6887 :
6888 : if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
6889 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
6890 : if (!SWIG_IsOK(res1)) {
6891 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_SetMetadata" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
6892 : }
6893 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
6894 : {
6895 : /* %typemap(in) char **dict */
6896 : arg2 = NULL;
6897 : if ( PySequence_Check( swig_obj[1] ) ) {
6898 : int bErr = FALSE;
6899 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
6900 : if ( bErr )
6901 : {
6902 : SWIG_fail;
6903 : }
6904 : }
6905 : else if ( PyMapping_Check( swig_obj[1] ) ) {
6906 : int bErr = FALSE;
6907 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
6908 : if ( bErr )
6909 : {
6910 : SWIG_fail;
6911 : }
6912 : }
6913 : else {
6914 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
6915 : SWIG_fail;
6916 : }
6917 : }
6918 : if (swig_obj[2]) {
6919 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
6920 : if (!SWIG_IsOK(res3)) {
6921 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MajorObject_SetMetadata" "', argument " "3"" of type '" "char const *""'");
6922 : }
6923 : arg3 = reinterpret_cast< char * >(buf3);
6924 : }
6925 : {
6926 : const int bLocalUseExceptions = GetUseExceptions();
6927 : if ( bLocalUseExceptions ) {
6928 : pushErrorHandler();
6929 : }
6930 : {
6931 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6932 : result = (CPLErr)GDALMajorObjectShadow_SetMetadata__SWIG_0(arg1,arg2,(char const *)arg3);
6933 : SWIG_PYTHON_THREAD_END_ALLOW;
6934 : }
6935 : if ( bLocalUseExceptions ) {
6936 : popErrorHandler();
6937 : }
6938 : #ifndef SED_HACKS
6939 : if ( bLocalUseExceptions ) {
6940 : CPLErr eclass = CPLGetLastErrorType();
6941 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6942 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6943 : }
6944 : }
6945 : #endif
6946 : }
6947 : resultobj = SWIG_From_int(static_cast< int >(result));
6948 : {
6949 : /* %typemap(freearg) char **dict */
6950 : CSLDestroy( arg2 );
6951 : }
6952 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
6953 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
6954 : return resultobj;
6955 : fail:
6956 : {
6957 : /* %typemap(freearg) char **dict */
6958 : CSLDestroy( arg2 );
6959 : }
6960 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
6961 : return NULL;
6962 : }
6963 :
6964 :
6965 : SWIGINTERN PyObject *_wrap_MajorObject_SetMetadata__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
6966 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6967 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
6968 : char *arg2 = (char *) 0 ;
6969 : char *arg3 = (char *) "" ;
6970 : void *argp1 = 0 ;
6971 : int res1 = 0 ;
6972 : int res2 ;
6973 : char *buf2 = 0 ;
6974 : int alloc2 = 0 ;
6975 : int res3 ;
6976 : char *buf3 = 0 ;
6977 : int alloc3 = 0 ;
6978 : CPLErr result;
6979 :
6980 : if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
6981 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
6982 : if (!SWIG_IsOK(res1)) {
6983 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_SetMetadata" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
6984 : }
6985 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
6986 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
6987 : if (!SWIG_IsOK(res2)) {
6988 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_SetMetadata" "', argument " "2"" of type '" "char *""'");
6989 : }
6990 : arg2 = reinterpret_cast< char * >(buf2);
6991 : if (swig_obj[2]) {
6992 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
6993 : if (!SWIG_IsOK(res3)) {
6994 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MajorObject_SetMetadata" "', argument " "3"" of type '" "char const *""'");
6995 : }
6996 : arg3 = reinterpret_cast< char * >(buf3);
6997 : }
6998 : {
6999 : const int bLocalUseExceptions = GetUseExceptions();
7000 : if ( bLocalUseExceptions ) {
7001 : pushErrorHandler();
7002 : }
7003 : {
7004 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7005 : result = (CPLErr)GDALMajorObjectShadow_SetMetadata__SWIG_1(arg1,arg2,(char const *)arg3);
7006 : SWIG_PYTHON_THREAD_END_ALLOW;
7007 : }
7008 : if ( bLocalUseExceptions ) {
7009 : popErrorHandler();
7010 : }
7011 : #ifndef SED_HACKS
7012 : if ( bLocalUseExceptions ) {
7013 : CPLErr eclass = CPLGetLastErrorType();
7014 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7015 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7016 : }
7017 : }
7018 : #endif
7019 : }
7020 : resultobj = SWIG_From_int(static_cast< int >(result));
7021 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7022 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7023 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7024 : return resultobj;
7025 : fail:
7026 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7027 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7028 : return NULL;
7029 : }
7030 :
7031 :
7032 35 : SWIGINTERN PyObject *_wrap_MajorObject_SetMetadata(PyObject *self, PyObject *args) {
7033 35 : Py_ssize_t argc;
7034 35 : PyObject *argv[4] = {
7035 : 0
7036 : };
7037 :
7038 35 : if (!(argc = SWIG_Python_UnpackTuple(args, "MajorObject_SetMetadata", 0, 3, argv))) SWIG_fail;
7039 35 : --argc;
7040 35 : if ((argc >= 2) && (argc <= 3)) {
7041 35 : int _v;
7042 35 : void *vptr = 0;
7043 35 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GDALMajorObjectShadow, 0);
7044 39 : _v = SWIG_CheckState(res);
7045 35 : if (_v) {
7046 35 : {
7047 : /* %typecheck(SWIG_TYPECHECK_POINTER) (char **dict) */
7048 : /* Note: we exclude explicitly strings, because they can be considered as a sequence of characters, */
7049 : /* which is not desirable since it makes it impossible to define bindings such as SetMetadata(string) and SetMetadata(array_of_string) */
7050 : /* (see #4816) */
7051 35 : _v = ((PyMapping_Check(argv[1]) || PySequence_Check(argv[1]) ) && !SWIG_CheckState(SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0)) ) ? 1 : 0;
7052 : }
7053 31 : if (_v) {
7054 31 : if (argc <= 2) {
7055 31 : return _wrap_MajorObject_SetMetadata__SWIG_0(self, argc, argv);
7056 : }
7057 3 : int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
7058 3 : _v = SWIG_CheckState(res);
7059 3 : if (_v) {
7060 3 : return _wrap_MajorObject_SetMetadata__SWIG_0(self, argc, argv);
7061 : }
7062 : }
7063 : }
7064 : }
7065 4 : if ((argc >= 2) && (argc <= 3)) {
7066 4 : int _v;
7067 4 : void *vptr = 0;
7068 4 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GDALMajorObjectShadow, 0);
7069 4 : _v = SWIG_CheckState(res);
7070 4 : if (_v) {
7071 4 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
7072 4 : _v = SWIG_CheckState(res);
7073 4 : if (_v) {
7074 4 : if (argc <= 2) {
7075 4 : return _wrap_MajorObject_SetMetadata__SWIG_1(self, argc, argv);
7076 : }
7077 1 : int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
7078 1 : _v = SWIG_CheckState(res);
7079 1 : if (_v) {
7080 1 : return _wrap_MajorObject_SetMetadata__SWIG_1(self, argc, argv);
7081 : }
7082 : }
7083 : }
7084 : }
7085 :
7086 0 : fail:
7087 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MajorObject_SetMetadata'.\n"
7088 : " Possible C/C++ prototypes are:\n"
7089 : " GDALMajorObjectShadow::SetMetadata(char **,char const *)\n"
7090 : " GDALMajorObjectShadow::SetMetadata(char *,char const *)\n");
7091 : return 0;
7092 : }
7093 :
7094 :
7095 478 : SWIGINTERN PyObject *_wrap_MajorObject_GetMetadataItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7096 478 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7097 478 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
7098 478 : char *arg2 = (char *) 0 ;
7099 478 : char *arg3 = (char *) "" ;
7100 478 : void *argp1 = 0 ;
7101 478 : int res1 = 0 ;
7102 478 : int res2 ;
7103 478 : char *buf2 = 0 ;
7104 478 : int alloc2 = 0 ;
7105 478 : int res3 ;
7106 478 : char *buf3 = 0 ;
7107 478 : int alloc3 = 0 ;
7108 478 : PyObject *swig_obj[3] ;
7109 478 : char *result = 0 ;
7110 :
7111 478 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_GetMetadataItem", 2, 3, swig_obj)) SWIG_fail;
7112 478 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
7113 478 : if (!SWIG_IsOK(res1)) {
7114 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetMetadataItem" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
7115 : }
7116 478 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
7117 478 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
7118 478 : if (!SWIG_IsOK(res2)) {
7119 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_GetMetadataItem" "', argument " "2"" of type '" "char const *""'");
7120 : }
7121 478 : arg2 = reinterpret_cast< char * >(buf2);
7122 478 : if (swig_obj[2]) {
7123 424 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
7124 424 : if (!SWIG_IsOK(res3)) {
7125 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MajorObject_GetMetadataItem" "', argument " "3"" of type '" "char const *""'");
7126 : }
7127 424 : arg3 = reinterpret_cast< char * >(buf3);
7128 : }
7129 478 : {
7130 478 : if (!arg2) {
7131 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
7132 : }
7133 : }
7134 478 : {
7135 478 : const int bLocalUseExceptions = GetUseExceptions();
7136 478 : if ( bLocalUseExceptions ) {
7137 432 : pushErrorHandler();
7138 : }
7139 478 : {
7140 478 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7141 478 : result = (char *)GDALMajorObjectShadow_GetMetadataItem(arg1,(char const *)arg2,(char const *)arg3);
7142 478 : SWIG_PYTHON_THREAD_END_ALLOW;
7143 : }
7144 478 : if ( bLocalUseExceptions ) {
7145 432 : popErrorHandler();
7146 : }
7147 : #ifndef SED_HACKS
7148 : if ( bLocalUseExceptions ) {
7149 : CPLErr eclass = CPLGetLastErrorType();
7150 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7151 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7152 : }
7153 : }
7154 : #endif
7155 : }
7156 478 : resultobj = SWIG_FromCharPtr((const char *)result);
7157 478 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7158 478 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7159 478 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7160 : return resultobj;
7161 0 : fail:
7162 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7163 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7164 : return NULL;
7165 : }
7166 :
7167 :
7168 295 : SWIGINTERN PyObject *_wrap_MajorObject_SetMetadataItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7169 295 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7170 295 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
7171 295 : char *arg2 = (char *) 0 ;
7172 295 : char *arg3 = (char *) 0 ;
7173 295 : char *arg4 = (char *) "" ;
7174 295 : void *argp1 = 0 ;
7175 295 : int res1 = 0 ;
7176 295 : int res2 ;
7177 295 : char *buf2 = 0 ;
7178 295 : int alloc2 = 0 ;
7179 295 : int res3 ;
7180 295 : char *buf3 = 0 ;
7181 295 : int alloc3 = 0 ;
7182 295 : int res4 ;
7183 295 : char *buf4 = 0 ;
7184 295 : int alloc4 = 0 ;
7185 295 : PyObject *swig_obj[4] ;
7186 295 : CPLErr result;
7187 :
7188 295 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_SetMetadataItem", 3, 4, swig_obj)) SWIG_fail;
7189 295 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
7190 295 : if (!SWIG_IsOK(res1)) {
7191 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_SetMetadataItem" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
7192 : }
7193 295 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
7194 295 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
7195 295 : if (!SWIG_IsOK(res2)) {
7196 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_SetMetadataItem" "', argument " "2"" of type '" "char const *""'");
7197 : }
7198 295 : arg2 = reinterpret_cast< char * >(buf2);
7199 295 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
7200 295 : if (!SWIG_IsOK(res3)) {
7201 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MajorObject_SetMetadataItem" "', argument " "3"" of type '" "char const *""'");
7202 : }
7203 295 : arg3 = reinterpret_cast< char * >(buf3);
7204 295 : if (swig_obj[3]) {
7205 5 : res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
7206 5 : if (!SWIG_IsOK(res4)) {
7207 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MajorObject_SetMetadataItem" "', argument " "4"" of type '" "char const *""'");
7208 : }
7209 5 : arg4 = reinterpret_cast< char * >(buf4);
7210 : }
7211 295 : {
7212 295 : if (!arg2) {
7213 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
7214 : }
7215 : }
7216 295 : {
7217 295 : const int bLocalUseExceptions = GetUseExceptions();
7218 295 : if ( bLocalUseExceptions ) {
7219 268 : pushErrorHandler();
7220 : }
7221 295 : {
7222 295 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7223 295 : result = (CPLErr)GDALMajorObjectShadow_SetMetadataItem(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
7224 295 : SWIG_PYTHON_THREAD_END_ALLOW;
7225 : }
7226 295 : if ( bLocalUseExceptions ) {
7227 268 : popErrorHandler();
7228 : }
7229 : #ifndef SED_HACKS
7230 : if ( bLocalUseExceptions ) {
7231 : CPLErr eclass = CPLGetLastErrorType();
7232 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7233 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7234 : }
7235 : }
7236 : #endif
7237 : }
7238 295 : resultobj = SWIG_From_int(static_cast< int >(result));
7239 295 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7240 295 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7241 295 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
7242 295 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7243 : return resultobj;
7244 0 : fail:
7245 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7246 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7247 0 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
7248 : return NULL;
7249 : }
7250 :
7251 :
7252 273 : SWIGINTERN PyObject *MajorObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7253 273 : PyObject *obj;
7254 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
7255 273 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALMajorObjectShadow, SWIG_NewClientData(obj));
7256 273 : return SWIG_Py_Void();
7257 : }
7258 :
7259 4532 : SWIGINTERN PyObject *_wrap_GetGEOSVersionMajor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7260 4532 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7261 4532 : int result;
7262 :
7263 4532 : if (!SWIG_Python_UnpackTuple(args, "GetGEOSVersionMajor", 0, 0, 0)) SWIG_fail;
7264 4532 : {
7265 4532 : const int bLocalUseExceptions = GetUseExceptions();
7266 4532 : if ( bLocalUseExceptions ) {
7267 529 : pushErrorHandler();
7268 : }
7269 4532 : {
7270 4532 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7271 4532 : result = (int)GetGEOSVersionMajor();
7272 4532 : SWIG_PYTHON_THREAD_END_ALLOW;
7273 : }
7274 4532 : if ( bLocalUseExceptions ) {
7275 529 : popErrorHandler();
7276 : }
7277 : #ifndef SED_HACKS
7278 : if ( bLocalUseExceptions ) {
7279 : CPLErr eclass = CPLGetLastErrorType();
7280 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7281 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7282 : }
7283 : }
7284 : #endif
7285 : }
7286 4532 : resultobj = SWIG_From_int(static_cast< int >(result));
7287 4532 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7288 : return resultobj;
7289 0 : fail:
7290 0 : return NULL;
7291 : }
7292 :
7293 :
7294 250 : SWIGINTERN PyObject *_wrap_GetGEOSVersionMinor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7295 250 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7296 250 : int result;
7297 :
7298 250 : if (!SWIG_Python_UnpackTuple(args, "GetGEOSVersionMinor", 0, 0, 0)) SWIG_fail;
7299 250 : {
7300 250 : const int bLocalUseExceptions = GetUseExceptions();
7301 250 : if ( bLocalUseExceptions ) {
7302 249 : pushErrorHandler();
7303 : }
7304 250 : {
7305 250 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7306 250 : result = (int)GetGEOSVersionMinor();
7307 250 : SWIG_PYTHON_THREAD_END_ALLOW;
7308 : }
7309 250 : if ( bLocalUseExceptions ) {
7310 249 : popErrorHandler();
7311 : }
7312 : #ifndef SED_HACKS
7313 : if ( bLocalUseExceptions ) {
7314 : CPLErr eclass = CPLGetLastErrorType();
7315 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7316 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7317 : }
7318 : }
7319 : #endif
7320 : }
7321 250 : resultobj = SWIG_From_int(static_cast< int >(result));
7322 250 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7323 : return resultobj;
7324 0 : fail:
7325 0 : return NULL;
7326 : }
7327 :
7328 :
7329 250 : SWIGINTERN PyObject *_wrap_GetGEOSVersionMicro(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7330 250 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7331 250 : int result;
7332 :
7333 250 : if (!SWIG_Python_UnpackTuple(args, "GetGEOSVersionMicro", 0, 0, 0)) SWIG_fail;
7334 250 : {
7335 250 : const int bLocalUseExceptions = GetUseExceptions();
7336 250 : if ( bLocalUseExceptions ) {
7337 249 : pushErrorHandler();
7338 : }
7339 250 : {
7340 250 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7341 250 : result = (int)GetGEOSVersionMicro();
7342 250 : SWIG_PYTHON_THREAD_END_ALLOW;
7343 : }
7344 250 : if ( bLocalUseExceptions ) {
7345 249 : popErrorHandler();
7346 : }
7347 : #ifndef SED_HACKS
7348 : if ( bLocalUseExceptions ) {
7349 : CPLErr eclass = CPLGetLastErrorType();
7350 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7351 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7352 : }
7353 : }
7354 : #endif
7355 : }
7356 250 : resultobj = SWIG_From_int(static_cast< int >(result));
7357 250 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7358 : return resultobj;
7359 0 : fail:
7360 0 : return NULL;
7361 : }
7362 :
7363 :
7364 4 : SWIGINTERN PyObject *_wrap_new_StyleTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7365 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7366 4 : OGRStyleTableShadow *result = 0 ;
7367 :
7368 4 : if (!SWIG_Python_UnpackTuple(args, "new_StyleTable", 0, 0, 0)) SWIG_fail;
7369 4 : {
7370 4 : const int bLocalUseExceptions = GetUseExceptions();
7371 4 : if ( bLocalUseExceptions ) {
7372 4 : pushErrorHandler();
7373 : }
7374 4 : {
7375 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7376 4 : result = (OGRStyleTableShadow *)new_OGRStyleTableShadow();
7377 4 : SWIG_PYTHON_THREAD_END_ALLOW;
7378 : }
7379 4 : if ( bLocalUseExceptions ) {
7380 4 : popErrorHandler();
7381 : }
7382 : #ifndef SED_HACKS
7383 : if ( bLocalUseExceptions ) {
7384 : CPLErr eclass = CPLGetLastErrorType();
7385 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7386 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7387 : }
7388 : }
7389 : #endif
7390 : }
7391 4 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRStyleTableShadow, SWIG_POINTER_NEW | 0 );
7392 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7393 : return resultobj;
7394 0 : fail:
7395 0 : return NULL;
7396 : }
7397 :
7398 :
7399 4 : SWIGINTERN PyObject *_wrap_delete_StyleTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7400 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7401 4 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7402 4 : void *argp1 = 0 ;
7403 4 : int res1 = 0 ;
7404 4 : PyObject *swig_obj[1] ;
7405 :
7406 4 : if (!args) SWIG_fail;
7407 4 : swig_obj[0] = args;
7408 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, SWIG_POINTER_DISOWN | 0 );
7409 4 : if (!SWIG_IsOK(res1)) {
7410 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StyleTable" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7411 : }
7412 4 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7413 4 : {
7414 4 : const int bLocalUseExceptions = GetUseExceptions();
7415 4 : if ( bLocalUseExceptions ) {
7416 4 : pushErrorHandler();
7417 : }
7418 4 : {
7419 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7420 4 : delete_OGRStyleTableShadow(arg1);
7421 4 : SWIG_PYTHON_THREAD_END_ALLOW;
7422 : }
7423 4 : if ( bLocalUseExceptions ) {
7424 4 : popErrorHandler();
7425 : }
7426 : #ifndef SED_HACKS
7427 : if ( bLocalUseExceptions ) {
7428 : CPLErr eclass = CPLGetLastErrorType();
7429 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7430 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7431 : }
7432 : }
7433 : #endif
7434 : }
7435 4 : resultobj = SWIG_Py_Void();
7436 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7437 : return resultobj;
7438 : fail:
7439 : return NULL;
7440 : }
7441 :
7442 :
7443 5 : SWIGINTERN PyObject *_wrap_StyleTable_AddStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7444 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7445 5 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7446 5 : char *arg2 = (char *) 0 ;
7447 5 : char *arg3 = (char *) 0 ;
7448 5 : void *argp1 = 0 ;
7449 5 : int res1 = 0 ;
7450 5 : int res2 ;
7451 5 : char *buf2 = 0 ;
7452 5 : int alloc2 = 0 ;
7453 5 : int res3 ;
7454 5 : char *buf3 = 0 ;
7455 5 : int alloc3 = 0 ;
7456 5 : PyObject *swig_obj[3] ;
7457 5 : int result;
7458 :
7459 5 : if (!SWIG_Python_UnpackTuple(args, "StyleTable_AddStyle", 3, 3, swig_obj)) SWIG_fail;
7460 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
7461 5 : if (!SWIG_IsOK(res1)) {
7462 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyleTable_AddStyle" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7463 : }
7464 5 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7465 5 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
7466 5 : if (!SWIG_IsOK(res2)) {
7467 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StyleTable_AddStyle" "', argument " "2"" of type '" "char const *""'");
7468 : }
7469 5 : arg2 = reinterpret_cast< char * >(buf2);
7470 5 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
7471 5 : if (!SWIG_IsOK(res3)) {
7472 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StyleTable_AddStyle" "', argument " "3"" of type '" "char const *""'");
7473 : }
7474 5 : arg3 = reinterpret_cast< char * >(buf3);
7475 5 : {
7476 5 : const int bLocalUseExceptions = GetUseExceptions();
7477 5 : if ( bLocalUseExceptions ) {
7478 5 : pushErrorHandler();
7479 : }
7480 5 : {
7481 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7482 5 : result = (int)OGRStyleTableShadow_AddStyle(arg1,(char const *)arg2,(char const *)arg3);
7483 5 : SWIG_PYTHON_THREAD_END_ALLOW;
7484 : }
7485 5 : if ( bLocalUseExceptions ) {
7486 5 : popErrorHandler();
7487 : }
7488 : #ifndef SED_HACKS
7489 : if ( bLocalUseExceptions ) {
7490 : CPLErr eclass = CPLGetLastErrorType();
7491 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7492 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7493 : }
7494 : }
7495 : #endif
7496 : }
7497 5 : resultobj = SWIG_From_int(static_cast< int >(result));
7498 5 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7499 5 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7500 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7501 : return resultobj;
7502 0 : fail:
7503 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7504 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7505 : return NULL;
7506 : }
7507 :
7508 :
7509 2 : SWIGINTERN PyObject *_wrap_StyleTable_LoadStyleTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7510 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7511 2 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7512 2 : char *arg2 = (char *) 0 ;
7513 2 : void *argp1 = 0 ;
7514 2 : int res1 = 0 ;
7515 2 : int bToFree2 = 0 ;
7516 2 : PyObject *swig_obj[2] ;
7517 2 : int result;
7518 :
7519 2 : if (!SWIG_Python_UnpackTuple(args, "StyleTable_LoadStyleTable", 2, 2, swig_obj)) SWIG_fail;
7520 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
7521 2 : if (!SWIG_IsOK(res1)) {
7522 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyleTable_LoadStyleTable" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7523 : }
7524 2 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7525 2 : {
7526 : /* %typemap(in) (const char *utf8_path) */
7527 2 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
7528 : {
7529 2 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
7530 : }
7531 : else
7532 : {
7533 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
7534 :
7535 : }
7536 2 : if (arg2 == NULL)
7537 : {
7538 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
7539 0 : SWIG_fail;
7540 : }
7541 : }
7542 2 : {
7543 2 : const int bLocalUseExceptions = GetUseExceptions();
7544 2 : if ( bLocalUseExceptions ) {
7545 2 : pushErrorHandler();
7546 : }
7547 2 : {
7548 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7549 2 : result = (int)OGRStyleTableShadow_LoadStyleTable(arg1,(char const *)arg2);
7550 2 : SWIG_PYTHON_THREAD_END_ALLOW;
7551 : }
7552 2 : if ( bLocalUseExceptions ) {
7553 2 : popErrorHandler();
7554 : }
7555 : #ifndef SED_HACKS
7556 : if ( bLocalUseExceptions ) {
7557 : CPLErr eclass = CPLGetLastErrorType();
7558 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7559 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7560 : }
7561 : }
7562 : #endif
7563 : }
7564 2 : resultobj = SWIG_From_int(static_cast< int >(result));
7565 2 : {
7566 : /* %typemap(freearg) (const char *utf8_path) */
7567 2 : GDALPythonFreeCStr(arg2, bToFree2);
7568 : }
7569 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7570 : return resultobj;
7571 0 : fail:
7572 0 : {
7573 : /* %typemap(freearg) (const char *utf8_path) */
7574 2 : GDALPythonFreeCStr(arg2, bToFree2);
7575 : }
7576 : return NULL;
7577 : }
7578 :
7579 :
7580 2 : SWIGINTERN PyObject *_wrap_StyleTable_SaveStyleTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7581 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7582 2 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7583 2 : char *arg2 = (char *) 0 ;
7584 2 : void *argp1 = 0 ;
7585 2 : int res1 = 0 ;
7586 2 : int bToFree2 = 0 ;
7587 2 : PyObject *swig_obj[2] ;
7588 2 : int result;
7589 :
7590 2 : if (!SWIG_Python_UnpackTuple(args, "StyleTable_SaveStyleTable", 2, 2, swig_obj)) SWIG_fail;
7591 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
7592 2 : if (!SWIG_IsOK(res1)) {
7593 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyleTable_SaveStyleTable" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7594 : }
7595 2 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7596 2 : {
7597 : /* %typemap(in) (const char *utf8_path) */
7598 2 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
7599 : {
7600 2 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
7601 : }
7602 : else
7603 : {
7604 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
7605 :
7606 : }
7607 2 : if (arg2 == NULL)
7608 : {
7609 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
7610 0 : SWIG_fail;
7611 : }
7612 : }
7613 2 : {
7614 2 : const int bLocalUseExceptions = GetUseExceptions();
7615 2 : if ( bLocalUseExceptions ) {
7616 2 : pushErrorHandler();
7617 : }
7618 2 : {
7619 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7620 2 : result = (int)OGRStyleTableShadow_SaveStyleTable(arg1,(char const *)arg2);
7621 2 : SWIG_PYTHON_THREAD_END_ALLOW;
7622 : }
7623 2 : if ( bLocalUseExceptions ) {
7624 2 : popErrorHandler();
7625 : }
7626 : #ifndef SED_HACKS
7627 : if ( bLocalUseExceptions ) {
7628 : CPLErr eclass = CPLGetLastErrorType();
7629 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7630 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7631 : }
7632 : }
7633 : #endif
7634 : }
7635 2 : resultobj = SWIG_From_int(static_cast< int >(result));
7636 2 : {
7637 : /* %typemap(freearg) (const char *utf8_path) */
7638 2 : GDALPythonFreeCStr(arg2, bToFree2);
7639 : }
7640 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7641 : return resultobj;
7642 0 : fail:
7643 0 : {
7644 : /* %typemap(freearg) (const char *utf8_path) */
7645 2 : GDALPythonFreeCStr(arg2, bToFree2);
7646 : }
7647 : return NULL;
7648 : }
7649 :
7650 :
7651 2 : SWIGINTERN PyObject *_wrap_StyleTable_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7652 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7653 2 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7654 2 : char *arg2 = (char *) 0 ;
7655 2 : void *argp1 = 0 ;
7656 2 : int res1 = 0 ;
7657 2 : int res2 ;
7658 2 : char *buf2 = 0 ;
7659 2 : int alloc2 = 0 ;
7660 2 : PyObject *swig_obj[2] ;
7661 2 : char *result = 0 ;
7662 :
7663 2 : if (!SWIG_Python_UnpackTuple(args, "StyleTable_Find", 2, 2, swig_obj)) SWIG_fail;
7664 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
7665 2 : if (!SWIG_IsOK(res1)) {
7666 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyleTable_Find" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7667 : }
7668 2 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7669 2 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
7670 2 : if (!SWIG_IsOK(res2)) {
7671 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StyleTable_Find" "', argument " "2"" of type '" "char const *""'");
7672 : }
7673 2 : arg2 = reinterpret_cast< char * >(buf2);
7674 2 : {
7675 2 : const int bLocalUseExceptions = GetUseExceptions();
7676 2 : if ( bLocalUseExceptions ) {
7677 2 : pushErrorHandler();
7678 : }
7679 2 : {
7680 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7681 2 : result = (char *)OGRStyleTableShadow_Find(arg1,(char const *)arg2);
7682 2 : SWIG_PYTHON_THREAD_END_ALLOW;
7683 : }
7684 2 : if ( bLocalUseExceptions ) {
7685 2 : popErrorHandler();
7686 : }
7687 : #ifndef SED_HACKS
7688 : if ( bLocalUseExceptions ) {
7689 : CPLErr eclass = CPLGetLastErrorType();
7690 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7691 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7692 : }
7693 : }
7694 : #endif
7695 : }
7696 2 : resultobj = SWIG_FromCharPtr((const char *)result);
7697 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7698 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7699 : return resultobj;
7700 0 : fail:
7701 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7702 : return NULL;
7703 : }
7704 :
7705 :
7706 1 : SWIGINTERN PyObject *_wrap_StyleTable_ResetStyleStringReading(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7707 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7708 1 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7709 1 : void *argp1 = 0 ;
7710 1 : int res1 = 0 ;
7711 1 : PyObject *swig_obj[1] ;
7712 :
7713 1 : if (!args) SWIG_fail;
7714 1 : swig_obj[0] = args;
7715 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
7716 1 : if (!SWIG_IsOK(res1)) {
7717 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyleTable_ResetStyleStringReading" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7718 : }
7719 1 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7720 1 : {
7721 1 : const int bLocalUseExceptions = GetUseExceptions();
7722 1 : if ( bLocalUseExceptions ) {
7723 1 : pushErrorHandler();
7724 : }
7725 1 : {
7726 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7727 1 : OGRStyleTableShadow_ResetStyleStringReading(arg1);
7728 1 : SWIG_PYTHON_THREAD_END_ALLOW;
7729 : }
7730 1 : if ( bLocalUseExceptions ) {
7731 1 : popErrorHandler();
7732 : }
7733 : #ifndef SED_HACKS
7734 : if ( bLocalUseExceptions ) {
7735 : CPLErr eclass = CPLGetLastErrorType();
7736 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7737 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7738 : }
7739 : }
7740 : #endif
7741 : }
7742 1 : resultobj = SWIG_Py_Void();
7743 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7744 : return resultobj;
7745 : fail:
7746 : return NULL;
7747 : }
7748 :
7749 :
7750 5 : SWIGINTERN PyObject *_wrap_StyleTable_GetNextStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7751 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7752 5 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7753 5 : void *argp1 = 0 ;
7754 5 : int res1 = 0 ;
7755 5 : PyObject *swig_obj[1] ;
7756 5 : char *result = 0 ;
7757 :
7758 5 : if (!args) SWIG_fail;
7759 5 : swig_obj[0] = args;
7760 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
7761 5 : if (!SWIG_IsOK(res1)) {
7762 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyleTable_GetNextStyle" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7763 : }
7764 5 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7765 5 : {
7766 5 : const int bLocalUseExceptions = GetUseExceptions();
7767 5 : if ( bLocalUseExceptions ) {
7768 5 : pushErrorHandler();
7769 : }
7770 5 : {
7771 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7772 5 : result = (char *)OGRStyleTableShadow_GetNextStyle(arg1);
7773 5 : SWIG_PYTHON_THREAD_END_ALLOW;
7774 : }
7775 5 : if ( bLocalUseExceptions ) {
7776 5 : popErrorHandler();
7777 : }
7778 : #ifndef SED_HACKS
7779 : if ( bLocalUseExceptions ) {
7780 : CPLErr eclass = CPLGetLastErrorType();
7781 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7782 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7783 : }
7784 : }
7785 : #endif
7786 : }
7787 5 : resultobj = SWIG_FromCharPtr((const char *)result);
7788 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7789 : return resultobj;
7790 : fail:
7791 : return NULL;
7792 : }
7793 :
7794 :
7795 1 : SWIGINTERN PyObject *_wrap_StyleTable_GetLastStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7796 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7797 1 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7798 1 : void *argp1 = 0 ;
7799 1 : int res1 = 0 ;
7800 1 : PyObject *swig_obj[1] ;
7801 1 : char *result = 0 ;
7802 :
7803 1 : if (!args) SWIG_fail;
7804 1 : swig_obj[0] = args;
7805 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
7806 1 : if (!SWIG_IsOK(res1)) {
7807 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyleTable_GetLastStyleName" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7808 : }
7809 1 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7810 1 : {
7811 1 : const int bLocalUseExceptions = GetUseExceptions();
7812 1 : if ( bLocalUseExceptions ) {
7813 1 : pushErrorHandler();
7814 : }
7815 1 : {
7816 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7817 1 : result = (char *)OGRStyleTableShadow_GetLastStyleName(arg1);
7818 1 : SWIG_PYTHON_THREAD_END_ALLOW;
7819 : }
7820 1 : if ( bLocalUseExceptions ) {
7821 1 : popErrorHandler();
7822 : }
7823 : #ifndef SED_HACKS
7824 : if ( bLocalUseExceptions ) {
7825 : CPLErr eclass = CPLGetLastErrorType();
7826 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7827 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7828 : }
7829 : }
7830 : #endif
7831 : }
7832 1 : resultobj = SWIG_FromCharPtr((const char *)result);
7833 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7834 : return resultobj;
7835 : fail:
7836 : return NULL;
7837 : }
7838 :
7839 :
7840 273 : SWIGINTERN PyObject *StyleTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7841 273 : PyObject *obj;
7842 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
7843 273 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRStyleTableShadow, SWIG_NewClientData(obj));
7844 273 : return SWIG_Py_Void();
7845 : }
7846 :
7847 4 : SWIGINTERN PyObject *StyleTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7848 4 : return SWIG_Python_InitShadowInstance(args);
7849 : }
7850 :
7851 4 : SWIGINTERN PyObject *_wrap_new_ArrowArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7852 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7853 4 : ArrowArray *result = 0 ;
7854 :
7855 4 : if (!SWIG_Python_UnpackTuple(args, "new_ArrowArray", 0, 0, 0)) SWIG_fail;
7856 4 : {
7857 4 : const int bLocalUseExceptions = GetUseExceptions();
7858 4 : if ( bLocalUseExceptions ) {
7859 4 : pushErrorHandler();
7860 : }
7861 4 : {
7862 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7863 4 : result = (ArrowArray *)new_ArrowArray();
7864 4 : SWIG_PYTHON_THREAD_END_ALLOW;
7865 : }
7866 4 : if ( bLocalUseExceptions ) {
7867 4 : popErrorHandler();
7868 : }
7869 : #ifndef SED_HACKS
7870 : if ( bLocalUseExceptions ) {
7871 : CPLErr eclass = CPLGetLastErrorType();
7872 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7873 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7874 : }
7875 : }
7876 : #endif
7877 : }
7878 4 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ArrowArray, SWIG_POINTER_NEW | 0 );
7879 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7880 : return resultobj;
7881 0 : fail:
7882 0 : return NULL;
7883 : }
7884 :
7885 :
7886 571 : SWIGINTERN PyObject *_wrap_delete_ArrowArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7887 571 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7888 571 : ArrowArray *arg1 = (ArrowArray *) 0 ;
7889 571 : void *argp1 = 0 ;
7890 571 : int res1 = 0 ;
7891 571 : PyObject *swig_obj[1] ;
7892 :
7893 571 : if (!args) SWIG_fail;
7894 571 : swig_obj[0] = args;
7895 571 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowArray, SWIG_POINTER_DISOWN | 0 );
7896 571 : if (!SWIG_IsOK(res1)) {
7897 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArrowArray" "', argument " "1"" of type '" "ArrowArray *""'");
7898 : }
7899 571 : arg1 = reinterpret_cast< ArrowArray * >(argp1);
7900 571 : {
7901 571 : const int bLocalUseExceptions = GetUseExceptions();
7902 571 : if ( bLocalUseExceptions ) {
7903 251 : pushErrorHandler();
7904 : }
7905 571 : {
7906 571 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7907 571 : delete_ArrowArray(arg1);
7908 571 : SWIG_PYTHON_THREAD_END_ALLOW;
7909 : }
7910 571 : if ( bLocalUseExceptions ) {
7911 251 : popErrorHandler();
7912 : }
7913 : #ifndef SED_HACKS
7914 : if ( bLocalUseExceptions ) {
7915 : CPLErr eclass = CPLGetLastErrorType();
7916 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7917 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7918 : }
7919 : }
7920 : #endif
7921 : }
7922 571 : resultobj = SWIG_Py_Void();
7923 571 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7924 : return resultobj;
7925 : fail:
7926 : return NULL;
7927 : }
7928 :
7929 :
7930 527 : SWIGINTERN PyObject *_wrap_ArrowArray__getPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7931 527 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7932 527 : ArrowArray *arg1 = (ArrowArray *) 0 ;
7933 527 : void *argp1 = 0 ;
7934 527 : int res1 = 0 ;
7935 527 : PyObject *swig_obj[1] ;
7936 527 : VoidPtrAsLong result;
7937 :
7938 527 : if (!args) SWIG_fail;
7939 527 : swig_obj[0] = args;
7940 527 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowArray, 0 | 0 );
7941 527 : if (!SWIG_IsOK(res1)) {
7942 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowArray__getPtr" "', argument " "1"" of type '" "ArrowArray *""'");
7943 : }
7944 527 : arg1 = reinterpret_cast< ArrowArray * >(argp1);
7945 527 : {
7946 527 : const int bLocalUseExceptions = GetUseExceptions();
7947 527 : if ( bLocalUseExceptions ) {
7948 208 : pushErrorHandler();
7949 : }
7950 527 : {
7951 527 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7952 527 : result = (VoidPtrAsLong)ArrowArray__getPtr(arg1);
7953 527 : SWIG_PYTHON_THREAD_END_ALLOW;
7954 : }
7955 527 : if ( bLocalUseExceptions ) {
7956 208 : popErrorHandler();
7957 : }
7958 : #ifndef SED_HACKS
7959 : if ( bLocalUseExceptions ) {
7960 : CPLErr eclass = CPLGetLastErrorType();
7961 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7962 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7963 : }
7964 : }
7965 : #endif
7966 : }
7967 527 : {
7968 527 : resultobj = PyLong_FromVoidPtr(result);
7969 : }
7970 527 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
7971 : return resultobj;
7972 : fail:
7973 : return NULL;
7974 : }
7975 :
7976 :
7977 1 : SWIGINTERN PyObject *_wrap_ArrowArray_GetChildrenCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7978 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7979 1 : ArrowArray *arg1 = (ArrowArray *) 0 ;
7980 1 : void *argp1 = 0 ;
7981 1 : int res1 = 0 ;
7982 1 : PyObject *swig_obj[1] ;
7983 1 : GIntBig result;
7984 :
7985 1 : if (!args) SWIG_fail;
7986 1 : swig_obj[0] = args;
7987 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowArray, 0 | 0 );
7988 1 : if (!SWIG_IsOK(res1)) {
7989 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowArray_GetChildrenCount" "', argument " "1"" of type '" "ArrowArray *""'");
7990 : }
7991 1 : arg1 = reinterpret_cast< ArrowArray * >(argp1);
7992 1 : {
7993 1 : const int bLocalUseExceptions = GetUseExceptions();
7994 1 : if ( bLocalUseExceptions ) {
7995 0 : pushErrorHandler();
7996 : }
7997 1 : {
7998 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7999 1 : result = ArrowArray_GetChildrenCount(arg1);
8000 1 : SWIG_PYTHON_THREAD_END_ALLOW;
8001 : }
8002 1 : if ( bLocalUseExceptions ) {
8003 0 : popErrorHandler();
8004 : }
8005 : #ifndef SED_HACKS
8006 : if ( bLocalUseExceptions ) {
8007 : CPLErr eclass = CPLGetLastErrorType();
8008 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8009 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8010 : }
8011 : }
8012 : #endif
8013 : }
8014 1 : {
8015 1 : resultobj = PyLong_FromLongLong(result);
8016 : }
8017 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8018 : return resultobj;
8019 : fail:
8020 : return NULL;
8021 : }
8022 :
8023 :
8024 0 : SWIGINTERN PyObject *_wrap_ArrowArray_GetLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8025 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8026 0 : ArrowArray *arg1 = (ArrowArray *) 0 ;
8027 0 : void *argp1 = 0 ;
8028 0 : int res1 = 0 ;
8029 0 : PyObject *swig_obj[1] ;
8030 0 : GIntBig result;
8031 :
8032 0 : if (!args) SWIG_fail;
8033 0 : swig_obj[0] = args;
8034 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowArray, 0 | 0 );
8035 0 : if (!SWIG_IsOK(res1)) {
8036 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowArray_GetLength" "', argument " "1"" of type '" "ArrowArray *""'");
8037 : }
8038 0 : arg1 = reinterpret_cast< ArrowArray * >(argp1);
8039 0 : {
8040 0 : const int bLocalUseExceptions = GetUseExceptions();
8041 0 : if ( bLocalUseExceptions ) {
8042 0 : pushErrorHandler();
8043 : }
8044 0 : {
8045 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8046 0 : result = ArrowArray_GetLength(arg1);
8047 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8048 : }
8049 0 : if ( bLocalUseExceptions ) {
8050 0 : popErrorHandler();
8051 : }
8052 : #ifndef SED_HACKS
8053 : if ( bLocalUseExceptions ) {
8054 : CPLErr eclass = CPLGetLastErrorType();
8055 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8056 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8057 : }
8058 : }
8059 : #endif
8060 : }
8061 0 : {
8062 0 : resultobj = PyLong_FromLongLong(result);
8063 : }
8064 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8065 : return resultobj;
8066 : fail:
8067 : return NULL;
8068 : }
8069 :
8070 :
8071 273 : SWIGINTERN PyObject *ArrowArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8072 273 : PyObject *obj;
8073 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
8074 273 : SWIG_TypeNewClientData(SWIGTYPE_p_ArrowArray, SWIG_NewClientData(obj));
8075 273 : return SWIG_Py_Void();
8076 : }
8077 :
8078 4 : SWIGINTERN PyObject *ArrowArray_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8079 4 : return SWIG_Python_InitShadowInstance(args);
8080 : }
8081 :
8082 126 : SWIGINTERN PyObject *_wrap_new_ArrowSchema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8083 126 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8084 126 : ArrowSchema *result = 0 ;
8085 :
8086 126 : if (!SWIG_Python_UnpackTuple(args, "new_ArrowSchema", 0, 0, 0)) SWIG_fail;
8087 126 : {
8088 126 : const int bLocalUseExceptions = GetUseExceptions();
8089 126 : if ( bLocalUseExceptions ) {
8090 126 : pushErrorHandler();
8091 : }
8092 126 : {
8093 126 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8094 126 : result = (ArrowSchema *)new_ArrowSchema();
8095 126 : SWIG_PYTHON_THREAD_END_ALLOW;
8096 : }
8097 126 : if ( bLocalUseExceptions ) {
8098 126 : popErrorHandler();
8099 : }
8100 : #ifndef SED_HACKS
8101 : if ( bLocalUseExceptions ) {
8102 : CPLErr eclass = CPLGetLastErrorType();
8103 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8104 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8105 : }
8106 : }
8107 : #endif
8108 : }
8109 126 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ArrowSchema, SWIG_POINTER_NEW | 0 );
8110 126 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8111 : return resultobj;
8112 0 : fail:
8113 0 : return NULL;
8114 : }
8115 :
8116 :
8117 506 : SWIGINTERN PyObject *_wrap_delete_ArrowSchema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8118 506 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8119 506 : ArrowSchema *arg1 = (ArrowSchema *) 0 ;
8120 506 : void *argp1 = 0 ;
8121 506 : int res1 = 0 ;
8122 506 : PyObject *swig_obj[1] ;
8123 :
8124 506 : if (!args) SWIG_fail;
8125 506 : swig_obj[0] = args;
8126 506 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowSchema, SWIG_POINTER_DISOWN | 0 );
8127 506 : if (!SWIG_IsOK(res1)) {
8128 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArrowSchema" "', argument " "1"" of type '" "ArrowSchema *""'");
8129 : }
8130 506 : arg1 = reinterpret_cast< ArrowSchema * >(argp1);
8131 506 : {
8132 506 : const int bLocalUseExceptions = GetUseExceptions();
8133 506 : if ( bLocalUseExceptions ) {
8134 389 : pushErrorHandler();
8135 : }
8136 506 : {
8137 506 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8138 506 : delete_ArrowSchema(arg1);
8139 506 : SWIG_PYTHON_THREAD_END_ALLOW;
8140 : }
8141 506 : if ( bLocalUseExceptions ) {
8142 389 : popErrorHandler();
8143 : }
8144 : #ifndef SED_HACKS
8145 : if ( bLocalUseExceptions ) {
8146 : CPLErr eclass = CPLGetLastErrorType();
8147 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8148 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8149 : }
8150 : }
8151 : #endif
8152 : }
8153 506 : resultobj = SWIG_Py_Void();
8154 506 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8155 : return resultobj;
8156 : fail:
8157 : return NULL;
8158 : }
8159 :
8160 :
8161 682 : SWIGINTERN PyObject *_wrap_ArrowSchema__getPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8162 682 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8163 682 : ArrowSchema *arg1 = (ArrowSchema *) 0 ;
8164 682 : void *argp1 = 0 ;
8165 682 : int res1 = 0 ;
8166 682 : PyObject *swig_obj[1] ;
8167 682 : VoidPtrAsLong result;
8168 :
8169 682 : if (!args) SWIG_fail;
8170 682 : swig_obj[0] = args;
8171 682 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowSchema, 0 | 0 );
8172 682 : if (!SWIG_IsOK(res1)) {
8173 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowSchema__getPtr" "', argument " "1"" of type '" "ArrowSchema *""'");
8174 : }
8175 682 : arg1 = reinterpret_cast< ArrowSchema * >(argp1);
8176 682 : {
8177 682 : const int bLocalUseExceptions = GetUseExceptions();
8178 682 : if ( bLocalUseExceptions ) {
8179 354 : pushErrorHandler();
8180 : }
8181 682 : {
8182 682 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8183 682 : result = (VoidPtrAsLong)ArrowSchema__getPtr(arg1);
8184 682 : SWIG_PYTHON_THREAD_END_ALLOW;
8185 : }
8186 682 : if ( bLocalUseExceptions ) {
8187 354 : popErrorHandler();
8188 : }
8189 : #ifndef SED_HACKS
8190 : if ( bLocalUseExceptions ) {
8191 : CPLErr eclass = CPLGetLastErrorType();
8192 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8193 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8194 : }
8195 : }
8196 : #endif
8197 : }
8198 682 : {
8199 682 : resultobj = PyLong_FromVoidPtr(result);
8200 : }
8201 682 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8202 : return resultobj;
8203 : fail:
8204 : return NULL;
8205 : }
8206 :
8207 :
8208 426 : SWIGINTERN PyObject *_wrap_ArrowSchema_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8209 426 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8210 426 : ArrowSchema *arg1 = (ArrowSchema *) 0 ;
8211 426 : void *argp1 = 0 ;
8212 426 : int res1 = 0 ;
8213 426 : PyObject *swig_obj[1] ;
8214 426 : char *result = 0 ;
8215 :
8216 426 : if (!args) SWIG_fail;
8217 426 : swig_obj[0] = args;
8218 426 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowSchema, 0 | 0 );
8219 426 : if (!SWIG_IsOK(res1)) {
8220 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowSchema_GetName" "', argument " "1"" of type '" "ArrowSchema *""'");
8221 : }
8222 426 : arg1 = reinterpret_cast< ArrowSchema * >(argp1);
8223 426 : {
8224 426 : const int bLocalUseExceptions = GetUseExceptions();
8225 426 : if ( bLocalUseExceptions ) {
8226 426 : pushErrorHandler();
8227 : }
8228 426 : {
8229 426 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8230 426 : result = (char *)ArrowSchema_GetName(arg1);
8231 426 : SWIG_PYTHON_THREAD_END_ALLOW;
8232 : }
8233 426 : if ( bLocalUseExceptions ) {
8234 426 : popErrorHandler();
8235 : }
8236 : #ifndef SED_HACKS
8237 : if ( bLocalUseExceptions ) {
8238 : CPLErr eclass = CPLGetLastErrorType();
8239 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8240 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8241 : }
8242 : }
8243 : #endif
8244 : }
8245 426 : resultobj = SWIG_FromCharPtr((const char *)result);
8246 426 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8247 : return resultobj;
8248 : fail:
8249 : return NULL;
8250 : }
8251 :
8252 :
8253 26 : SWIGINTERN PyObject *_wrap_ArrowSchema_GetChildrenCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8254 26 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8255 26 : ArrowSchema *arg1 = (ArrowSchema *) 0 ;
8256 26 : void *argp1 = 0 ;
8257 26 : int res1 = 0 ;
8258 26 : PyObject *swig_obj[1] ;
8259 26 : GIntBig result;
8260 :
8261 26 : if (!args) SWIG_fail;
8262 26 : swig_obj[0] = args;
8263 26 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowSchema, 0 | 0 );
8264 26 : if (!SWIG_IsOK(res1)) {
8265 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowSchema_GetChildrenCount" "', argument " "1"" of type '" "ArrowSchema *""'");
8266 : }
8267 26 : arg1 = reinterpret_cast< ArrowSchema * >(argp1);
8268 26 : {
8269 26 : const int bLocalUseExceptions = GetUseExceptions();
8270 26 : if ( bLocalUseExceptions ) {
8271 26 : pushErrorHandler();
8272 : }
8273 26 : {
8274 26 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8275 26 : result = ArrowSchema_GetChildrenCount(arg1);
8276 26 : SWIG_PYTHON_THREAD_END_ALLOW;
8277 : }
8278 26 : if ( bLocalUseExceptions ) {
8279 26 : popErrorHandler();
8280 : }
8281 : #ifndef SED_HACKS
8282 : if ( bLocalUseExceptions ) {
8283 : CPLErr eclass = CPLGetLastErrorType();
8284 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8285 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8286 : }
8287 : }
8288 : #endif
8289 : }
8290 26 : {
8291 26 : resultobj = PyLong_FromLongLong(result);
8292 : }
8293 26 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8294 : return resultobj;
8295 : fail:
8296 : return NULL;
8297 : }
8298 :
8299 :
8300 833 : SWIGINTERN PyObject *_wrap_ArrowSchema_GetChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8301 833 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8302 833 : ArrowSchema *arg1 = (ArrowSchema *) 0 ;
8303 833 : int arg2 ;
8304 833 : void *argp1 = 0 ;
8305 833 : int res1 = 0 ;
8306 833 : int val2 ;
8307 833 : int ecode2 = 0 ;
8308 833 : PyObject *swig_obj[2] ;
8309 833 : ArrowSchema *result = 0 ;
8310 :
8311 833 : if (!SWIG_Python_UnpackTuple(args, "ArrowSchema_GetChild", 2, 2, swig_obj)) SWIG_fail;
8312 833 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowSchema, 0 | 0 );
8313 833 : if (!SWIG_IsOK(res1)) {
8314 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowSchema_GetChild" "', argument " "1"" of type '" "ArrowSchema *""'");
8315 : }
8316 833 : arg1 = reinterpret_cast< ArrowSchema * >(argp1);
8317 833 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8318 833 : if (!SWIG_IsOK(ecode2)) {
8319 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArrowSchema_GetChild" "', argument " "2"" of type '" "int""'");
8320 : }
8321 833 : arg2 = static_cast< int >(val2);
8322 833 : {
8323 833 : const int bLocalUseExceptions = GetUseExceptions();
8324 833 : if ( bLocalUseExceptions ) {
8325 833 : pushErrorHandler();
8326 : }
8327 833 : {
8328 833 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8329 833 : result = (ArrowSchema *)ArrowSchema_GetChild(arg1,arg2);
8330 833 : SWIG_PYTHON_THREAD_END_ALLOW;
8331 : }
8332 833 : if ( bLocalUseExceptions ) {
8333 833 : popErrorHandler();
8334 : }
8335 : #ifndef SED_HACKS
8336 : if ( bLocalUseExceptions ) {
8337 : CPLErr eclass = CPLGetLastErrorType();
8338 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8339 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8340 : }
8341 : }
8342 : #endif
8343 : }
8344 833 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ArrowSchema, 0 | 0 );
8345 833 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8346 : return resultobj;
8347 : fail:
8348 : return NULL;
8349 : }
8350 :
8351 :
8352 273 : SWIGINTERN PyObject *ArrowSchema_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8353 273 : PyObject *obj;
8354 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
8355 273 : SWIG_TypeNewClientData(SWIGTYPE_p_ArrowSchema, SWIG_NewClientData(obj));
8356 273 : return SWIG_Py_Void();
8357 : }
8358 :
8359 126 : SWIGINTERN PyObject *ArrowSchema_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8360 126 : return SWIG_Python_InitShadowInstance(args);
8361 : }
8362 :
8363 350 : SWIGINTERN PyObject *_wrap_delete_ArrowArrayStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8364 350 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8365 350 : ArrowArrayStream *arg1 = (ArrowArrayStream *) 0 ;
8366 350 : void *argp1 = 0 ;
8367 350 : int res1 = 0 ;
8368 350 : PyObject *swig_obj[1] ;
8369 :
8370 350 : if (!args) SWIG_fail;
8371 350 : swig_obj[0] = args;
8372 350 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowArrayStream, SWIG_POINTER_DISOWN | 0 );
8373 350 : if (!SWIG_IsOK(res1)) {
8374 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArrowArrayStream" "', argument " "1"" of type '" "ArrowArrayStream *""'");
8375 : }
8376 350 : arg1 = reinterpret_cast< ArrowArrayStream * >(argp1);
8377 350 : {
8378 350 : const int bLocalUseExceptions = GetUseExceptions();
8379 350 : if ( bLocalUseExceptions ) {
8380 250 : pushErrorHandler();
8381 : }
8382 350 : {
8383 350 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8384 350 : delete_ArrowArrayStream(arg1);
8385 350 : SWIG_PYTHON_THREAD_END_ALLOW;
8386 : }
8387 350 : if ( bLocalUseExceptions ) {
8388 250 : popErrorHandler();
8389 : }
8390 : #ifndef SED_HACKS
8391 : if ( bLocalUseExceptions ) {
8392 : CPLErr eclass = CPLGetLastErrorType();
8393 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8394 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8395 : }
8396 : }
8397 : #endif
8398 : }
8399 350 : resultobj = SWIG_Py_Void();
8400 350 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8401 : return resultobj;
8402 : fail:
8403 : return NULL;
8404 : }
8405 :
8406 :
8407 380 : SWIGINTERN PyObject *_wrap_ArrowArrayStream_GetSchema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8408 380 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8409 380 : ArrowArrayStream *arg1 = (ArrowArrayStream *) 0 ;
8410 380 : void *argp1 = 0 ;
8411 380 : int res1 = 0 ;
8412 380 : PyObject *swig_obj[1] ;
8413 380 : ArrowSchema *result = 0 ;
8414 :
8415 380 : if (!args) SWIG_fail;
8416 380 : swig_obj[0] = args;
8417 380 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowArrayStream, 0 | 0 );
8418 380 : if (!SWIG_IsOK(res1)) {
8419 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowArrayStream_GetSchema" "', argument " "1"" of type '" "ArrowArrayStream *""'");
8420 : }
8421 380 : arg1 = reinterpret_cast< ArrowArrayStream * >(argp1);
8422 380 : {
8423 380 : const int bLocalUseExceptions = GetUseExceptions();
8424 380 : if ( bLocalUseExceptions ) {
8425 263 : pushErrorHandler();
8426 : }
8427 380 : {
8428 380 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8429 380 : result = (ArrowSchema *)ArrowArrayStream_GetSchema(arg1);
8430 380 : SWIG_PYTHON_THREAD_END_ALLOW;
8431 : }
8432 380 : if ( bLocalUseExceptions ) {
8433 263 : popErrorHandler();
8434 : }
8435 : #ifndef SED_HACKS
8436 : if ( bLocalUseExceptions ) {
8437 : CPLErr eclass = CPLGetLastErrorType();
8438 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8439 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8440 : }
8441 : }
8442 : #endif
8443 : }
8444 380 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ArrowSchema, SWIG_POINTER_OWN | 0 );
8445 380 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8446 : return resultobj;
8447 : fail:
8448 : return NULL;
8449 : }
8450 :
8451 :
8452 888 : SWIGINTERN PyObject *_wrap_ArrowArrayStream_GetNextRecordBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8453 888 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8454 888 : ArrowArrayStream *arg1 = (ArrowArrayStream *) 0 ;
8455 888 : char **arg2 = (char **) NULL ;
8456 888 : void *argp1 = 0 ;
8457 888 : int res1 = 0 ;
8458 888 : PyObject *swig_obj[2] ;
8459 888 : ArrowArray *result = 0 ;
8460 :
8461 888 : if (!SWIG_Python_UnpackTuple(args, "ArrowArrayStream_GetNextRecordBatch", 1, 2, swig_obj)) SWIG_fail;
8462 888 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowArrayStream, 0 | 0 );
8463 888 : if (!SWIG_IsOK(res1)) {
8464 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowArrayStream_GetNextRecordBatch" "', argument " "1"" of type '" "ArrowArrayStream *""'");
8465 : }
8466 888 : arg1 = reinterpret_cast< ArrowArrayStream * >(argp1);
8467 888 : if (swig_obj[1]) {
8468 0 : {
8469 : /* %typemap(in) char **dict */
8470 0 : arg2 = NULL;
8471 0 : if ( PySequence_Check( swig_obj[1] ) ) {
8472 0 : int bErr = FALSE;
8473 0 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
8474 0 : if ( bErr )
8475 : {
8476 0 : SWIG_fail;
8477 : }
8478 : }
8479 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
8480 0 : int bErr = FALSE;
8481 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
8482 0 : if ( bErr )
8483 : {
8484 0 : SWIG_fail;
8485 : }
8486 : }
8487 : else {
8488 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
8489 0 : SWIG_fail;
8490 : }
8491 : }
8492 : }
8493 888 : {
8494 888 : const int bLocalUseExceptions = GetUseExceptions();
8495 888 : if ( bLocalUseExceptions ) {
8496 478 : pushErrorHandler();
8497 : }
8498 888 : {
8499 888 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8500 888 : result = (ArrowArray *)ArrowArrayStream_GetNextRecordBatch(arg1,arg2);
8501 888 : SWIG_PYTHON_THREAD_END_ALLOW;
8502 : }
8503 888 : if ( bLocalUseExceptions ) {
8504 478 : popErrorHandler();
8505 : }
8506 : #ifndef SED_HACKS
8507 : if ( bLocalUseExceptions ) {
8508 : CPLErr eclass = CPLGetLastErrorType();
8509 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8510 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8511 : }
8512 : }
8513 : #endif
8514 : }
8515 888 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ArrowArray, SWIG_POINTER_OWN | 0 );
8516 888 : {
8517 : /* %typemap(freearg) char **dict */
8518 888 : CSLDestroy( arg2 );
8519 : }
8520 924 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8521 : return resultobj;
8522 0 : fail:
8523 0 : {
8524 : /* %typemap(freearg) char **dict */
8525 0 : CSLDestroy( arg2 );
8526 : }
8527 : return NULL;
8528 : }
8529 :
8530 :
8531 273 : SWIGINTERN PyObject *ArrowArrayStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8532 273 : PyObject *obj;
8533 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
8534 273 : SWIG_TypeNewClientData(SWIGTYPE_p_ArrowArrayStream, SWIG_NewClientData(obj));
8535 273 : return SWIG_Py_Void();
8536 : }
8537 :
8538 264 : SWIGINTERN PyObject *_wrap_Layer_GetDataset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8539 264 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8540 264 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
8541 264 : void *argp1 = 0 ;
8542 264 : int res1 = 0 ;
8543 264 : PyObject *swig_obj[1] ;
8544 264 : GDALDatasetShadow *result = 0 ;
8545 :
8546 264 : if (!args) SWIG_fail;
8547 264 : swig_obj[0] = args;
8548 264 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
8549 264 : if (!SWIG_IsOK(res1)) {
8550 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetDataset" "', argument " "1"" of type '" "OGRLayerShadow *""'");
8551 : }
8552 264 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
8553 264 : {
8554 264 : const int bLocalUseExceptions = GetUseExceptions();
8555 264 : if ( bLocalUseExceptions ) {
8556 124 : pushErrorHandler();
8557 : }
8558 264 : {
8559 264 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8560 264 : result = (GDALDatasetShadow *)OGRLayerShadow_GetDataset(arg1);
8561 264 : SWIG_PYTHON_THREAD_END_ALLOW;
8562 : }
8563 264 : if ( bLocalUseExceptions ) {
8564 124 : popErrorHandler();
8565 : }
8566 : #ifndef SED_HACKS
8567 : if ( bLocalUseExceptions ) {
8568 : CPLErr eclass = CPLGetLastErrorType();
8569 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8570 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8571 : }
8572 : }
8573 : #endif
8574 : }
8575 264 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
8576 264 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8577 : return resultobj;
8578 : fail:
8579 : return NULL;
8580 : }
8581 :
8582 :
8583 29 : SWIGINTERN PyObject *_wrap_Layer_Rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8584 29 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8585 29 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
8586 29 : char *arg2 = (char *) 0 ;
8587 29 : void *argp1 = 0 ;
8588 29 : int res1 = 0 ;
8589 29 : int res2 ;
8590 29 : char *buf2 = 0 ;
8591 29 : int alloc2 = 0 ;
8592 29 : PyObject *swig_obj[2] ;
8593 29 : OGRErr result;
8594 :
8595 29 : if (!SWIG_Python_UnpackTuple(args, "Layer_Rename", 2, 2, swig_obj)) SWIG_fail;
8596 29 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
8597 29 : if (!SWIG_IsOK(res1)) {
8598 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_Rename" "', argument " "1"" of type '" "OGRLayerShadow *""'");
8599 : }
8600 29 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
8601 29 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
8602 29 : if (!SWIG_IsOK(res2)) {
8603 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_Rename" "', argument " "2"" of type '" "char const *""'");
8604 : }
8605 29 : arg2 = reinterpret_cast< char * >(buf2);
8606 29 : {
8607 29 : if (!arg2) {
8608 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
8609 : }
8610 : }
8611 29 : {
8612 29 : const int bLocalUseExceptions = GetUseExceptions();
8613 29 : if ( bLocalUseExceptions ) {
8614 3 : pushErrorHandler();
8615 : }
8616 29 : {
8617 29 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8618 29 : result = (OGRErr)OGRLayerShadow_Rename(arg1,(char const *)arg2);
8619 29 : SWIG_PYTHON_THREAD_END_ALLOW;
8620 : }
8621 29 : if ( bLocalUseExceptions ) {
8622 3 : popErrorHandler();
8623 : }
8624 : #ifndef SED_HACKS
8625 : if ( bLocalUseExceptions ) {
8626 : CPLErr eclass = CPLGetLastErrorType();
8627 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8628 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8629 : }
8630 : }
8631 : #endif
8632 : }
8633 29 : {
8634 : /* %typemap(out) OGRErr */
8635 41 : if ( result != 0 && GetUseExceptions()) {
8636 0 : const char* pszMessage = CPLGetLastErrorMsg();
8637 0 : if( pszMessage[0] != '\0' )
8638 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
8639 : else
8640 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
8641 0 : SWIG_fail;
8642 : }
8643 : }
8644 29 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8645 29 : {
8646 : /* %typemap(ret) OGRErr */
8647 29 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
8648 29 : resultobj = PyInt_FromLong( result );
8649 : }
8650 : }
8651 29 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8652 : return resultobj;
8653 0 : fail:
8654 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8655 : return NULL;
8656 : }
8657 :
8658 :
8659 0 : SWIGINTERN PyObject *_wrap_Layer_GetRefCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8660 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8661 0 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
8662 0 : void *argp1 = 0 ;
8663 0 : int res1 = 0 ;
8664 0 : PyObject *swig_obj[1] ;
8665 0 : int result;
8666 :
8667 0 : if (!args) SWIG_fail;
8668 0 : swig_obj[0] = args;
8669 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
8670 0 : if (!SWIG_IsOK(res1)) {
8671 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetRefCount" "', argument " "1"" of type '" "OGRLayerShadow *""'");
8672 : }
8673 0 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
8674 0 : {
8675 0 : const int bLocalUseExceptions = GetUseExceptions();
8676 0 : if ( bLocalUseExceptions ) {
8677 0 : pushErrorHandler();
8678 : }
8679 0 : {
8680 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8681 0 : result = (int)OGRLayerShadow_GetRefCount(arg1);
8682 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8683 : }
8684 0 : if ( bLocalUseExceptions ) {
8685 0 : popErrorHandler();
8686 : }
8687 : #ifndef SED_HACKS
8688 : if ( bLocalUseExceptions ) {
8689 : CPLErr eclass = CPLGetLastErrorType();
8690 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8691 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8692 : }
8693 : }
8694 : #endif
8695 : }
8696 0 : resultobj = SWIG_From_int(static_cast< int >(result));
8697 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8698 : return resultobj;
8699 : fail:
8700 : return NULL;
8701 : }
8702 :
8703 :
8704 : SWIGINTERN PyObject *_wrap_Layer_SetSpatialFilter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
8705 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8706 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
8707 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8708 : void *argp1 = 0 ;
8709 : int res1 = 0 ;
8710 : void *argp2 = 0 ;
8711 : int res2 = 0 ;
8712 :
8713 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
8714 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
8715 : if (!SWIG_IsOK(res1)) {
8716 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetSpatialFilter" "', argument " "1"" of type '" "OGRLayerShadow *""'");
8717 : }
8718 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
8719 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
8720 : if (!SWIG_IsOK(res2)) {
8721 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_SetSpatialFilter" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
8722 : }
8723 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8724 : {
8725 : const int bLocalUseExceptions = GetUseExceptions();
8726 : if ( bLocalUseExceptions ) {
8727 : pushErrorHandler();
8728 : }
8729 : {
8730 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8731 : OGRLayerShadow_SetSpatialFilter__SWIG_0(arg1,arg2);
8732 : SWIG_PYTHON_THREAD_END_ALLOW;
8733 : }
8734 : if ( bLocalUseExceptions ) {
8735 : popErrorHandler();
8736 : }
8737 : #ifndef SED_HACKS
8738 : if ( bLocalUseExceptions ) {
8739 : CPLErr eclass = CPLGetLastErrorType();
8740 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8741 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8742 : }
8743 : }
8744 : #endif
8745 : }
8746 : resultobj = SWIG_Py_Void();
8747 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8748 : return resultobj;
8749 : fail:
8750 : return NULL;
8751 : }
8752 :
8753 :
8754 : SWIGINTERN PyObject *_wrap_Layer_SetSpatialFilterRect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
8755 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8756 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
8757 : double arg2 ;
8758 : double arg3 ;
8759 : double arg4 ;
8760 : double arg5 ;
8761 : void *argp1 = 0 ;
8762 : int res1 = 0 ;
8763 : double val2 ;
8764 : int ecode2 = 0 ;
8765 : double val3 ;
8766 : int ecode3 = 0 ;
8767 : double val4 ;
8768 : int ecode4 = 0 ;
8769 : double val5 ;
8770 : int ecode5 = 0 ;
8771 :
8772 : if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
8773 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
8774 : if (!SWIG_IsOK(res1)) {
8775 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetSpatialFilterRect" "', argument " "1"" of type '" "OGRLayerShadow *""'");
8776 : }
8777 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
8778 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8779 : if (!SWIG_IsOK(ecode2)) {
8780 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_SetSpatialFilterRect" "', argument " "2"" of type '" "double""'");
8781 : }
8782 : arg2 = static_cast< double >(val2);
8783 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8784 : if (!SWIG_IsOK(ecode3)) {
8785 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Layer_SetSpatialFilterRect" "', argument " "3"" of type '" "double""'");
8786 : }
8787 : arg3 = static_cast< double >(val3);
8788 : ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8789 : if (!SWIG_IsOK(ecode4)) {
8790 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_SetSpatialFilterRect" "', argument " "4"" of type '" "double""'");
8791 : }
8792 : arg4 = static_cast< double >(val4);
8793 : ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
8794 : if (!SWIG_IsOK(ecode5)) {
8795 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Layer_SetSpatialFilterRect" "', argument " "5"" of type '" "double""'");
8796 : }
8797 : arg5 = static_cast< double >(val5);
8798 : {
8799 : const int bLocalUseExceptions = GetUseExceptions();
8800 : if ( bLocalUseExceptions ) {
8801 : pushErrorHandler();
8802 : }
8803 : {
8804 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8805 : OGRLayerShadow_SetSpatialFilterRect__SWIG_0(arg1,arg2,arg3,arg4,arg5);
8806 : SWIG_PYTHON_THREAD_END_ALLOW;
8807 : }
8808 : if ( bLocalUseExceptions ) {
8809 : popErrorHandler();
8810 : }
8811 : #ifndef SED_HACKS
8812 : if ( bLocalUseExceptions ) {
8813 : CPLErr eclass = CPLGetLastErrorType();
8814 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8815 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8816 : }
8817 : }
8818 : #endif
8819 : }
8820 : resultobj = SWIG_Py_Void();
8821 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8822 : return resultobj;
8823 : fail:
8824 : return NULL;
8825 : }
8826 :
8827 :
8828 : SWIGINTERN PyObject *_wrap_Layer_SetSpatialFilter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
8829 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8830 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
8831 : int arg2 ;
8832 : OGRGeometryShadow *arg3 = (OGRGeometryShadow *) 0 ;
8833 : void *argp1 = 0 ;
8834 : int res1 = 0 ;
8835 : int val2 ;
8836 : int ecode2 = 0 ;
8837 : void *argp3 = 0 ;
8838 : int res3 = 0 ;
8839 :
8840 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
8841 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
8842 : if (!SWIG_IsOK(res1)) {
8843 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetSpatialFilter" "', argument " "1"" of type '" "OGRLayerShadow *""'");
8844 : }
8845 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
8846 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8847 : if (!SWIG_IsOK(ecode2)) {
8848 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_SetSpatialFilter" "', argument " "2"" of type '" "int""'");
8849 : }
8850 : arg2 = static_cast< int >(val2);
8851 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
8852 : if (!SWIG_IsOK(res3)) {
8853 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_SetSpatialFilter" "', argument " "3"" of type '" "OGRGeometryShadow *""'");
8854 : }
8855 : arg3 = reinterpret_cast< OGRGeometryShadow * >(argp3);
8856 : {
8857 : const int bLocalUseExceptions = GetUseExceptions();
8858 : if ( bLocalUseExceptions ) {
8859 : pushErrorHandler();
8860 : }
8861 : {
8862 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8863 : OGRLayerShadow_SetSpatialFilter__SWIG_1(arg1,arg2,arg3);
8864 : SWIG_PYTHON_THREAD_END_ALLOW;
8865 : }
8866 : if ( bLocalUseExceptions ) {
8867 : popErrorHandler();
8868 : }
8869 : #ifndef SED_HACKS
8870 : if ( bLocalUseExceptions ) {
8871 : CPLErr eclass = CPLGetLastErrorType();
8872 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8873 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8874 : }
8875 : }
8876 : #endif
8877 : }
8878 : resultobj = SWIG_Py_Void();
8879 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
8880 : return resultobj;
8881 : fail:
8882 : return NULL;
8883 : }
8884 :
8885 :
8886 659 : SWIGINTERN PyObject *_wrap_Layer_SetSpatialFilter(PyObject *self, PyObject *args) {
8887 659 : Py_ssize_t argc;
8888 659 : PyObject *argv[4] = {
8889 : 0
8890 : };
8891 :
8892 659 : if (!(argc = SWIG_Python_UnpackTuple(args, "Layer_SetSpatialFilter", 0, 3, argv))) SWIG_fail;
8893 659 : --argc;
8894 659 : if (argc == 2) {
8895 647 : int _v;
8896 647 : void *vptr = 0;
8897 647 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRLayerShadow, 0);
8898 647 : _v = SWIG_CheckState(res);
8899 647 : if (_v) {
8900 647 : void *vptr = 0;
8901 647 : int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
8902 647 : _v = SWIG_CheckState(res);
8903 0 : if (_v) {
8904 647 : return _wrap_Layer_SetSpatialFilter__SWIG_0(self, argc, argv);
8905 : }
8906 : }
8907 : }
8908 12 : if (argc == 3) {
8909 12 : int _v;
8910 12 : void *vptr = 0;
8911 12 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRLayerShadow, 0);
8912 12 : _v = SWIG_CheckState(res);
8913 12 : if (_v) {
8914 12 : {
8915 12 : int res = SWIG_AsVal_int(argv[1], NULL);
8916 12 : _v = SWIG_CheckState(res);
8917 : }
8918 12 : if (_v) {
8919 12 : void *vptr = 0;
8920 12 : int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
8921 12 : _v = SWIG_CheckState(res);
8922 0 : if (_v) {
8923 12 : return _wrap_Layer_SetSpatialFilter__SWIG_1(self, argc, argv);
8924 : }
8925 : }
8926 : }
8927 : }
8928 :
8929 0 : fail:
8930 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Layer_SetSpatialFilter'.\n"
8931 : " Possible C/C++ prototypes are:\n"
8932 : " OGRLayerShadow::SetSpatialFilter(OGRGeometryShadow *)\n"
8933 : " OGRLayerShadow::SetSpatialFilter(int,OGRGeometryShadow *)\n");
8934 : return 0;
8935 : }
8936 :
8937 :
8938 : SWIGINTERN PyObject *_wrap_Layer_SetSpatialFilterRect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
8939 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8940 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
8941 : int arg2 ;
8942 : double arg3 ;
8943 : double arg4 ;
8944 : double arg5 ;
8945 : double arg6 ;
8946 : void *argp1 = 0 ;
8947 : int res1 = 0 ;
8948 : int val2 ;
8949 : int ecode2 = 0 ;
8950 : double val3 ;
8951 : int ecode3 = 0 ;
8952 : double val4 ;
8953 : int ecode4 = 0 ;
8954 : double val5 ;
8955 : int ecode5 = 0 ;
8956 : double val6 ;
8957 : int ecode6 = 0 ;
8958 :
8959 : if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
8960 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
8961 : if (!SWIG_IsOK(res1)) {
8962 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetSpatialFilterRect" "', argument " "1"" of type '" "OGRLayerShadow *""'");
8963 : }
8964 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
8965 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8966 : if (!SWIG_IsOK(ecode2)) {
8967 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_SetSpatialFilterRect" "', argument " "2"" of type '" "int""'");
8968 : }
8969 : arg2 = static_cast< int >(val2);
8970 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8971 : if (!SWIG_IsOK(ecode3)) {
8972 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Layer_SetSpatialFilterRect" "', argument " "3"" of type '" "double""'");
8973 : }
8974 : arg3 = static_cast< double >(val3);
8975 : ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8976 : if (!SWIG_IsOK(ecode4)) {
8977 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_SetSpatialFilterRect" "', argument " "4"" of type '" "double""'");
8978 : }
8979 : arg4 = static_cast< double >(val4);
8980 : ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
8981 : if (!SWIG_IsOK(ecode5)) {
8982 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Layer_SetSpatialFilterRect" "', argument " "5"" of type '" "double""'");
8983 : }
8984 : arg5 = static_cast< double >(val5);
8985 : ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
8986 : if (!SWIG_IsOK(ecode6)) {
8987 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Layer_SetSpatialFilterRect" "', argument " "6"" of type '" "double""'");
8988 : }
8989 : arg6 = static_cast< double >(val6);
8990 : {
8991 : const int bLocalUseExceptions = GetUseExceptions();
8992 : if ( bLocalUseExceptions ) {
8993 : pushErrorHandler();
8994 : }
8995 : {
8996 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8997 : OGRLayerShadow_SetSpatialFilterRect__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
8998 : SWIG_PYTHON_THREAD_END_ALLOW;
8999 : }
9000 : if ( bLocalUseExceptions ) {
9001 : popErrorHandler();
9002 : }
9003 : #ifndef SED_HACKS
9004 : if ( bLocalUseExceptions ) {
9005 : CPLErr eclass = CPLGetLastErrorType();
9006 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9007 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9008 : }
9009 : }
9010 : #endif
9011 : }
9012 : resultobj = SWIG_Py_Void();
9013 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9014 : return resultobj;
9015 : fail:
9016 : return NULL;
9017 : }
9018 :
9019 :
9020 47728 : SWIGINTERN PyObject *_wrap_Layer_SetSpatialFilterRect(PyObject *self, PyObject *args) {
9021 47728 : Py_ssize_t argc;
9022 47728 : PyObject *argv[7] = {
9023 : 0
9024 : };
9025 :
9026 47728 : if (!(argc = SWIG_Python_UnpackTuple(args, "Layer_SetSpatialFilterRect", 0, 6, argv))) SWIG_fail;
9027 47728 : --argc;
9028 47728 : if (argc == 5) {
9029 47713 : int _v;
9030 47713 : void *vptr = 0;
9031 47713 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRLayerShadow, 0);
9032 47713 : _v = SWIG_CheckState(res);
9033 47713 : if (_v) {
9034 47713 : {
9035 47713 : int res = SWIG_AsVal_double(argv[1], NULL);
9036 47713 : _v = SWIG_CheckState(res);
9037 : }
9038 47713 : if (_v) {
9039 47713 : {
9040 47713 : int res = SWIG_AsVal_double(argv[2], NULL);
9041 47713 : _v = SWIG_CheckState(res);
9042 : }
9043 47713 : if (_v) {
9044 47713 : {
9045 47713 : int res = SWIG_AsVal_double(argv[3], NULL);
9046 47713 : _v = SWIG_CheckState(res);
9047 : }
9048 47713 : if (_v) {
9049 47713 : {
9050 47713 : int res = SWIG_AsVal_double(argv[4], NULL);
9051 47713 : _v = SWIG_CheckState(res);
9052 : }
9053 47713 : if (_v) {
9054 47713 : return _wrap_Layer_SetSpatialFilterRect__SWIG_0(self, argc, argv);
9055 : }
9056 : }
9057 : }
9058 : }
9059 : }
9060 : }
9061 15 : if (argc == 6) {
9062 15 : int _v;
9063 15 : void *vptr = 0;
9064 15 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRLayerShadow, 0);
9065 15 : _v = SWIG_CheckState(res);
9066 15 : if (_v) {
9067 15 : {
9068 15 : int res = SWIG_AsVal_int(argv[1], NULL);
9069 15 : _v = SWIG_CheckState(res);
9070 : }
9071 15 : if (_v) {
9072 15 : {
9073 15 : int res = SWIG_AsVal_double(argv[2], NULL);
9074 15 : _v = SWIG_CheckState(res);
9075 : }
9076 15 : if (_v) {
9077 15 : {
9078 15 : int res = SWIG_AsVal_double(argv[3], NULL);
9079 15 : _v = SWIG_CheckState(res);
9080 : }
9081 15 : if (_v) {
9082 15 : {
9083 15 : int res = SWIG_AsVal_double(argv[4], NULL);
9084 15 : _v = SWIG_CheckState(res);
9085 : }
9086 15 : if (_v) {
9087 15 : {
9088 15 : int res = SWIG_AsVal_double(argv[5], NULL);
9089 15 : _v = SWIG_CheckState(res);
9090 : }
9091 15 : if (_v) {
9092 15 : return _wrap_Layer_SetSpatialFilterRect__SWIG_1(self, argc, argv);
9093 : }
9094 : }
9095 : }
9096 : }
9097 : }
9098 : }
9099 : }
9100 :
9101 0 : fail:
9102 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Layer_SetSpatialFilterRect'.\n"
9103 : " Possible C/C++ prototypes are:\n"
9104 : " OGRLayerShadow::SetSpatialFilterRect(double,double,double,double)\n"
9105 : " OGRLayerShadow::SetSpatialFilterRect(int,double,double,double,double)\n");
9106 : return 0;
9107 : }
9108 :
9109 :
9110 5 : SWIGINTERN PyObject *_wrap_Layer_GetSpatialFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9111 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9112 5 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9113 5 : void *argp1 = 0 ;
9114 5 : int res1 = 0 ;
9115 5 : PyObject *swig_obj[1] ;
9116 5 : OGRGeometryShadow *result = 0 ;
9117 :
9118 5 : if (!args) SWIG_fail;
9119 5 : swig_obj[0] = args;
9120 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9121 5 : if (!SWIG_IsOK(res1)) {
9122 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetSpatialFilter" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9123 : }
9124 5 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9125 5 : {
9126 5 : const int bLocalUseExceptions = GetUseExceptions();
9127 5 : if ( bLocalUseExceptions ) {
9128 1 : pushErrorHandler();
9129 : }
9130 5 : {
9131 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9132 5 : result = (OGRGeometryShadow *)OGRLayerShadow_GetSpatialFilter(arg1);
9133 5 : SWIG_PYTHON_THREAD_END_ALLOW;
9134 : }
9135 5 : if ( bLocalUseExceptions ) {
9136 1 : popErrorHandler();
9137 : }
9138 : #ifndef SED_HACKS
9139 : if ( bLocalUseExceptions ) {
9140 : CPLErr eclass = CPLGetLastErrorType();
9141 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9142 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9143 : }
9144 : }
9145 : #endif
9146 : }
9147 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
9148 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9149 : return resultobj;
9150 : fail:
9151 : return NULL;
9152 : }
9153 :
9154 :
9155 1443 : SWIGINTERN PyObject *_wrap_Layer_SetAttributeFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9156 1443 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9157 1443 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9158 1443 : char *arg2 = (char *) 0 ;
9159 1443 : void *argp1 = 0 ;
9160 1443 : int res1 = 0 ;
9161 1443 : int res2 ;
9162 1443 : char *buf2 = 0 ;
9163 1443 : int alloc2 = 0 ;
9164 1443 : PyObject *swig_obj[2] ;
9165 1443 : OGRErr result;
9166 :
9167 1443 : if (!SWIG_Python_UnpackTuple(args, "Layer_SetAttributeFilter", 2, 2, swig_obj)) SWIG_fail;
9168 1443 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9169 1443 : if (!SWIG_IsOK(res1)) {
9170 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetAttributeFilter" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9171 : }
9172 1443 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9173 1443 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
9174 1443 : if (!SWIG_IsOK(res2)) {
9175 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_SetAttributeFilter" "', argument " "2"" of type '" "char *""'");
9176 : }
9177 1443 : arg2 = reinterpret_cast< char * >(buf2);
9178 1443 : {
9179 1443 : const int bLocalUseExceptions = GetUseExceptions();
9180 1443 : if ( bLocalUseExceptions ) {
9181 864 : pushErrorHandler();
9182 : }
9183 1443 : {
9184 1443 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9185 1443 : result = (OGRErr)OGRLayerShadow_SetAttributeFilter(arg1,arg2);
9186 1443 : SWIG_PYTHON_THREAD_END_ALLOW;
9187 : }
9188 1443 : if ( bLocalUseExceptions ) {
9189 864 : popErrorHandler();
9190 : }
9191 : #ifndef SED_HACKS
9192 : if ( bLocalUseExceptions ) {
9193 : CPLErr eclass = CPLGetLastErrorType();
9194 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9195 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9196 : }
9197 : }
9198 : #endif
9199 : }
9200 1443 : {
9201 : /* %typemap(out) OGRErr */
9202 1479 : if ( result != 0 && GetUseExceptions()) {
9203 4 : const char* pszMessage = CPLGetLastErrorMsg();
9204 4 : if( pszMessage[0] != '\0' )
9205 4 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
9206 : else
9207 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9208 4 : SWIG_fail;
9209 : }
9210 : }
9211 1439 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9212 1439 : {
9213 : /* %typemap(ret) OGRErr */
9214 1439 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
9215 1439 : resultobj = PyInt_FromLong( result );
9216 : }
9217 : }
9218 1443 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9219 : return resultobj;
9220 4 : fail:
9221 4 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9222 : return NULL;
9223 : }
9224 :
9225 :
9226 17639 : SWIGINTERN PyObject *_wrap_Layer_ResetReading(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9227 17639 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9228 17639 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9229 17639 : void *argp1 = 0 ;
9230 17639 : int res1 = 0 ;
9231 17639 : PyObject *swig_obj[1] ;
9232 :
9233 17639 : if (!args) SWIG_fail;
9234 17639 : swig_obj[0] = args;
9235 17639 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9236 17639 : if (!SWIG_IsOK(res1)) {
9237 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_ResetReading" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9238 : }
9239 17639 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9240 17639 : {
9241 17639 : const int bLocalUseExceptions = GetUseExceptions();
9242 17639 : if ( bLocalUseExceptions ) {
9243 13310 : pushErrorHandler();
9244 : }
9245 17639 : {
9246 17639 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9247 17639 : OGRLayerShadow_ResetReading(arg1);
9248 17639 : SWIG_PYTHON_THREAD_END_ALLOW;
9249 : }
9250 17639 : if ( bLocalUseExceptions ) {
9251 13310 : popErrorHandler();
9252 : }
9253 : #ifndef SED_HACKS
9254 : if ( bLocalUseExceptions ) {
9255 : CPLErr eclass = CPLGetLastErrorType();
9256 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9257 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9258 : }
9259 : }
9260 : #endif
9261 : }
9262 17639 : resultobj = SWIG_Py_Void();
9263 17639 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9264 : return resultobj;
9265 : fail:
9266 : return NULL;
9267 : }
9268 :
9269 :
9270 1227 : SWIGINTERN PyObject *_wrap_Layer_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9271 1227 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9272 1227 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9273 1227 : void *argp1 = 0 ;
9274 1227 : int res1 = 0 ;
9275 1227 : PyObject *swig_obj[1] ;
9276 1227 : char *result = 0 ;
9277 :
9278 1227 : if (!args) SWIG_fail;
9279 1227 : swig_obj[0] = args;
9280 1227 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9281 1227 : if (!SWIG_IsOK(res1)) {
9282 12 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetName" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9283 : }
9284 1221 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9285 1221 : {
9286 1221 : const int bLocalUseExceptions = GetUseExceptions();
9287 1221 : if ( bLocalUseExceptions ) {
9288 831 : pushErrorHandler();
9289 : }
9290 1221 : {
9291 1221 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9292 1221 : result = (char *)OGRLayerShadow_GetName(arg1);
9293 1221 : SWIG_PYTHON_THREAD_END_ALLOW;
9294 : }
9295 1221 : if ( bLocalUseExceptions ) {
9296 831 : popErrorHandler();
9297 : }
9298 : #ifndef SED_HACKS
9299 : if ( bLocalUseExceptions ) {
9300 : CPLErr eclass = CPLGetLastErrorType();
9301 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9302 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9303 : }
9304 : }
9305 : #endif
9306 : }
9307 1221 : resultobj = SWIG_FromCharPtr((const char *)result);
9308 1229 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9309 : return resultobj;
9310 : fail:
9311 : return NULL;
9312 : }
9313 :
9314 :
9315 1102 : SWIGINTERN PyObject *_wrap_Layer_GetGeomType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9316 1102 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9317 1102 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9318 1102 : void *argp1 = 0 ;
9319 1102 : int res1 = 0 ;
9320 1102 : PyObject *swig_obj[1] ;
9321 1102 : OGRwkbGeometryType result;
9322 :
9323 1102 : if (!args) SWIG_fail;
9324 1102 : swig_obj[0] = args;
9325 1102 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9326 1102 : if (!SWIG_IsOK(res1)) {
9327 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetGeomType" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9328 : }
9329 1102 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9330 1102 : {
9331 1102 : const int bLocalUseExceptions = GetUseExceptions();
9332 1102 : if ( bLocalUseExceptions ) {
9333 612 : pushErrorHandler();
9334 : }
9335 1102 : {
9336 1102 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9337 1102 : result = (OGRwkbGeometryType)OGRLayerShadow_GetGeomType(arg1);
9338 1102 : SWIG_PYTHON_THREAD_END_ALLOW;
9339 : }
9340 1102 : if ( bLocalUseExceptions ) {
9341 612 : popErrorHandler();
9342 : }
9343 : #ifndef SED_HACKS
9344 : if ( bLocalUseExceptions ) {
9345 : CPLErr eclass = CPLGetLastErrorType();
9346 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9347 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9348 : }
9349 : }
9350 : #endif
9351 : }
9352 1102 : resultobj = SWIG_From_int(static_cast< int >(result));
9353 1102 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9354 : return resultobj;
9355 : fail:
9356 : return NULL;
9357 : }
9358 :
9359 :
9360 688 : SWIGINTERN PyObject *_wrap_Layer_GetGeometryColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9361 688 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9362 688 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9363 688 : void *argp1 = 0 ;
9364 688 : int res1 = 0 ;
9365 688 : PyObject *swig_obj[1] ;
9366 688 : char *result = 0 ;
9367 :
9368 688 : if (!args) SWIG_fail;
9369 688 : swig_obj[0] = args;
9370 688 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9371 688 : if (!SWIG_IsOK(res1)) {
9372 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetGeometryColumn" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9373 : }
9374 688 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9375 688 : {
9376 688 : const int bLocalUseExceptions = GetUseExceptions();
9377 688 : if ( bLocalUseExceptions ) {
9378 513 : pushErrorHandler();
9379 : }
9380 688 : {
9381 688 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9382 688 : result = (char *)OGRLayerShadow_GetGeometryColumn(arg1);
9383 688 : SWIG_PYTHON_THREAD_END_ALLOW;
9384 : }
9385 688 : if ( bLocalUseExceptions ) {
9386 513 : popErrorHandler();
9387 : }
9388 : #ifndef SED_HACKS
9389 : if ( bLocalUseExceptions ) {
9390 : CPLErr eclass = CPLGetLastErrorType();
9391 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9392 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9393 : }
9394 : }
9395 : #endif
9396 : }
9397 688 : resultobj = SWIG_FromCharPtr((const char *)result);
9398 688 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9399 : return resultobj;
9400 : fail:
9401 : return NULL;
9402 : }
9403 :
9404 :
9405 385 : SWIGINTERN PyObject *_wrap_Layer_GetFIDColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9406 385 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9407 385 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9408 385 : void *argp1 = 0 ;
9409 385 : int res1 = 0 ;
9410 385 : PyObject *swig_obj[1] ;
9411 385 : char *result = 0 ;
9412 :
9413 385 : if (!args) SWIG_fail;
9414 385 : swig_obj[0] = args;
9415 385 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9416 385 : if (!SWIG_IsOK(res1)) {
9417 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetFIDColumn" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9418 : }
9419 385 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9420 385 : {
9421 385 : const int bLocalUseExceptions = GetUseExceptions();
9422 385 : if ( bLocalUseExceptions ) {
9423 123 : pushErrorHandler();
9424 : }
9425 385 : {
9426 385 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9427 385 : result = (char *)OGRLayerShadow_GetFIDColumn(arg1);
9428 385 : SWIG_PYTHON_THREAD_END_ALLOW;
9429 : }
9430 385 : if ( bLocalUseExceptions ) {
9431 123 : popErrorHandler();
9432 : }
9433 : #ifndef SED_HACKS
9434 : if ( bLocalUseExceptions ) {
9435 : CPLErr eclass = CPLGetLastErrorType();
9436 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9437 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9438 : }
9439 : }
9440 : #endif
9441 : }
9442 385 : resultobj = SWIG_FromCharPtr((const char *)result);
9443 385 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9444 : return resultobj;
9445 : fail:
9446 : return NULL;
9447 : }
9448 :
9449 :
9450 2528 : SWIGINTERN PyObject *_wrap_Layer_GetFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9451 2528 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9452 2528 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9453 2528 : GIntBig arg2 ;
9454 2528 : void *argp1 = 0 ;
9455 2528 : int res1 = 0 ;
9456 2528 : PyObject *swig_obj[2] ;
9457 2528 : OGRFeatureShadow *result = 0 ;
9458 :
9459 2528 : if (!SWIG_Python_UnpackTuple(args, "Layer_GetFeature", 2, 2, swig_obj)) SWIG_fail;
9460 2528 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9461 2528 : if (!SWIG_IsOK(res1)) {
9462 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9463 : }
9464 2528 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9465 2528 : {
9466 2528 : arg2 = (GIntBig)PyLong_AsLongLong(swig_obj[1]);
9467 : }
9468 2528 : {
9469 2528 : const int bLocalUseExceptions = GetUseExceptions();
9470 2528 : if ( bLocalUseExceptions ) {
9471 2091 : pushErrorHandler();
9472 : }
9473 2528 : {
9474 2528 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9475 2528 : result = (OGRFeatureShadow *)OGRLayerShadow_GetFeature(arg1,arg2);
9476 2528 : SWIG_PYTHON_THREAD_END_ALLOW;
9477 : }
9478 2528 : if ( bLocalUseExceptions ) {
9479 2091 : popErrorHandler();
9480 : }
9481 : #ifndef SED_HACKS
9482 : if ( bLocalUseExceptions ) {
9483 : CPLErr eclass = CPLGetLastErrorType();
9484 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9485 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9486 : }
9487 : }
9488 : #endif
9489 : }
9490 2528 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_OWN | 0 );
9491 2538 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9492 : return resultobj;
9493 : fail:
9494 : return NULL;
9495 : }
9496 :
9497 :
9498 79097 : SWIGINTERN PyObject *_wrap_Layer_GetNextFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9499 79097 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9500 79097 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9501 79097 : void *argp1 = 0 ;
9502 79097 : int res1 = 0 ;
9503 79097 : PyObject *swig_obj[1] ;
9504 79097 : OGRFeatureShadow *result = 0 ;
9505 :
9506 79097 : if (!args) SWIG_fail;
9507 79097 : swig_obj[0] = args;
9508 79097 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9509 79097 : if (!SWIG_IsOK(res1)) {
9510 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetNextFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9511 : }
9512 79097 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9513 79097 : {
9514 79097 : const int bLocalUseExceptions = GetUseExceptions();
9515 79097 : if ( bLocalUseExceptions ) {
9516 50212 : pushErrorHandler();
9517 : }
9518 79097 : {
9519 79097 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9520 79097 : result = (OGRFeatureShadow *)OGRLayerShadow_GetNextFeature(arg1);
9521 79097 : SWIG_PYTHON_THREAD_END_ALLOW;
9522 : }
9523 79097 : if ( bLocalUseExceptions ) {
9524 50212 : popErrorHandler();
9525 : }
9526 : #ifndef SED_HACKS
9527 : if ( bLocalUseExceptions ) {
9528 : CPLErr eclass = CPLGetLastErrorType();
9529 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9530 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9531 : }
9532 : }
9533 : #endif
9534 : }
9535 79097 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_OWN | 0 );
9536 79135 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9537 : return resultobj;
9538 : fail:
9539 : return NULL;
9540 : }
9541 :
9542 :
9543 39 : SWIGINTERN PyObject *_wrap_Layer_SetNextByIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9544 39 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9545 39 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9546 39 : GIntBig arg2 ;
9547 39 : void *argp1 = 0 ;
9548 39 : int res1 = 0 ;
9549 39 : PyObject *swig_obj[2] ;
9550 39 : OGRErr result;
9551 :
9552 39 : if (!SWIG_Python_UnpackTuple(args, "Layer_SetNextByIndex", 2, 2, swig_obj)) SWIG_fail;
9553 39 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9554 39 : if (!SWIG_IsOK(res1)) {
9555 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetNextByIndex" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9556 : }
9557 39 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9558 39 : {
9559 39 : arg2 = (GIntBig)PyLong_AsLongLong(swig_obj[1]);
9560 : }
9561 39 : {
9562 39 : const int bLocalUseExceptions = GetUseExceptions();
9563 39 : if ( bLocalUseExceptions ) {
9564 0 : pushErrorHandler();
9565 : }
9566 39 : {
9567 39 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9568 39 : result = (OGRErr)OGRLayerShadow_SetNextByIndex(arg1,arg2);
9569 39 : SWIG_PYTHON_THREAD_END_ALLOW;
9570 : }
9571 39 : if ( bLocalUseExceptions ) {
9572 0 : popErrorHandler();
9573 : }
9574 : #ifndef SED_HACKS
9575 : if ( bLocalUseExceptions ) {
9576 : CPLErr eclass = CPLGetLastErrorType();
9577 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9578 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9579 : }
9580 : }
9581 : #endif
9582 : }
9583 39 : {
9584 : /* %typemap(out) OGRErr */
9585 49 : if ( result != 0 && GetUseExceptions()) {
9586 0 : const char* pszMessage = CPLGetLastErrorMsg();
9587 0 : if( pszMessage[0] != '\0' )
9588 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
9589 : else
9590 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9591 0 : SWIG_fail;
9592 : }
9593 : }
9594 39 : {
9595 : /* %typemap(ret) OGRErr */
9596 39 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
9597 39 : resultobj = PyInt_FromLong( result );
9598 : }
9599 : }
9600 39 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9601 : return resultobj;
9602 : fail:
9603 : return NULL;
9604 : }
9605 :
9606 :
9607 2478 : SWIGINTERN PyObject *_wrap_Layer_SetFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9608 2478 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9609 2478 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9610 2478 : OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
9611 2478 : void *argp1 = 0 ;
9612 2478 : int res1 = 0 ;
9613 2478 : void *argp2 = 0 ;
9614 2478 : int res2 = 0 ;
9615 2478 : PyObject *swig_obj[2] ;
9616 2478 : OGRErr result;
9617 :
9618 2478 : if (!SWIG_Python_UnpackTuple(args, "Layer_SetFeature", 2, 2, swig_obj)) SWIG_fail;
9619 2478 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9620 2478 : if (!SWIG_IsOK(res1)) {
9621 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9622 : }
9623 2478 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9624 2478 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
9625 2478 : if (!SWIG_IsOK(res2)) {
9626 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_SetFeature" "', argument " "2"" of type '" "OGRFeatureShadow *""'");
9627 : }
9628 2478 : arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
9629 2478 : {
9630 2478 : if (!arg2) {
9631 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
9632 : }
9633 : }
9634 2478 : {
9635 2478 : const int bLocalUseExceptions = GetUseExceptions();
9636 2478 : if ( bLocalUseExceptions ) {
9637 24 : pushErrorHandler();
9638 : }
9639 2478 : {
9640 2478 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9641 2478 : result = (OGRErr)OGRLayerShadow_SetFeature(arg1,arg2);
9642 2478 : SWIG_PYTHON_THREAD_END_ALLOW;
9643 : }
9644 2478 : if ( bLocalUseExceptions ) {
9645 24 : popErrorHandler();
9646 : }
9647 : #ifndef SED_HACKS
9648 : if ( bLocalUseExceptions ) {
9649 : CPLErr eclass = CPLGetLastErrorType();
9650 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9651 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9652 : }
9653 : }
9654 : #endif
9655 : }
9656 2478 : {
9657 : /* %typemap(out) OGRErr */
9658 2532 : if ( result != 0 && GetUseExceptions()) {
9659 3 : const char* pszMessage = CPLGetLastErrorMsg();
9660 3 : if( pszMessage[0] != '\0' )
9661 3 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
9662 : else
9663 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9664 3 : SWIG_fail;
9665 : }
9666 : }
9667 2475 : {
9668 : /* %typemap(ret) OGRErr */
9669 2475 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
9670 2475 : resultobj = PyInt_FromLong( result );
9671 : }
9672 : }
9673 2478 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9674 : return resultobj;
9675 : fail:
9676 : return NULL;
9677 : }
9678 :
9679 :
9680 281907 : SWIGINTERN PyObject *_wrap_Layer_CreateFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9681 281907 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9682 281907 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9683 281907 : OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
9684 281907 : void *argp1 = 0 ;
9685 281907 : int res1 = 0 ;
9686 281907 : void *argp2 = 0 ;
9687 281907 : int res2 = 0 ;
9688 281907 : PyObject *swig_obj[2] ;
9689 281907 : OGRErr result;
9690 :
9691 281907 : if (!SWIG_Python_UnpackTuple(args, "Layer_CreateFeature", 2, 2, swig_obj)) SWIG_fail;
9692 281907 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9693 281907 : if (!SWIG_IsOK(res1)) {
9694 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_CreateFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9695 : }
9696 281907 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9697 281907 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
9698 281907 : if (!SWIG_IsOK(res2)) {
9699 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_CreateFeature" "', argument " "2"" of type '" "OGRFeatureShadow *""'");
9700 : }
9701 281907 : arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
9702 281907 : {
9703 281907 : if (!arg2) {
9704 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
9705 : }
9706 : }
9707 281907 : {
9708 281907 : const int bLocalUseExceptions = GetUseExceptions();
9709 281907 : if ( bLocalUseExceptions ) {
9710 221440 : pushErrorHandler();
9711 : }
9712 281907 : {
9713 281907 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9714 281907 : result = (OGRErr)OGRLayerShadow_CreateFeature(arg1,arg2);
9715 281907 : SWIG_PYTHON_THREAD_END_ALLOW;
9716 : }
9717 281907 : if ( bLocalUseExceptions ) {
9718 221440 : popErrorHandler();
9719 : }
9720 : #ifndef SED_HACKS
9721 : if ( bLocalUseExceptions ) {
9722 : CPLErr eclass = CPLGetLastErrorType();
9723 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9724 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9725 : }
9726 : }
9727 : #endif
9728 : }
9729 281907 : {
9730 : /* %typemap(out) OGRErr */
9731 282064 : if ( result != 0 && GetUseExceptions()) {
9732 29 : const char* pszMessage = CPLGetLastErrorMsg();
9733 29 : if( pszMessage[0] != '\0' )
9734 29 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
9735 : else
9736 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9737 29 : SWIG_fail;
9738 : }
9739 : }
9740 281878 : {
9741 : /* %typemap(ret) OGRErr */
9742 281878 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
9743 281878 : resultobj = PyInt_FromLong( result );
9744 : }
9745 : }
9746 281907 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9747 : return resultobj;
9748 : fail:
9749 : return NULL;
9750 : }
9751 :
9752 :
9753 31 : SWIGINTERN PyObject *_wrap_Layer_UpsertFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9754 31 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9755 31 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9756 31 : OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
9757 31 : void *argp1 = 0 ;
9758 31 : int res1 = 0 ;
9759 31 : void *argp2 = 0 ;
9760 31 : int res2 = 0 ;
9761 31 : PyObject *swig_obj[2] ;
9762 31 : OGRErr result;
9763 :
9764 31 : if (!SWIG_Python_UnpackTuple(args, "Layer_UpsertFeature", 2, 2, swig_obj)) SWIG_fail;
9765 31 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9766 31 : if (!SWIG_IsOK(res1)) {
9767 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_UpsertFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9768 : }
9769 31 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9770 31 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
9771 31 : if (!SWIG_IsOK(res2)) {
9772 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_UpsertFeature" "', argument " "2"" of type '" "OGRFeatureShadow *""'");
9773 : }
9774 31 : arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
9775 31 : {
9776 31 : if (!arg2) {
9777 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
9778 : }
9779 : }
9780 31 : {
9781 31 : const int bLocalUseExceptions = GetUseExceptions();
9782 31 : if ( bLocalUseExceptions ) {
9783 0 : pushErrorHandler();
9784 : }
9785 31 : {
9786 31 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9787 31 : result = (OGRErr)OGRLayerShadow_UpsertFeature(arg1,arg2);
9788 31 : SWIG_PYTHON_THREAD_END_ALLOW;
9789 : }
9790 31 : if ( bLocalUseExceptions ) {
9791 0 : popErrorHandler();
9792 : }
9793 : #ifndef SED_HACKS
9794 : if ( bLocalUseExceptions ) {
9795 : CPLErr eclass = CPLGetLastErrorType();
9796 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9797 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9798 : }
9799 : }
9800 : #endif
9801 : }
9802 31 : {
9803 : /* %typemap(out) OGRErr */
9804 32 : if ( result != 0 && GetUseExceptions()) {
9805 0 : const char* pszMessage = CPLGetLastErrorMsg();
9806 0 : if( pszMessage[0] != '\0' )
9807 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
9808 : else
9809 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9810 0 : SWIG_fail;
9811 : }
9812 : }
9813 31 : {
9814 : /* %typemap(ret) OGRErr */
9815 31 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
9816 31 : resultobj = PyInt_FromLong( result );
9817 : }
9818 : }
9819 31 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9820 : return resultobj;
9821 : fail:
9822 : return NULL;
9823 : }
9824 :
9825 :
9826 31 : SWIGINTERN PyObject *_wrap_Layer_UpdateFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9827 31 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9828 31 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9829 31 : OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
9830 31 : int arg3 ;
9831 31 : int *arg4 = (int *) 0 ;
9832 31 : int arg5 ;
9833 31 : int *arg6 = (int *) 0 ;
9834 31 : bool arg7 ;
9835 31 : void *argp1 = 0 ;
9836 31 : int res1 = 0 ;
9837 31 : void *argp2 = 0 ;
9838 31 : int res2 = 0 ;
9839 31 : bool val7 ;
9840 31 : int ecode7 = 0 ;
9841 31 : PyObject *swig_obj[5] ;
9842 31 : OGRErr result;
9843 :
9844 31 : if (!SWIG_Python_UnpackTuple(args, "Layer_UpdateFeature", 5, 5, swig_obj)) SWIG_fail;
9845 31 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9846 31 : if (!SWIG_IsOK(res1)) {
9847 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_UpdateFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9848 : }
9849 31 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9850 31 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
9851 31 : if (!SWIG_IsOK(res2)) {
9852 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_UpdateFeature" "', argument " "2"" of type '" "OGRFeatureShadow *""'");
9853 : }
9854 31 : arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
9855 31 : {
9856 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
9857 31 : arg4 = CreateCIntListFromSequence(swig_obj[2], &arg3);
9858 31 : if( arg3 < 0 ) {
9859 0 : SWIG_fail;
9860 : }
9861 : }
9862 31 : {
9863 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
9864 31 : arg6 = CreateCIntListFromSequence(swig_obj[3], &arg5);
9865 31 : if( arg5 < 0 ) {
9866 0 : SWIG_fail;
9867 : }
9868 : }
9869 31 : ecode7 = SWIG_AsVal_bool(swig_obj[4], &val7);
9870 31 : if (!SWIG_IsOK(ecode7)) {
9871 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Layer_UpdateFeature" "', argument " "7"" of type '" "bool""'");
9872 : }
9873 31 : arg7 = static_cast< bool >(val7);
9874 31 : {
9875 31 : if (!arg2) {
9876 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
9877 : }
9878 : }
9879 31 : {
9880 31 : const int bLocalUseExceptions = GetUseExceptions();
9881 31 : if ( bLocalUseExceptions ) {
9882 4 : pushErrorHandler();
9883 : }
9884 31 : {
9885 31 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9886 31 : result = (OGRErr)OGRLayerShadow_UpdateFeature(arg1,arg2,arg3,(int const *)arg4,arg5,(int const *)arg6,arg7);
9887 31 : SWIG_PYTHON_THREAD_END_ALLOW;
9888 : }
9889 31 : if ( bLocalUseExceptions ) {
9890 4 : popErrorHandler();
9891 : }
9892 : #ifndef SED_HACKS
9893 : if ( bLocalUseExceptions ) {
9894 : CPLErr eclass = CPLGetLastErrorType();
9895 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9896 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9897 : }
9898 : }
9899 : #endif
9900 : }
9901 31 : {
9902 : /* %typemap(out) OGRErr */
9903 43 : if ( result != 0 && GetUseExceptions()) {
9904 0 : const char* pszMessage = CPLGetLastErrorMsg();
9905 0 : if( pszMessage[0] != '\0' )
9906 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
9907 : else
9908 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9909 0 : SWIG_fail;
9910 : }
9911 : }
9912 31 : {
9913 : /* %typemap(freearg) (int nList, int* pList) */
9914 31 : free(arg4);
9915 : }
9916 31 : {
9917 : /* %typemap(freearg) (int nList, int* pList) */
9918 31 : free(arg6);
9919 : }
9920 31 : {
9921 : /* %typemap(ret) OGRErr */
9922 31 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
9923 31 : resultobj = PyInt_FromLong( result );
9924 : }
9925 : }
9926 31 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9927 : return resultobj;
9928 0 : fail:
9929 0 : {
9930 : /* %typemap(freearg) (int nList, int* pList) */
9931 0 : free(arg4);
9932 : }
9933 0 : {
9934 : /* %typemap(freearg) (int nList, int* pList) */
9935 0 : free(arg6);
9936 : }
9937 0 : return NULL;
9938 : }
9939 :
9940 :
9941 3355 : SWIGINTERN PyObject *_wrap_Layer_DeleteFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9942 3355 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9943 3355 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9944 3355 : GIntBig arg2 ;
9945 3355 : void *argp1 = 0 ;
9946 3355 : int res1 = 0 ;
9947 3355 : PyObject *swig_obj[2] ;
9948 3355 : OGRErr result;
9949 :
9950 3355 : if (!SWIG_Python_UnpackTuple(args, "Layer_DeleteFeature", 2, 2, swig_obj)) SWIG_fail;
9951 3355 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9952 3355 : if (!SWIG_IsOK(res1)) {
9953 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_DeleteFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9954 : }
9955 3355 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9956 3355 : {
9957 3355 : arg2 = (GIntBig)PyLong_AsLongLong(swig_obj[1]);
9958 : }
9959 3355 : {
9960 3355 : const int bLocalUseExceptions = GetUseExceptions();
9961 3355 : if ( bLocalUseExceptions ) {
9962 36 : pushErrorHandler();
9963 : }
9964 3355 : {
9965 3355 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9966 3355 : result = (OGRErr)OGRLayerShadow_DeleteFeature(arg1,arg2);
9967 3355 : SWIG_PYTHON_THREAD_END_ALLOW;
9968 : }
9969 3355 : if ( bLocalUseExceptions ) {
9970 36 : popErrorHandler();
9971 : }
9972 : #ifndef SED_HACKS
9973 : if ( bLocalUseExceptions ) {
9974 : CPLErr eclass = CPLGetLastErrorType();
9975 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9976 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9977 : }
9978 : }
9979 : #endif
9980 : }
9981 3355 : {
9982 : /* %typemap(out) OGRErr */
9983 3403 : if ( result != 0 && GetUseExceptions()) {
9984 7 : const char* pszMessage = CPLGetLastErrorMsg();
9985 7 : if( pszMessage[0] != '\0' )
9986 2 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
9987 : else
9988 5 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9989 7 : SWIG_fail;
9990 : }
9991 : }
9992 3348 : {
9993 : /* %typemap(ret) OGRErr */
9994 3348 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
9995 3348 : resultobj = PyInt_FromLong( result );
9996 : }
9997 : }
9998 3355 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
9999 : return resultobj;
10000 : fail:
10001 : return NULL;
10002 : }
10003 :
10004 :
10005 251 : SWIGINTERN PyObject *_wrap_Layer_SyncToDisk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10006 251 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10007 251 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10008 251 : void *argp1 = 0 ;
10009 251 : int res1 = 0 ;
10010 251 : PyObject *swig_obj[1] ;
10011 251 : OGRErr result;
10012 :
10013 251 : if (!args) SWIG_fail;
10014 251 : swig_obj[0] = args;
10015 251 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10016 251 : if (!SWIG_IsOK(res1)) {
10017 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SyncToDisk" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10018 : }
10019 251 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10020 251 : {
10021 251 : const int bLocalUseExceptions = GetUseExceptions();
10022 251 : if ( bLocalUseExceptions ) {
10023 19 : pushErrorHandler();
10024 : }
10025 251 : {
10026 251 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10027 251 : result = (OGRErr)OGRLayerShadow_SyncToDisk(arg1);
10028 251 : SWIG_PYTHON_THREAD_END_ALLOW;
10029 : }
10030 251 : if ( bLocalUseExceptions ) {
10031 19 : popErrorHandler();
10032 : }
10033 : #ifndef SED_HACKS
10034 : if ( bLocalUseExceptions ) {
10035 : CPLErr eclass = CPLGetLastErrorType();
10036 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10037 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10038 : }
10039 : }
10040 : #endif
10041 : }
10042 251 : {
10043 : /* %typemap(out) OGRErr */
10044 253 : if ( result != 0 && GetUseExceptions()) {
10045 0 : const char* pszMessage = CPLGetLastErrorMsg();
10046 0 : if( pszMessage[0] != '\0' )
10047 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10048 : else
10049 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10050 0 : SWIG_fail;
10051 : }
10052 : }
10053 251 : {
10054 : /* %typemap(ret) OGRErr */
10055 251 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10056 251 : resultobj = PyInt_FromLong( result );
10057 : }
10058 : }
10059 251 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10060 : return resultobj;
10061 : fail:
10062 : return NULL;
10063 : }
10064 :
10065 :
10066 126733 : SWIGINTERN PyObject *_wrap_Layer_GetLayerDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10067 126733 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10068 126733 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10069 126733 : void *argp1 = 0 ;
10070 126733 : int res1 = 0 ;
10071 126733 : PyObject *swig_obj[1] ;
10072 126733 : OGRFeatureDefnShadow *result = 0 ;
10073 :
10074 126733 : if (!args) SWIG_fail;
10075 126733 : swig_obj[0] = args;
10076 126733 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10077 126733 : if (!SWIG_IsOK(res1)) {
10078 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetLayerDefn" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10079 : }
10080 126733 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10081 126733 : {
10082 126733 : const int bLocalUseExceptions = GetUseExceptions();
10083 126733 : if ( bLocalUseExceptions ) {
10084 64391 : pushErrorHandler();
10085 : }
10086 126733 : {
10087 126733 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10088 126733 : result = (OGRFeatureDefnShadow *)OGRLayerShadow_GetLayerDefn(arg1);
10089 126733 : SWIG_PYTHON_THREAD_END_ALLOW;
10090 : }
10091 126733 : if ( bLocalUseExceptions ) {
10092 64391 : popErrorHandler();
10093 : }
10094 : #ifndef SED_HACKS
10095 : if ( bLocalUseExceptions ) {
10096 : CPLErr eclass = CPLGetLastErrorType();
10097 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10098 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10099 : }
10100 : }
10101 : #endif
10102 : }
10103 126733 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureDefnShadow, SWIG_POINTER_OWN | 0 );
10104 126741 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10105 : return resultobj;
10106 : fail:
10107 : return NULL;
10108 : }
10109 :
10110 :
10111 36765 : SWIGINTERN PyObject *_wrap_Layer_GetFeatureCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10112 36765 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10113 36765 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10114 36765 : int arg2 = (int) 1 ;
10115 36765 : void *argp1 = 0 ;
10116 36765 : int res1 = 0 ;
10117 36765 : int val2 ;
10118 36765 : int ecode2 = 0 ;
10119 36765 : PyObject * obj0 = 0 ;
10120 36765 : PyObject * obj1 = 0 ;
10121 36765 : char * kwnames[] = {
10122 : (char *)"self", (char *)"force", NULL
10123 : };
10124 36765 : GIntBig result;
10125 :
10126 36765 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Layer_GetFeatureCount", kwnames, &obj0, &obj1)) SWIG_fail;
10127 36765 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10128 36765 : if (!SWIG_IsOK(res1)) {
10129 16 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetFeatureCount" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10130 : }
10131 36757 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10132 36757 : if (obj1) {
10133 54 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10134 54 : if (!SWIG_IsOK(ecode2)) {
10135 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_GetFeatureCount" "', argument " "2"" of type '" "int""'");
10136 : }
10137 : arg2 = static_cast< int >(val2);
10138 : }
10139 36757 : {
10140 36757 : const int bLocalUseExceptions = GetUseExceptions();
10141 36757 : if ( bLocalUseExceptions ) {
10142 2713 : pushErrorHandler();
10143 : }
10144 36757 : {
10145 36757 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10146 36757 : result = OGRLayerShadow_GetFeatureCount(arg1,arg2);
10147 36757 : SWIG_PYTHON_THREAD_END_ALLOW;
10148 : }
10149 36757 : if ( bLocalUseExceptions ) {
10150 2713 : popErrorHandler();
10151 : }
10152 : #ifndef SED_HACKS
10153 : if ( bLocalUseExceptions ) {
10154 : CPLErr eclass = CPLGetLastErrorType();
10155 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10156 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10157 : }
10158 : }
10159 : #endif
10160 : }
10161 36757 : {
10162 36757 : resultobj = PyLong_FromLongLong(result);
10163 : }
10164 36783 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10165 : return resultobj;
10166 : fail:
10167 : return NULL;
10168 : }
10169 :
10170 :
10171 372 : SWIGINTERN PyObject *_wrap_Layer_GetExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10172 372 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10173 372 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10174 372 : double *arg2 ;
10175 372 : int *arg3 = (int *) NULL ;
10176 372 : int arg4 = (int) 1 ;
10177 372 : int arg5 = (int) 0 ;
10178 372 : int arg6 = (int) 0 ;
10179 372 : void *argp1 = 0 ;
10180 372 : int res1 = 0 ;
10181 372 : double argout2[4] ;
10182 372 : int isvalid2 ;
10183 372 : int val4 ;
10184 372 : int ecode4 = 0 ;
10185 372 : int val5 ;
10186 372 : int ecode5 = 0 ;
10187 372 : int val6 ;
10188 372 : int ecode6 = 0 ;
10189 372 : PyObject * obj0 = 0 ;
10190 372 : PyObject * obj1 = 0 ;
10191 372 : PyObject * obj2 = 0 ;
10192 372 : PyObject * obj3 = 0 ;
10193 372 : char * kwnames[] = {
10194 : (char *)"self", (char *)"force", (char *)"can_return_null", (char *)"geom_field", NULL
10195 : };
10196 :
10197 372 : {
10198 : /* %typemap(in,numinputs=0) (double argout2[4], int* isvalid2) */
10199 372 : arg2 = argout2;
10200 372 : arg3 = &isvalid2;
10201 : }
10202 372 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Layer_GetExtent", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
10203 372 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10204 372 : if (!SWIG_IsOK(res1)) {
10205 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetExtent" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10206 : }
10207 372 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10208 372 : if (obj1) {
10209 54 : ecode4 = SWIG_AsVal_int(obj1, &val4);
10210 54 : if (!SWIG_IsOK(ecode4)) {
10211 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_GetExtent" "', argument " "4"" of type '" "int""'");
10212 : }
10213 : arg4 = static_cast< int >(val4);
10214 : }
10215 372 : if (obj2) {
10216 36 : ecode5 = SWIG_AsVal_int(obj2, &val5);
10217 36 : if (!SWIG_IsOK(ecode5)) {
10218 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Layer_GetExtent" "', argument " "5"" of type '" "int""'");
10219 : }
10220 : arg5 = static_cast< int >(val5);
10221 : }
10222 372 : if (obj3) {
10223 78 : ecode6 = SWIG_AsVal_int(obj3, &val6);
10224 78 : if (!SWIG_IsOK(ecode6)) {
10225 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Layer_GetExtent" "', argument " "6"" of type '" "int""'");
10226 : }
10227 : arg6 = static_cast< int >(val6);
10228 : }
10229 372 : {
10230 372 : const int bLocalUseExceptions = GetUseExceptions();
10231 372 : if ( bLocalUseExceptions ) {
10232 232 : pushErrorHandler();
10233 : }
10234 372 : {
10235 372 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10236 372 : OGRLayerShadow_GetExtent(arg1,arg2,arg3,arg4,arg5,arg6);
10237 372 : SWIG_PYTHON_THREAD_END_ALLOW;
10238 : }
10239 372 : if ( bLocalUseExceptions ) {
10240 232 : popErrorHandler();
10241 : }
10242 : #ifndef SED_HACKS
10243 : if ( bLocalUseExceptions ) {
10244 : CPLErr eclass = CPLGetLastErrorType();
10245 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10246 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10247 : }
10248 : }
10249 : #endif
10250 : }
10251 372 : resultobj = SWIG_Py_Void();
10252 372 : {
10253 : /* %typemap(argout) (double argout[4], int* isvalid) */
10254 372 : PyObject *r;
10255 372 : if ( !*arg3 ) {
10256 9 : Py_INCREF(Py_None);
10257 9 : r = Py_None;
10258 : }
10259 : else {
10260 363 : r = CreateTupleFromDoubleArray(arg2, 4);
10261 : }
10262 : #if 0x040001 >= 0x040300
10263 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
10264 : #else
10265 372 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
10266 : #endif
10267 : }
10268 450 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10269 : return resultobj;
10270 : fail:
10271 : return NULL;
10272 : }
10273 :
10274 :
10275 60 : SWIGINTERN PyObject *_wrap_Layer_GetExtent3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10276 60 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10277 60 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10278 60 : double *arg2 ;
10279 60 : int *arg3 = (int *) NULL ;
10280 60 : int arg4 = (int) 1 ;
10281 60 : int arg5 = (int) 0 ;
10282 60 : int arg6 = (int) 0 ;
10283 60 : void *argp1 = 0 ;
10284 60 : int res1 = 0 ;
10285 60 : double argout2[6] ;
10286 60 : int isvalid2 ;
10287 60 : int val4 ;
10288 60 : int ecode4 = 0 ;
10289 60 : int val5 ;
10290 60 : int ecode5 = 0 ;
10291 60 : int val6 ;
10292 60 : int ecode6 = 0 ;
10293 60 : PyObject * obj0 = 0 ;
10294 60 : PyObject * obj1 = 0 ;
10295 60 : PyObject * obj2 = 0 ;
10296 60 : PyObject * obj3 = 0 ;
10297 60 : char * kwnames[] = {
10298 : (char *)"self", (char *)"force", (char *)"can_return_null", (char *)"geom_field", NULL
10299 : };
10300 :
10301 60 : {
10302 : /* %typemap(in,numinputs=0) (double argout2[6], int* isvalid2) */
10303 60 : arg2 = argout2;
10304 60 : arg3 = &isvalid2;
10305 : }
10306 60 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Layer_GetExtent3D", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
10307 60 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10308 60 : if (!SWIG_IsOK(res1)) {
10309 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetExtent3D" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10310 : }
10311 60 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10312 60 : if (obj1) {
10313 0 : ecode4 = SWIG_AsVal_int(obj1, &val4);
10314 0 : if (!SWIG_IsOK(ecode4)) {
10315 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_GetExtent3D" "', argument " "4"" of type '" "int""'");
10316 : }
10317 : arg4 = static_cast< int >(val4);
10318 : }
10319 60 : if (obj2) {
10320 1 : ecode5 = SWIG_AsVal_int(obj2, &val5);
10321 1 : if (!SWIG_IsOK(ecode5)) {
10322 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Layer_GetExtent3D" "', argument " "5"" of type '" "int""'");
10323 : }
10324 : arg5 = static_cast< int >(val5);
10325 : }
10326 60 : if (obj3) {
10327 0 : ecode6 = SWIG_AsVal_int(obj3, &val6);
10328 0 : if (!SWIG_IsOK(ecode6)) {
10329 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Layer_GetExtent3D" "', argument " "6"" of type '" "int""'");
10330 : }
10331 : arg6 = static_cast< int >(val6);
10332 : }
10333 60 : {
10334 60 : const int bLocalUseExceptions = GetUseExceptions();
10335 60 : if ( bLocalUseExceptions ) {
10336 35 : pushErrorHandler();
10337 : }
10338 60 : {
10339 60 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10340 60 : OGRLayerShadow_GetExtent3D(arg1,arg2,arg3,arg4,arg5,arg6);
10341 60 : SWIG_PYTHON_THREAD_END_ALLOW;
10342 : }
10343 60 : if ( bLocalUseExceptions ) {
10344 35 : popErrorHandler();
10345 : }
10346 : #ifndef SED_HACKS
10347 : if ( bLocalUseExceptions ) {
10348 : CPLErr eclass = CPLGetLastErrorType();
10349 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10350 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10351 : }
10352 : }
10353 : #endif
10354 : }
10355 60 : resultobj = SWIG_Py_Void();
10356 60 : {
10357 : /* %typemap(argout) (double argout[6], int* isvalid) */
10358 60 : PyObject *r;
10359 60 : if ( !*arg3 ) {
10360 1 : Py_INCREF(Py_None);
10361 1 : r = Py_None;
10362 : }
10363 : else {
10364 59 : r = CreateTupleFromDoubleArray(arg2, 6);
10365 : }
10366 : #if 0x040001 >= 0x040300
10367 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
10368 : #else
10369 60 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
10370 : #endif
10371 : }
10372 60 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10373 : return resultobj;
10374 : fail:
10375 : return NULL;
10376 : }
10377 :
10378 :
10379 753 : SWIGINTERN PyObject *_wrap_Layer_TestCapability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10380 753 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10381 753 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10382 753 : char *arg2 = (char *) 0 ;
10383 753 : void *argp1 = 0 ;
10384 753 : int res1 = 0 ;
10385 753 : int res2 ;
10386 753 : char *buf2 = 0 ;
10387 753 : int alloc2 = 0 ;
10388 753 : PyObject *swig_obj[2] ;
10389 753 : bool result;
10390 :
10391 753 : if (!SWIG_Python_UnpackTuple(args, "Layer_TestCapability", 2, 2, swig_obj)) SWIG_fail;
10392 753 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10393 753 : if (!SWIG_IsOK(res1)) {
10394 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_TestCapability" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10395 : }
10396 753 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10397 753 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
10398 753 : if (!SWIG_IsOK(res2)) {
10399 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_TestCapability" "', argument " "2"" of type '" "char const *""'");
10400 : }
10401 753 : arg2 = reinterpret_cast< char * >(buf2);
10402 753 : {
10403 753 : const int bLocalUseExceptions = GetUseExceptions();
10404 753 : if ( bLocalUseExceptions ) {
10405 390 : pushErrorHandler();
10406 : }
10407 753 : {
10408 753 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10409 753 : result = (bool)OGRLayerShadow_TestCapability(arg1,(char const *)arg2);
10410 753 : SWIG_PYTHON_THREAD_END_ALLOW;
10411 : }
10412 753 : if ( bLocalUseExceptions ) {
10413 390 : popErrorHandler();
10414 : }
10415 : #ifndef SED_HACKS
10416 : if ( bLocalUseExceptions ) {
10417 : CPLErr eclass = CPLGetLastErrorType();
10418 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10419 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10420 : }
10421 : }
10422 : #endif
10423 : }
10424 753 : resultobj = SWIG_From_bool(static_cast< bool >(result));
10425 753 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10426 757 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10427 : return resultobj;
10428 0 : fail:
10429 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10430 : return NULL;
10431 : }
10432 :
10433 :
10434 77219 : SWIGINTERN PyObject *_wrap_Layer_CreateField(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10435 77219 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10436 77219 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10437 77219 : OGRFieldDefnShadow *arg2 = (OGRFieldDefnShadow *) 0 ;
10438 77219 : int arg3 = (int) 1 ;
10439 77219 : void *argp1 = 0 ;
10440 77219 : int res1 = 0 ;
10441 77219 : void *argp2 = 0 ;
10442 77219 : int res2 = 0 ;
10443 77219 : int val3 ;
10444 77219 : int ecode3 = 0 ;
10445 77219 : PyObject * obj0 = 0 ;
10446 77219 : PyObject * obj1 = 0 ;
10447 77219 : PyObject * obj2 = 0 ;
10448 77219 : char * kwnames[] = {
10449 : (char *)"self", (char *)"field_def", (char *)"approx_ok", NULL
10450 : };
10451 77219 : OGRErr result;
10452 :
10453 77219 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Layer_CreateField", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
10454 77219 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10455 77219 : if (!SWIG_IsOK(res1)) {
10456 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_CreateField" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10457 : }
10458 77219 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10459 77219 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
10460 77219 : if (!SWIG_IsOK(res2)) {
10461 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_CreateField" "', argument " "2"" of type '" "OGRFieldDefnShadow *""'");
10462 : }
10463 77219 : arg2 = reinterpret_cast< OGRFieldDefnShadow * >(argp2);
10464 77219 : if (obj2) {
10465 24 : ecode3 = SWIG_AsVal_int(obj2, &val3);
10466 24 : if (!SWIG_IsOK(ecode3)) {
10467 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Layer_CreateField" "', argument " "3"" of type '" "int""'");
10468 : }
10469 : arg3 = static_cast< int >(val3);
10470 : }
10471 77219 : {
10472 77219 : if (!arg2) {
10473 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10474 : }
10475 : }
10476 77219 : {
10477 77219 : const int bLocalUseExceptions = GetUseExceptions();
10478 77219 : if ( bLocalUseExceptions ) {
10479 69300 : pushErrorHandler();
10480 : }
10481 77219 : {
10482 77219 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10483 77219 : result = (OGRErr)OGRLayerShadow_CreateField(arg1,arg2,arg3);
10484 77219 : SWIG_PYTHON_THREAD_END_ALLOW;
10485 : }
10486 77219 : if ( bLocalUseExceptions ) {
10487 69300 : popErrorHandler();
10488 : }
10489 : #ifndef SED_HACKS
10490 : if ( bLocalUseExceptions ) {
10491 : CPLErr eclass = CPLGetLastErrorType();
10492 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10493 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10494 : }
10495 : }
10496 : #endif
10497 : }
10498 77219 : {
10499 : /* %typemap(out) OGRErr */
10500 77279 : if ( result != 0 && GetUseExceptions()) {
10501 16 : const char* pszMessage = CPLGetLastErrorMsg();
10502 16 : if( pszMessage[0] != '\0' )
10503 16 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10504 : else
10505 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10506 16 : SWIG_fail;
10507 : }
10508 : }
10509 77203 : {
10510 : /* %typemap(ret) OGRErr */
10511 77203 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10512 77203 : resultobj = PyInt_FromLong( result );
10513 : }
10514 : }
10515 77219 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10516 : return resultobj;
10517 : fail:
10518 : return NULL;
10519 : }
10520 :
10521 :
10522 372 : SWIGINTERN PyObject *_wrap_Layer_DeleteField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10523 372 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10524 372 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10525 372 : int arg2 ;
10526 372 : void *argp1 = 0 ;
10527 372 : int res1 = 0 ;
10528 372 : int val2 ;
10529 372 : int ecode2 = 0 ;
10530 372 : PyObject *swig_obj[2] ;
10531 372 : OGRErr result;
10532 :
10533 372 : if (!SWIG_Python_UnpackTuple(args, "Layer_DeleteField", 2, 2, swig_obj)) SWIG_fail;
10534 372 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10535 372 : if (!SWIG_IsOK(res1)) {
10536 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_DeleteField" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10537 : }
10538 372 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10539 372 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10540 372 : if (!SWIG_IsOK(ecode2)) {
10541 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_DeleteField" "', argument " "2"" of type '" "int""'");
10542 : }
10543 372 : arg2 = static_cast< int >(val2);
10544 372 : {
10545 372 : const int bLocalUseExceptions = GetUseExceptions();
10546 372 : if ( bLocalUseExceptions ) {
10547 6 : pushErrorHandler();
10548 : }
10549 372 : {
10550 372 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10551 372 : result = (OGRErr)OGRLayerShadow_DeleteField(arg1,arg2);
10552 372 : SWIG_PYTHON_THREAD_END_ALLOW;
10553 : }
10554 372 : if ( bLocalUseExceptions ) {
10555 6 : popErrorHandler();
10556 : }
10557 : #ifndef SED_HACKS
10558 : if ( bLocalUseExceptions ) {
10559 : CPLErr eclass = CPLGetLastErrorType();
10560 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10561 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10562 : }
10563 : }
10564 : #endif
10565 : }
10566 372 : {
10567 : /* %typemap(out) OGRErr */
10568 393 : if ( result != 0 && GetUseExceptions()) {
10569 3 : const char* pszMessage = CPLGetLastErrorMsg();
10570 3 : if( pszMessage[0] != '\0' )
10571 3 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10572 : else
10573 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10574 3 : SWIG_fail;
10575 : }
10576 : }
10577 369 : {
10578 : /* %typemap(ret) OGRErr */
10579 369 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10580 369 : resultobj = PyInt_FromLong( result );
10581 : }
10582 : }
10583 372 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10584 : return resultobj;
10585 : fail:
10586 : return NULL;
10587 : }
10588 :
10589 :
10590 34 : SWIGINTERN PyObject *_wrap_Layer_ReorderField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10591 34 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10592 34 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10593 34 : int arg2 ;
10594 34 : int arg3 ;
10595 34 : void *argp1 = 0 ;
10596 34 : int res1 = 0 ;
10597 34 : int val2 ;
10598 34 : int ecode2 = 0 ;
10599 34 : int val3 ;
10600 34 : int ecode3 = 0 ;
10601 34 : PyObject *swig_obj[3] ;
10602 34 : OGRErr result;
10603 :
10604 34 : if (!SWIG_Python_UnpackTuple(args, "Layer_ReorderField", 3, 3, swig_obj)) SWIG_fail;
10605 34 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10606 34 : if (!SWIG_IsOK(res1)) {
10607 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_ReorderField" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10608 : }
10609 34 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10610 34 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10611 34 : if (!SWIG_IsOK(ecode2)) {
10612 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_ReorderField" "', argument " "2"" of type '" "int""'");
10613 : }
10614 34 : arg2 = static_cast< int >(val2);
10615 34 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10616 34 : if (!SWIG_IsOK(ecode3)) {
10617 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Layer_ReorderField" "', argument " "3"" of type '" "int""'");
10618 : }
10619 34 : arg3 = static_cast< int >(val3);
10620 34 : {
10621 34 : const int bLocalUseExceptions = GetUseExceptions();
10622 34 : if ( bLocalUseExceptions ) {
10623 0 : pushErrorHandler();
10624 : }
10625 34 : {
10626 34 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10627 34 : result = (OGRErr)OGRLayerShadow_ReorderField(arg1,arg2,arg3);
10628 34 : SWIG_PYTHON_THREAD_END_ALLOW;
10629 : }
10630 34 : if ( bLocalUseExceptions ) {
10631 0 : popErrorHandler();
10632 : }
10633 : #ifndef SED_HACKS
10634 : if ( bLocalUseExceptions ) {
10635 : CPLErr eclass = CPLGetLastErrorType();
10636 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10637 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10638 : }
10639 : }
10640 : #endif
10641 : }
10642 34 : {
10643 : /* %typemap(out) OGRErr */
10644 34 : if ( result != 0 && GetUseExceptions()) {
10645 0 : const char* pszMessage = CPLGetLastErrorMsg();
10646 0 : if( pszMessage[0] != '\0' )
10647 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10648 : else
10649 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10650 0 : SWIG_fail;
10651 : }
10652 : }
10653 34 : {
10654 : /* %typemap(ret) OGRErr */
10655 34 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10656 34 : resultobj = PyInt_FromLong( result );
10657 : }
10658 : }
10659 34 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10660 : return resultobj;
10661 : fail:
10662 : return NULL;
10663 : }
10664 :
10665 :
10666 43 : SWIGINTERN PyObject *_wrap_Layer_ReorderFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10667 43 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10668 43 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10669 43 : int arg2 ;
10670 43 : int *arg3 = (int *) 0 ;
10671 43 : void *argp1 = 0 ;
10672 43 : int res1 = 0 ;
10673 43 : PyObject *swig_obj[2] ;
10674 43 : OGRErr result;
10675 :
10676 43 : if (!SWIG_Python_UnpackTuple(args, "Layer_ReorderFields", 2, 2, swig_obj)) SWIG_fail;
10677 43 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10678 43 : if (!SWIG_IsOK(res1)) {
10679 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_ReorderFields" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10680 : }
10681 43 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10682 43 : {
10683 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
10684 43 : arg3 = CreateCIntListFromSequence(swig_obj[1], &arg2);
10685 43 : if( arg2 < 0 ) {
10686 0 : SWIG_fail;
10687 : }
10688 : }
10689 43 : {
10690 43 : const int bLocalUseExceptions = GetUseExceptions();
10691 43 : if ( bLocalUseExceptions ) {
10692 0 : pushErrorHandler();
10693 : }
10694 43 : {
10695 43 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10696 43 : result = (OGRErr)OGRLayerShadow_ReorderFields(arg1,arg2,arg3);
10697 43 : SWIG_PYTHON_THREAD_END_ALLOW;
10698 : }
10699 43 : if ( bLocalUseExceptions ) {
10700 0 : popErrorHandler();
10701 : }
10702 : #ifndef SED_HACKS
10703 : if ( bLocalUseExceptions ) {
10704 : CPLErr eclass = CPLGetLastErrorType();
10705 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10706 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10707 : }
10708 : }
10709 : #endif
10710 : }
10711 43 : {
10712 : /* %typemap(out) OGRErr */
10713 53 : if ( result != 0 && GetUseExceptions()) {
10714 0 : const char* pszMessage = CPLGetLastErrorMsg();
10715 0 : if( pszMessage[0] != '\0' )
10716 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10717 : else
10718 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10719 0 : SWIG_fail;
10720 : }
10721 : }
10722 43 : {
10723 : /* %typemap(freearg) (int nList, int* pList) */
10724 43 : free(arg3);
10725 : }
10726 43 : {
10727 : /* %typemap(ret) OGRErr */
10728 43 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10729 43 : resultobj = PyInt_FromLong( result );
10730 : }
10731 : }
10732 43 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10733 : return resultobj;
10734 0 : fail:
10735 0 : {
10736 : /* %typemap(freearg) (int nList, int* pList) */
10737 0 : free(arg3);
10738 : }
10739 0 : return NULL;
10740 : }
10741 :
10742 :
10743 126 : SWIGINTERN PyObject *_wrap_Layer_AlterFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10744 126 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10745 126 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10746 126 : int arg2 ;
10747 126 : OGRFieldDefnShadow *arg3 = (OGRFieldDefnShadow *) 0 ;
10748 126 : int arg4 ;
10749 126 : void *argp1 = 0 ;
10750 126 : int res1 = 0 ;
10751 126 : int val2 ;
10752 126 : int ecode2 = 0 ;
10753 126 : void *argp3 = 0 ;
10754 126 : int res3 = 0 ;
10755 126 : int val4 ;
10756 126 : int ecode4 = 0 ;
10757 126 : PyObject *swig_obj[4] ;
10758 126 : OGRErr result;
10759 :
10760 126 : if (!SWIG_Python_UnpackTuple(args, "Layer_AlterFieldDefn", 4, 4, swig_obj)) SWIG_fail;
10761 126 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10762 126 : if (!SWIG_IsOK(res1)) {
10763 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_AlterFieldDefn" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10764 : }
10765 126 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10766 126 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10767 126 : if (!SWIG_IsOK(ecode2)) {
10768 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_AlterFieldDefn" "', argument " "2"" of type '" "int""'");
10769 : }
10770 126 : arg2 = static_cast< int >(val2);
10771 126 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
10772 126 : if (!SWIG_IsOK(res3)) {
10773 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_AlterFieldDefn" "', argument " "3"" of type '" "OGRFieldDefnShadow *""'");
10774 : }
10775 126 : arg3 = reinterpret_cast< OGRFieldDefnShadow * >(argp3);
10776 126 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
10777 126 : if (!SWIG_IsOK(ecode4)) {
10778 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_AlterFieldDefn" "', argument " "4"" of type '" "int""'");
10779 : }
10780 126 : arg4 = static_cast< int >(val4);
10781 126 : {
10782 126 : if (!arg3) {
10783 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10784 : }
10785 : }
10786 126 : {
10787 126 : const int bLocalUseExceptions = GetUseExceptions();
10788 126 : if ( bLocalUseExceptions ) {
10789 1 : pushErrorHandler();
10790 : }
10791 126 : {
10792 126 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10793 126 : result = (OGRErr)OGRLayerShadow_AlterFieldDefn(arg1,arg2,arg3,arg4);
10794 126 : SWIG_PYTHON_THREAD_END_ALLOW;
10795 : }
10796 126 : if ( bLocalUseExceptions ) {
10797 1 : popErrorHandler();
10798 : }
10799 : #ifndef SED_HACKS
10800 : if ( bLocalUseExceptions ) {
10801 : CPLErr eclass = CPLGetLastErrorType();
10802 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10803 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10804 : }
10805 : }
10806 : #endif
10807 : }
10808 126 : {
10809 : /* %typemap(out) OGRErr */
10810 160 : if ( result != 0 && GetUseExceptions()) {
10811 0 : const char* pszMessage = CPLGetLastErrorMsg();
10812 0 : if( pszMessage[0] != '\0' )
10813 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10814 : else
10815 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10816 0 : SWIG_fail;
10817 : }
10818 : }
10819 126 : {
10820 : /* %typemap(ret) OGRErr */
10821 126 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10822 126 : resultobj = PyInt_FromLong( result );
10823 : }
10824 : }
10825 126 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10826 : return resultobj;
10827 : fail:
10828 : return NULL;
10829 : }
10830 :
10831 :
10832 33 : SWIGINTERN PyObject *_wrap_Layer_AlterGeomFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10833 33 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10834 33 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10835 33 : int arg2 ;
10836 33 : OGRGeomFieldDefnShadow *arg3 = (OGRGeomFieldDefnShadow *) 0 ;
10837 33 : int arg4 ;
10838 33 : void *argp1 = 0 ;
10839 33 : int res1 = 0 ;
10840 33 : int val2 ;
10841 33 : int ecode2 = 0 ;
10842 33 : void *argp3 = 0 ;
10843 33 : int res3 = 0 ;
10844 33 : int val4 ;
10845 33 : int ecode4 = 0 ;
10846 33 : PyObject *swig_obj[4] ;
10847 33 : OGRErr result;
10848 :
10849 33 : if (!SWIG_Python_UnpackTuple(args, "Layer_AlterGeomFieldDefn", 4, 4, swig_obj)) SWIG_fail;
10850 33 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10851 33 : if (!SWIG_IsOK(res1)) {
10852 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_AlterGeomFieldDefn" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10853 : }
10854 33 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10855 33 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10856 33 : if (!SWIG_IsOK(ecode2)) {
10857 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_AlterGeomFieldDefn" "', argument " "2"" of type '" "int""'");
10858 : }
10859 33 : arg2 = static_cast< int >(val2);
10860 33 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
10861 33 : if (!SWIG_IsOK(res3)) {
10862 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_AlterGeomFieldDefn" "', argument " "3"" of type '" "OGRGeomFieldDefnShadow const *""'");
10863 : }
10864 33 : arg3 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp3);
10865 33 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
10866 33 : if (!SWIG_IsOK(ecode4)) {
10867 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_AlterGeomFieldDefn" "', argument " "4"" of type '" "int""'");
10868 : }
10869 33 : arg4 = static_cast< int >(val4);
10870 33 : {
10871 33 : if (!arg3) {
10872 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10873 : }
10874 : }
10875 33 : {
10876 33 : const int bLocalUseExceptions = GetUseExceptions();
10877 33 : if ( bLocalUseExceptions ) {
10878 4 : pushErrorHandler();
10879 : }
10880 33 : {
10881 33 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10882 33 : result = (OGRErr)OGRLayerShadow_AlterGeomFieldDefn(arg1,arg2,(OGRGeomFieldDefnShadow const *)arg3,arg4);
10883 33 : SWIG_PYTHON_THREAD_END_ALLOW;
10884 : }
10885 33 : if ( bLocalUseExceptions ) {
10886 4 : popErrorHandler();
10887 : }
10888 : #ifndef SED_HACKS
10889 : if ( bLocalUseExceptions ) {
10890 : CPLErr eclass = CPLGetLastErrorType();
10891 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10892 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10893 : }
10894 : }
10895 : #endif
10896 : }
10897 33 : {
10898 : /* %typemap(out) OGRErr */
10899 41 : if ( result != 0 && GetUseExceptions()) {
10900 0 : const char* pszMessage = CPLGetLastErrorMsg();
10901 0 : if( pszMessage[0] != '\0' )
10902 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10903 : else
10904 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10905 0 : SWIG_fail;
10906 : }
10907 : }
10908 33 : {
10909 : /* %typemap(ret) OGRErr */
10910 33 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10911 33 : resultobj = PyInt_FromLong( result );
10912 : }
10913 : }
10914 33 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10915 : return resultobj;
10916 : fail:
10917 : return NULL;
10918 : }
10919 :
10920 :
10921 120 : SWIGINTERN PyObject *_wrap_Layer_CreateGeomField(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10922 120 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10923 120 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10924 120 : OGRGeomFieldDefnShadow *arg2 = (OGRGeomFieldDefnShadow *) 0 ;
10925 120 : int arg3 = (int) 1 ;
10926 120 : void *argp1 = 0 ;
10927 120 : int res1 = 0 ;
10928 120 : void *argp2 = 0 ;
10929 120 : int res2 = 0 ;
10930 120 : int val3 ;
10931 120 : int ecode3 = 0 ;
10932 120 : PyObject * obj0 = 0 ;
10933 120 : PyObject * obj1 = 0 ;
10934 120 : PyObject * obj2 = 0 ;
10935 120 : char * kwnames[] = {
10936 : (char *)"self", (char *)"field_def", (char *)"approx_ok", NULL
10937 : };
10938 120 : OGRErr result;
10939 :
10940 120 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Layer_CreateGeomField", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
10941 120 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10942 120 : if (!SWIG_IsOK(res1)) {
10943 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_CreateGeomField" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10944 : }
10945 120 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10946 120 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
10947 120 : if (!SWIG_IsOK(res2)) {
10948 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_CreateGeomField" "', argument " "2"" of type '" "OGRGeomFieldDefnShadow *""'");
10949 : }
10950 120 : arg2 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp2);
10951 120 : if (obj2) {
10952 2 : ecode3 = SWIG_AsVal_int(obj2, &val3);
10953 2 : if (!SWIG_IsOK(ecode3)) {
10954 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Layer_CreateGeomField" "', argument " "3"" of type '" "int""'");
10955 : }
10956 : arg3 = static_cast< int >(val3);
10957 : }
10958 120 : {
10959 120 : if (!arg2) {
10960 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10961 : }
10962 : }
10963 120 : {
10964 120 : const int bLocalUseExceptions = GetUseExceptions();
10965 120 : if ( bLocalUseExceptions ) {
10966 39 : pushErrorHandler();
10967 : }
10968 120 : {
10969 120 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10970 120 : result = (OGRErr)OGRLayerShadow_CreateGeomField(arg1,arg2,arg3);
10971 120 : SWIG_PYTHON_THREAD_END_ALLOW;
10972 : }
10973 120 : if ( bLocalUseExceptions ) {
10974 39 : popErrorHandler();
10975 : }
10976 : #ifndef SED_HACKS
10977 : if ( bLocalUseExceptions ) {
10978 : CPLErr eclass = CPLGetLastErrorType();
10979 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10980 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10981 : }
10982 : }
10983 : #endif
10984 : }
10985 120 : {
10986 : /* %typemap(out) OGRErr */
10987 130 : if ( result != 0 && GetUseExceptions()) {
10988 1 : const char* pszMessage = CPLGetLastErrorMsg();
10989 1 : if( pszMessage[0] != '\0' )
10990 1 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10991 : else
10992 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10993 1 : SWIG_fail;
10994 : }
10995 : }
10996 119 : {
10997 : /* %typemap(ret) OGRErr */
10998 119 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10999 119 : resultobj = PyInt_FromLong( result );
11000 : }
11001 : }
11002 120 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11003 : return resultobj;
11004 : fail:
11005 : return NULL;
11006 : }
11007 :
11008 :
11009 149 : SWIGINTERN PyObject *_wrap_Layer_StartTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11010 149 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11011 149 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11012 149 : void *argp1 = 0 ;
11013 149 : int res1 = 0 ;
11014 149 : PyObject *swig_obj[1] ;
11015 149 : OGRErr result;
11016 :
11017 149 : if (!args) SWIG_fail;
11018 149 : swig_obj[0] = args;
11019 149 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11020 149 : if (!SWIG_IsOK(res1)) {
11021 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_StartTransaction" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11022 : }
11023 149 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11024 149 : {
11025 149 : const int bLocalUseExceptions = GetUseExceptions();
11026 149 : if ( bLocalUseExceptions ) {
11027 16 : pushErrorHandler();
11028 : }
11029 149 : {
11030 149 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11031 149 : result = (OGRErr)OGRLayerShadow_StartTransaction(arg1);
11032 149 : SWIG_PYTHON_THREAD_END_ALLOW;
11033 : }
11034 149 : if ( bLocalUseExceptions ) {
11035 16 : popErrorHandler();
11036 : }
11037 : #ifndef SED_HACKS
11038 : if ( bLocalUseExceptions ) {
11039 : CPLErr eclass = CPLGetLastErrorType();
11040 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11041 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11042 : }
11043 : }
11044 : #endif
11045 : }
11046 149 : {
11047 : /* %typemap(out) OGRErr */
11048 153 : if ( result != 0 && GetUseExceptions()) {
11049 0 : const char* pszMessage = CPLGetLastErrorMsg();
11050 0 : if( pszMessage[0] != '\0' )
11051 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
11052 : else
11053 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11054 0 : SWIG_fail;
11055 : }
11056 : }
11057 149 : {
11058 : /* %typemap(ret) OGRErr */
11059 149 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
11060 149 : resultobj = PyInt_FromLong( result );
11061 : }
11062 : }
11063 149 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11064 : return resultobj;
11065 : fail:
11066 : return NULL;
11067 : }
11068 :
11069 :
11070 129 : SWIGINTERN PyObject *_wrap_Layer_CommitTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11071 129 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11072 129 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11073 129 : void *argp1 = 0 ;
11074 129 : int res1 = 0 ;
11075 129 : PyObject *swig_obj[1] ;
11076 129 : OGRErr result;
11077 :
11078 129 : if (!args) SWIG_fail;
11079 129 : swig_obj[0] = args;
11080 129 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11081 129 : if (!SWIG_IsOK(res1)) {
11082 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_CommitTransaction" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11083 : }
11084 129 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11085 129 : {
11086 129 : const int bLocalUseExceptions = GetUseExceptions();
11087 129 : if ( bLocalUseExceptions ) {
11088 16 : pushErrorHandler();
11089 : }
11090 129 : {
11091 129 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11092 129 : result = (OGRErr)OGRLayerShadow_CommitTransaction(arg1);
11093 129 : SWIG_PYTHON_THREAD_END_ALLOW;
11094 : }
11095 129 : if ( bLocalUseExceptions ) {
11096 16 : popErrorHandler();
11097 : }
11098 : #ifndef SED_HACKS
11099 : if ( bLocalUseExceptions ) {
11100 : CPLErr eclass = CPLGetLastErrorType();
11101 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11102 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11103 : }
11104 : }
11105 : #endif
11106 : }
11107 129 : {
11108 : /* %typemap(out) OGRErr */
11109 147 : if ( result != 0 && GetUseExceptions()) {
11110 0 : const char* pszMessage = CPLGetLastErrorMsg();
11111 0 : if( pszMessage[0] != '\0' )
11112 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
11113 : else
11114 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11115 0 : SWIG_fail;
11116 : }
11117 : }
11118 129 : {
11119 : /* %typemap(ret) OGRErr */
11120 129 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
11121 129 : resultobj = PyInt_FromLong( result );
11122 : }
11123 : }
11124 129 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11125 : return resultobj;
11126 : fail:
11127 : return NULL;
11128 : }
11129 :
11130 :
11131 26 : SWIGINTERN PyObject *_wrap_Layer_RollbackTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11132 26 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11133 26 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11134 26 : void *argp1 = 0 ;
11135 26 : int res1 = 0 ;
11136 26 : PyObject *swig_obj[1] ;
11137 26 : OGRErr result;
11138 :
11139 26 : if (!args) SWIG_fail;
11140 26 : swig_obj[0] = args;
11141 26 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11142 26 : if (!SWIG_IsOK(res1)) {
11143 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_RollbackTransaction" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11144 : }
11145 26 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11146 26 : {
11147 26 : const int bLocalUseExceptions = GetUseExceptions();
11148 26 : if ( bLocalUseExceptions ) {
11149 0 : pushErrorHandler();
11150 : }
11151 26 : {
11152 26 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11153 26 : result = (OGRErr)OGRLayerShadow_RollbackTransaction(arg1);
11154 26 : SWIG_PYTHON_THREAD_END_ALLOW;
11155 : }
11156 26 : if ( bLocalUseExceptions ) {
11157 0 : popErrorHandler();
11158 : }
11159 : #ifndef SED_HACKS
11160 : if ( bLocalUseExceptions ) {
11161 : CPLErr eclass = CPLGetLastErrorType();
11162 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11163 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11164 : }
11165 : }
11166 : #endif
11167 : }
11168 26 : {
11169 : /* %typemap(out) OGRErr */
11170 33 : if ( result != 0 && GetUseExceptions()) {
11171 0 : const char* pszMessage = CPLGetLastErrorMsg();
11172 0 : if( pszMessage[0] != '\0' )
11173 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
11174 : else
11175 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11176 0 : SWIG_fail;
11177 : }
11178 : }
11179 26 : {
11180 : /* %typemap(ret) OGRErr */
11181 26 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
11182 26 : resultobj = PyInt_FromLong( result );
11183 : }
11184 : }
11185 26 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11186 : return resultobj;
11187 : fail:
11188 : return NULL;
11189 : }
11190 :
11191 :
11192 2 : SWIGINTERN PyObject *_wrap_Layer_FindFieldIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11193 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11194 2 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11195 2 : char *arg2 = (char *) 0 ;
11196 2 : int arg3 ;
11197 2 : void *argp1 = 0 ;
11198 2 : int res1 = 0 ;
11199 2 : int res2 ;
11200 2 : char *buf2 = 0 ;
11201 2 : int alloc2 = 0 ;
11202 2 : int val3 ;
11203 2 : int ecode3 = 0 ;
11204 2 : PyObject *swig_obj[3] ;
11205 2 : int result;
11206 :
11207 2 : if (!SWIG_Python_UnpackTuple(args, "Layer_FindFieldIndex", 3, 3, swig_obj)) SWIG_fail;
11208 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11209 2 : if (!SWIG_IsOK(res1)) {
11210 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_FindFieldIndex" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11211 : }
11212 2 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11213 2 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
11214 2 : if (!SWIG_IsOK(res2)) {
11215 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_FindFieldIndex" "', argument " "2"" of type '" "char const *""'");
11216 : }
11217 2 : arg2 = reinterpret_cast< char * >(buf2);
11218 2 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11219 2 : if (!SWIG_IsOK(ecode3)) {
11220 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Layer_FindFieldIndex" "', argument " "3"" of type '" "int""'");
11221 : }
11222 2 : arg3 = static_cast< int >(val3);
11223 2 : {
11224 2 : const int bLocalUseExceptions = GetUseExceptions();
11225 2 : if ( bLocalUseExceptions ) {
11226 0 : pushErrorHandler();
11227 : }
11228 2 : {
11229 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11230 2 : result = (int)OGRLayerShadow_FindFieldIndex(arg1,(char const *)arg2,arg3);
11231 2 : SWIG_PYTHON_THREAD_END_ALLOW;
11232 : }
11233 2 : if ( bLocalUseExceptions ) {
11234 0 : popErrorHandler();
11235 : }
11236 : #ifndef SED_HACKS
11237 : if ( bLocalUseExceptions ) {
11238 : CPLErr eclass = CPLGetLastErrorType();
11239 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11240 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11241 : }
11242 : }
11243 : #endif
11244 : }
11245 2 : resultobj = SWIG_From_int(static_cast< int >(result));
11246 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11247 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11248 : return resultobj;
11249 0 : fail:
11250 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11251 : return NULL;
11252 : }
11253 :
11254 :
11255 908 : SWIGINTERN PyObject *_wrap_Layer_GetSpatialRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11256 908 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11257 908 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11258 908 : void *argp1 = 0 ;
11259 908 : int res1 = 0 ;
11260 908 : PyObject *swig_obj[1] ;
11261 908 : OSRSpatialReferenceShadow *result = 0 ;
11262 :
11263 908 : if (!args) SWIG_fail;
11264 908 : swig_obj[0] = args;
11265 908 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11266 908 : if (!SWIG_IsOK(res1)) {
11267 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetSpatialRef" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11268 : }
11269 908 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11270 908 : {
11271 908 : const int bLocalUseExceptions = GetUseExceptions();
11272 908 : if ( bLocalUseExceptions ) {
11273 495 : pushErrorHandler();
11274 : }
11275 908 : {
11276 908 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11277 908 : result = (OSRSpatialReferenceShadow *)OGRLayerShadow_GetSpatialRef(arg1);
11278 908 : SWIG_PYTHON_THREAD_END_ALLOW;
11279 : }
11280 908 : if ( bLocalUseExceptions ) {
11281 495 : popErrorHandler();
11282 : }
11283 : #ifndef SED_HACKS
11284 : if ( bLocalUseExceptions ) {
11285 : CPLErr eclass = CPLGetLastErrorType();
11286 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11287 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11288 : }
11289 : }
11290 : #endif
11291 : }
11292 908 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_OWN | 0 );
11293 908 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11294 : return resultobj;
11295 : fail:
11296 : return NULL;
11297 : }
11298 :
11299 :
11300 0 : SWIGINTERN PyObject *_wrap_Layer_GetFeaturesRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11301 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11302 0 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11303 0 : void *argp1 = 0 ;
11304 0 : int res1 = 0 ;
11305 0 : PyObject *swig_obj[1] ;
11306 0 : GIntBig result;
11307 :
11308 0 : if (!args) SWIG_fail;
11309 0 : swig_obj[0] = args;
11310 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11311 0 : if (!SWIG_IsOK(res1)) {
11312 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetFeaturesRead" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11313 : }
11314 0 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11315 0 : {
11316 0 : const int bLocalUseExceptions = GetUseExceptions();
11317 0 : if ( bLocalUseExceptions ) {
11318 0 : pushErrorHandler();
11319 : }
11320 0 : {
11321 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11322 0 : result = OGRLayerShadow_GetFeaturesRead(arg1);
11323 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11324 : }
11325 0 : if ( bLocalUseExceptions ) {
11326 0 : popErrorHandler();
11327 : }
11328 : #ifndef SED_HACKS
11329 : if ( bLocalUseExceptions ) {
11330 : CPLErr eclass = CPLGetLastErrorType();
11331 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11332 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11333 : }
11334 : }
11335 : #endif
11336 : }
11337 0 : {
11338 0 : resultobj = PyLong_FromLongLong(result);
11339 : }
11340 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11341 : return resultobj;
11342 : fail:
11343 : return NULL;
11344 : }
11345 :
11346 :
11347 265 : SWIGINTERN PyObject *_wrap_Layer_SetIgnoredFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11348 265 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11349 265 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11350 265 : char **arg2 = (char **) 0 ;
11351 265 : void *argp1 = 0 ;
11352 265 : int res1 = 0 ;
11353 265 : PyObject *swig_obj[2] ;
11354 265 : OGRErr result;
11355 :
11356 265 : if (!SWIG_Python_UnpackTuple(args, "Layer_SetIgnoredFields", 2, 2, swig_obj)) SWIG_fail;
11357 265 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11358 265 : if (!SWIG_IsOK(res1)) {
11359 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetIgnoredFields" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11360 : }
11361 265 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11362 265 : {
11363 : /* %typemap(in) char **dict */
11364 265 : arg2 = NULL;
11365 265 : if ( PySequence_Check( swig_obj[1] ) ) {
11366 265 : int bErr = FALSE;
11367 265 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
11368 265 : if ( bErr )
11369 : {
11370 0 : SWIG_fail;
11371 : }
11372 : }
11373 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
11374 0 : int bErr = FALSE;
11375 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
11376 0 : if ( bErr )
11377 : {
11378 0 : SWIG_fail;
11379 : }
11380 : }
11381 : else {
11382 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
11383 0 : SWIG_fail;
11384 : }
11385 : }
11386 265 : {
11387 265 : const int bLocalUseExceptions = GetUseExceptions();
11388 265 : if ( bLocalUseExceptions ) {
11389 246 : pushErrorHandler();
11390 : }
11391 265 : {
11392 265 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11393 265 : result = (OGRErr)OGRLayerShadow_SetIgnoredFields(arg1,(char const **)arg2);
11394 265 : SWIG_PYTHON_THREAD_END_ALLOW;
11395 : }
11396 265 : if ( bLocalUseExceptions ) {
11397 246 : popErrorHandler();
11398 : }
11399 : #ifndef SED_HACKS
11400 : if ( bLocalUseExceptions ) {
11401 : CPLErr eclass = CPLGetLastErrorType();
11402 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11403 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11404 : }
11405 : }
11406 : #endif
11407 : }
11408 265 : {
11409 : /* %typemap(out) OGRErr */
11410 265 : if ( result != 0 && GetUseExceptions()) {
11411 0 : const char* pszMessage = CPLGetLastErrorMsg();
11412 0 : if( pszMessage[0] != '\0' )
11413 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
11414 : else
11415 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11416 0 : SWIG_fail;
11417 : }
11418 : }
11419 265 : {
11420 : /* %typemap(freearg) char **dict */
11421 265 : CSLDestroy( arg2 );
11422 : }
11423 265 : {
11424 : /* %typemap(ret) OGRErr */
11425 265 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
11426 265 : resultobj = PyInt_FromLong( result );
11427 : }
11428 : }
11429 267 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11430 : return resultobj;
11431 0 : fail:
11432 0 : {
11433 : /* %typemap(freearg) char **dict */
11434 0 : CSLDestroy( arg2 );
11435 : }
11436 : return NULL;
11437 : }
11438 :
11439 :
11440 7 : SWIGINTERN PyObject *_wrap_Layer_Intersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11441 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11442 7 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11443 7 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
11444 7 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
11445 7 : char **arg4 = (char **) NULL ;
11446 7 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
11447 7 : void *arg6 = (void *) NULL ;
11448 7 : void *argp1 = 0 ;
11449 7 : int res1 = 0 ;
11450 7 : void *argp2 = 0 ;
11451 7 : int res2 = 0 ;
11452 7 : void *argp3 = 0 ;
11453 7 : int res3 = 0 ;
11454 7 : PyObject * obj0 = 0 ;
11455 7 : PyObject * obj1 = 0 ;
11456 7 : PyObject * obj2 = 0 ;
11457 7 : PyObject * obj3 = 0 ;
11458 7 : PyObject * obj4 = 0 ;
11459 7 : PyObject * obj5 = 0 ;
11460 7 : char * kwnames[] = {
11461 : (char *)"self", (char *)"method_layer", (char *)"result_layer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
11462 : };
11463 7 : OGRErr result;
11464 :
11465 : /* %typemap(arginit) ( const char* callback_data=NULL) */
11466 7 : PyProgressData *psProgressInfo;
11467 7 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
11468 7 : psProgressInfo->nLastReported = -1;
11469 7 : psProgressInfo->psPyCallback = NULL;
11470 7 : psProgressInfo->psPyCallbackData = NULL;
11471 7 : arg6 = psProgressInfo;
11472 7 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:Layer_Intersection", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
11473 7 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11474 7 : if (!SWIG_IsOK(res1)) {
11475 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_Intersection" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11476 : }
11477 7 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11478 7 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11479 7 : if (!SWIG_IsOK(res2)) {
11480 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_Intersection" "', argument " "2"" of type '" "OGRLayerShadow *""'");
11481 : }
11482 7 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
11483 7 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11484 7 : if (!SWIG_IsOK(res3)) {
11485 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_Intersection" "', argument " "3"" of type '" "OGRLayerShadow *""'");
11486 : }
11487 7 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
11488 7 : if (obj3) {
11489 6 : {
11490 : /* %typemap(in) char **dict */
11491 6 : arg4 = NULL;
11492 6 : if ( PySequence_Check( obj3 ) ) {
11493 6 : int bErr = FALSE;
11494 6 : arg4 = CSLFromPySequence(obj3, &bErr);
11495 6 : if ( bErr )
11496 : {
11497 0 : SWIG_fail;
11498 : }
11499 : }
11500 0 : else if ( PyMapping_Check( obj3 ) ) {
11501 0 : int bErr = FALSE;
11502 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
11503 0 : if ( bErr )
11504 : {
11505 0 : SWIG_fail;
11506 : }
11507 : }
11508 : else {
11509 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
11510 0 : SWIG_fail;
11511 : }
11512 : }
11513 : }
11514 7 : if (obj4) {
11515 1 : {
11516 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
11517 : /* callback_func typemap */
11518 :
11519 : /* In some cases 0 is passed instead of None. */
11520 : /* See https://github.com/OSGeo/gdal/pull/219 */
11521 1 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
11522 : {
11523 0 : if( PyLong_AsLong(obj4) == 0 )
11524 : {
11525 0 : obj4 = Py_None;
11526 : }
11527 : }
11528 :
11529 1 : if (obj4 && obj4 != Py_None ) {
11530 1 : void* cbfunction = NULL;
11531 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
11532 : (void**)&cbfunction,
11533 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
11534 : SWIG_POINTER_EXCEPTION | 0 ));
11535 :
11536 1 : if ( cbfunction == GDALTermProgress ) {
11537 : arg5 = GDALTermProgress;
11538 : } else {
11539 1 : if (!PyCallable_Check(obj4)) {
11540 0 : PyErr_SetString( PyExc_RuntimeError,
11541 : "Object given is not a Python function" );
11542 0 : SWIG_fail;
11543 : }
11544 1 : psProgressInfo->psPyCallback = obj4;
11545 1 : arg5 = PyProgressProxy;
11546 : }
11547 :
11548 : }
11549 :
11550 : }
11551 : }
11552 7 : if (obj5) {
11553 0 : {
11554 : /* %typemap(in) ( void* callback_data=NULL) */
11555 0 : psProgressInfo->psPyCallbackData = obj5 ;
11556 : }
11557 : }
11558 7 : {
11559 7 : const int bLocalUseExceptions = GetUseExceptions();
11560 7 : if ( bLocalUseExceptions ) {
11561 7 : pushErrorHandler();
11562 : }
11563 7 : {
11564 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11565 7 : result = (OGRErr)OGRLayerShadow_Intersection(arg1,arg2,arg3,arg4,arg5,arg6);
11566 7 : SWIG_PYTHON_THREAD_END_ALLOW;
11567 : }
11568 7 : if ( bLocalUseExceptions ) {
11569 7 : popErrorHandler();
11570 : }
11571 : #ifndef SED_HACKS
11572 : if ( bLocalUseExceptions ) {
11573 : CPLErr eclass = CPLGetLastErrorType();
11574 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11575 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11576 : }
11577 : }
11578 : #endif
11579 : }
11580 7 : {
11581 : /* %typemap(out) OGRErr */
11582 7 : if ( result != 0 && GetUseExceptions()) {
11583 0 : const char* pszMessage = CPLGetLastErrorMsg();
11584 0 : if( pszMessage[0] != '\0' )
11585 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
11586 : else
11587 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11588 0 : SWIG_fail;
11589 : }
11590 : }
11591 7 : {
11592 : /* %typemap(freearg) char **dict */
11593 7 : CSLDestroy( arg4 );
11594 : }
11595 7 : {
11596 : /* %typemap(freearg) ( void* callback_data=NULL) */
11597 :
11598 7 : CPLFree(psProgressInfo);
11599 :
11600 : }
11601 7 : {
11602 : /* %typemap(ret) OGRErr */
11603 7 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
11604 7 : resultobj = PyInt_FromLong( result );
11605 : }
11606 : }
11607 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11608 : return resultobj;
11609 0 : fail:
11610 0 : {
11611 : /* %typemap(freearg) char **dict */
11612 0 : CSLDestroy( arg4 );
11613 : }
11614 0 : {
11615 : /* %typemap(freearg) ( void* callback_data=NULL) */
11616 :
11617 0 : CPLFree(psProgressInfo);
11618 :
11619 : }
11620 : return NULL;
11621 : }
11622 :
11623 :
11624 7 : SWIGINTERN PyObject *_wrap_Layer_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11625 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11626 7 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11627 7 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
11628 7 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
11629 7 : char **arg4 = (char **) NULL ;
11630 7 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
11631 7 : void *arg6 = (void *) NULL ;
11632 7 : void *argp1 = 0 ;
11633 7 : int res1 = 0 ;
11634 7 : void *argp2 = 0 ;
11635 7 : int res2 = 0 ;
11636 7 : void *argp3 = 0 ;
11637 7 : int res3 = 0 ;
11638 7 : PyObject * obj0 = 0 ;
11639 7 : PyObject * obj1 = 0 ;
11640 7 : PyObject * obj2 = 0 ;
11641 7 : PyObject * obj3 = 0 ;
11642 7 : PyObject * obj4 = 0 ;
11643 7 : PyObject * obj5 = 0 ;
11644 7 : char * kwnames[] = {
11645 : (char *)"self", (char *)"method_layer", (char *)"result_layer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
11646 : };
11647 7 : OGRErr result;
11648 :
11649 : /* %typemap(arginit) ( const char* callback_data=NULL) */
11650 7 : PyProgressData *psProgressInfo;
11651 7 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
11652 7 : psProgressInfo->nLastReported = -1;
11653 7 : psProgressInfo->psPyCallback = NULL;
11654 7 : psProgressInfo->psPyCallbackData = NULL;
11655 7 : arg6 = psProgressInfo;
11656 7 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:Layer_Union", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
11657 7 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11658 7 : if (!SWIG_IsOK(res1)) {
11659 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_Union" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11660 : }
11661 7 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11662 7 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11663 7 : if (!SWIG_IsOK(res2)) {
11664 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_Union" "', argument " "2"" of type '" "OGRLayerShadow *""'");
11665 : }
11666 7 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
11667 7 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11668 7 : if (!SWIG_IsOK(res3)) {
11669 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_Union" "', argument " "3"" of type '" "OGRLayerShadow *""'");
11670 : }
11671 7 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
11672 7 : if (obj3) {
11673 5 : {
11674 : /* %typemap(in) char **dict */
11675 5 : arg4 = NULL;
11676 5 : if ( PySequence_Check( obj3 ) ) {
11677 5 : int bErr = FALSE;
11678 5 : arg4 = CSLFromPySequence(obj3, &bErr);
11679 5 : if ( bErr )
11680 : {
11681 0 : SWIG_fail;
11682 : }
11683 : }
11684 0 : else if ( PyMapping_Check( obj3 ) ) {
11685 0 : int bErr = FALSE;
11686 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
11687 0 : if ( bErr )
11688 : {
11689 0 : SWIG_fail;
11690 : }
11691 : }
11692 : else {
11693 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
11694 0 : SWIG_fail;
11695 : }
11696 : }
11697 : }
11698 7 : if (obj4) {
11699 1 : {
11700 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
11701 : /* callback_func typemap */
11702 :
11703 : /* In some cases 0 is passed instead of None. */
11704 : /* See https://github.com/OSGeo/gdal/pull/219 */
11705 1 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
11706 : {
11707 0 : if( PyLong_AsLong(obj4) == 0 )
11708 : {
11709 0 : obj4 = Py_None;
11710 : }
11711 : }
11712 :
11713 1 : if (obj4 && obj4 != Py_None ) {
11714 1 : void* cbfunction = NULL;
11715 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
11716 : (void**)&cbfunction,
11717 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
11718 : SWIG_POINTER_EXCEPTION | 0 ));
11719 :
11720 1 : if ( cbfunction == GDALTermProgress ) {
11721 : arg5 = GDALTermProgress;
11722 : } else {
11723 1 : if (!PyCallable_Check(obj4)) {
11724 0 : PyErr_SetString( PyExc_RuntimeError,
11725 : "Object given is not a Python function" );
11726 0 : SWIG_fail;
11727 : }
11728 1 : psProgressInfo->psPyCallback = obj4;
11729 1 : arg5 = PyProgressProxy;
11730 : }
11731 :
11732 : }
11733 :
11734 : }
11735 : }
11736 7 : if (obj5) {
11737 0 : {
11738 : /* %typemap(in) ( void* callback_data=NULL) */
11739 0 : psProgressInfo->psPyCallbackData = obj5 ;
11740 : }
11741 : }
11742 7 : {
11743 7 : const int bLocalUseExceptions = GetUseExceptions();
11744 7 : if ( bLocalUseExceptions ) {
11745 7 : pushErrorHandler();
11746 : }
11747 7 : {
11748 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11749 7 : result = (OGRErr)OGRLayerShadow_Union(arg1,arg2,arg3,arg4,arg5,arg6);
11750 7 : SWIG_PYTHON_THREAD_END_ALLOW;
11751 : }
11752 7 : if ( bLocalUseExceptions ) {
11753 7 : popErrorHandler();
11754 : }
11755 : #ifndef SED_HACKS
11756 : if ( bLocalUseExceptions ) {
11757 : CPLErr eclass = CPLGetLastErrorType();
11758 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11759 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11760 : }
11761 : }
11762 : #endif
11763 : }
11764 7 : {
11765 : /* %typemap(out) OGRErr */
11766 7 : if ( result != 0 && GetUseExceptions()) {
11767 0 : const char* pszMessage = CPLGetLastErrorMsg();
11768 0 : if( pszMessage[0] != '\0' )
11769 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
11770 : else
11771 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11772 0 : SWIG_fail;
11773 : }
11774 : }
11775 7 : {
11776 : /* %typemap(freearg) char **dict */
11777 7 : CSLDestroy( arg4 );
11778 : }
11779 7 : {
11780 : /* %typemap(freearg) ( void* callback_data=NULL) */
11781 :
11782 7 : CPLFree(psProgressInfo);
11783 :
11784 : }
11785 7 : {
11786 : /* %typemap(ret) OGRErr */
11787 7 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
11788 7 : resultobj = PyInt_FromLong( result );
11789 : }
11790 : }
11791 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11792 : return resultobj;
11793 0 : fail:
11794 0 : {
11795 : /* %typemap(freearg) char **dict */
11796 0 : CSLDestroy( arg4 );
11797 : }
11798 0 : {
11799 : /* %typemap(freearg) ( void* callback_data=NULL) */
11800 :
11801 0 : CPLFree(psProgressInfo);
11802 :
11803 : }
11804 : return NULL;
11805 : }
11806 :
11807 :
11808 4 : SWIGINTERN PyObject *_wrap_Layer_SymDifference(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11809 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11810 4 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11811 4 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
11812 4 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
11813 4 : char **arg4 = (char **) NULL ;
11814 4 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
11815 4 : void *arg6 = (void *) NULL ;
11816 4 : void *argp1 = 0 ;
11817 4 : int res1 = 0 ;
11818 4 : void *argp2 = 0 ;
11819 4 : int res2 = 0 ;
11820 4 : void *argp3 = 0 ;
11821 4 : int res3 = 0 ;
11822 4 : PyObject * obj0 = 0 ;
11823 4 : PyObject * obj1 = 0 ;
11824 4 : PyObject * obj2 = 0 ;
11825 4 : PyObject * obj3 = 0 ;
11826 4 : PyObject * obj4 = 0 ;
11827 4 : PyObject * obj5 = 0 ;
11828 4 : char * kwnames[] = {
11829 : (char *)"self", (char *)"method_layer", (char *)"result_layer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
11830 : };
11831 4 : OGRErr result;
11832 :
11833 : /* %typemap(arginit) ( const char* callback_data=NULL) */
11834 4 : PyProgressData *psProgressInfo;
11835 4 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
11836 4 : psProgressInfo->nLastReported = -1;
11837 4 : psProgressInfo->psPyCallback = NULL;
11838 4 : psProgressInfo->psPyCallbackData = NULL;
11839 4 : arg6 = psProgressInfo;
11840 4 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:Layer_SymDifference", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
11841 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11842 4 : if (!SWIG_IsOK(res1)) {
11843 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SymDifference" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11844 : }
11845 4 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11846 4 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11847 4 : if (!SWIG_IsOK(res2)) {
11848 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_SymDifference" "', argument " "2"" of type '" "OGRLayerShadow *""'");
11849 : }
11850 4 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
11851 4 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11852 4 : if (!SWIG_IsOK(res3)) {
11853 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_SymDifference" "', argument " "3"" of type '" "OGRLayerShadow *""'");
11854 : }
11855 4 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
11856 4 : if (obj3) {
11857 2 : {
11858 : /* %typemap(in) char **dict */
11859 2 : arg4 = NULL;
11860 2 : if ( PySequence_Check( obj3 ) ) {
11861 2 : int bErr = FALSE;
11862 2 : arg4 = CSLFromPySequence(obj3, &bErr);
11863 2 : if ( bErr )
11864 : {
11865 0 : SWIG_fail;
11866 : }
11867 : }
11868 0 : else if ( PyMapping_Check( obj3 ) ) {
11869 0 : int bErr = FALSE;
11870 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
11871 0 : if ( bErr )
11872 : {
11873 0 : SWIG_fail;
11874 : }
11875 : }
11876 : else {
11877 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
11878 0 : SWIG_fail;
11879 : }
11880 : }
11881 : }
11882 4 : if (obj4) {
11883 1 : {
11884 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
11885 : /* callback_func typemap */
11886 :
11887 : /* In some cases 0 is passed instead of None. */
11888 : /* See https://github.com/OSGeo/gdal/pull/219 */
11889 1 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
11890 : {
11891 0 : if( PyLong_AsLong(obj4) == 0 )
11892 : {
11893 0 : obj4 = Py_None;
11894 : }
11895 : }
11896 :
11897 1 : if (obj4 && obj4 != Py_None ) {
11898 1 : void* cbfunction = NULL;
11899 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
11900 : (void**)&cbfunction,
11901 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
11902 : SWIG_POINTER_EXCEPTION | 0 ));
11903 :
11904 1 : if ( cbfunction == GDALTermProgress ) {
11905 : arg5 = GDALTermProgress;
11906 : } else {
11907 1 : if (!PyCallable_Check(obj4)) {
11908 0 : PyErr_SetString( PyExc_RuntimeError,
11909 : "Object given is not a Python function" );
11910 0 : SWIG_fail;
11911 : }
11912 1 : psProgressInfo->psPyCallback = obj4;
11913 1 : arg5 = PyProgressProxy;
11914 : }
11915 :
11916 : }
11917 :
11918 : }
11919 : }
11920 4 : if (obj5) {
11921 0 : {
11922 : /* %typemap(in) ( void* callback_data=NULL) */
11923 0 : psProgressInfo->psPyCallbackData = obj5 ;
11924 : }
11925 : }
11926 4 : {
11927 4 : const int bLocalUseExceptions = GetUseExceptions();
11928 4 : if ( bLocalUseExceptions ) {
11929 4 : pushErrorHandler();
11930 : }
11931 4 : {
11932 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11933 4 : result = (OGRErr)OGRLayerShadow_SymDifference(arg1,arg2,arg3,arg4,arg5,arg6);
11934 4 : SWIG_PYTHON_THREAD_END_ALLOW;
11935 : }
11936 4 : if ( bLocalUseExceptions ) {
11937 4 : popErrorHandler();
11938 : }
11939 : #ifndef SED_HACKS
11940 : if ( bLocalUseExceptions ) {
11941 : CPLErr eclass = CPLGetLastErrorType();
11942 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11943 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11944 : }
11945 : }
11946 : #endif
11947 : }
11948 4 : {
11949 : /* %typemap(out) OGRErr */
11950 4 : if ( result != 0 && GetUseExceptions()) {
11951 0 : const char* pszMessage = CPLGetLastErrorMsg();
11952 0 : if( pszMessage[0] != '\0' )
11953 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
11954 : else
11955 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11956 0 : SWIG_fail;
11957 : }
11958 : }
11959 4 : {
11960 : /* %typemap(freearg) char **dict */
11961 4 : CSLDestroy( arg4 );
11962 : }
11963 4 : {
11964 : /* %typemap(freearg) ( void* callback_data=NULL) */
11965 :
11966 4 : CPLFree(psProgressInfo);
11967 :
11968 : }
11969 4 : {
11970 : /* %typemap(ret) OGRErr */
11971 4 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
11972 4 : resultobj = PyInt_FromLong( result );
11973 : }
11974 : }
11975 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11976 : return resultobj;
11977 0 : fail:
11978 0 : {
11979 : /* %typemap(freearg) char **dict */
11980 0 : CSLDestroy( arg4 );
11981 : }
11982 0 : {
11983 : /* %typemap(freearg) ( void* callback_data=NULL) */
11984 :
11985 0 : CPLFree(psProgressInfo);
11986 :
11987 : }
11988 : return NULL;
11989 : }
11990 :
11991 :
11992 6 : SWIGINTERN PyObject *_wrap_Layer_Identity(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11993 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11994 6 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11995 6 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
11996 6 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
11997 6 : char **arg4 = (char **) NULL ;
11998 6 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
11999 6 : void *arg6 = (void *) NULL ;
12000 6 : void *argp1 = 0 ;
12001 6 : int res1 = 0 ;
12002 6 : void *argp2 = 0 ;
12003 6 : int res2 = 0 ;
12004 6 : void *argp3 = 0 ;
12005 6 : int res3 = 0 ;
12006 6 : PyObject * obj0 = 0 ;
12007 6 : PyObject * obj1 = 0 ;
12008 6 : PyObject * obj2 = 0 ;
12009 6 : PyObject * obj3 = 0 ;
12010 6 : PyObject * obj4 = 0 ;
12011 6 : PyObject * obj5 = 0 ;
12012 6 : char * kwnames[] = {
12013 : (char *)"self", (char *)"method_layer", (char *)"result_layer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
12014 : };
12015 6 : OGRErr result;
12016 :
12017 : /* %typemap(arginit) ( const char* callback_data=NULL) */
12018 6 : PyProgressData *psProgressInfo;
12019 6 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
12020 6 : psProgressInfo->nLastReported = -1;
12021 6 : psProgressInfo->psPyCallback = NULL;
12022 6 : psProgressInfo->psPyCallbackData = NULL;
12023 6 : arg6 = psProgressInfo;
12024 6 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:Layer_Identity", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
12025 6 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12026 6 : if (!SWIG_IsOK(res1)) {
12027 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_Identity" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12028 : }
12029 6 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12030 6 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12031 6 : if (!SWIG_IsOK(res2)) {
12032 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_Identity" "', argument " "2"" of type '" "OGRLayerShadow *""'");
12033 : }
12034 6 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
12035 6 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12036 6 : if (!SWIG_IsOK(res3)) {
12037 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_Identity" "', argument " "3"" of type '" "OGRLayerShadow *""'");
12038 : }
12039 6 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
12040 6 : if (obj3) {
12041 5 : {
12042 : /* %typemap(in) char **dict */
12043 5 : arg4 = NULL;
12044 5 : if ( PySequence_Check( obj3 ) ) {
12045 5 : int bErr = FALSE;
12046 5 : arg4 = CSLFromPySequence(obj3, &bErr);
12047 5 : if ( bErr )
12048 : {
12049 0 : SWIG_fail;
12050 : }
12051 : }
12052 0 : else if ( PyMapping_Check( obj3 ) ) {
12053 0 : int bErr = FALSE;
12054 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
12055 0 : if ( bErr )
12056 : {
12057 0 : SWIG_fail;
12058 : }
12059 : }
12060 : else {
12061 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
12062 0 : SWIG_fail;
12063 : }
12064 : }
12065 : }
12066 6 : if (obj4) {
12067 1 : {
12068 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
12069 : /* callback_func typemap */
12070 :
12071 : /* In some cases 0 is passed instead of None. */
12072 : /* See https://github.com/OSGeo/gdal/pull/219 */
12073 1 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
12074 : {
12075 0 : if( PyLong_AsLong(obj4) == 0 )
12076 : {
12077 0 : obj4 = Py_None;
12078 : }
12079 : }
12080 :
12081 1 : if (obj4 && obj4 != Py_None ) {
12082 1 : void* cbfunction = NULL;
12083 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
12084 : (void**)&cbfunction,
12085 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
12086 : SWIG_POINTER_EXCEPTION | 0 ));
12087 :
12088 1 : if ( cbfunction == GDALTermProgress ) {
12089 : arg5 = GDALTermProgress;
12090 : } else {
12091 1 : if (!PyCallable_Check(obj4)) {
12092 0 : PyErr_SetString( PyExc_RuntimeError,
12093 : "Object given is not a Python function" );
12094 0 : SWIG_fail;
12095 : }
12096 1 : psProgressInfo->psPyCallback = obj4;
12097 1 : arg5 = PyProgressProxy;
12098 : }
12099 :
12100 : }
12101 :
12102 : }
12103 : }
12104 6 : if (obj5) {
12105 0 : {
12106 : /* %typemap(in) ( void* callback_data=NULL) */
12107 0 : psProgressInfo->psPyCallbackData = obj5 ;
12108 : }
12109 : }
12110 6 : {
12111 6 : const int bLocalUseExceptions = GetUseExceptions();
12112 6 : if ( bLocalUseExceptions ) {
12113 6 : pushErrorHandler();
12114 : }
12115 6 : {
12116 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12117 6 : result = (OGRErr)OGRLayerShadow_Identity(arg1,arg2,arg3,arg4,arg5,arg6);
12118 6 : SWIG_PYTHON_THREAD_END_ALLOW;
12119 : }
12120 6 : if ( bLocalUseExceptions ) {
12121 6 : popErrorHandler();
12122 : }
12123 : #ifndef SED_HACKS
12124 : if ( bLocalUseExceptions ) {
12125 : CPLErr eclass = CPLGetLastErrorType();
12126 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12127 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12128 : }
12129 : }
12130 : #endif
12131 : }
12132 6 : {
12133 : /* %typemap(out) OGRErr */
12134 6 : if ( result != 0 && GetUseExceptions()) {
12135 0 : const char* pszMessage = CPLGetLastErrorMsg();
12136 0 : if( pszMessage[0] != '\0' )
12137 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
12138 : else
12139 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12140 0 : SWIG_fail;
12141 : }
12142 : }
12143 6 : {
12144 : /* %typemap(freearg) char **dict */
12145 6 : CSLDestroy( arg4 );
12146 : }
12147 6 : {
12148 : /* %typemap(freearg) ( void* callback_data=NULL) */
12149 :
12150 6 : CPLFree(psProgressInfo);
12151 :
12152 : }
12153 6 : {
12154 : /* %typemap(ret) OGRErr */
12155 6 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
12156 6 : resultobj = PyInt_FromLong( result );
12157 : }
12158 : }
12159 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12160 : return resultobj;
12161 0 : fail:
12162 0 : {
12163 : /* %typemap(freearg) char **dict */
12164 0 : CSLDestroy( arg4 );
12165 : }
12166 0 : {
12167 : /* %typemap(freearg) ( void* callback_data=NULL) */
12168 :
12169 0 : CPLFree(psProgressInfo);
12170 :
12171 : }
12172 : return NULL;
12173 : }
12174 :
12175 :
12176 5 : SWIGINTERN PyObject *_wrap_Layer_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12177 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12178 5 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12179 5 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
12180 5 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
12181 5 : char **arg4 = (char **) NULL ;
12182 5 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
12183 5 : void *arg6 = (void *) NULL ;
12184 5 : void *argp1 = 0 ;
12185 5 : int res1 = 0 ;
12186 5 : void *argp2 = 0 ;
12187 5 : int res2 = 0 ;
12188 5 : void *argp3 = 0 ;
12189 5 : int res3 = 0 ;
12190 5 : PyObject * obj0 = 0 ;
12191 5 : PyObject * obj1 = 0 ;
12192 5 : PyObject * obj2 = 0 ;
12193 5 : PyObject * obj3 = 0 ;
12194 5 : PyObject * obj4 = 0 ;
12195 5 : PyObject * obj5 = 0 ;
12196 5 : char * kwnames[] = {
12197 : (char *)"self", (char *)"method_layer", (char *)"result_layer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
12198 : };
12199 5 : OGRErr result;
12200 :
12201 : /* %typemap(arginit) ( const char* callback_data=NULL) */
12202 5 : PyProgressData *psProgressInfo;
12203 5 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
12204 5 : psProgressInfo->nLastReported = -1;
12205 5 : psProgressInfo->psPyCallback = NULL;
12206 5 : psProgressInfo->psPyCallbackData = NULL;
12207 5 : arg6 = psProgressInfo;
12208 5 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:Layer_Update", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
12209 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12210 5 : if (!SWIG_IsOK(res1)) {
12211 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_Update" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12212 : }
12213 5 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12214 5 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12215 5 : if (!SWIG_IsOK(res2)) {
12216 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_Update" "', argument " "2"" of type '" "OGRLayerShadow *""'");
12217 : }
12218 5 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
12219 5 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12220 5 : if (!SWIG_IsOK(res3)) {
12221 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_Update" "', argument " "3"" of type '" "OGRLayerShadow *""'");
12222 : }
12223 5 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
12224 5 : if (obj3) {
12225 2 : {
12226 : /* %typemap(in) char **dict */
12227 2 : arg4 = NULL;
12228 2 : if ( PySequence_Check( obj3 ) ) {
12229 2 : int bErr = FALSE;
12230 2 : arg4 = CSLFromPySequence(obj3, &bErr);
12231 2 : if ( bErr )
12232 : {
12233 0 : SWIG_fail;
12234 : }
12235 : }
12236 0 : else if ( PyMapping_Check( obj3 ) ) {
12237 0 : int bErr = FALSE;
12238 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
12239 0 : if ( bErr )
12240 : {
12241 0 : SWIG_fail;
12242 : }
12243 : }
12244 : else {
12245 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
12246 0 : SWIG_fail;
12247 : }
12248 : }
12249 : }
12250 5 : if (obj4) {
12251 1 : {
12252 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
12253 : /* callback_func typemap */
12254 :
12255 : /* In some cases 0 is passed instead of None. */
12256 : /* See https://github.com/OSGeo/gdal/pull/219 */
12257 1 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
12258 : {
12259 0 : if( PyLong_AsLong(obj4) == 0 )
12260 : {
12261 0 : obj4 = Py_None;
12262 : }
12263 : }
12264 :
12265 1 : if (obj4 && obj4 != Py_None ) {
12266 1 : void* cbfunction = NULL;
12267 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
12268 : (void**)&cbfunction,
12269 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
12270 : SWIG_POINTER_EXCEPTION | 0 ));
12271 :
12272 1 : if ( cbfunction == GDALTermProgress ) {
12273 : arg5 = GDALTermProgress;
12274 : } else {
12275 1 : if (!PyCallable_Check(obj4)) {
12276 0 : PyErr_SetString( PyExc_RuntimeError,
12277 : "Object given is not a Python function" );
12278 0 : SWIG_fail;
12279 : }
12280 1 : psProgressInfo->psPyCallback = obj4;
12281 1 : arg5 = PyProgressProxy;
12282 : }
12283 :
12284 : }
12285 :
12286 : }
12287 : }
12288 5 : if (obj5) {
12289 0 : {
12290 : /* %typemap(in) ( void* callback_data=NULL) */
12291 0 : psProgressInfo->psPyCallbackData = obj5 ;
12292 : }
12293 : }
12294 5 : {
12295 5 : const int bLocalUseExceptions = GetUseExceptions();
12296 5 : if ( bLocalUseExceptions ) {
12297 5 : pushErrorHandler();
12298 : }
12299 5 : {
12300 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12301 5 : result = (OGRErr)OGRLayerShadow_Update(arg1,arg2,arg3,arg4,arg5,arg6);
12302 5 : SWIG_PYTHON_THREAD_END_ALLOW;
12303 : }
12304 5 : if ( bLocalUseExceptions ) {
12305 5 : popErrorHandler();
12306 : }
12307 : #ifndef SED_HACKS
12308 : if ( bLocalUseExceptions ) {
12309 : CPLErr eclass = CPLGetLastErrorType();
12310 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12311 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12312 : }
12313 : }
12314 : #endif
12315 : }
12316 5 : {
12317 : /* %typemap(out) OGRErr */
12318 5 : if ( result != 0 && GetUseExceptions()) {
12319 0 : const char* pszMessage = CPLGetLastErrorMsg();
12320 0 : if( pszMessage[0] != '\0' )
12321 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
12322 : else
12323 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12324 0 : SWIG_fail;
12325 : }
12326 : }
12327 5 : {
12328 : /* %typemap(freearg) char **dict */
12329 5 : CSLDestroy( arg4 );
12330 : }
12331 5 : {
12332 : /* %typemap(freearg) ( void* callback_data=NULL) */
12333 :
12334 5 : CPLFree(psProgressInfo);
12335 :
12336 : }
12337 5 : {
12338 : /* %typemap(ret) OGRErr */
12339 5 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
12340 5 : resultobj = PyInt_FromLong( result );
12341 : }
12342 : }
12343 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12344 : return resultobj;
12345 0 : fail:
12346 0 : {
12347 : /* %typemap(freearg) char **dict */
12348 0 : CSLDestroy( arg4 );
12349 : }
12350 0 : {
12351 : /* %typemap(freearg) ( void* callback_data=NULL) */
12352 :
12353 0 : CPLFree(psProgressInfo);
12354 :
12355 : }
12356 : return NULL;
12357 : }
12358 :
12359 :
12360 3 : SWIGINTERN PyObject *_wrap_Layer_Clip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12361 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12362 3 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12363 3 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
12364 3 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
12365 3 : char **arg4 = (char **) NULL ;
12366 3 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
12367 3 : void *arg6 = (void *) NULL ;
12368 3 : void *argp1 = 0 ;
12369 3 : int res1 = 0 ;
12370 3 : void *argp2 = 0 ;
12371 3 : int res2 = 0 ;
12372 3 : void *argp3 = 0 ;
12373 3 : int res3 = 0 ;
12374 3 : PyObject * obj0 = 0 ;
12375 3 : PyObject * obj1 = 0 ;
12376 3 : PyObject * obj2 = 0 ;
12377 3 : PyObject * obj3 = 0 ;
12378 3 : PyObject * obj4 = 0 ;
12379 3 : PyObject * obj5 = 0 ;
12380 3 : char * kwnames[] = {
12381 : (char *)"self", (char *)"method_layer", (char *)"result_layer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
12382 : };
12383 3 : OGRErr result;
12384 :
12385 : /* %typemap(arginit) ( const char* callback_data=NULL) */
12386 3 : PyProgressData *psProgressInfo;
12387 3 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
12388 3 : psProgressInfo->nLastReported = -1;
12389 3 : psProgressInfo->psPyCallback = NULL;
12390 3 : psProgressInfo->psPyCallbackData = NULL;
12391 3 : arg6 = psProgressInfo;
12392 3 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:Layer_Clip", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
12393 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12394 3 : if (!SWIG_IsOK(res1)) {
12395 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_Clip" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12396 : }
12397 3 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12398 3 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12399 3 : if (!SWIG_IsOK(res2)) {
12400 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_Clip" "', argument " "2"" of type '" "OGRLayerShadow *""'");
12401 : }
12402 3 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
12403 3 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12404 3 : if (!SWIG_IsOK(res3)) {
12405 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_Clip" "', argument " "3"" of type '" "OGRLayerShadow *""'");
12406 : }
12407 3 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
12408 3 : if (obj3) {
12409 2 : {
12410 : /* %typemap(in) char **dict */
12411 2 : arg4 = NULL;
12412 2 : if ( PySequence_Check( obj3 ) ) {
12413 2 : int bErr = FALSE;
12414 2 : arg4 = CSLFromPySequence(obj3, &bErr);
12415 2 : if ( bErr )
12416 : {
12417 0 : SWIG_fail;
12418 : }
12419 : }
12420 0 : else if ( PyMapping_Check( obj3 ) ) {
12421 0 : int bErr = FALSE;
12422 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
12423 0 : if ( bErr )
12424 : {
12425 0 : SWIG_fail;
12426 : }
12427 : }
12428 : else {
12429 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
12430 0 : SWIG_fail;
12431 : }
12432 : }
12433 : }
12434 3 : if (obj4) {
12435 1 : {
12436 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
12437 : /* callback_func typemap */
12438 :
12439 : /* In some cases 0 is passed instead of None. */
12440 : /* See https://github.com/OSGeo/gdal/pull/219 */
12441 1 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
12442 : {
12443 0 : if( PyLong_AsLong(obj4) == 0 )
12444 : {
12445 0 : obj4 = Py_None;
12446 : }
12447 : }
12448 :
12449 1 : if (obj4 && obj4 != Py_None ) {
12450 1 : void* cbfunction = NULL;
12451 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
12452 : (void**)&cbfunction,
12453 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
12454 : SWIG_POINTER_EXCEPTION | 0 ));
12455 :
12456 1 : if ( cbfunction == GDALTermProgress ) {
12457 : arg5 = GDALTermProgress;
12458 : } else {
12459 1 : if (!PyCallable_Check(obj4)) {
12460 0 : PyErr_SetString( PyExc_RuntimeError,
12461 : "Object given is not a Python function" );
12462 0 : SWIG_fail;
12463 : }
12464 1 : psProgressInfo->psPyCallback = obj4;
12465 1 : arg5 = PyProgressProxy;
12466 : }
12467 :
12468 : }
12469 :
12470 : }
12471 : }
12472 3 : if (obj5) {
12473 0 : {
12474 : /* %typemap(in) ( void* callback_data=NULL) */
12475 0 : psProgressInfo->psPyCallbackData = obj5 ;
12476 : }
12477 : }
12478 3 : {
12479 3 : const int bLocalUseExceptions = GetUseExceptions();
12480 3 : if ( bLocalUseExceptions ) {
12481 3 : pushErrorHandler();
12482 : }
12483 3 : {
12484 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12485 3 : result = (OGRErr)OGRLayerShadow_Clip(arg1,arg2,arg3,arg4,arg5,arg6);
12486 3 : SWIG_PYTHON_THREAD_END_ALLOW;
12487 : }
12488 3 : if ( bLocalUseExceptions ) {
12489 3 : popErrorHandler();
12490 : }
12491 : #ifndef SED_HACKS
12492 : if ( bLocalUseExceptions ) {
12493 : CPLErr eclass = CPLGetLastErrorType();
12494 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12495 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12496 : }
12497 : }
12498 : #endif
12499 : }
12500 3 : {
12501 : /* %typemap(out) OGRErr */
12502 3 : if ( result != 0 && GetUseExceptions()) {
12503 0 : const char* pszMessage = CPLGetLastErrorMsg();
12504 0 : if( pszMessage[0] != '\0' )
12505 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
12506 : else
12507 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12508 0 : SWIG_fail;
12509 : }
12510 : }
12511 3 : {
12512 : /* %typemap(freearg) char **dict */
12513 3 : CSLDestroy( arg4 );
12514 : }
12515 3 : {
12516 : /* %typemap(freearg) ( void* callback_data=NULL) */
12517 :
12518 3 : CPLFree(psProgressInfo);
12519 :
12520 : }
12521 3 : {
12522 : /* %typemap(ret) OGRErr */
12523 3 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
12524 3 : resultobj = PyInt_FromLong( result );
12525 : }
12526 : }
12527 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12528 : return resultobj;
12529 0 : fail:
12530 0 : {
12531 : /* %typemap(freearg) char **dict */
12532 0 : CSLDestroy( arg4 );
12533 : }
12534 0 : {
12535 : /* %typemap(freearg) ( void* callback_data=NULL) */
12536 :
12537 0 : CPLFree(psProgressInfo);
12538 :
12539 : }
12540 : return NULL;
12541 : }
12542 :
12543 :
12544 6 : SWIGINTERN PyObject *_wrap_Layer_Erase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12545 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12546 6 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12547 6 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
12548 6 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
12549 6 : char **arg4 = (char **) NULL ;
12550 6 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
12551 6 : void *arg6 = (void *) NULL ;
12552 6 : void *argp1 = 0 ;
12553 6 : int res1 = 0 ;
12554 6 : void *argp2 = 0 ;
12555 6 : int res2 = 0 ;
12556 6 : void *argp3 = 0 ;
12557 6 : int res3 = 0 ;
12558 6 : PyObject * obj0 = 0 ;
12559 6 : PyObject * obj1 = 0 ;
12560 6 : PyObject * obj2 = 0 ;
12561 6 : PyObject * obj3 = 0 ;
12562 6 : PyObject * obj4 = 0 ;
12563 6 : PyObject * obj5 = 0 ;
12564 6 : char * kwnames[] = {
12565 : (char *)"self", (char *)"method_layer", (char *)"result_layer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
12566 : };
12567 6 : OGRErr result;
12568 :
12569 : /* %typemap(arginit) ( const char* callback_data=NULL) */
12570 6 : PyProgressData *psProgressInfo;
12571 6 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
12572 6 : psProgressInfo->nLastReported = -1;
12573 6 : psProgressInfo->psPyCallback = NULL;
12574 6 : psProgressInfo->psPyCallbackData = NULL;
12575 6 : arg6 = psProgressInfo;
12576 6 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:Layer_Erase", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
12577 6 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12578 6 : if (!SWIG_IsOK(res1)) {
12579 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_Erase" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12580 : }
12581 6 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12582 6 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12583 6 : if (!SWIG_IsOK(res2)) {
12584 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_Erase" "', argument " "2"" of type '" "OGRLayerShadow *""'");
12585 : }
12586 6 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
12587 6 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12588 6 : if (!SWIG_IsOK(res3)) {
12589 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_Erase" "', argument " "3"" of type '" "OGRLayerShadow *""'");
12590 : }
12591 6 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
12592 6 : if (obj3) {
12593 3 : {
12594 : /* %typemap(in) char **dict */
12595 3 : arg4 = NULL;
12596 3 : if ( PySequence_Check( obj3 ) ) {
12597 3 : int bErr = FALSE;
12598 3 : arg4 = CSLFromPySequence(obj3, &bErr);
12599 3 : if ( bErr )
12600 : {
12601 0 : SWIG_fail;
12602 : }
12603 : }
12604 0 : else if ( PyMapping_Check( obj3 ) ) {
12605 0 : int bErr = FALSE;
12606 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
12607 0 : if ( bErr )
12608 : {
12609 0 : SWIG_fail;
12610 : }
12611 : }
12612 : else {
12613 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
12614 0 : SWIG_fail;
12615 : }
12616 : }
12617 : }
12618 6 : if (obj4) {
12619 1 : {
12620 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
12621 : /* callback_func typemap */
12622 :
12623 : /* In some cases 0 is passed instead of None. */
12624 : /* See https://github.com/OSGeo/gdal/pull/219 */
12625 1 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
12626 : {
12627 0 : if( PyLong_AsLong(obj4) == 0 )
12628 : {
12629 0 : obj4 = Py_None;
12630 : }
12631 : }
12632 :
12633 1 : if (obj4 && obj4 != Py_None ) {
12634 1 : void* cbfunction = NULL;
12635 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
12636 : (void**)&cbfunction,
12637 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
12638 : SWIG_POINTER_EXCEPTION | 0 ));
12639 :
12640 1 : if ( cbfunction == GDALTermProgress ) {
12641 : arg5 = GDALTermProgress;
12642 : } else {
12643 1 : if (!PyCallable_Check(obj4)) {
12644 0 : PyErr_SetString( PyExc_RuntimeError,
12645 : "Object given is not a Python function" );
12646 0 : SWIG_fail;
12647 : }
12648 1 : psProgressInfo->psPyCallback = obj4;
12649 1 : arg5 = PyProgressProxy;
12650 : }
12651 :
12652 : }
12653 :
12654 : }
12655 : }
12656 6 : if (obj5) {
12657 0 : {
12658 : /* %typemap(in) ( void* callback_data=NULL) */
12659 0 : psProgressInfo->psPyCallbackData = obj5 ;
12660 : }
12661 : }
12662 6 : {
12663 6 : const int bLocalUseExceptions = GetUseExceptions();
12664 6 : if ( bLocalUseExceptions ) {
12665 6 : pushErrorHandler();
12666 : }
12667 6 : {
12668 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12669 6 : result = (OGRErr)OGRLayerShadow_Erase(arg1,arg2,arg3,arg4,arg5,arg6);
12670 6 : SWIG_PYTHON_THREAD_END_ALLOW;
12671 : }
12672 6 : if ( bLocalUseExceptions ) {
12673 6 : popErrorHandler();
12674 : }
12675 : #ifndef SED_HACKS
12676 : if ( bLocalUseExceptions ) {
12677 : CPLErr eclass = CPLGetLastErrorType();
12678 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12679 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12680 : }
12681 : }
12682 : #endif
12683 : }
12684 6 : {
12685 : /* %typemap(out) OGRErr */
12686 6 : if ( result != 0 && GetUseExceptions()) {
12687 0 : const char* pszMessage = CPLGetLastErrorMsg();
12688 0 : if( pszMessage[0] != '\0' )
12689 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
12690 : else
12691 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12692 0 : SWIG_fail;
12693 : }
12694 : }
12695 6 : {
12696 : /* %typemap(freearg) char **dict */
12697 6 : CSLDestroy( arg4 );
12698 : }
12699 6 : {
12700 : /* %typemap(freearg) ( void* callback_data=NULL) */
12701 :
12702 6 : CPLFree(psProgressInfo);
12703 :
12704 : }
12705 6 : {
12706 : /* %typemap(ret) OGRErr */
12707 6 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
12708 6 : resultobj = PyInt_FromLong( result );
12709 : }
12710 : }
12711 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12712 : return resultobj;
12713 0 : fail:
12714 0 : {
12715 : /* %typemap(freearg) char **dict */
12716 0 : CSLDestroy( arg4 );
12717 : }
12718 0 : {
12719 : /* %typemap(freearg) ( void* callback_data=NULL) */
12720 :
12721 0 : CPLFree(psProgressInfo);
12722 :
12723 : }
12724 : return NULL;
12725 : }
12726 :
12727 :
12728 3 : SWIGINTERN PyObject *_wrap_Layer_GetStyleTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12729 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12730 3 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12731 3 : void *argp1 = 0 ;
12732 3 : int res1 = 0 ;
12733 3 : PyObject *swig_obj[1] ;
12734 3 : OGRStyleTableShadow *result = 0 ;
12735 :
12736 3 : if (!args) SWIG_fail;
12737 3 : swig_obj[0] = args;
12738 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12739 3 : if (!SWIG_IsOK(res1)) {
12740 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetStyleTable" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12741 : }
12742 3 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12743 3 : {
12744 3 : const int bLocalUseExceptions = GetUseExceptions();
12745 3 : if ( bLocalUseExceptions ) {
12746 3 : pushErrorHandler();
12747 : }
12748 3 : {
12749 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12750 3 : result = (OGRStyleTableShadow *)OGRLayerShadow_GetStyleTable(arg1);
12751 3 : SWIG_PYTHON_THREAD_END_ALLOW;
12752 : }
12753 3 : if ( bLocalUseExceptions ) {
12754 3 : popErrorHandler();
12755 : }
12756 : #ifndef SED_HACKS
12757 : if ( bLocalUseExceptions ) {
12758 : CPLErr eclass = CPLGetLastErrorType();
12759 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12760 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12761 : }
12762 : }
12763 : #endif
12764 : }
12765 3 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
12766 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12767 : return resultobj;
12768 : fail:
12769 : return NULL;
12770 : }
12771 :
12772 :
12773 2 : SWIGINTERN PyObject *_wrap_Layer_SetStyleTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12774 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12775 2 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12776 2 : OGRStyleTableShadow *arg2 = (OGRStyleTableShadow *) 0 ;
12777 2 : void *argp1 = 0 ;
12778 2 : int res1 = 0 ;
12779 2 : void *argp2 = 0 ;
12780 2 : int res2 = 0 ;
12781 2 : PyObject *swig_obj[2] ;
12782 :
12783 2 : if (!SWIG_Python_UnpackTuple(args, "Layer_SetStyleTable", 2, 2, swig_obj)) SWIG_fail;
12784 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12785 2 : if (!SWIG_IsOK(res1)) {
12786 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetStyleTable" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12787 : }
12788 2 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12789 2 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
12790 2 : if (!SWIG_IsOK(res2)) {
12791 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_SetStyleTable" "', argument " "2"" of type '" "OGRStyleTableShadow *""'");
12792 : }
12793 2 : arg2 = reinterpret_cast< OGRStyleTableShadow * >(argp2);
12794 2 : {
12795 2 : const int bLocalUseExceptions = GetUseExceptions();
12796 2 : if ( bLocalUseExceptions ) {
12797 2 : pushErrorHandler();
12798 : }
12799 2 : {
12800 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12801 2 : OGRLayerShadow_SetStyleTable(arg1,arg2);
12802 2 : SWIG_PYTHON_THREAD_END_ALLOW;
12803 : }
12804 2 : if ( bLocalUseExceptions ) {
12805 2 : popErrorHandler();
12806 : }
12807 : #ifndef SED_HACKS
12808 : if ( bLocalUseExceptions ) {
12809 : CPLErr eclass = CPLGetLastErrorType();
12810 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12811 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12812 : }
12813 : }
12814 : #endif
12815 : }
12816 2 : resultobj = SWIG_Py_Void();
12817 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12818 : return resultobj;
12819 : fail:
12820 : return NULL;
12821 : }
12822 :
12823 :
12824 16 : SWIGINTERN PyObject *_wrap_Layer_ExportArrowArrayStreamPyCapsule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12825 16 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12826 16 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12827 16 : char **arg2 = (char **) NULL ;
12828 16 : void *argp1 = 0 ;
12829 16 : int res1 = 0 ;
12830 16 : PyObject *swig_obj[2] ;
12831 16 : PyObject *result = 0 ;
12832 :
12833 16 : if (!SWIG_Python_UnpackTuple(args, "Layer_ExportArrowArrayStreamPyCapsule", 1, 2, swig_obj)) SWIG_fail;
12834 16 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12835 16 : if (!SWIG_IsOK(res1)) {
12836 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_ExportArrowArrayStreamPyCapsule" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12837 : }
12838 16 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12839 16 : if (swig_obj[1]) {
12840 1 : {
12841 : /* %typemap(in) char **dict */
12842 1 : arg2 = NULL;
12843 1 : if ( PySequence_Check( swig_obj[1] ) ) {
12844 0 : int bErr = FALSE;
12845 0 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
12846 0 : if ( bErr )
12847 : {
12848 0 : SWIG_fail;
12849 : }
12850 : }
12851 1 : else if ( PyMapping_Check( swig_obj[1] ) ) {
12852 1 : int bErr = FALSE;
12853 1 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
12854 1 : if ( bErr )
12855 : {
12856 0 : SWIG_fail;
12857 : }
12858 : }
12859 : else {
12860 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
12861 0 : SWIG_fail;
12862 : }
12863 : }
12864 : }
12865 16 : {
12866 16 : const int bLocalUseExceptions = GetUseExceptions();
12867 16 : if ( bLocalUseExceptions ) {
12868 16 : pushErrorHandler();
12869 : }
12870 16 : {
12871 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12872 16 : result = (PyObject *)OGRLayerShadow_ExportArrowArrayStreamPyCapsule(arg1,arg2);
12873 16 : SWIG_PYTHON_THREAD_END_ALLOW;
12874 : }
12875 16 : if ( bLocalUseExceptions ) {
12876 16 : popErrorHandler();
12877 : }
12878 : #ifndef SED_HACKS
12879 : if ( bLocalUseExceptions ) {
12880 : CPLErr eclass = CPLGetLastErrorType();
12881 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12882 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12883 : }
12884 : }
12885 : #endif
12886 : }
12887 16 : resultobj = result;
12888 16 : {
12889 : /* %typemap(freearg) char **dict */
12890 16 : CSLDestroy( arg2 );
12891 : }
12892 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12893 : return resultobj;
12894 0 : fail:
12895 0 : {
12896 : /* %typemap(freearg) char **dict */
12897 0 : CSLDestroy( arg2 );
12898 : }
12899 : return NULL;
12900 : }
12901 :
12902 :
12903 352 : SWIGINTERN PyObject *_wrap_Layer_GetArrowStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12904 352 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12905 352 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12906 352 : char **arg2 = (char **) NULL ;
12907 352 : void *argp1 = 0 ;
12908 352 : int res1 = 0 ;
12909 352 : PyObject *swig_obj[2] ;
12910 352 : ArrowArrayStream *result = 0 ;
12911 :
12912 352 : if (!SWIG_Python_UnpackTuple(args, "Layer_GetArrowStream", 1, 2, swig_obj)) SWIG_fail;
12913 352 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12914 352 : if (!SWIG_IsOK(res1)) {
12915 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetArrowStream" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12916 : }
12917 352 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12918 352 : if (swig_obj[1]) {
12919 325 : {
12920 : /* %typemap(in) char **dict */
12921 325 : arg2 = NULL;
12922 325 : if ( PySequence_Check( swig_obj[1] ) ) {
12923 325 : int bErr = FALSE;
12924 325 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
12925 325 : if ( bErr )
12926 : {
12927 0 : SWIG_fail;
12928 : }
12929 : }
12930 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
12931 0 : int bErr = FALSE;
12932 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
12933 0 : if ( bErr )
12934 : {
12935 0 : SWIG_fail;
12936 : }
12937 : }
12938 : else {
12939 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
12940 0 : SWIG_fail;
12941 : }
12942 : }
12943 : }
12944 352 : {
12945 352 : const int bLocalUseExceptions = GetUseExceptions();
12946 352 : if ( bLocalUseExceptions ) {
12947 234 : pushErrorHandler();
12948 : }
12949 352 : {
12950 352 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12951 352 : result = (ArrowArrayStream *)OGRLayerShadow_GetArrowStream(arg1,arg2);
12952 352 : SWIG_PYTHON_THREAD_END_ALLOW;
12953 : }
12954 352 : if ( bLocalUseExceptions ) {
12955 234 : popErrorHandler();
12956 : }
12957 : #ifndef SED_HACKS
12958 : if ( bLocalUseExceptions ) {
12959 : CPLErr eclass = CPLGetLastErrorType();
12960 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12961 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12962 : }
12963 : }
12964 : #endif
12965 : }
12966 352 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ArrowArrayStream, SWIG_POINTER_OWN | 0 );
12967 352 : {
12968 : /* %typemap(freearg) char **dict */
12969 352 : CSLDestroy( arg2 );
12970 : }
12971 352 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12972 : return resultobj;
12973 0 : fail:
12974 0 : {
12975 : /* %typemap(freearg) char **dict */
12976 0 : CSLDestroy( arg2 );
12977 : }
12978 : return NULL;
12979 : }
12980 :
12981 :
12982 19 : SWIGINTERN PyObject *_wrap_Layer_IsArrowSchemaSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12983 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12984 19 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12985 19 : ArrowSchema *arg2 = (ArrowSchema *) 0 ;
12986 19 : bool *arg3 = (bool *) 0 ;
12987 19 : char **arg4 = (char **) 0 ;
12988 19 : char **arg5 = (char **) NULL ;
12989 19 : void *argp1 = 0 ;
12990 19 : int res1 = 0 ;
12991 19 : void *argp2 = 0 ;
12992 19 : int res2 = 0 ;
12993 19 : bool ret3 ;
12994 19 : char *errorMsg3 ;
12995 19 : PyObject *swig_obj[3] ;
12996 :
12997 19 : {
12998 : /* %typemap(in,numinputs=0) (bool* pbRet, char **errorMsg3) */
12999 19 : arg3 = &ret3;
13000 19 : arg4 = &errorMsg3;
13001 : }
13002 19 : if (!SWIG_Python_UnpackTuple(args, "Layer_IsArrowSchemaSupported", 2, 3, swig_obj)) SWIG_fail;
13003 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13004 19 : if (!SWIG_IsOK(res1)) {
13005 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_IsArrowSchemaSupported" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13006 : }
13007 19 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13008 19 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ArrowSchema, 0 | 0 );
13009 19 : if (!SWIG_IsOK(res2)) {
13010 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_IsArrowSchemaSupported" "', argument " "2"" of type '" "ArrowSchema const *""'");
13011 : }
13012 19 : arg2 = reinterpret_cast< ArrowSchema * >(argp2);
13013 19 : if (swig_obj[2]) {
13014 3 : {
13015 : /* %typemap(in) char **dict */
13016 3 : arg5 = NULL;
13017 3 : if ( PySequence_Check( swig_obj[2] ) ) {
13018 3 : int bErr = FALSE;
13019 3 : arg5 = CSLFromPySequence(swig_obj[2], &bErr);
13020 3 : if ( bErr )
13021 : {
13022 0 : SWIG_fail;
13023 : }
13024 : }
13025 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
13026 0 : int bErr = FALSE;
13027 0 : arg5 = CSLFromPyMapping(swig_obj[2], &bErr);
13028 0 : if ( bErr )
13029 : {
13030 0 : SWIG_fail;
13031 : }
13032 : }
13033 : else {
13034 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
13035 0 : SWIG_fail;
13036 : }
13037 : }
13038 : }
13039 19 : {
13040 19 : const int bLocalUseExceptions = GetUseExceptions();
13041 19 : if ( bLocalUseExceptions ) {
13042 19 : pushErrorHandler();
13043 : }
13044 19 : {
13045 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13046 19 : OGRLayerShadow_IsArrowSchemaSupported(arg1,(ArrowSchema const *)arg2,arg3,arg4,arg5);
13047 19 : SWIG_PYTHON_THREAD_END_ALLOW;
13048 : }
13049 19 : if ( bLocalUseExceptions ) {
13050 19 : popErrorHandler();
13051 : }
13052 : #ifndef SED_HACKS
13053 : if ( bLocalUseExceptions ) {
13054 : CPLErr eclass = CPLGetLastErrorType();
13055 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13056 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13057 : }
13058 : }
13059 : #endif
13060 : }
13061 19 : resultobj = SWIG_Py_Void();
13062 19 : {
13063 : /* %typemap(argout) (bool* pbRet, char **errorMsg)*/
13064 19 : Py_DECREF(resultobj);
13065 19 : resultobj = PyTuple_New(2);
13066 19 : PyTuple_SetItem(resultobj, 0, PyBool_FromLong(*arg3));
13067 19 : if( *arg4 )
13068 : {
13069 4 : PyTuple_SetItem(resultobj, 1, PyUnicode_FromString(*arg4));
13070 4 : VSIFree(*arg4);
13071 : }
13072 : else
13073 : {
13074 15 : PyTuple_SetItem(resultobj, 1, Py_None);
13075 15 : Py_INCREF(Py_None);
13076 : }
13077 : }
13078 19 : {
13079 : /* %typemap(freearg) char **dict */
13080 19 : CSLDestroy( arg5 );
13081 : }
13082 19 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13083 : return resultobj;
13084 0 : fail:
13085 0 : {
13086 : /* %typemap(freearg) char **dict */
13087 0 : CSLDestroy( arg5 );
13088 : }
13089 : return NULL;
13090 : }
13091 :
13092 :
13093 526 : SWIGINTERN PyObject *_wrap_Layer_CreateFieldFromArrowSchema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13094 526 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13095 526 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
13096 526 : ArrowSchema *arg2 = (ArrowSchema *) 0 ;
13097 526 : char **arg3 = (char **) NULL ;
13098 526 : void *argp1 = 0 ;
13099 526 : int res1 = 0 ;
13100 526 : void *argp2 = 0 ;
13101 526 : int res2 = 0 ;
13102 526 : PyObject *swig_obj[3] ;
13103 526 : OGRErr result;
13104 :
13105 526 : if (!SWIG_Python_UnpackTuple(args, "Layer_CreateFieldFromArrowSchema", 2, 3, swig_obj)) SWIG_fail;
13106 526 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13107 526 : if (!SWIG_IsOK(res1)) {
13108 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_CreateFieldFromArrowSchema" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13109 : }
13110 526 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13111 526 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ArrowSchema, 0 | 0 );
13112 526 : if (!SWIG_IsOK(res2)) {
13113 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_CreateFieldFromArrowSchema" "', argument " "2"" of type '" "ArrowSchema const *""'");
13114 : }
13115 526 : arg2 = reinterpret_cast< ArrowSchema * >(argp2);
13116 526 : if (swig_obj[2]) {
13117 119 : {
13118 : /* %typemap(in) char **dict */
13119 119 : arg3 = NULL;
13120 119 : if ( PySequence_Check( swig_obj[2] ) ) {
13121 119 : int bErr = FALSE;
13122 119 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
13123 119 : if ( bErr )
13124 : {
13125 0 : SWIG_fail;
13126 : }
13127 : }
13128 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
13129 0 : int bErr = FALSE;
13130 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
13131 0 : if ( bErr )
13132 : {
13133 0 : SWIG_fail;
13134 : }
13135 : }
13136 : else {
13137 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
13138 0 : SWIG_fail;
13139 : }
13140 : }
13141 : }
13142 526 : {
13143 526 : const int bLocalUseExceptions = GetUseExceptions();
13144 526 : if ( bLocalUseExceptions ) {
13145 526 : pushErrorHandler();
13146 : }
13147 526 : {
13148 526 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13149 526 : result = (OGRErr)OGRLayerShadow_CreateFieldFromArrowSchema(arg1,(ArrowSchema const *)arg2,arg3);
13150 526 : SWIG_PYTHON_THREAD_END_ALLOW;
13151 : }
13152 526 : if ( bLocalUseExceptions ) {
13153 526 : popErrorHandler();
13154 : }
13155 : #ifndef SED_HACKS
13156 : if ( bLocalUseExceptions ) {
13157 : CPLErr eclass = CPLGetLastErrorType();
13158 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13159 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13160 : }
13161 : }
13162 : #endif
13163 : }
13164 526 : {
13165 : /* %typemap(out) OGRErr */
13166 526 : if ( result != 0 && GetUseExceptions()) {
13167 0 : const char* pszMessage = CPLGetLastErrorMsg();
13168 0 : if( pszMessage[0] != '\0' )
13169 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13170 : else
13171 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
13172 0 : SWIG_fail;
13173 : }
13174 : }
13175 526 : {
13176 : /* %typemap(freearg) char **dict */
13177 526 : CSLDestroy( arg3 );
13178 : }
13179 526 : {
13180 : /* %typemap(ret) OGRErr */
13181 526 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
13182 526 : resultobj = PyInt_FromLong( result );
13183 : }
13184 : }
13185 526 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13186 : return resultobj;
13187 0 : fail:
13188 0 : {
13189 : /* %typemap(freearg) char **dict */
13190 0 : CSLDestroy( arg3 );
13191 : }
13192 : return NULL;
13193 : }
13194 :
13195 :
13196 47 : SWIGINTERN PyObject *_wrap_Layer_WriteArrowBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13197 47 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13198 47 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
13199 47 : ArrowSchema *arg2 = (ArrowSchema *) 0 ;
13200 47 : ArrowArray *arg3 = (ArrowArray *) 0 ;
13201 47 : char **arg4 = (char **) NULL ;
13202 47 : void *argp1 = 0 ;
13203 47 : int res1 = 0 ;
13204 47 : void *argp2 = 0 ;
13205 47 : int res2 = 0 ;
13206 47 : void *argp3 = 0 ;
13207 47 : int res3 = 0 ;
13208 47 : PyObject *swig_obj[4] ;
13209 47 : OGRErr result;
13210 :
13211 47 : if (!SWIG_Python_UnpackTuple(args, "Layer_WriteArrowBatch", 3, 4, swig_obj)) SWIG_fail;
13212 47 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13213 47 : if (!SWIG_IsOK(res1)) {
13214 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_WriteArrowBatch" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13215 : }
13216 47 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13217 47 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ArrowSchema, 0 | 0 );
13218 47 : if (!SWIG_IsOK(res2)) {
13219 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_WriteArrowBatch" "', argument " "2"" of type '" "ArrowSchema const *""'");
13220 : }
13221 47 : arg2 = reinterpret_cast< ArrowSchema * >(argp2);
13222 47 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ArrowArray, 0 | 0 );
13223 47 : if (!SWIG_IsOK(res3)) {
13224 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_WriteArrowBatch" "', argument " "3"" of type '" "ArrowArray *""'");
13225 : }
13226 47 : arg3 = reinterpret_cast< ArrowArray * >(argp3);
13227 47 : if (swig_obj[3]) {
13228 23 : {
13229 : /* %typemap(in) char **dict */
13230 23 : arg4 = NULL;
13231 23 : if ( PySequence_Check( swig_obj[3] ) ) {
13232 11 : int bErr = FALSE;
13233 11 : arg4 = CSLFromPySequence(swig_obj[3], &bErr);
13234 11 : if ( bErr )
13235 : {
13236 0 : SWIG_fail;
13237 : }
13238 : }
13239 12 : else if ( PyMapping_Check( swig_obj[3] ) ) {
13240 12 : int bErr = FALSE;
13241 12 : arg4 = CSLFromPyMapping(swig_obj[3], &bErr);
13242 12 : if ( bErr )
13243 : {
13244 0 : SWIG_fail;
13245 : }
13246 : }
13247 : else {
13248 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
13249 0 : SWIG_fail;
13250 : }
13251 : }
13252 : }
13253 47 : {
13254 47 : const int bLocalUseExceptions = GetUseExceptions();
13255 47 : if ( bLocalUseExceptions ) {
13256 47 : pushErrorHandler();
13257 : }
13258 47 : {
13259 47 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13260 47 : result = (OGRErr)OGRLayerShadow_WriteArrowBatch(arg1,(ArrowSchema const *)arg2,arg3,arg4);
13261 47 : SWIG_PYTHON_THREAD_END_ALLOW;
13262 : }
13263 47 : if ( bLocalUseExceptions ) {
13264 47 : popErrorHandler();
13265 : }
13266 : #ifndef SED_HACKS
13267 : if ( bLocalUseExceptions ) {
13268 : CPLErr eclass = CPLGetLastErrorType();
13269 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13270 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13271 : }
13272 : }
13273 : #endif
13274 : }
13275 47 : {
13276 : /* %typemap(out) OGRErr */
13277 58 : if ( result != 0 && GetUseExceptions()) {
13278 11 : const char* pszMessage = CPLGetLastErrorMsg();
13279 11 : if( pszMessage[0] != '\0' )
13280 11 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13281 : else
13282 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
13283 11 : SWIG_fail;
13284 : }
13285 : }
13286 36 : {
13287 : /* %typemap(freearg) char **dict */
13288 36 : CSLDestroy( arg4 );
13289 : }
13290 36 : {
13291 : /* %typemap(ret) OGRErr */
13292 36 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
13293 36 : resultobj = PyInt_FromLong( result );
13294 : }
13295 : }
13296 47 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13297 : return resultobj;
13298 11 : fail:
13299 11 : {
13300 : /* %typemap(freearg) char **dict */
13301 11 : CSLDestroy( arg4 );
13302 : }
13303 : return NULL;
13304 : }
13305 :
13306 :
13307 12 : SWIGINTERN PyObject *_wrap_Layer_WriteArrowStreamCapsule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13308 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13309 12 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
13310 12 : PyObject *arg2 = (PyObject *) 0 ;
13311 12 : int arg3 ;
13312 12 : char **arg4 = (char **) NULL ;
13313 12 : void *argp1 = 0 ;
13314 12 : int res1 = 0 ;
13315 12 : int val3 ;
13316 12 : int ecode3 = 0 ;
13317 12 : PyObject *swig_obj[4] ;
13318 12 : OGRErr result;
13319 :
13320 12 : if (!SWIG_Python_UnpackTuple(args, "Layer_WriteArrowStreamCapsule", 3, 4, swig_obj)) SWIG_fail;
13321 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13322 12 : if (!SWIG_IsOK(res1)) {
13323 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_WriteArrowStreamCapsule" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13324 : }
13325 12 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13326 12 : arg2 = swig_obj[1];
13327 12 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
13328 12 : if (!SWIG_IsOK(ecode3)) {
13329 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Layer_WriteArrowStreamCapsule" "', argument " "3"" of type '" "int""'");
13330 : }
13331 12 : arg3 = static_cast< int >(val3);
13332 12 : if (swig_obj[3]) {
13333 12 : {
13334 : /* %typemap(in) char **dict */
13335 12 : arg4 = NULL;
13336 12 : if ( PySequence_Check( swig_obj[3] ) ) {
13337 12 : int bErr = FALSE;
13338 12 : arg4 = CSLFromPySequence(swig_obj[3], &bErr);
13339 12 : if ( bErr )
13340 : {
13341 0 : SWIG_fail;
13342 : }
13343 : }
13344 0 : else if ( PyMapping_Check( swig_obj[3] ) ) {
13345 0 : int bErr = FALSE;
13346 0 : arg4 = CSLFromPyMapping(swig_obj[3], &bErr);
13347 0 : if ( bErr )
13348 : {
13349 0 : SWIG_fail;
13350 : }
13351 : }
13352 : else {
13353 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
13354 0 : SWIG_fail;
13355 : }
13356 : }
13357 : }
13358 12 : {
13359 12 : const int bLocalUseExceptions = GetUseExceptions();
13360 12 : if ( bLocalUseExceptions ) {
13361 12 : pushErrorHandler();
13362 : }
13363 12 : {
13364 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13365 12 : result = (OGRErr)OGRLayerShadow_WriteArrowStreamCapsule(arg1,arg2,arg3,arg4);
13366 12 : SWIG_PYTHON_THREAD_END_ALLOW;
13367 : }
13368 12 : if ( bLocalUseExceptions ) {
13369 12 : popErrorHandler();
13370 : }
13371 : #ifndef SED_HACKS
13372 : if ( bLocalUseExceptions ) {
13373 : CPLErr eclass = CPLGetLastErrorType();
13374 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13375 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13376 : }
13377 : }
13378 : #endif
13379 : }
13380 12 : {
13381 : /* %typemap(out) OGRErr */
13382 12 : if ( result != 0 && GetUseExceptions()) {
13383 0 : const char* pszMessage = CPLGetLastErrorMsg();
13384 0 : if( pszMessage[0] != '\0' )
13385 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13386 : else
13387 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
13388 0 : SWIG_fail;
13389 : }
13390 : }
13391 12 : {
13392 : /* %typemap(freearg) char **dict */
13393 12 : CSLDestroy( arg4 );
13394 : }
13395 12 : {
13396 : /* %typemap(ret) OGRErr */
13397 12 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
13398 12 : resultobj = PyInt_FromLong( result );
13399 : }
13400 : }
13401 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13402 : return resultobj;
13403 0 : fail:
13404 0 : {
13405 : /* %typemap(freearg) char **dict */
13406 0 : CSLDestroy( arg4 );
13407 : }
13408 : return NULL;
13409 : }
13410 :
13411 :
13412 0 : SWIGINTERN PyObject *_wrap_Layer_WriteArrowSchemaAndArrowArrayCapsule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13413 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13414 0 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
13415 0 : PyObject *arg2 = (PyObject *) 0 ;
13416 0 : PyObject *arg3 = (PyObject *) 0 ;
13417 0 : int arg4 ;
13418 0 : char **arg5 = (char **) NULL ;
13419 0 : void *argp1 = 0 ;
13420 0 : int res1 = 0 ;
13421 0 : int val4 ;
13422 0 : int ecode4 = 0 ;
13423 0 : PyObject *swig_obj[5] ;
13424 0 : OGRErr result;
13425 :
13426 0 : if (!SWIG_Python_UnpackTuple(args, "Layer_WriteArrowSchemaAndArrowArrayCapsule", 4, 5, swig_obj)) SWIG_fail;
13427 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13428 0 : if (!SWIG_IsOK(res1)) {
13429 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_WriteArrowSchemaAndArrowArrayCapsule" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13430 : }
13431 0 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13432 0 : arg2 = swig_obj[1];
13433 0 : arg3 = swig_obj[2];
13434 0 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
13435 0 : if (!SWIG_IsOK(ecode4)) {
13436 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_WriteArrowSchemaAndArrowArrayCapsule" "', argument " "4"" of type '" "int""'");
13437 : }
13438 0 : arg4 = static_cast< int >(val4);
13439 0 : if (swig_obj[4]) {
13440 0 : {
13441 : /* %typemap(in) char **dict */
13442 0 : arg5 = NULL;
13443 0 : if ( PySequence_Check( swig_obj[4] ) ) {
13444 0 : int bErr = FALSE;
13445 0 : arg5 = CSLFromPySequence(swig_obj[4], &bErr);
13446 0 : if ( bErr )
13447 : {
13448 0 : SWIG_fail;
13449 : }
13450 : }
13451 0 : else if ( PyMapping_Check( swig_obj[4] ) ) {
13452 0 : int bErr = FALSE;
13453 0 : arg5 = CSLFromPyMapping(swig_obj[4], &bErr);
13454 0 : if ( bErr )
13455 : {
13456 0 : SWIG_fail;
13457 : }
13458 : }
13459 : else {
13460 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
13461 0 : SWIG_fail;
13462 : }
13463 : }
13464 : }
13465 0 : {
13466 0 : const int bLocalUseExceptions = GetUseExceptions();
13467 0 : if ( bLocalUseExceptions ) {
13468 0 : pushErrorHandler();
13469 : }
13470 0 : {
13471 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13472 0 : result = (OGRErr)OGRLayerShadow_WriteArrowSchemaAndArrowArrayCapsule(arg1,arg2,arg3,arg4,arg5);
13473 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13474 : }
13475 0 : if ( bLocalUseExceptions ) {
13476 0 : popErrorHandler();
13477 : }
13478 : #ifndef SED_HACKS
13479 : if ( bLocalUseExceptions ) {
13480 : CPLErr eclass = CPLGetLastErrorType();
13481 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13482 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13483 : }
13484 : }
13485 : #endif
13486 : }
13487 0 : {
13488 : /* %typemap(out) OGRErr */
13489 0 : if ( result != 0 && GetUseExceptions()) {
13490 0 : const char* pszMessage = CPLGetLastErrorMsg();
13491 0 : if( pszMessage[0] != '\0' )
13492 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13493 : else
13494 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
13495 0 : SWIG_fail;
13496 : }
13497 : }
13498 0 : {
13499 : /* %typemap(freearg) char **dict */
13500 0 : CSLDestroy( arg5 );
13501 : }
13502 0 : {
13503 : /* %typemap(ret) OGRErr */
13504 0 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
13505 0 : resultobj = PyInt_FromLong( result );
13506 : }
13507 : }
13508 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13509 : return resultobj;
13510 0 : fail:
13511 0 : {
13512 : /* %typemap(freearg) char **dict */
13513 0 : CSLDestroy( arg5 );
13514 : }
13515 : return NULL;
13516 : }
13517 :
13518 :
13519 54 : SWIGINTERN PyObject *_wrap_Layer_GetGeometryTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13520 54 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13521 54 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
13522 54 : OGRGeometryTypeCounter **arg2 = (OGRGeometryTypeCounter **) 0 ;
13523 54 : int *arg3 = (int *) 0 ;
13524 54 : int arg4 = (int) 0 ;
13525 54 : int arg5 = (int) 0 ;
13526 54 : GDALProgressFunc arg6 = (GDALProgressFunc) NULL ;
13527 54 : void *arg7 = (void *) NULL ;
13528 54 : void *argp1 = 0 ;
13529 54 : int res1 = 0 ;
13530 54 : OGRGeometryTypeCounter *pRet2 = NULL ;
13531 54 : int nEntryCount2 = 0 ;
13532 54 : int val4 ;
13533 54 : int ecode4 = 0 ;
13534 54 : int val5 ;
13535 54 : int ecode5 = 0 ;
13536 54 : PyObject * obj0 = 0 ;
13537 54 : PyObject * obj1 = 0 ;
13538 54 : PyObject * obj2 = 0 ;
13539 54 : PyObject * obj3 = 0 ;
13540 54 : PyObject * obj4 = 0 ;
13541 54 : char * kwnames[] = {
13542 : (char *)"self", (char *)"geom_field", (char *)"flags", (char *)"callback", (char *)"callback_data", NULL
13543 : };
13544 :
13545 : /* %typemap(arginit) ( const char* callback_data=NULL) */
13546 54 : PyProgressData *psProgressInfo;
13547 54 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
13548 54 : psProgressInfo->nLastReported = -1;
13549 54 : psProgressInfo->psPyCallback = NULL;
13550 54 : psProgressInfo->psPyCallbackData = NULL;
13551 54 : arg7 = psProgressInfo;
13552 54 : {
13553 : /* %typemap(in,numinputs=0) (OGRGeometryTypeCounter** ppRet, int* pnEntryCount) */
13554 54 : arg2 = &pRet2;
13555 54 : arg3 = &nEntryCount2;
13556 : }
13557 54 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOO:Layer_GetGeometryTypes", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
13558 54 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13559 54 : if (!SWIG_IsOK(res1)) {
13560 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetGeometryTypes" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13561 : }
13562 54 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13563 54 : if (obj1) {
13564 6 : ecode4 = SWIG_AsVal_int(obj1, &val4);
13565 6 : if (!SWIG_IsOK(ecode4)) {
13566 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_GetGeometryTypes" "', argument " "4"" of type '" "int""'");
13567 : }
13568 : arg4 = static_cast< int >(val4);
13569 : }
13570 54 : if (obj2) {
13571 19 : ecode5 = SWIG_AsVal_int(obj2, &val5);
13572 19 : if (!SWIG_IsOK(ecode5)) {
13573 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Layer_GetGeometryTypes" "', argument " "5"" of type '" "int""'");
13574 : }
13575 : arg5 = static_cast< int >(val5);
13576 : }
13577 54 : if (obj3) {
13578 6 : {
13579 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
13580 : /* callback_func typemap */
13581 :
13582 : /* In some cases 0 is passed instead of None. */
13583 : /* See https://github.com/OSGeo/gdal/pull/219 */
13584 6 : if ( PyLong_Check(obj3) || PyInt_Check(obj3) )
13585 : {
13586 0 : if( PyLong_AsLong(obj3) == 0 )
13587 : {
13588 0 : obj3 = Py_None;
13589 : }
13590 : }
13591 :
13592 6 : if (obj3 && obj3 != Py_None ) {
13593 6 : void* cbfunction = NULL;
13594 6 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj3,
13595 : (void**)&cbfunction,
13596 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
13597 : SWIG_POINTER_EXCEPTION | 0 ));
13598 :
13599 6 : if ( cbfunction == GDALTermProgress ) {
13600 : arg6 = GDALTermProgress;
13601 : } else {
13602 6 : if (!PyCallable_Check(obj3)) {
13603 0 : PyErr_SetString( PyExc_RuntimeError,
13604 : "Object given is not a Python function" );
13605 0 : SWIG_fail;
13606 : }
13607 6 : psProgressInfo->psPyCallback = obj3;
13608 6 : arg6 = PyProgressProxy;
13609 : }
13610 :
13611 : }
13612 :
13613 : }
13614 : }
13615 54 : if (obj4) {
13616 0 : {
13617 : /* %typemap(in) ( void* callback_data=NULL) */
13618 0 : psProgressInfo->psPyCallbackData = obj4 ;
13619 : }
13620 : }
13621 54 : {
13622 54 : const int bLocalUseExceptions = GetUseExceptions();
13623 54 : if ( bLocalUseExceptions ) {
13624 12 : pushErrorHandler();
13625 : }
13626 54 : {
13627 54 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13628 54 : OGRLayerShadow_GetGeometryTypes(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
13629 54 : SWIG_PYTHON_THREAD_END_ALLOW;
13630 : }
13631 54 : if ( bLocalUseExceptions ) {
13632 12 : popErrorHandler();
13633 : }
13634 : #ifndef SED_HACKS
13635 : if ( bLocalUseExceptions ) {
13636 : CPLErr eclass = CPLGetLastErrorType();
13637 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13638 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13639 : }
13640 : }
13641 : #endif
13642 : }
13643 54 : resultobj = SWIG_Py_Void();
13644 54 : {
13645 : /* %typemap(argout) (OGRGeometryTypeCounter** ppRet, int* pnEntryCount) */
13646 54 : Py_DECREF(resultobj);
13647 54 : int nEntryCount = *(arg3);
13648 54 : OGRGeometryTypeCounter* pRet = *(arg2);
13649 54 : if( pRet == NULL )
13650 : {
13651 6 : PyErr_SetString( PyExc_RuntimeError, CPLGetLastErrorMsg() );
13652 6 : SWIG_fail;
13653 : }
13654 48 : resultobj = PyDict_New();
13655 153 : for(int i = 0; i < nEntryCount; ++ i)
13656 : {
13657 105 : PyObject *key = PyInt_FromLong( (int)(pRet[i].eGeomType) );
13658 105 : PyObject *val = PyLong_FromLongLong( pRet[i].nCount );
13659 105 : PyDict_SetItem(resultobj, key, val );
13660 105 : Py_DECREF(key);
13661 105 : Py_DECREF(val);
13662 : }
13663 : }
13664 48 : {
13665 : /* %typemap(freearg) (OGRGeometryTypeCounter** ppRet, int* pnEntryCount) */
13666 48 : VSIFree(*arg2);
13667 : }
13668 48 : {
13669 : /* %typemap(freearg) ( void* callback_data=NULL) */
13670 :
13671 48 : CPLFree(psProgressInfo);
13672 :
13673 : }
13674 54 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13675 : return resultobj;
13676 6 : fail:
13677 6 : {
13678 : /* %typemap(freearg) (OGRGeometryTypeCounter** ppRet, int* pnEntryCount) */
13679 6 : VSIFree(*arg2);
13680 : }
13681 6 : {
13682 : /* %typemap(freearg) ( void* callback_data=NULL) */
13683 :
13684 6 : CPLFree(psProgressInfo);
13685 :
13686 : }
13687 : return NULL;
13688 : }
13689 :
13690 :
13691 4 : SWIGINTERN PyObject *_wrap_Layer_GetSupportedSRSList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13692 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13693 4 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
13694 4 : OGRSpatialReferenceH **arg2 = (OGRSpatialReferenceH **) 0 ;
13695 4 : int *arg3 = (int *) 0 ;
13696 4 : int arg4 = (int) 0 ;
13697 4 : void *argp1 = 0 ;
13698 4 : int res1 = 0 ;
13699 4 : OGRSpatialReferenceH *pRet2 = NULL ;
13700 4 : int nEntryCount2 = 0 ;
13701 4 : int val4 ;
13702 4 : int ecode4 = 0 ;
13703 4 : PyObject * obj0 = 0 ;
13704 4 : PyObject * obj1 = 0 ;
13705 4 : char * kwnames[] = {
13706 : (char *)"self", (char *)"geom_field", NULL
13707 : };
13708 :
13709 4 : {
13710 : /* %typemap(in,numinputs=0) (OGRSpatialReferenceH** ppRet, int* pnEntryCount) */
13711 4 : arg2 = &pRet2;
13712 4 : arg3 = &nEntryCount2;
13713 : }
13714 4 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Layer_GetSupportedSRSList", kwnames, &obj0, &obj1)) SWIG_fail;
13715 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13716 4 : if (!SWIG_IsOK(res1)) {
13717 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetSupportedSRSList" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13718 : }
13719 4 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13720 4 : if (obj1) {
13721 0 : ecode4 = SWIG_AsVal_int(obj1, &val4);
13722 0 : if (!SWIG_IsOK(ecode4)) {
13723 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_GetSupportedSRSList" "', argument " "4"" of type '" "int""'");
13724 : }
13725 : arg4 = static_cast< int >(val4);
13726 : }
13727 4 : {
13728 4 : const int bLocalUseExceptions = GetUseExceptions();
13729 4 : if ( bLocalUseExceptions ) {
13730 2 : pushErrorHandler();
13731 : }
13732 4 : {
13733 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13734 4 : OGRLayerShadow_GetSupportedSRSList(arg1,arg2,arg3,arg4);
13735 4 : SWIG_PYTHON_THREAD_END_ALLOW;
13736 : }
13737 4 : if ( bLocalUseExceptions ) {
13738 2 : popErrorHandler();
13739 : }
13740 : #ifndef SED_HACKS
13741 : if ( bLocalUseExceptions ) {
13742 : CPLErr eclass = CPLGetLastErrorType();
13743 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13744 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13745 : }
13746 : }
13747 : #endif
13748 : }
13749 4 : resultobj = SWIG_Py_Void();
13750 4 : {
13751 : /* %typemap(argout) (OGRSpatialReferenceH** ppRet, int* pnEntryCount) */
13752 4 : Py_DECREF(resultobj);
13753 4 : int nEntryCount = *(arg3);
13754 4 : OGRSpatialReferenceH* pRet = *(arg2);
13755 4 : if( nEntryCount == 0)
13756 : {
13757 2 : Py_INCREF(Py_None);
13758 2 : resultobj = Py_None;
13759 : }
13760 : else
13761 : {
13762 2 : resultobj = PyList_New(nEntryCount);
13763 2 : if( !resultobj ) {
13764 0 : SWIG_fail;
13765 : }
13766 7 : for(int i = 0; i < nEntryCount; ++ i)
13767 : {
13768 5 : OSRReference(pRet[i]);
13769 5 : PyList_SetItem(resultobj, i, SWIG_NewPointerObj(
13770 : SWIG_as_voidptr(pRet[i]),SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_OWN) );
13771 : }
13772 : }
13773 : }
13774 4 : {
13775 : /* %typemap(freearg) (OGRSpatialReferenceH** ppRet, int* pnEntryCount) */
13776 4 : OSRFreeSRSArray(*arg2);
13777 : }
13778 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13779 : return resultobj;
13780 0 : fail:
13781 0 : {
13782 : /* %typemap(freearg) (OGRSpatialReferenceH** ppRet, int* pnEntryCount) */
13783 0 : OSRFreeSRSArray(*arg2);
13784 : }
13785 : return NULL;
13786 : }
13787 :
13788 :
13789 9 : SWIGINTERN PyObject *_wrap_Layer_SetActiveSRS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13790 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13791 9 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
13792 9 : int arg2 ;
13793 9 : OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) 0 ;
13794 9 : void *argp1 = 0 ;
13795 9 : int res1 = 0 ;
13796 9 : int val2 ;
13797 9 : int ecode2 = 0 ;
13798 9 : void *argp3 = 0 ;
13799 9 : int res3 = 0 ;
13800 9 : PyObject *swig_obj[3] ;
13801 9 : OGRErr result;
13802 :
13803 9 : if (!SWIG_Python_UnpackTuple(args, "Layer_SetActiveSRS", 3, 3, swig_obj)) SWIG_fail;
13804 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13805 9 : if (!SWIG_IsOK(res1)) {
13806 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetActiveSRS" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13807 : }
13808 9 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13809 9 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13810 9 : if (!SWIG_IsOK(ecode2)) {
13811 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_SetActiveSRS" "', argument " "2"" of type '" "int""'");
13812 : }
13813 9 : arg2 = static_cast< int >(val2);
13814 9 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
13815 9 : if (!SWIG_IsOK(res3)) {
13816 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_SetActiveSRS" "', argument " "3"" of type '" "OSRSpatialReferenceShadow *""'");
13817 : }
13818 9 : arg3 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp3);
13819 9 : {
13820 9 : const int bLocalUseExceptions = GetUseExceptions();
13821 9 : if ( bLocalUseExceptions ) {
13822 4 : pushErrorHandler();
13823 : }
13824 9 : {
13825 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13826 9 : result = (OGRErr)OGRLayerShadow_SetActiveSRS(arg1,arg2,arg3);
13827 9 : SWIG_PYTHON_THREAD_END_ALLOW;
13828 : }
13829 9 : if ( bLocalUseExceptions ) {
13830 4 : popErrorHandler();
13831 : }
13832 : #ifndef SED_HACKS
13833 : if ( bLocalUseExceptions ) {
13834 : CPLErr eclass = CPLGetLastErrorType();
13835 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13836 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13837 : }
13838 : }
13839 : #endif
13840 : }
13841 9 : {
13842 : /* %typemap(out) OGRErr */
13843 14 : if ( result != 0 && GetUseExceptions()) {
13844 2 : const char* pszMessage = CPLGetLastErrorMsg();
13845 2 : if( pszMessage[0] != '\0' )
13846 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13847 : else
13848 2 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
13849 2 : SWIG_fail;
13850 : }
13851 : }
13852 7 : {
13853 : /* %typemap(ret) OGRErr */
13854 7 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
13855 7 : resultobj = PyInt_FromLong( result );
13856 : }
13857 : }
13858 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13859 : return resultobj;
13860 : fail:
13861 : return NULL;
13862 : }
13863 :
13864 :
13865 273 : SWIGINTERN PyObject *Layer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13866 273 : PyObject *obj;
13867 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
13868 273 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRLayerShadow, SWIG_NewClientData(obj));
13869 273 : return SWIG_Py_Void();
13870 : }
13871 :
13872 201094 : SWIGINTERN PyObject *_wrap_delete_Feature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13873 201094 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13874 201094 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
13875 201094 : void *argp1 = 0 ;
13876 201094 : int res1 = 0 ;
13877 201094 : PyObject *swig_obj[1] ;
13878 :
13879 201094 : if (!args) SWIG_fail;
13880 201094 : swig_obj[0] = args;
13881 201094 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_DISOWN | 0 );
13882 201094 : if (!SWIG_IsOK(res1)) {
13883 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Feature" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
13884 : }
13885 201094 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
13886 201094 : {
13887 201094 : const int bLocalUseExceptions = GetUseExceptions();
13888 201094 : if ( bLocalUseExceptions ) {
13889 112453 : pushErrorHandler();
13890 : }
13891 201094 : {
13892 201094 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13893 201094 : delete_OGRFeatureShadow(arg1);
13894 201094 : SWIG_PYTHON_THREAD_END_ALLOW;
13895 : }
13896 201094 : if ( bLocalUseExceptions ) {
13897 112453 : popErrorHandler();
13898 : }
13899 : #ifndef SED_HACKS
13900 : if ( bLocalUseExceptions ) {
13901 : CPLErr eclass = CPLGetLastErrorType();
13902 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13903 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13904 : }
13905 : }
13906 : #endif
13907 : }
13908 201094 : resultobj = SWIG_Py_Void();
13909 201094 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13910 : return resultobj;
13911 : fail:
13912 : return NULL;
13913 : }
13914 :
13915 :
13916 120637 : SWIGINTERN PyObject *_wrap_new_Feature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13917 120637 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13918 120637 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
13919 120637 : void *argp1 = 0 ;
13920 120637 : int res1 = 0 ;
13921 120637 : PyObject * obj0 = 0 ;
13922 120637 : char * kwnames[] = {
13923 : (char *)"feature_def", NULL
13924 : };
13925 120637 : OGRFeatureShadow *result = 0 ;
13926 :
13927 120637 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_Feature", kwnames, &obj0)) SWIG_fail;
13928 120637 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
13929 120637 : if (!SWIG_IsOK(res1)) {
13930 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Feature" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
13931 : }
13932 120637 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
13933 120637 : {
13934 120637 : if (!arg1) {
13935 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
13936 : }
13937 : }
13938 120637 : {
13939 120637 : const int bLocalUseExceptions = GetUseExceptions();
13940 120637 : if ( bLocalUseExceptions ) {
13941 61507 : pushErrorHandler();
13942 : }
13943 120637 : {
13944 120637 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13945 120637 : result = (OGRFeatureShadow *)new_OGRFeatureShadow(arg1);
13946 120637 : SWIG_PYTHON_THREAD_END_ALLOW;
13947 : }
13948 120637 : if ( bLocalUseExceptions ) {
13949 61507 : popErrorHandler();
13950 : }
13951 : #ifndef SED_HACKS
13952 : if ( bLocalUseExceptions ) {
13953 : CPLErr eclass = CPLGetLastErrorType();
13954 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13955 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13956 : }
13957 : }
13958 : #endif
13959 : }
13960 120637 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_NEW | 0 );
13961 120637 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13962 : return resultobj;
13963 : fail:
13964 : return NULL;
13965 : }
13966 :
13967 :
13968 44858 : SWIGINTERN PyObject *_wrap_Feature_GetDefnRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13969 44858 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13970 44858 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
13971 44858 : void *argp1 = 0 ;
13972 44858 : int res1 = 0 ;
13973 44858 : PyObject *swig_obj[1] ;
13974 44858 : OGRFeatureDefnShadow *result = 0 ;
13975 :
13976 44858 : if (!args) SWIG_fail;
13977 44858 : swig_obj[0] = args;
13978 44858 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
13979 44858 : if (!SWIG_IsOK(res1)) {
13980 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetDefnRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
13981 : }
13982 44858 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
13983 44858 : {
13984 44858 : const int bLocalUseExceptions = GetUseExceptions();
13985 44858 : if ( bLocalUseExceptions ) {
13986 21608 : pushErrorHandler();
13987 : }
13988 44858 : {
13989 44858 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13990 44858 : result = (OGRFeatureDefnShadow *)OGRFeatureShadow_GetDefnRef(arg1);
13991 44858 : SWIG_PYTHON_THREAD_END_ALLOW;
13992 : }
13993 44858 : if ( bLocalUseExceptions ) {
13994 21608 : popErrorHandler();
13995 : }
13996 : #ifndef SED_HACKS
13997 : if ( bLocalUseExceptions ) {
13998 : CPLErr eclass = CPLGetLastErrorType();
13999 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14000 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14001 : }
14002 : }
14003 : #endif
14004 : }
14005 44858 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
14006 44858 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14007 : return resultobj;
14008 : fail:
14009 : return NULL;
14010 : }
14011 :
14012 :
14013 235394 : SWIGINTERN PyObject *_wrap_Feature_SetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14014 235394 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14015 235394 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14016 235394 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
14017 235394 : void *argp1 = 0 ;
14018 235394 : int res1 = 0 ;
14019 235394 : void *argp2 = 0 ;
14020 235394 : int res2 = 0 ;
14021 235394 : PyObject *swig_obj[2] ;
14022 235394 : OGRErr result;
14023 :
14024 235394 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetGeometry", 2, 2, swig_obj)) SWIG_fail;
14025 235394 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14026 235394 : if (!SWIG_IsOK(res1)) {
14027 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetGeometry" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14028 : }
14029 235394 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14030 235394 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
14031 235394 : if (!SWIG_IsOK(res2)) {
14032 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_SetGeometry" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
14033 : }
14034 235394 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
14035 235394 : {
14036 235394 : const int bLocalUseExceptions = GetUseExceptions();
14037 235394 : if ( bLocalUseExceptions ) {
14038 218104 : pushErrorHandler();
14039 : }
14040 235394 : {
14041 235394 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14042 235394 : result = (OGRErr)OGRFeatureShadow_SetGeometry(arg1,arg2);
14043 235394 : SWIG_PYTHON_THREAD_END_ALLOW;
14044 : }
14045 235394 : if ( bLocalUseExceptions ) {
14046 218104 : popErrorHandler();
14047 : }
14048 : #ifndef SED_HACKS
14049 : if ( bLocalUseExceptions ) {
14050 : CPLErr eclass = CPLGetLastErrorType();
14051 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14052 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14053 : }
14054 : }
14055 : #endif
14056 : }
14057 235394 : {
14058 : /* %typemap(out) OGRErr */
14059 235396 : if ( result != 0 && GetUseExceptions()) {
14060 0 : const char* pszMessage = CPLGetLastErrorMsg();
14061 0 : if( pszMessage[0] != '\0' )
14062 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
14063 : else
14064 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
14065 0 : SWIG_fail;
14066 : }
14067 : }
14068 235394 : {
14069 : /* %typemap(ret) OGRErr */
14070 235394 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
14071 235394 : resultobj = PyInt_FromLong( result );
14072 : }
14073 : }
14074 235394 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14075 : return resultobj;
14076 : fail:
14077 : return NULL;
14078 : }
14079 :
14080 :
14081 33924 : SWIGINTERN PyObject *_wrap_Feature_SetGeometryDirectly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14082 33924 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14083 33924 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14084 33924 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
14085 33924 : void *argp1 = 0 ;
14086 33924 : int res1 = 0 ;
14087 33924 : int res2 = 0 ;
14088 33924 : PyObject *swig_obj[2] ;
14089 33924 : OGRErr result;
14090 :
14091 33924 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetGeometryDirectly", 2, 2, swig_obj)) SWIG_fail;
14092 33924 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14093 33924 : if (!SWIG_IsOK(res1)) {
14094 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetGeometryDirectly" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14095 : }
14096 33924 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14097 33924 : res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN | 0 );
14098 33924 : if (!SWIG_IsOK(res2)) {
14099 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_SetGeometryDirectly" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
14100 : }
14101 33924 : {
14102 33924 : const int bLocalUseExceptions = GetUseExceptions();
14103 33924 : if ( bLocalUseExceptions ) {
14104 1050 : pushErrorHandler();
14105 : }
14106 33924 : {
14107 33924 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14108 33924 : result = (OGRErr)OGRFeatureShadow_SetGeometryDirectly(arg1,arg2);
14109 33924 : SWIG_PYTHON_THREAD_END_ALLOW;
14110 : }
14111 33924 : if ( bLocalUseExceptions ) {
14112 1050 : popErrorHandler();
14113 : }
14114 : #ifndef SED_HACKS
14115 : if ( bLocalUseExceptions ) {
14116 : CPLErr eclass = CPLGetLastErrorType();
14117 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14118 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14119 : }
14120 : }
14121 : #endif
14122 : }
14123 33924 : {
14124 : /* %typemap(out) OGRErr */
14125 33925 : if ( result != 0 && GetUseExceptions()) {
14126 0 : const char* pszMessage = CPLGetLastErrorMsg();
14127 0 : if( pszMessage[0] != '\0' )
14128 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
14129 : else
14130 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
14131 0 : SWIG_fail;
14132 : }
14133 : }
14134 33924 : {
14135 : /* %typemap(ret) OGRErr */
14136 33924 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
14137 33924 : resultobj = PyInt_FromLong( result );
14138 : }
14139 : }
14140 33924 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14141 : return resultobj;
14142 : fail:
14143 : return NULL;
14144 : }
14145 :
14146 :
14147 38230 : SWIGINTERN PyObject *_wrap_Feature_GetGeometryRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14148 38230 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14149 38230 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14150 38230 : void *argp1 = 0 ;
14151 38230 : int res1 = 0 ;
14152 38230 : PyObject *swig_obj[1] ;
14153 38230 : OGRGeometryShadow *result = 0 ;
14154 :
14155 38230 : if (!args) SWIG_fail;
14156 38230 : swig_obj[0] = args;
14157 38230 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14158 38230 : if (!SWIG_IsOK(res1)) {
14159 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetGeometryRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14160 : }
14161 38230 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14162 38230 : {
14163 38230 : const int bLocalUseExceptions = GetUseExceptions();
14164 38230 : if ( bLocalUseExceptions ) {
14165 32887 : pushErrorHandler();
14166 : }
14167 38230 : {
14168 38230 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14169 38230 : result = (OGRGeometryShadow *)OGRFeatureShadow_GetGeometryRef(arg1);
14170 38230 : SWIG_PYTHON_THREAD_END_ALLOW;
14171 : }
14172 38230 : if ( bLocalUseExceptions ) {
14173 32887 : popErrorHandler();
14174 : }
14175 : #ifndef SED_HACKS
14176 : if ( bLocalUseExceptions ) {
14177 : CPLErr eclass = CPLGetLastErrorType();
14178 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14179 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14180 : }
14181 : }
14182 : #endif
14183 : }
14184 38230 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
14185 38230 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14186 : return resultobj;
14187 : fail:
14188 : return NULL;
14189 : }
14190 :
14191 :
14192 : SWIGINTERN PyObject *_wrap_Feature_SetGeomField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14193 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14194 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14195 : int arg2 ;
14196 : OGRGeometryShadow *arg3 = (OGRGeometryShadow *) 0 ;
14197 : void *argp1 = 0 ;
14198 : int res1 = 0 ;
14199 : int val2 ;
14200 : int ecode2 = 0 ;
14201 : void *argp3 = 0 ;
14202 : int res3 = 0 ;
14203 : OGRErr result;
14204 :
14205 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
14206 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14207 : if (!SWIG_IsOK(res1)) {
14208 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetGeomField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14209 : }
14210 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14211 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14212 : if (!SWIG_IsOK(ecode2)) {
14213 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetGeomField" "', argument " "2"" of type '" "int""'");
14214 : }
14215 : arg2 = static_cast< int >(val2);
14216 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
14217 : if (!SWIG_IsOK(res3)) {
14218 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Feature_SetGeomField" "', argument " "3"" of type '" "OGRGeometryShadow *""'");
14219 : }
14220 : arg3 = reinterpret_cast< OGRGeometryShadow * >(argp3);
14221 : {
14222 : const int bLocalUseExceptions = GetUseExceptions();
14223 : if ( bLocalUseExceptions ) {
14224 : pushErrorHandler();
14225 : }
14226 : {
14227 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14228 : result = (OGRErr)OGRFeatureShadow_SetGeomField__SWIG_0(arg1,arg2,arg3);
14229 : SWIG_PYTHON_THREAD_END_ALLOW;
14230 : }
14231 : if ( bLocalUseExceptions ) {
14232 : popErrorHandler();
14233 : }
14234 : #ifndef SED_HACKS
14235 : if ( bLocalUseExceptions ) {
14236 : CPLErr eclass = CPLGetLastErrorType();
14237 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14238 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14239 : }
14240 : }
14241 : #endif
14242 : }
14243 : {
14244 : /* %typemap(out) OGRErr */
14245 : if ( result != 0 && GetUseExceptions()) {
14246 : const char* pszMessage = CPLGetLastErrorMsg();
14247 : if( pszMessage[0] != '\0' )
14248 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
14249 : else
14250 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
14251 : SWIG_fail;
14252 : }
14253 : }
14254 : {
14255 : /* %typemap(ret) OGRErr */
14256 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
14257 : resultobj = PyInt_FromLong( result );
14258 : }
14259 : }
14260 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14261 : return resultobj;
14262 : fail:
14263 : return NULL;
14264 : }
14265 :
14266 :
14267 : SWIGINTERN PyObject *_wrap_Feature_SetGeomField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14268 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14269 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14270 : char *arg2 = (char *) 0 ;
14271 : OGRGeometryShadow *arg3 = (OGRGeometryShadow *) 0 ;
14272 : void *argp1 = 0 ;
14273 : int res1 = 0 ;
14274 : int bToFree2 = 0 ;
14275 : void *argp3 = 0 ;
14276 : int res3 = 0 ;
14277 : OGRErr result;
14278 :
14279 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
14280 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14281 : if (!SWIG_IsOK(res1)) {
14282 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetGeomField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14283 : }
14284 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14285 : {
14286 : /* %typemap(in) (const char *utf8_path) */
14287 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
14288 : {
14289 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
14290 : }
14291 : else
14292 : {
14293 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
14294 :
14295 : }
14296 : if (arg2 == NULL)
14297 : {
14298 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
14299 : SWIG_fail;
14300 : }
14301 : }
14302 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
14303 : if (!SWIG_IsOK(res3)) {
14304 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Feature_SetGeomField" "', argument " "3"" of type '" "OGRGeometryShadow *""'");
14305 : }
14306 : arg3 = reinterpret_cast< OGRGeometryShadow * >(argp3);
14307 : {
14308 : const int bLocalUseExceptions = GetUseExceptions();
14309 : if ( bLocalUseExceptions ) {
14310 : pushErrorHandler();
14311 : }
14312 : {
14313 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14314 : result = (OGRErr)OGRFeatureShadow_SetGeomField__SWIG_1(arg1,(char const *)arg2,arg3);
14315 : SWIG_PYTHON_THREAD_END_ALLOW;
14316 : }
14317 : if ( bLocalUseExceptions ) {
14318 : popErrorHandler();
14319 : }
14320 : #ifndef SED_HACKS
14321 : if ( bLocalUseExceptions ) {
14322 : CPLErr eclass = CPLGetLastErrorType();
14323 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14324 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14325 : }
14326 : }
14327 : #endif
14328 : }
14329 : {
14330 : /* %typemap(out) OGRErr */
14331 : if ( result != 0 && GetUseExceptions()) {
14332 : const char* pszMessage = CPLGetLastErrorMsg();
14333 : if( pszMessage[0] != '\0' )
14334 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
14335 : else
14336 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
14337 : SWIG_fail;
14338 : }
14339 : }
14340 : {
14341 : /* %typemap(freearg) (const char *utf8_path) */
14342 : GDALPythonFreeCStr(arg2, bToFree2);
14343 : }
14344 : {
14345 : /* %typemap(ret) OGRErr */
14346 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
14347 : resultobj = PyInt_FromLong( result );
14348 : }
14349 : }
14350 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14351 : return resultobj;
14352 : fail:
14353 : {
14354 : /* %typemap(freearg) (const char *utf8_path) */
14355 : GDALPythonFreeCStr(arg2, bToFree2);
14356 : }
14357 : return NULL;
14358 : }
14359 :
14360 :
14361 221 : SWIGINTERN PyObject *_wrap_Feature_SetGeomField(PyObject *self, PyObject *args) {
14362 221 : Py_ssize_t argc;
14363 221 : PyObject *argv[4] = {
14364 : 0
14365 : };
14366 :
14367 221 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_SetGeomField", 0, 3, argv))) SWIG_fail;
14368 221 : --argc;
14369 221 : if (argc == 3) {
14370 221 : int _v;
14371 221 : void *vptr = 0;
14372 221 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
14373 222 : _v = SWIG_CheckState(res);
14374 221 : if (_v) {
14375 221 : {
14376 221 : int res = SWIG_AsVal_int(argv[1], NULL);
14377 221 : _v = SWIG_CheckState(res);
14378 : }
14379 220 : if (_v) {
14380 220 : void *vptr = 0;
14381 220 : int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
14382 220 : _v = SWIG_CheckState(res);
14383 0 : if (_v) {
14384 220 : return _wrap_Feature_SetGeomField__SWIG_0(self, argc, argv);
14385 : }
14386 : }
14387 : }
14388 : }
14389 1 : if (argc == 3) {
14390 1 : int _v;
14391 1 : void *vptr = 0;
14392 1 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
14393 1 : _v = SWIG_CheckState(res);
14394 1 : if (_v) {
14395 1 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
14396 1 : _v = SWIG_CheckState(res);
14397 1 : if (_v) {
14398 1 : void *vptr = 0;
14399 1 : int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
14400 1 : _v = SWIG_CheckState(res);
14401 0 : if (_v) {
14402 1 : return _wrap_Feature_SetGeomField__SWIG_1(self, argc, argv);
14403 : }
14404 : }
14405 : }
14406 : }
14407 :
14408 0 : fail:
14409 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_SetGeomField'.\n"
14410 : " Possible C/C++ prototypes are:\n"
14411 : " OGRFeatureShadow::SetGeomField(int,OGRGeometryShadow *)\n"
14412 : " OGRFeatureShadow::SetGeomField(char const *,OGRGeometryShadow *)\n");
14413 : return 0;
14414 : }
14415 :
14416 :
14417 : SWIGINTERN PyObject *_wrap_Feature_SetGeomFieldDirectly__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14418 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14419 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14420 : int arg2 ;
14421 : OGRGeometryShadow *arg3 = (OGRGeometryShadow *) 0 ;
14422 : void *argp1 = 0 ;
14423 : int res1 = 0 ;
14424 : int val2 ;
14425 : int ecode2 = 0 ;
14426 : int res3 = 0 ;
14427 : OGRErr result;
14428 :
14429 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
14430 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14431 : if (!SWIG_IsOK(res1)) {
14432 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetGeomFieldDirectly" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14433 : }
14434 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14435 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14436 : if (!SWIG_IsOK(ecode2)) {
14437 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetGeomFieldDirectly" "', argument " "2"" of type '" "int""'");
14438 : }
14439 : arg2 = static_cast< int >(val2);
14440 : res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN | 0 );
14441 : if (!SWIG_IsOK(res3)) {
14442 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Feature_SetGeomFieldDirectly" "', argument " "3"" of type '" "OGRGeometryShadow *""'");
14443 : }
14444 : {
14445 : const int bLocalUseExceptions = GetUseExceptions();
14446 : if ( bLocalUseExceptions ) {
14447 : pushErrorHandler();
14448 : }
14449 : {
14450 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14451 : result = (OGRErr)OGRFeatureShadow_SetGeomFieldDirectly__SWIG_0(arg1,arg2,arg3);
14452 : SWIG_PYTHON_THREAD_END_ALLOW;
14453 : }
14454 : if ( bLocalUseExceptions ) {
14455 : popErrorHandler();
14456 : }
14457 : #ifndef SED_HACKS
14458 : if ( bLocalUseExceptions ) {
14459 : CPLErr eclass = CPLGetLastErrorType();
14460 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14461 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14462 : }
14463 : }
14464 : #endif
14465 : }
14466 : {
14467 : /* %typemap(out) OGRErr */
14468 : if ( result != 0 && GetUseExceptions()) {
14469 : const char* pszMessage = CPLGetLastErrorMsg();
14470 : if( pszMessage[0] != '\0' )
14471 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
14472 : else
14473 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
14474 : SWIG_fail;
14475 : }
14476 : }
14477 : {
14478 : /* %typemap(ret) OGRErr */
14479 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
14480 : resultobj = PyInt_FromLong( result );
14481 : }
14482 : }
14483 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14484 : return resultobj;
14485 : fail:
14486 : return NULL;
14487 : }
14488 :
14489 :
14490 : SWIGINTERN PyObject *_wrap_Feature_SetGeomFieldDirectly__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14491 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14492 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14493 : char *arg2 = (char *) 0 ;
14494 : OGRGeometryShadow *arg3 = (OGRGeometryShadow *) 0 ;
14495 : void *argp1 = 0 ;
14496 : int res1 = 0 ;
14497 : int bToFree2 = 0 ;
14498 : int res3 = 0 ;
14499 : OGRErr result;
14500 :
14501 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
14502 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14503 : if (!SWIG_IsOK(res1)) {
14504 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetGeomFieldDirectly" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14505 : }
14506 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14507 : {
14508 : /* %typemap(in) (const char *utf8_path) */
14509 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
14510 : {
14511 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
14512 : }
14513 : else
14514 : {
14515 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
14516 :
14517 : }
14518 : if (arg2 == NULL)
14519 : {
14520 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
14521 : SWIG_fail;
14522 : }
14523 : }
14524 : res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN | 0 );
14525 : if (!SWIG_IsOK(res3)) {
14526 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Feature_SetGeomFieldDirectly" "', argument " "3"" of type '" "OGRGeometryShadow *""'");
14527 : }
14528 : {
14529 : const int bLocalUseExceptions = GetUseExceptions();
14530 : if ( bLocalUseExceptions ) {
14531 : pushErrorHandler();
14532 : }
14533 : {
14534 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14535 : result = (OGRErr)OGRFeatureShadow_SetGeomFieldDirectly__SWIG_1(arg1,(char const *)arg2,arg3);
14536 : SWIG_PYTHON_THREAD_END_ALLOW;
14537 : }
14538 : if ( bLocalUseExceptions ) {
14539 : popErrorHandler();
14540 : }
14541 : #ifndef SED_HACKS
14542 : if ( bLocalUseExceptions ) {
14543 : CPLErr eclass = CPLGetLastErrorType();
14544 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14545 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14546 : }
14547 : }
14548 : #endif
14549 : }
14550 : {
14551 : /* %typemap(out) OGRErr */
14552 : if ( result != 0 && GetUseExceptions()) {
14553 : const char* pszMessage = CPLGetLastErrorMsg();
14554 : if( pszMessage[0] != '\0' )
14555 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
14556 : else
14557 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
14558 : SWIG_fail;
14559 : }
14560 : }
14561 : {
14562 : /* %typemap(freearg) (const char *utf8_path) */
14563 : GDALPythonFreeCStr(arg2, bToFree2);
14564 : }
14565 : {
14566 : /* %typemap(ret) OGRErr */
14567 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
14568 : resultobj = PyInt_FromLong( result );
14569 : }
14570 : }
14571 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14572 : return resultobj;
14573 : fail:
14574 : {
14575 : /* %typemap(freearg) (const char *utf8_path) */
14576 : GDALPythonFreeCStr(arg2, bToFree2);
14577 : }
14578 : return NULL;
14579 : }
14580 :
14581 :
14582 35 : SWIGINTERN PyObject *_wrap_Feature_SetGeomFieldDirectly(PyObject *self, PyObject *args) {
14583 35 : Py_ssize_t argc;
14584 35 : PyObject *argv[4] = {
14585 : 0
14586 : };
14587 :
14588 35 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_SetGeomFieldDirectly", 0, 3, argv))) SWIG_fail;
14589 35 : --argc;
14590 35 : if (argc == 3) {
14591 35 : int _v;
14592 35 : void *vptr = 0;
14593 35 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
14594 51 : _v = SWIG_CheckState(res);
14595 35 : if (_v) {
14596 35 : {
14597 35 : int res = SWIG_AsVal_int(argv[1], NULL);
14598 35 : _v = SWIG_CheckState(res);
14599 : }
14600 19 : if (_v) {
14601 19 : void *vptr = 0;
14602 19 : int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
14603 19 : _v = SWIG_CheckState(res);
14604 0 : if (_v) {
14605 19 : return _wrap_Feature_SetGeomFieldDirectly__SWIG_0(self, argc, argv);
14606 : }
14607 : }
14608 : }
14609 : }
14610 16 : if (argc == 3) {
14611 16 : int _v;
14612 16 : void *vptr = 0;
14613 16 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
14614 16 : _v = SWIG_CheckState(res);
14615 16 : if (_v) {
14616 16 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
14617 16 : _v = SWIG_CheckState(res);
14618 16 : if (_v) {
14619 16 : void *vptr = 0;
14620 16 : int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
14621 16 : _v = SWIG_CheckState(res);
14622 0 : if (_v) {
14623 16 : return _wrap_Feature_SetGeomFieldDirectly__SWIG_1(self, argc, argv);
14624 : }
14625 : }
14626 : }
14627 : }
14628 :
14629 0 : fail:
14630 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_SetGeomFieldDirectly'.\n"
14631 : " Possible C/C++ prototypes are:\n"
14632 : " OGRFeatureShadow::SetGeomFieldDirectly(int,OGRGeometryShadow *)\n"
14633 : " OGRFeatureShadow::SetGeomFieldDirectly(char const *,OGRGeometryShadow *)\n");
14634 : return 0;
14635 : }
14636 :
14637 :
14638 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14639 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14640 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14641 : int arg2 ;
14642 : void *argp1 = 0 ;
14643 : int res1 = 0 ;
14644 : int val2 ;
14645 : int ecode2 = 0 ;
14646 : OGRGeometryShadow *result = 0 ;
14647 :
14648 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14649 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14650 : if (!SWIG_IsOK(res1)) {
14651 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetGeomFieldRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14652 : }
14653 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14654 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14655 : if (!SWIG_IsOK(ecode2)) {
14656 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetGeomFieldRef" "', argument " "2"" of type '" "int""'");
14657 : }
14658 : arg2 = static_cast< int >(val2);
14659 : {
14660 : const int bLocalUseExceptions = GetUseExceptions();
14661 : if ( bLocalUseExceptions ) {
14662 : pushErrorHandler();
14663 : }
14664 : {
14665 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14666 : result = (OGRGeometryShadow *)OGRFeatureShadow_GetGeomFieldRef__SWIG_0(arg1,arg2);
14667 : SWIG_PYTHON_THREAD_END_ALLOW;
14668 : }
14669 : if ( bLocalUseExceptions ) {
14670 : popErrorHandler();
14671 : }
14672 : #ifndef SED_HACKS
14673 : if ( bLocalUseExceptions ) {
14674 : CPLErr eclass = CPLGetLastErrorType();
14675 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14676 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14677 : }
14678 : }
14679 : #endif
14680 : }
14681 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
14682 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14683 : return resultobj;
14684 : fail:
14685 : return NULL;
14686 : }
14687 :
14688 :
14689 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14690 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14691 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14692 : char *arg2 = (char *) 0 ;
14693 : void *argp1 = 0 ;
14694 : int res1 = 0 ;
14695 : int bToFree2 = 0 ;
14696 : OGRGeometryShadow *result = 0 ;
14697 :
14698 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14699 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14700 : if (!SWIG_IsOK(res1)) {
14701 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetGeomFieldRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14702 : }
14703 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14704 : {
14705 : /* %typemap(in) (const char *utf8_path) */
14706 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
14707 : {
14708 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
14709 : }
14710 : else
14711 : {
14712 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
14713 :
14714 : }
14715 : if (arg2 == NULL)
14716 : {
14717 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
14718 : SWIG_fail;
14719 : }
14720 : }
14721 : {
14722 : const int bLocalUseExceptions = GetUseExceptions();
14723 : if ( bLocalUseExceptions ) {
14724 : pushErrorHandler();
14725 : }
14726 : {
14727 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14728 : result = (OGRGeometryShadow *)OGRFeatureShadow_GetGeomFieldRef__SWIG_1(arg1,(char const *)arg2);
14729 : SWIG_PYTHON_THREAD_END_ALLOW;
14730 : }
14731 : if ( bLocalUseExceptions ) {
14732 : popErrorHandler();
14733 : }
14734 : #ifndef SED_HACKS
14735 : if ( bLocalUseExceptions ) {
14736 : CPLErr eclass = CPLGetLastErrorType();
14737 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14738 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14739 : }
14740 : }
14741 : #endif
14742 : }
14743 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
14744 : {
14745 : /* %typemap(freearg) (const char *utf8_path) */
14746 : GDALPythonFreeCStr(arg2, bToFree2);
14747 : }
14748 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14749 : return resultobj;
14750 : fail:
14751 : {
14752 : /* %typemap(freearg) (const char *utf8_path) */
14753 : GDALPythonFreeCStr(arg2, bToFree2);
14754 : }
14755 : return NULL;
14756 : }
14757 :
14758 :
14759 361 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldRef(PyObject *self, PyObject *args) {
14760 361 : Py_ssize_t argc;
14761 361 : PyObject *argv[3] = {
14762 : 0
14763 : };
14764 :
14765 361 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetGeomFieldRef", 0, 2, argv))) SWIG_fail;
14766 361 : --argc;
14767 361 : if (argc == 2) {
14768 361 : int _v;
14769 361 : void *vptr = 0;
14770 361 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
14771 417 : _v = SWIG_CheckState(res);
14772 361 : if (_v) {
14773 361 : {
14774 361 : int res = SWIG_AsVal_int(argv[1], NULL);
14775 361 : _v = SWIG_CheckState(res);
14776 : }
14777 305 : if (_v) {
14778 305 : return _wrap_Feature_GetGeomFieldRef__SWIG_0(self, argc, argv);
14779 : }
14780 : }
14781 : }
14782 56 : if (argc == 2) {
14783 56 : int _v;
14784 56 : void *vptr = 0;
14785 56 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
14786 56 : _v = SWIG_CheckState(res);
14787 56 : if (_v) {
14788 56 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
14789 56 : _v = SWIG_CheckState(res);
14790 56 : if (_v) {
14791 56 : return _wrap_Feature_GetGeomFieldRef__SWIG_1(self, argc, argv);
14792 : }
14793 : }
14794 : }
14795 :
14796 0 : fail:
14797 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetGeomFieldRef'.\n"
14798 : " Possible C/C++ prototypes are:\n"
14799 : " OGRFeatureShadow::GetGeomFieldRef(int)\n"
14800 : " OGRFeatureShadow::GetGeomFieldRef(char const *)\n");
14801 : return 0;
14802 : }
14803 :
14804 :
14805 49 : SWIGINTERN PyObject *_wrap_Feature_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14806 49 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14807 49 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14808 49 : void *argp1 = 0 ;
14809 49 : int res1 = 0 ;
14810 49 : PyObject *swig_obj[1] ;
14811 49 : OGRFeatureShadow *result = 0 ;
14812 :
14813 49 : if (!args) SWIG_fail;
14814 49 : swig_obj[0] = args;
14815 49 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14816 49 : if (!SWIG_IsOK(res1)) {
14817 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_Clone" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14818 : }
14819 49 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14820 49 : {
14821 49 : const int bLocalUseExceptions = GetUseExceptions();
14822 49 : if ( bLocalUseExceptions ) {
14823 43 : pushErrorHandler();
14824 : }
14825 49 : {
14826 49 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14827 49 : result = (OGRFeatureShadow *)OGRFeatureShadow_Clone(arg1);
14828 49 : SWIG_PYTHON_THREAD_END_ALLOW;
14829 : }
14830 49 : if ( bLocalUseExceptions ) {
14831 43 : popErrorHandler();
14832 : }
14833 : #ifndef SED_HACKS
14834 : if ( bLocalUseExceptions ) {
14835 : CPLErr eclass = CPLGetLastErrorType();
14836 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14837 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14838 : }
14839 : }
14840 : #endif
14841 : }
14842 49 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_OWN | 0 );
14843 49 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14844 : return resultobj;
14845 : fail:
14846 : return NULL;
14847 : }
14848 :
14849 :
14850 109 : SWIGINTERN PyObject *_wrap_Feature_Equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14851 109 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14852 109 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14853 109 : OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
14854 109 : void *argp1 = 0 ;
14855 109 : int res1 = 0 ;
14856 109 : void *argp2 = 0 ;
14857 109 : int res2 = 0 ;
14858 109 : PyObject *swig_obj[2] ;
14859 109 : bool result;
14860 :
14861 109 : if (!SWIG_Python_UnpackTuple(args, "Feature_Equal", 2, 2, swig_obj)) SWIG_fail;
14862 109 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14863 109 : if (!SWIG_IsOK(res1)) {
14864 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_Equal" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14865 : }
14866 109 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14867 109 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14868 109 : if (!SWIG_IsOK(res2)) {
14869 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_Equal" "', argument " "2"" of type '" "OGRFeatureShadow *""'");
14870 : }
14871 109 : arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
14872 109 : {
14873 109 : if (!arg2) {
14874 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
14875 : }
14876 : }
14877 109 : {
14878 109 : const int bLocalUseExceptions = GetUseExceptions();
14879 109 : if ( bLocalUseExceptions ) {
14880 97 : pushErrorHandler();
14881 : }
14882 109 : {
14883 109 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14884 109 : result = (bool)OGRFeatureShadow_Equal(arg1,arg2);
14885 109 : SWIG_PYTHON_THREAD_END_ALLOW;
14886 : }
14887 109 : if ( bLocalUseExceptions ) {
14888 97 : popErrorHandler();
14889 : }
14890 : #ifndef SED_HACKS
14891 : if ( bLocalUseExceptions ) {
14892 : CPLErr eclass = CPLGetLastErrorType();
14893 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14894 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14895 : }
14896 : }
14897 : #endif
14898 : }
14899 109 : resultobj = SWIG_From_bool(static_cast< bool >(result));
14900 109 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14901 : return resultobj;
14902 : fail:
14903 : return NULL;
14904 : }
14905 :
14906 :
14907 109884 : SWIGINTERN PyObject *_wrap_Feature_GetFieldCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14908 109884 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14909 109884 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14910 109884 : void *argp1 = 0 ;
14911 109884 : int res1 = 0 ;
14912 109884 : PyObject *swig_obj[1] ;
14913 109884 : int result;
14914 :
14915 109884 : if (!args) SWIG_fail;
14916 109884 : swig_obj[0] = args;
14917 109884 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14918 109884 : if (!SWIG_IsOK(res1)) {
14919 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldCount" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14920 : }
14921 109884 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14922 109884 : {
14923 109884 : const int bLocalUseExceptions = GetUseExceptions();
14924 109884 : if ( bLocalUseExceptions ) {
14925 90789 : pushErrorHandler();
14926 : }
14927 109884 : {
14928 109884 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14929 109884 : result = (int)OGRFeatureShadow_GetFieldCount(arg1);
14930 109884 : SWIG_PYTHON_THREAD_END_ALLOW;
14931 : }
14932 109884 : if ( bLocalUseExceptions ) {
14933 90789 : popErrorHandler();
14934 : }
14935 : #ifndef SED_HACKS
14936 : if ( bLocalUseExceptions ) {
14937 : CPLErr eclass = CPLGetLastErrorType();
14938 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14939 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14940 : }
14941 : }
14942 : #endif
14943 : }
14944 109884 : resultobj = SWIG_From_int(static_cast< int >(result));
14945 109884 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14946 : return resultobj;
14947 : fail:
14948 : return NULL;
14949 : }
14950 :
14951 :
14952 : SWIGINTERN PyObject *_wrap_Feature_GetFieldDefnRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14953 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14954 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14955 : int arg2 ;
14956 : void *argp1 = 0 ;
14957 : int res1 = 0 ;
14958 : int val2 ;
14959 : int ecode2 = 0 ;
14960 : OGRFieldDefnShadow *result = 0 ;
14961 :
14962 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14963 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14964 : if (!SWIG_IsOK(res1)) {
14965 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldDefnRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14966 : }
14967 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14968 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14969 : if (!SWIG_IsOK(ecode2)) {
14970 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldDefnRef" "', argument " "2"" of type '" "int""'");
14971 : }
14972 : arg2 = static_cast< int >(val2);
14973 : {
14974 : const int bLocalUseExceptions = GetUseExceptions();
14975 : if ( bLocalUseExceptions ) {
14976 : pushErrorHandler();
14977 : }
14978 : {
14979 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14980 : result = (OGRFieldDefnShadow *)OGRFeatureShadow_GetFieldDefnRef__SWIG_0(arg1,arg2);
14981 : SWIG_PYTHON_THREAD_END_ALLOW;
14982 : }
14983 : if ( bLocalUseExceptions ) {
14984 : popErrorHandler();
14985 : }
14986 : #ifndef SED_HACKS
14987 : if ( bLocalUseExceptions ) {
14988 : CPLErr eclass = CPLGetLastErrorType();
14989 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14990 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14991 : }
14992 : }
14993 : #endif
14994 : }
14995 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
14996 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14997 : return resultobj;
14998 : fail:
14999 : return NULL;
15000 : }
15001 :
15002 :
15003 : SWIGINTERN PyObject *_wrap_Feature_GetFieldDefnRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15004 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15005 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15006 : char *arg2 = (char *) 0 ;
15007 : void *argp1 = 0 ;
15008 : int res1 = 0 ;
15009 : int bToFree2 = 0 ;
15010 : OGRFieldDefnShadow *result = 0 ;
15011 :
15012 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15013 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15014 : if (!SWIG_IsOK(res1)) {
15015 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldDefnRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15016 : }
15017 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15018 : {
15019 : /* %typemap(in) (const char *utf8_path) */
15020 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
15021 : {
15022 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
15023 : }
15024 : else
15025 : {
15026 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
15027 :
15028 : }
15029 : if (arg2 == NULL)
15030 : {
15031 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15032 : SWIG_fail;
15033 : }
15034 : }
15035 : {
15036 : const int bLocalUseExceptions = GetUseExceptions();
15037 : if ( bLocalUseExceptions ) {
15038 : pushErrorHandler();
15039 : }
15040 : {
15041 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15042 : result = (OGRFieldDefnShadow *)OGRFeatureShadow_GetFieldDefnRef__SWIG_1(arg1,(char const *)arg2);
15043 : SWIG_PYTHON_THREAD_END_ALLOW;
15044 : }
15045 : if ( bLocalUseExceptions ) {
15046 : popErrorHandler();
15047 : }
15048 : #ifndef SED_HACKS
15049 : if ( bLocalUseExceptions ) {
15050 : CPLErr eclass = CPLGetLastErrorType();
15051 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15052 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15053 : }
15054 : }
15055 : #endif
15056 : }
15057 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
15058 : {
15059 : /* %typemap(freearg) (const char *utf8_path) */
15060 : GDALPythonFreeCStr(arg2, bToFree2);
15061 : }
15062 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15063 : return resultobj;
15064 : fail:
15065 : {
15066 : /* %typemap(freearg) (const char *utf8_path) */
15067 : GDALPythonFreeCStr(arg2, bToFree2);
15068 : }
15069 : return NULL;
15070 : }
15071 :
15072 :
15073 87217 : SWIGINTERN PyObject *_wrap_Feature_GetFieldDefnRef(PyObject *self, PyObject *args) {
15074 87217 : Py_ssize_t argc;
15075 87217 : PyObject *argv[3] = {
15076 : 0
15077 : };
15078 :
15079 87217 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldDefnRef", 0, 2, argv))) SWIG_fail;
15080 87217 : --argc;
15081 87217 : if (argc == 2) {
15082 87217 : int _v;
15083 87217 : void *vptr = 0;
15084 87217 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15085 87231 : _v = SWIG_CheckState(res);
15086 87217 : if (_v) {
15087 87217 : {
15088 87217 : int res = SWIG_AsVal_int(argv[1], NULL);
15089 87217 : _v = SWIG_CheckState(res);
15090 : }
15091 87203 : if (_v) {
15092 87203 : return _wrap_Feature_GetFieldDefnRef__SWIG_0(self, argc, argv);
15093 : }
15094 : }
15095 : }
15096 14 : if (argc == 2) {
15097 14 : int _v;
15098 14 : void *vptr = 0;
15099 14 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15100 14 : _v = SWIG_CheckState(res);
15101 14 : if (_v) {
15102 14 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
15103 14 : _v = SWIG_CheckState(res);
15104 14 : if (_v) {
15105 14 : return _wrap_Feature_GetFieldDefnRef__SWIG_1(self, argc, argv);
15106 : }
15107 : }
15108 : }
15109 :
15110 0 : fail:
15111 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldDefnRef'.\n"
15112 : " Possible C/C++ prototypes are:\n"
15113 : " OGRFeatureShadow::GetFieldDefnRef(int)\n"
15114 : " OGRFeatureShadow::GetFieldDefnRef(char const *)\n");
15115 : return 0;
15116 : }
15117 :
15118 :
15119 121 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15120 121 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15121 121 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15122 121 : void *argp1 = 0 ;
15123 121 : int res1 = 0 ;
15124 121 : PyObject *swig_obj[1] ;
15125 121 : int result;
15126 :
15127 121 : if (!args) SWIG_fail;
15128 121 : swig_obj[0] = args;
15129 121 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15130 121 : if (!SWIG_IsOK(res1)) {
15131 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetGeomFieldCount" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15132 : }
15133 121 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15134 121 : {
15135 121 : const int bLocalUseExceptions = GetUseExceptions();
15136 121 : if ( bLocalUseExceptions ) {
15137 51 : pushErrorHandler();
15138 : }
15139 121 : {
15140 121 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15141 121 : result = (int)OGRFeatureShadow_GetGeomFieldCount(arg1);
15142 121 : SWIG_PYTHON_THREAD_END_ALLOW;
15143 : }
15144 121 : if ( bLocalUseExceptions ) {
15145 51 : popErrorHandler();
15146 : }
15147 : #ifndef SED_HACKS
15148 : if ( bLocalUseExceptions ) {
15149 : CPLErr eclass = CPLGetLastErrorType();
15150 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15151 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15152 : }
15153 : }
15154 : #endif
15155 : }
15156 121 : resultobj = SWIG_From_int(static_cast< int >(result));
15157 121 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15158 : return resultobj;
15159 : fail:
15160 : return NULL;
15161 : }
15162 :
15163 :
15164 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldDefnRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15165 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15166 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15167 : int arg2 ;
15168 : void *argp1 = 0 ;
15169 : int res1 = 0 ;
15170 : int val2 ;
15171 : int ecode2 = 0 ;
15172 : OGRGeomFieldDefnShadow *result = 0 ;
15173 :
15174 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15175 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15176 : if (!SWIG_IsOK(res1)) {
15177 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetGeomFieldDefnRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15178 : }
15179 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15180 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15181 : if (!SWIG_IsOK(ecode2)) {
15182 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetGeomFieldDefnRef" "', argument " "2"" of type '" "int""'");
15183 : }
15184 : arg2 = static_cast< int >(val2);
15185 : {
15186 : const int bLocalUseExceptions = GetUseExceptions();
15187 : if ( bLocalUseExceptions ) {
15188 : pushErrorHandler();
15189 : }
15190 : {
15191 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15192 : result = (OGRGeomFieldDefnShadow *)OGRFeatureShadow_GetGeomFieldDefnRef__SWIG_0(arg1,arg2);
15193 : SWIG_PYTHON_THREAD_END_ALLOW;
15194 : }
15195 : if ( bLocalUseExceptions ) {
15196 : popErrorHandler();
15197 : }
15198 : #ifndef SED_HACKS
15199 : if ( bLocalUseExceptions ) {
15200 : CPLErr eclass = CPLGetLastErrorType();
15201 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15202 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15203 : }
15204 : }
15205 : #endif
15206 : }
15207 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
15208 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15209 : return resultobj;
15210 : fail:
15211 : return NULL;
15212 : }
15213 :
15214 :
15215 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldDefnRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15216 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15217 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15218 : char *arg2 = (char *) 0 ;
15219 : void *argp1 = 0 ;
15220 : int res1 = 0 ;
15221 : int bToFree2 = 0 ;
15222 : OGRGeomFieldDefnShadow *result = 0 ;
15223 :
15224 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15225 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15226 : if (!SWIG_IsOK(res1)) {
15227 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetGeomFieldDefnRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15228 : }
15229 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15230 : {
15231 : /* %typemap(in) (const char *utf8_path) */
15232 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
15233 : {
15234 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
15235 : }
15236 : else
15237 : {
15238 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
15239 :
15240 : }
15241 : if (arg2 == NULL)
15242 : {
15243 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15244 : SWIG_fail;
15245 : }
15246 : }
15247 : {
15248 : const int bLocalUseExceptions = GetUseExceptions();
15249 : if ( bLocalUseExceptions ) {
15250 : pushErrorHandler();
15251 : }
15252 : {
15253 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15254 : result = (OGRGeomFieldDefnShadow *)OGRFeatureShadow_GetGeomFieldDefnRef__SWIG_1(arg1,(char const *)arg2);
15255 : SWIG_PYTHON_THREAD_END_ALLOW;
15256 : }
15257 : if ( bLocalUseExceptions ) {
15258 : popErrorHandler();
15259 : }
15260 : #ifndef SED_HACKS
15261 : if ( bLocalUseExceptions ) {
15262 : CPLErr eclass = CPLGetLastErrorType();
15263 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15264 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15265 : }
15266 : }
15267 : #endif
15268 : }
15269 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
15270 : {
15271 : /* %typemap(freearg) (const char *utf8_path) */
15272 : GDALPythonFreeCStr(arg2, bToFree2);
15273 : }
15274 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15275 : return resultobj;
15276 : fail:
15277 : {
15278 : /* %typemap(freearg) (const char *utf8_path) */
15279 : GDALPythonFreeCStr(arg2, bToFree2);
15280 : }
15281 : return NULL;
15282 : }
15283 :
15284 :
15285 2 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldDefnRef(PyObject *self, PyObject *args) {
15286 2 : Py_ssize_t argc;
15287 2 : PyObject *argv[3] = {
15288 : 0
15289 : };
15290 :
15291 2 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetGeomFieldDefnRef", 0, 2, argv))) SWIG_fail;
15292 2 : --argc;
15293 2 : if (argc == 2) {
15294 2 : int _v;
15295 2 : void *vptr = 0;
15296 2 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15297 2 : _v = SWIG_CheckState(res);
15298 2 : if (_v) {
15299 2 : {
15300 2 : int res = SWIG_AsVal_int(argv[1], NULL);
15301 2 : _v = SWIG_CheckState(res);
15302 : }
15303 2 : if (_v) {
15304 2 : return _wrap_Feature_GetGeomFieldDefnRef__SWIG_0(self, argc, argv);
15305 : }
15306 : }
15307 : }
15308 0 : if (argc == 2) {
15309 0 : int _v;
15310 0 : void *vptr = 0;
15311 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15312 0 : _v = SWIG_CheckState(res);
15313 0 : if (_v) {
15314 0 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
15315 0 : _v = SWIG_CheckState(res);
15316 0 : if (_v) {
15317 0 : return _wrap_Feature_GetGeomFieldDefnRef__SWIG_1(self, argc, argv);
15318 : }
15319 : }
15320 : }
15321 :
15322 0 : fail:
15323 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetGeomFieldDefnRef'.\n"
15324 : " Possible C/C++ prototypes are:\n"
15325 : " OGRFeatureShadow::GetGeomFieldDefnRef(int)\n"
15326 : " OGRFeatureShadow::GetGeomFieldDefnRef(char const *)\n");
15327 : return 0;
15328 : }
15329 :
15330 :
15331 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15332 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15333 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15334 : int arg2 ;
15335 : void *argp1 = 0 ;
15336 : int res1 = 0 ;
15337 : int val2 ;
15338 : int ecode2 = 0 ;
15339 : char *result = 0 ;
15340 :
15341 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15342 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15343 : if (!SWIG_IsOK(res1)) {
15344 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15345 : }
15346 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15347 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15348 : if (!SWIG_IsOK(ecode2)) {
15349 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsString" "', argument " "2"" of type '" "int""'");
15350 : }
15351 : arg2 = static_cast< int >(val2);
15352 : {
15353 : const int bLocalUseExceptions = GetUseExceptions();
15354 : if ( bLocalUseExceptions ) {
15355 : pushErrorHandler();
15356 : }
15357 : {
15358 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15359 : result = (char *)OGRFeatureShadow_GetFieldAsString__SWIG_0(arg1,arg2);
15360 : SWIG_PYTHON_THREAD_END_ALLOW;
15361 : }
15362 : if ( bLocalUseExceptions ) {
15363 : popErrorHandler();
15364 : }
15365 : #ifndef SED_HACKS
15366 : if ( bLocalUseExceptions ) {
15367 : CPLErr eclass = CPLGetLastErrorType();
15368 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15369 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15370 : }
15371 : }
15372 : #endif
15373 : }
15374 : resultobj = SWIG_FromCharPtr((const char *)result);
15375 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15376 : return resultobj;
15377 : fail:
15378 : return NULL;
15379 : }
15380 :
15381 :
15382 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15383 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15384 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15385 : char *arg2 = (char *) 0 ;
15386 : void *argp1 = 0 ;
15387 : int res1 = 0 ;
15388 : int bToFree2 = 0 ;
15389 : char *result = 0 ;
15390 :
15391 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15392 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15393 : if (!SWIG_IsOK(res1)) {
15394 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15395 : }
15396 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15397 : {
15398 : /* %typemap(in) (const char *utf8_path) */
15399 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
15400 : {
15401 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
15402 : }
15403 : else
15404 : {
15405 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
15406 :
15407 : }
15408 : if (arg2 == NULL)
15409 : {
15410 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15411 : SWIG_fail;
15412 : }
15413 : }
15414 : {
15415 : const int bLocalUseExceptions = GetUseExceptions();
15416 : if ( bLocalUseExceptions ) {
15417 : pushErrorHandler();
15418 : }
15419 : {
15420 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15421 : result = (char *)OGRFeatureShadow_GetFieldAsString__SWIG_1(arg1,(char const *)arg2);
15422 : SWIG_PYTHON_THREAD_END_ALLOW;
15423 : }
15424 : if ( bLocalUseExceptions ) {
15425 : popErrorHandler();
15426 : }
15427 : #ifndef SED_HACKS
15428 : if ( bLocalUseExceptions ) {
15429 : CPLErr eclass = CPLGetLastErrorType();
15430 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15431 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15432 : }
15433 : }
15434 : #endif
15435 : }
15436 : resultobj = SWIG_FromCharPtr((const char *)result);
15437 : {
15438 : /* %typemap(freearg) (const char *utf8_path) */
15439 : GDALPythonFreeCStr(arg2, bToFree2);
15440 : }
15441 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15442 : return resultobj;
15443 : fail:
15444 : {
15445 : /* %typemap(freearg) (const char *utf8_path) */
15446 : GDALPythonFreeCStr(arg2, bToFree2);
15447 : }
15448 : return NULL;
15449 : }
15450 :
15451 :
15452 10688 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsString(PyObject *self, PyObject *args) {
15453 10688 : Py_ssize_t argc;
15454 10688 : PyObject *argv[3] = {
15455 : 0
15456 : };
15457 :
15458 10688 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsString", 0, 2, argv))) SWIG_fail;
15459 10688 : --argc;
15460 10688 : if (argc == 2) {
15461 10688 : int _v;
15462 10688 : void *vptr = 0;
15463 10688 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15464 11533 : _v = SWIG_CheckState(res);
15465 10688 : if (_v) {
15466 10688 : {
15467 10688 : int res = SWIG_AsVal_int(argv[1], NULL);
15468 10688 : _v = SWIG_CheckState(res);
15469 : }
15470 9843 : if (_v) {
15471 9843 : return _wrap_Feature_GetFieldAsString__SWIG_0(self, argc, argv);
15472 : }
15473 : }
15474 : }
15475 845 : if (argc == 2) {
15476 845 : int _v;
15477 845 : void *vptr = 0;
15478 845 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15479 845 : _v = SWIG_CheckState(res);
15480 845 : if (_v) {
15481 845 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
15482 845 : _v = SWIG_CheckState(res);
15483 845 : if (_v) {
15484 845 : return _wrap_Feature_GetFieldAsString__SWIG_1(self, argc, argv);
15485 : }
15486 : }
15487 : }
15488 :
15489 0 : fail:
15490 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsString'.\n"
15491 : " Possible C/C++ prototypes are:\n"
15492 : " OGRFeatureShadow::GetFieldAsString(int)\n"
15493 : " OGRFeatureShadow::GetFieldAsString(char const *)\n");
15494 : return 0;
15495 : }
15496 :
15497 :
15498 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsISO8601DateTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15499 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15500 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15501 : int arg2 ;
15502 : char **arg3 = (char **) 0 ;
15503 : void *argp1 = 0 ;
15504 : int res1 = 0 ;
15505 : int val2 ;
15506 : int ecode2 = 0 ;
15507 : char *result = 0 ;
15508 :
15509 : if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
15510 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15511 : if (!SWIG_IsOK(res1)) {
15512 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsISO8601DateTime" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15513 : }
15514 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15515 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15516 : if (!SWIG_IsOK(ecode2)) {
15517 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsISO8601DateTime" "', argument " "2"" of type '" "int""'");
15518 : }
15519 : arg2 = static_cast< int >(val2);
15520 : if (swig_obj[2]) {
15521 : {
15522 : /* %typemap(in) char **dict */
15523 : arg3 = NULL;
15524 : if ( PySequence_Check( swig_obj[2] ) ) {
15525 : int bErr = FALSE;
15526 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
15527 : if ( bErr )
15528 : {
15529 : SWIG_fail;
15530 : }
15531 : }
15532 : else if ( PyMapping_Check( swig_obj[2] ) ) {
15533 : int bErr = FALSE;
15534 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
15535 : if ( bErr )
15536 : {
15537 : SWIG_fail;
15538 : }
15539 : }
15540 : else {
15541 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
15542 : SWIG_fail;
15543 : }
15544 : }
15545 : }
15546 : {
15547 : const int bLocalUseExceptions = GetUseExceptions();
15548 : if ( bLocalUseExceptions ) {
15549 : pushErrorHandler();
15550 : }
15551 : {
15552 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15553 : result = (char *)OGRFeatureShadow_GetFieldAsISO8601DateTime__SWIG_0(arg1,arg2,arg3);
15554 : SWIG_PYTHON_THREAD_END_ALLOW;
15555 : }
15556 : if ( bLocalUseExceptions ) {
15557 : popErrorHandler();
15558 : }
15559 : #ifndef SED_HACKS
15560 : if ( bLocalUseExceptions ) {
15561 : CPLErr eclass = CPLGetLastErrorType();
15562 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15563 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15564 : }
15565 : }
15566 : #endif
15567 : }
15568 : resultobj = SWIG_FromCharPtr((const char *)result);
15569 : {
15570 : /* %typemap(freearg) char **dict */
15571 : CSLDestroy( arg3 );
15572 : }
15573 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15574 : return resultobj;
15575 : fail:
15576 : {
15577 : /* %typemap(freearg) char **dict */
15578 : CSLDestroy( arg3 );
15579 : }
15580 : return NULL;
15581 : }
15582 :
15583 :
15584 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsISO8601DateTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15585 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15586 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15587 : char *arg2 = (char *) 0 ;
15588 : char **arg3 = (char **) 0 ;
15589 : void *argp1 = 0 ;
15590 : int res1 = 0 ;
15591 : int bToFree2 = 0 ;
15592 : char *result = 0 ;
15593 :
15594 : if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
15595 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15596 : if (!SWIG_IsOK(res1)) {
15597 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsISO8601DateTime" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15598 : }
15599 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15600 : {
15601 : /* %typemap(in) (const char *utf8_path) */
15602 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
15603 : {
15604 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
15605 : }
15606 : else
15607 : {
15608 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
15609 :
15610 : }
15611 : if (arg2 == NULL)
15612 : {
15613 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15614 : SWIG_fail;
15615 : }
15616 : }
15617 : if (swig_obj[2]) {
15618 : {
15619 : /* %typemap(in) char **dict */
15620 : arg3 = NULL;
15621 : if ( PySequence_Check( swig_obj[2] ) ) {
15622 : int bErr = FALSE;
15623 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
15624 : if ( bErr )
15625 : {
15626 : SWIG_fail;
15627 : }
15628 : }
15629 : else if ( PyMapping_Check( swig_obj[2] ) ) {
15630 : int bErr = FALSE;
15631 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
15632 : if ( bErr )
15633 : {
15634 : SWIG_fail;
15635 : }
15636 : }
15637 : else {
15638 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
15639 : SWIG_fail;
15640 : }
15641 : }
15642 : }
15643 : {
15644 : const int bLocalUseExceptions = GetUseExceptions();
15645 : if ( bLocalUseExceptions ) {
15646 : pushErrorHandler();
15647 : }
15648 : {
15649 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15650 : result = (char *)OGRFeatureShadow_GetFieldAsISO8601DateTime__SWIG_1(arg1,(char const *)arg2,arg3);
15651 : SWIG_PYTHON_THREAD_END_ALLOW;
15652 : }
15653 : if ( bLocalUseExceptions ) {
15654 : popErrorHandler();
15655 : }
15656 : #ifndef SED_HACKS
15657 : if ( bLocalUseExceptions ) {
15658 : CPLErr eclass = CPLGetLastErrorType();
15659 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15660 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15661 : }
15662 : }
15663 : #endif
15664 : }
15665 : resultobj = SWIG_FromCharPtr((const char *)result);
15666 : {
15667 : /* %typemap(freearg) (const char *utf8_path) */
15668 : GDALPythonFreeCStr(arg2, bToFree2);
15669 : }
15670 : {
15671 : /* %typemap(freearg) char **dict */
15672 : CSLDestroy( arg3 );
15673 : }
15674 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15675 : return resultobj;
15676 : fail:
15677 : {
15678 : /* %typemap(freearg) (const char *utf8_path) */
15679 : GDALPythonFreeCStr(arg2, bToFree2);
15680 : }
15681 : {
15682 : /* %typemap(freearg) char **dict */
15683 : CSLDestroy( arg3 );
15684 : }
15685 : return NULL;
15686 : }
15687 :
15688 :
15689 8 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsISO8601DateTime(PyObject *self, PyObject *args) {
15690 8 : Py_ssize_t argc;
15691 8 : PyObject *argv[4] = {
15692 : 0
15693 : };
15694 :
15695 8 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsISO8601DateTime", 0, 3, argv))) SWIG_fail;
15696 8 : --argc;
15697 8 : if ((argc >= 2) && (argc <= 3)) {
15698 8 : int _v;
15699 8 : void *vptr = 0;
15700 8 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15701 14 : _v = SWIG_CheckState(res);
15702 8 : if (_v) {
15703 8 : {
15704 8 : int res = SWIG_AsVal_int(argv[1], NULL);
15705 8 : _v = SWIG_CheckState(res);
15706 : }
15707 2 : if (_v) {
15708 2 : if (argc <= 2) {
15709 2 : return _wrap_Feature_GetFieldAsISO8601DateTime__SWIG_0(self, argc, argv);
15710 : }
15711 0 : {
15712 : /* %typecheck(SWIG_TYPECHECK_POINTER) (char **dict) */
15713 : /* Note: we exclude explicitly strings, because they can be considered as a sequence of characters, */
15714 : /* which is not desirable since it makes it impossible to define bindings such as SetMetadata(string) and SetMetadata(array_of_string) */
15715 : /* (see #4816) */
15716 0 : _v = ((PyMapping_Check(argv[2]) || PySequence_Check(argv[2]) ) && !SWIG_CheckState(SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0)) ) ? 1 : 0;
15717 : }
15718 0 : if (_v) {
15719 0 : return _wrap_Feature_GetFieldAsISO8601DateTime__SWIG_0(self, argc, argv);
15720 : }
15721 : }
15722 : }
15723 : }
15724 6 : if ((argc >= 2) && (argc <= 3)) {
15725 6 : int _v;
15726 6 : void *vptr = 0;
15727 6 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15728 6 : _v = SWIG_CheckState(res);
15729 6 : if (_v) {
15730 6 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
15731 6 : _v = SWIG_CheckState(res);
15732 6 : if (_v) {
15733 6 : if (argc <= 2) {
15734 6 : return _wrap_Feature_GetFieldAsISO8601DateTime__SWIG_1(self, argc, argv);
15735 : }
15736 0 : {
15737 : /* %typecheck(SWIG_TYPECHECK_POINTER) (char **dict) */
15738 : /* Note: we exclude explicitly strings, because they can be considered as a sequence of characters, */
15739 : /* which is not desirable since it makes it impossible to define bindings such as SetMetadata(string) and SetMetadata(array_of_string) */
15740 : /* (see #4816) */
15741 0 : _v = ((PyMapping_Check(argv[2]) || PySequence_Check(argv[2]) ) && !SWIG_CheckState(SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0)) ) ? 1 : 0;
15742 : }
15743 0 : if (_v) {
15744 0 : return _wrap_Feature_GetFieldAsISO8601DateTime__SWIG_1(self, argc, argv);
15745 : }
15746 : }
15747 : }
15748 : }
15749 :
15750 0 : fail:
15751 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsISO8601DateTime'.\n"
15752 : " Possible C/C++ prototypes are:\n"
15753 : " OGRFeatureShadow::GetFieldAsISO8601DateTime(int,char **)\n"
15754 : " OGRFeatureShadow::GetFieldAsISO8601DateTime(char const *,char **)\n");
15755 : return 0;
15756 : }
15757 :
15758 :
15759 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsInteger__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15760 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15761 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15762 : int arg2 ;
15763 : void *argp1 = 0 ;
15764 : int res1 = 0 ;
15765 : int val2 ;
15766 : int ecode2 = 0 ;
15767 : int result;
15768 :
15769 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15770 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15771 : if (!SWIG_IsOK(res1)) {
15772 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsInteger" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15773 : }
15774 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15775 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15776 : if (!SWIG_IsOK(ecode2)) {
15777 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsInteger" "', argument " "2"" of type '" "int""'");
15778 : }
15779 : arg2 = static_cast< int >(val2);
15780 : {
15781 : const int bLocalUseExceptions = GetUseExceptions();
15782 : if ( bLocalUseExceptions ) {
15783 : pushErrorHandler();
15784 : }
15785 : {
15786 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15787 : result = (int)OGRFeatureShadow_GetFieldAsInteger__SWIG_0(arg1,arg2);
15788 : SWIG_PYTHON_THREAD_END_ALLOW;
15789 : }
15790 : if ( bLocalUseExceptions ) {
15791 : popErrorHandler();
15792 : }
15793 : #ifndef SED_HACKS
15794 : if ( bLocalUseExceptions ) {
15795 : CPLErr eclass = CPLGetLastErrorType();
15796 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15797 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15798 : }
15799 : }
15800 : #endif
15801 : }
15802 : resultobj = SWIG_From_int(static_cast< int >(result));
15803 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15804 : return resultobj;
15805 : fail:
15806 : return NULL;
15807 : }
15808 :
15809 :
15810 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsInteger__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15811 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15812 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15813 : char *arg2 = (char *) 0 ;
15814 : void *argp1 = 0 ;
15815 : int res1 = 0 ;
15816 : int bToFree2 = 0 ;
15817 : int result;
15818 :
15819 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15820 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15821 : if (!SWIG_IsOK(res1)) {
15822 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsInteger" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15823 : }
15824 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15825 : {
15826 : /* %typemap(in) (const char *utf8_path) */
15827 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
15828 : {
15829 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
15830 : }
15831 : else
15832 : {
15833 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
15834 :
15835 : }
15836 : if (arg2 == NULL)
15837 : {
15838 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15839 : SWIG_fail;
15840 : }
15841 : }
15842 : {
15843 : const int bLocalUseExceptions = GetUseExceptions();
15844 : if ( bLocalUseExceptions ) {
15845 : pushErrorHandler();
15846 : }
15847 : {
15848 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15849 : result = (int)OGRFeatureShadow_GetFieldAsInteger__SWIG_1(arg1,(char const *)arg2);
15850 : SWIG_PYTHON_THREAD_END_ALLOW;
15851 : }
15852 : if ( bLocalUseExceptions ) {
15853 : popErrorHandler();
15854 : }
15855 : #ifndef SED_HACKS
15856 : if ( bLocalUseExceptions ) {
15857 : CPLErr eclass = CPLGetLastErrorType();
15858 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15859 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15860 : }
15861 : }
15862 : #endif
15863 : }
15864 : resultobj = SWIG_From_int(static_cast< int >(result));
15865 : {
15866 : /* %typemap(freearg) (const char *utf8_path) */
15867 : GDALPythonFreeCStr(arg2, bToFree2);
15868 : }
15869 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15870 : return resultobj;
15871 : fail:
15872 : {
15873 : /* %typemap(freearg) (const char *utf8_path) */
15874 : GDALPythonFreeCStr(arg2, bToFree2);
15875 : }
15876 : return NULL;
15877 : }
15878 :
15879 :
15880 87784 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsInteger(PyObject *self, PyObject *args) {
15881 87784 : Py_ssize_t argc;
15882 87784 : PyObject *argv[3] = {
15883 : 0
15884 : };
15885 :
15886 87784 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsInteger", 0, 2, argv))) SWIG_fail;
15887 87784 : --argc;
15888 87784 : if (argc == 2) {
15889 87784 : int _v;
15890 87784 : void *vptr = 0;
15891 87784 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15892 88001 : _v = SWIG_CheckState(res);
15893 87784 : if (_v) {
15894 87784 : {
15895 87784 : int res = SWIG_AsVal_int(argv[1], NULL);
15896 87784 : _v = SWIG_CheckState(res);
15897 : }
15898 87567 : if (_v) {
15899 87567 : return _wrap_Feature_GetFieldAsInteger__SWIG_0(self, argc, argv);
15900 : }
15901 : }
15902 : }
15903 217 : if (argc == 2) {
15904 217 : int _v;
15905 217 : void *vptr = 0;
15906 217 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15907 217 : _v = SWIG_CheckState(res);
15908 217 : if (_v) {
15909 217 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
15910 217 : _v = SWIG_CheckState(res);
15911 217 : if (_v) {
15912 217 : return _wrap_Feature_GetFieldAsInteger__SWIG_1(self, argc, argv);
15913 : }
15914 : }
15915 : }
15916 :
15917 0 : fail:
15918 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsInteger'.\n"
15919 : " Possible C/C++ prototypes are:\n"
15920 : " OGRFeatureShadow::GetFieldAsInteger(int)\n"
15921 : " OGRFeatureShadow::GetFieldAsInteger(char const *)\n");
15922 : return 0;
15923 : }
15924 :
15925 :
15926 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsInteger64__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15927 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15928 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15929 : int arg2 ;
15930 : void *argp1 = 0 ;
15931 : int res1 = 0 ;
15932 : int val2 ;
15933 : int ecode2 = 0 ;
15934 : GIntBig result;
15935 :
15936 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15937 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15938 : if (!SWIG_IsOK(res1)) {
15939 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsInteger64" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15940 : }
15941 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15942 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15943 : if (!SWIG_IsOK(ecode2)) {
15944 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsInteger64" "', argument " "2"" of type '" "int""'");
15945 : }
15946 : arg2 = static_cast< int >(val2);
15947 : {
15948 : const int bLocalUseExceptions = GetUseExceptions();
15949 : if ( bLocalUseExceptions ) {
15950 : pushErrorHandler();
15951 : }
15952 : {
15953 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15954 : result = OGRFeatureShadow_GetFieldAsInteger64__SWIG_0(arg1,arg2);
15955 : SWIG_PYTHON_THREAD_END_ALLOW;
15956 : }
15957 : if ( bLocalUseExceptions ) {
15958 : popErrorHandler();
15959 : }
15960 : #ifndef SED_HACKS
15961 : if ( bLocalUseExceptions ) {
15962 : CPLErr eclass = CPLGetLastErrorType();
15963 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15964 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15965 : }
15966 : }
15967 : #endif
15968 : }
15969 : {
15970 : resultobj = PyLong_FromLongLong(result);
15971 : }
15972 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15973 : return resultobj;
15974 : fail:
15975 : return NULL;
15976 : }
15977 :
15978 :
15979 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsInteger64__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15980 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15981 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15982 : char *arg2 = (char *) 0 ;
15983 : void *argp1 = 0 ;
15984 : int res1 = 0 ;
15985 : int bToFree2 = 0 ;
15986 : GIntBig result;
15987 :
15988 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15989 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15990 : if (!SWIG_IsOK(res1)) {
15991 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsInteger64" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15992 : }
15993 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15994 : {
15995 : /* %typemap(in) (const char *utf8_path) */
15996 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
15997 : {
15998 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
15999 : }
16000 : else
16001 : {
16002 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
16003 :
16004 : }
16005 : if (arg2 == NULL)
16006 : {
16007 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
16008 : SWIG_fail;
16009 : }
16010 : }
16011 : {
16012 : const int bLocalUseExceptions = GetUseExceptions();
16013 : if ( bLocalUseExceptions ) {
16014 : pushErrorHandler();
16015 : }
16016 : {
16017 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16018 : result = OGRFeatureShadow_GetFieldAsInteger64__SWIG_1(arg1,(char const *)arg2);
16019 : SWIG_PYTHON_THREAD_END_ALLOW;
16020 : }
16021 : if ( bLocalUseExceptions ) {
16022 : popErrorHandler();
16023 : }
16024 : #ifndef SED_HACKS
16025 : if ( bLocalUseExceptions ) {
16026 : CPLErr eclass = CPLGetLastErrorType();
16027 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16028 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16029 : }
16030 : }
16031 : #endif
16032 : }
16033 : {
16034 : resultobj = PyLong_FromLongLong(result);
16035 : }
16036 : {
16037 : /* %typemap(freearg) (const char *utf8_path) */
16038 : GDALPythonFreeCStr(arg2, bToFree2);
16039 : }
16040 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16041 : return resultobj;
16042 : fail:
16043 : {
16044 : /* %typemap(freearg) (const char *utf8_path) */
16045 : GDALPythonFreeCStr(arg2, bToFree2);
16046 : }
16047 : return NULL;
16048 : }
16049 :
16050 :
16051 1433 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsInteger64(PyObject *self, PyObject *args) {
16052 1433 : Py_ssize_t argc;
16053 1433 : PyObject *argv[3] = {
16054 : 0
16055 : };
16056 :
16057 1433 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsInteger64", 0, 2, argv))) SWIG_fail;
16058 1433 : --argc;
16059 1433 : if (argc == 2) {
16060 1433 : int _v;
16061 1433 : void *vptr = 0;
16062 1433 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16063 1433 : _v = SWIG_CheckState(res);
16064 1433 : if (_v) {
16065 1433 : {
16066 1433 : int res = SWIG_AsVal_int(argv[1], NULL);
16067 1433 : _v = SWIG_CheckState(res);
16068 : }
16069 1433 : if (_v) {
16070 1433 : return _wrap_Feature_GetFieldAsInteger64__SWIG_0(self, argc, argv);
16071 : }
16072 : }
16073 : }
16074 0 : if (argc == 2) {
16075 0 : int _v;
16076 0 : void *vptr = 0;
16077 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16078 0 : _v = SWIG_CheckState(res);
16079 0 : if (_v) {
16080 0 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16081 0 : _v = SWIG_CheckState(res);
16082 0 : if (_v) {
16083 0 : return _wrap_Feature_GetFieldAsInteger64__SWIG_1(self, argc, argv);
16084 : }
16085 : }
16086 : }
16087 :
16088 0 : fail:
16089 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsInteger64'.\n"
16090 : " Possible C/C++ prototypes are:\n"
16091 : " OGRFeatureShadow::GetFieldAsInteger64(int)\n"
16092 : " OGRFeatureShadow::GetFieldAsInteger64(char const *)\n");
16093 : return 0;
16094 : }
16095 :
16096 :
16097 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDouble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16098 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16099 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16100 : int arg2 ;
16101 : void *argp1 = 0 ;
16102 : int res1 = 0 ;
16103 : int val2 ;
16104 : int ecode2 = 0 ;
16105 : double result;
16106 :
16107 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16108 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16109 : if (!SWIG_IsOK(res1)) {
16110 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsDouble" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16111 : }
16112 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16113 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
16114 : if (!SWIG_IsOK(ecode2)) {
16115 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsDouble" "', argument " "2"" of type '" "int""'");
16116 : }
16117 : arg2 = static_cast< int >(val2);
16118 : {
16119 : const int bLocalUseExceptions = GetUseExceptions();
16120 : if ( bLocalUseExceptions ) {
16121 : pushErrorHandler();
16122 : }
16123 : {
16124 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16125 : result = (double)OGRFeatureShadow_GetFieldAsDouble__SWIG_0(arg1,arg2);
16126 : SWIG_PYTHON_THREAD_END_ALLOW;
16127 : }
16128 : if ( bLocalUseExceptions ) {
16129 : popErrorHandler();
16130 : }
16131 : #ifndef SED_HACKS
16132 : if ( bLocalUseExceptions ) {
16133 : CPLErr eclass = CPLGetLastErrorType();
16134 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16135 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16136 : }
16137 : }
16138 : #endif
16139 : }
16140 : resultobj = SWIG_From_double(static_cast< double >(result));
16141 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16142 : return resultobj;
16143 : fail:
16144 : return NULL;
16145 : }
16146 :
16147 :
16148 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDouble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16149 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16150 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16151 : char *arg2 = (char *) 0 ;
16152 : void *argp1 = 0 ;
16153 : int res1 = 0 ;
16154 : int bToFree2 = 0 ;
16155 : double result;
16156 :
16157 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16158 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16159 : if (!SWIG_IsOK(res1)) {
16160 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsDouble" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16161 : }
16162 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16163 : {
16164 : /* %typemap(in) (const char *utf8_path) */
16165 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
16166 : {
16167 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
16168 : }
16169 : else
16170 : {
16171 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
16172 :
16173 : }
16174 : if (arg2 == NULL)
16175 : {
16176 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
16177 : SWIG_fail;
16178 : }
16179 : }
16180 : {
16181 : const int bLocalUseExceptions = GetUseExceptions();
16182 : if ( bLocalUseExceptions ) {
16183 : pushErrorHandler();
16184 : }
16185 : {
16186 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16187 : result = (double)OGRFeatureShadow_GetFieldAsDouble__SWIG_1(arg1,(char const *)arg2);
16188 : SWIG_PYTHON_THREAD_END_ALLOW;
16189 : }
16190 : if ( bLocalUseExceptions ) {
16191 : popErrorHandler();
16192 : }
16193 : #ifndef SED_HACKS
16194 : if ( bLocalUseExceptions ) {
16195 : CPLErr eclass = CPLGetLastErrorType();
16196 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16197 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16198 : }
16199 : }
16200 : #endif
16201 : }
16202 : resultobj = SWIG_From_double(static_cast< double >(result));
16203 : {
16204 : /* %typemap(freearg) (const char *utf8_path) */
16205 : GDALPythonFreeCStr(arg2, bToFree2);
16206 : }
16207 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16208 : return resultobj;
16209 : fail:
16210 : {
16211 : /* %typemap(freearg) (const char *utf8_path) */
16212 : GDALPythonFreeCStr(arg2, bToFree2);
16213 : }
16214 : return NULL;
16215 : }
16216 :
16217 :
16218 1964 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDouble(PyObject *self, PyObject *args) {
16219 1964 : Py_ssize_t argc;
16220 1964 : PyObject *argv[3] = {
16221 : 0
16222 : };
16223 :
16224 1964 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsDouble", 0, 2, argv))) SWIG_fail;
16225 1964 : --argc;
16226 1964 : if (argc == 2) {
16227 1964 : int _v;
16228 1964 : void *vptr = 0;
16229 1964 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16230 2016 : _v = SWIG_CheckState(res);
16231 1964 : if (_v) {
16232 1964 : {
16233 1964 : int res = SWIG_AsVal_int(argv[1], NULL);
16234 1964 : _v = SWIG_CheckState(res);
16235 : }
16236 1912 : if (_v) {
16237 1912 : return _wrap_Feature_GetFieldAsDouble__SWIG_0(self, argc, argv);
16238 : }
16239 : }
16240 : }
16241 52 : if (argc == 2) {
16242 52 : int _v;
16243 52 : void *vptr = 0;
16244 52 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16245 52 : _v = SWIG_CheckState(res);
16246 52 : if (_v) {
16247 52 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16248 52 : _v = SWIG_CheckState(res);
16249 52 : if (_v) {
16250 52 : return _wrap_Feature_GetFieldAsDouble__SWIG_1(self, argc, argv);
16251 : }
16252 : }
16253 : }
16254 :
16255 0 : fail:
16256 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsDouble'.\n"
16257 : " Possible C/C++ prototypes are:\n"
16258 : " OGRFeatureShadow::GetFieldAsDouble(int)\n"
16259 : " OGRFeatureShadow::GetFieldAsDouble(char const *)\n");
16260 : return 0;
16261 : }
16262 :
16263 :
16264 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDateTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16265 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16266 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16267 : int arg2 ;
16268 : int *arg3 = (int *) 0 ;
16269 : int *arg4 = (int *) 0 ;
16270 : int *arg5 = (int *) 0 ;
16271 : int *arg6 = (int *) 0 ;
16272 : int *arg7 = (int *) 0 ;
16273 : float *arg8 = (float *) 0 ;
16274 : int *arg9 = (int *) 0 ;
16275 : void *argp1 = 0 ;
16276 : int res1 = 0 ;
16277 : int val2 ;
16278 : int ecode2 = 0 ;
16279 : int temp3 ;
16280 : int res3 = SWIG_TMPOBJ ;
16281 : int temp4 ;
16282 : int res4 = SWIG_TMPOBJ ;
16283 : int temp5 ;
16284 : int res5 = SWIG_TMPOBJ ;
16285 : int temp6 ;
16286 : int res6 = SWIG_TMPOBJ ;
16287 : int temp7 ;
16288 : int res7 = SWIG_TMPOBJ ;
16289 : float temp8 ;
16290 : int res8 = SWIG_TMPOBJ ;
16291 : int temp9 ;
16292 : int res9 = SWIG_TMPOBJ ;
16293 :
16294 : arg3 = &temp3;
16295 : arg4 = &temp4;
16296 : arg5 = &temp5;
16297 : arg6 = &temp6;
16298 : arg7 = &temp7;
16299 : arg8 = &temp8;
16300 : arg9 = &temp9;
16301 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16302 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16303 : if (!SWIG_IsOK(res1)) {
16304 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsDateTime" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16305 : }
16306 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16307 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
16308 : if (!SWIG_IsOK(ecode2)) {
16309 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsDateTime" "', argument " "2"" of type '" "int""'");
16310 : }
16311 : arg2 = static_cast< int >(val2);
16312 : {
16313 : const int bLocalUseExceptions = GetUseExceptions();
16314 : if ( bLocalUseExceptions ) {
16315 : pushErrorHandler();
16316 : }
16317 : {
16318 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16319 : OGRFeatureShadow_GetFieldAsDateTime__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
16320 : SWIG_PYTHON_THREAD_END_ALLOW;
16321 : }
16322 : if ( bLocalUseExceptions ) {
16323 : popErrorHandler();
16324 : }
16325 : #ifndef SED_HACKS
16326 : if ( bLocalUseExceptions ) {
16327 : CPLErr eclass = CPLGetLastErrorType();
16328 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16329 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16330 : }
16331 : }
16332 : #endif
16333 : }
16334 : resultobj = SWIG_Py_Void();
16335 : if (ReturnSame(SWIG_IsTmpObj(res3))) {
16336 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
16337 : } else {
16338 : int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16339 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16340 : }
16341 : if (ReturnSame(SWIG_IsTmpObj(res4))) {
16342 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
16343 : } else {
16344 : int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16345 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
16346 : }
16347 : if (ReturnSame(SWIG_IsTmpObj(res5))) {
16348 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
16349 : } else {
16350 : int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16351 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
16352 : }
16353 : if (ReturnSame(SWIG_IsTmpObj(res6))) {
16354 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
16355 : } else {
16356 : int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16357 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
16358 : }
16359 : if (ReturnSame(SWIG_IsTmpObj(res7))) {
16360 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg7)));
16361 : } else {
16362 : int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16363 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
16364 : }
16365 : if (ReturnSame(SWIG_IsTmpObj(res8))) {
16366 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg8)));
16367 : } else {
16368 : int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16369 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_float, new_flags));
16370 : }
16371 : if (ReturnSame(SWIG_IsTmpObj(res9))) {
16372 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg9)));
16373 : } else {
16374 : int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16375 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_int, new_flags));
16376 : }
16377 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16378 : return resultobj;
16379 : fail:
16380 : return NULL;
16381 : }
16382 :
16383 :
16384 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDateTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16385 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16386 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16387 : char *arg2 = (char *) 0 ;
16388 : int *arg3 = (int *) 0 ;
16389 : int *arg4 = (int *) 0 ;
16390 : int *arg5 = (int *) 0 ;
16391 : int *arg6 = (int *) 0 ;
16392 : int *arg7 = (int *) 0 ;
16393 : float *arg8 = (float *) 0 ;
16394 : int *arg9 = (int *) 0 ;
16395 : void *argp1 = 0 ;
16396 : int res1 = 0 ;
16397 : int bToFree2 = 0 ;
16398 : int temp3 ;
16399 : int res3 = SWIG_TMPOBJ ;
16400 : int temp4 ;
16401 : int res4 = SWIG_TMPOBJ ;
16402 : int temp5 ;
16403 : int res5 = SWIG_TMPOBJ ;
16404 : int temp6 ;
16405 : int res6 = SWIG_TMPOBJ ;
16406 : int temp7 ;
16407 : int res7 = SWIG_TMPOBJ ;
16408 : float temp8 ;
16409 : int res8 = SWIG_TMPOBJ ;
16410 : int temp9 ;
16411 : int res9 = SWIG_TMPOBJ ;
16412 :
16413 : arg3 = &temp3;
16414 : arg4 = &temp4;
16415 : arg5 = &temp5;
16416 : arg6 = &temp6;
16417 : arg7 = &temp7;
16418 : arg8 = &temp8;
16419 : arg9 = &temp9;
16420 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16421 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16422 : if (!SWIG_IsOK(res1)) {
16423 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsDateTime" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16424 : }
16425 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16426 : {
16427 : /* %typemap(in) (const char *utf8_path) */
16428 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
16429 : {
16430 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
16431 : }
16432 : else
16433 : {
16434 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
16435 :
16436 : }
16437 : if (arg2 == NULL)
16438 : {
16439 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
16440 : SWIG_fail;
16441 : }
16442 : }
16443 : {
16444 : const int bLocalUseExceptions = GetUseExceptions();
16445 : if ( bLocalUseExceptions ) {
16446 : pushErrorHandler();
16447 : }
16448 : {
16449 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16450 : OGRFeatureShadow_GetFieldAsDateTime__SWIG_1(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
16451 : SWIG_PYTHON_THREAD_END_ALLOW;
16452 : }
16453 : if ( bLocalUseExceptions ) {
16454 : popErrorHandler();
16455 : }
16456 : #ifndef SED_HACKS
16457 : if ( bLocalUseExceptions ) {
16458 : CPLErr eclass = CPLGetLastErrorType();
16459 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16460 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16461 : }
16462 : }
16463 : #endif
16464 : }
16465 : resultobj = SWIG_Py_Void();
16466 : if (ReturnSame(SWIG_IsTmpObj(res3))) {
16467 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
16468 : } else {
16469 : int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16470 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16471 : }
16472 : if (ReturnSame(SWIG_IsTmpObj(res4))) {
16473 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
16474 : } else {
16475 : int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16476 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
16477 : }
16478 : if (ReturnSame(SWIG_IsTmpObj(res5))) {
16479 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
16480 : } else {
16481 : int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16482 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
16483 : }
16484 : if (ReturnSame(SWIG_IsTmpObj(res6))) {
16485 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
16486 : } else {
16487 : int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16488 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
16489 : }
16490 : if (ReturnSame(SWIG_IsTmpObj(res7))) {
16491 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg7)));
16492 : } else {
16493 : int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16494 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
16495 : }
16496 : if (ReturnSame(SWIG_IsTmpObj(res8))) {
16497 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg8)));
16498 : } else {
16499 : int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16500 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_float, new_flags));
16501 : }
16502 : if (ReturnSame(SWIG_IsTmpObj(res9))) {
16503 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg9)));
16504 : } else {
16505 : int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16506 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_int, new_flags));
16507 : }
16508 : {
16509 : /* %typemap(freearg) (const char *utf8_path) */
16510 : GDALPythonFreeCStr(arg2, bToFree2);
16511 : }
16512 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16513 : return resultobj;
16514 : fail:
16515 : {
16516 : /* %typemap(freearg) (const char *utf8_path) */
16517 : GDALPythonFreeCStr(arg2, bToFree2);
16518 : }
16519 : return NULL;
16520 : }
16521 :
16522 :
16523 87 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDateTime(PyObject *self, PyObject *args) {
16524 87 : Py_ssize_t argc;
16525 87 : PyObject *argv[3] = {
16526 : 0
16527 : };
16528 :
16529 87 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsDateTime", 0, 2, argv))) SWIG_fail;
16530 87 : --argc;
16531 87 : if (argc == 2) {
16532 87 : int _v;
16533 87 : void *vptr = 0;
16534 87 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16535 88 : _v = SWIG_CheckState(res);
16536 87 : if (_v) {
16537 87 : {
16538 87 : int res = SWIG_AsVal_int(argv[1], NULL);
16539 87 : _v = SWIG_CheckState(res);
16540 : }
16541 86 : if (_v) {
16542 86 : return _wrap_Feature_GetFieldAsDateTime__SWIG_0(self, argc, argv);
16543 : }
16544 : }
16545 : }
16546 1 : if (argc == 2) {
16547 1 : int _v;
16548 1 : void *vptr = 0;
16549 1 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16550 1 : _v = SWIG_CheckState(res);
16551 1 : if (_v) {
16552 1 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16553 1 : _v = SWIG_CheckState(res);
16554 1 : if (_v) {
16555 1 : return _wrap_Feature_GetFieldAsDateTime__SWIG_1(self, argc, argv);
16556 : }
16557 : }
16558 : }
16559 :
16560 0 : fail:
16561 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsDateTime'.\n"
16562 : " Possible C/C++ prototypes are:\n"
16563 : " OGRFeatureShadow::GetFieldAsDateTime(int,int *,int *,int *,int *,int *,float *,int *)\n"
16564 : " OGRFeatureShadow::GetFieldAsDateTime(char const *,int *,int *,int *,int *,int *,float *,int *)\n");
16565 : return 0;
16566 : }
16567 :
16568 :
16569 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsIntegerList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16570 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16571 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16572 : int arg2 ;
16573 : int *arg3 = (int *) 0 ;
16574 : int **arg4 = (int **) 0 ;
16575 : void *argp1 = 0 ;
16576 : int res1 = 0 ;
16577 : int val2 ;
16578 : int ecode2 = 0 ;
16579 : int nLen3 = 0 ;
16580 : int *pList3 = NULL ;
16581 :
16582 : {
16583 : /* %typemap(in,numinputs=0) (int *nLen3, const int **pList3) (int nLen3, int *pList3) */
16584 : arg3 = &nLen3;
16585 : arg4 = &pList3;
16586 : }
16587 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16588 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16589 : if (!SWIG_IsOK(res1)) {
16590 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsIntegerList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16591 : }
16592 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16593 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
16594 : if (!SWIG_IsOK(ecode2)) {
16595 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsIntegerList" "', argument " "2"" of type '" "int""'");
16596 : }
16597 : arg2 = static_cast< int >(val2);
16598 : {
16599 : const int bLocalUseExceptions = GetUseExceptions();
16600 : if ( bLocalUseExceptions ) {
16601 : pushErrorHandler();
16602 : }
16603 : {
16604 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16605 : OGRFeatureShadow_GetFieldAsIntegerList__SWIG_0(arg1,arg2,arg3,(int const **)arg4);
16606 : SWIG_PYTHON_THREAD_END_ALLOW;
16607 : }
16608 : if ( bLocalUseExceptions ) {
16609 : popErrorHandler();
16610 : }
16611 : #ifndef SED_HACKS
16612 : if ( bLocalUseExceptions ) {
16613 : CPLErr eclass = CPLGetLastErrorType();
16614 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16615 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16616 : }
16617 : }
16618 : #endif
16619 : }
16620 : resultobj = SWIG_Py_Void();
16621 : {
16622 : /* %typemap(argout) (int *nLen, const int **pList ) */
16623 : Py_DECREF(resultobj);
16624 : PyObject *out = PyList_New( *arg3 );
16625 : if( !out ) {
16626 : SWIG_fail;
16627 : }
16628 : for( int i=0; i<*arg3; i++ ) {
16629 : PyObject *val = PyInt_FromLong( (*arg4)[i] );
16630 : PyList_SetItem( out, i, val );
16631 : }
16632 : resultobj = out;
16633 : }
16634 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16635 : return resultobj;
16636 : fail:
16637 : return NULL;
16638 : }
16639 :
16640 :
16641 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsIntegerList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16642 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16643 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16644 : char *arg2 = (char *) 0 ;
16645 : int *arg3 = (int *) 0 ;
16646 : int **arg4 = (int **) 0 ;
16647 : void *argp1 = 0 ;
16648 : int res1 = 0 ;
16649 : int bToFree2 = 0 ;
16650 : int nLen3 = 0 ;
16651 : int *pList3 = NULL ;
16652 :
16653 : {
16654 : /* %typemap(in,numinputs=0) (int *nLen3, const int **pList3) (int nLen3, int *pList3) */
16655 : arg3 = &nLen3;
16656 : arg4 = &pList3;
16657 : }
16658 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16659 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16660 : if (!SWIG_IsOK(res1)) {
16661 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsIntegerList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16662 : }
16663 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16664 : {
16665 : /* %typemap(in) (const char *utf8_path) */
16666 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
16667 : {
16668 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
16669 : }
16670 : else
16671 : {
16672 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
16673 :
16674 : }
16675 : if (arg2 == NULL)
16676 : {
16677 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
16678 : SWIG_fail;
16679 : }
16680 : }
16681 : {
16682 : const int bLocalUseExceptions = GetUseExceptions();
16683 : if ( bLocalUseExceptions ) {
16684 : pushErrorHandler();
16685 : }
16686 : {
16687 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16688 : OGRFeatureShadow_GetFieldAsIntegerList__SWIG_1(arg1,(char const *)arg2,arg3,(int const **)arg4);
16689 : SWIG_PYTHON_THREAD_END_ALLOW;
16690 : }
16691 : if ( bLocalUseExceptions ) {
16692 : popErrorHandler();
16693 : }
16694 : #ifndef SED_HACKS
16695 : if ( bLocalUseExceptions ) {
16696 : CPLErr eclass = CPLGetLastErrorType();
16697 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16698 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16699 : }
16700 : }
16701 : #endif
16702 : }
16703 : resultobj = SWIG_Py_Void();
16704 : {
16705 : /* %typemap(argout) (int *nLen, const int **pList ) */
16706 : Py_DECREF(resultobj);
16707 : PyObject *out = PyList_New( *arg3 );
16708 : if( !out ) {
16709 : SWIG_fail;
16710 : }
16711 : for( int i=0; i<*arg3; i++ ) {
16712 : PyObject *val = PyInt_FromLong( (*arg4)[i] );
16713 : PyList_SetItem( out, i, val );
16714 : }
16715 : resultobj = out;
16716 : }
16717 : {
16718 : /* %typemap(freearg) (const char *utf8_path) */
16719 : GDALPythonFreeCStr(arg2, bToFree2);
16720 : }
16721 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16722 : return resultobj;
16723 : fail:
16724 : {
16725 : /* %typemap(freearg) (const char *utf8_path) */
16726 : GDALPythonFreeCStr(arg2, bToFree2);
16727 : }
16728 : return NULL;
16729 : }
16730 :
16731 :
16732 810 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsIntegerList(PyObject *self, PyObject *args) {
16733 810 : Py_ssize_t argc;
16734 810 : PyObject *argv[3] = {
16735 : 0
16736 : };
16737 :
16738 810 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsIntegerList", 0, 2, argv))) SWIG_fail;
16739 810 : --argc;
16740 810 : if (argc == 2) {
16741 810 : int _v;
16742 810 : void *vptr = 0;
16743 810 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16744 810 : _v = SWIG_CheckState(res);
16745 810 : if (_v) {
16746 810 : {
16747 810 : int res = SWIG_AsVal_int(argv[1], NULL);
16748 810 : _v = SWIG_CheckState(res);
16749 : }
16750 810 : if (_v) {
16751 810 : return _wrap_Feature_GetFieldAsIntegerList__SWIG_0(self, argc, argv);
16752 : }
16753 : }
16754 : }
16755 0 : if (argc == 2) {
16756 0 : int _v;
16757 0 : void *vptr = 0;
16758 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16759 0 : _v = SWIG_CheckState(res);
16760 0 : if (_v) {
16761 0 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16762 0 : _v = SWIG_CheckState(res);
16763 0 : if (_v) {
16764 0 : return _wrap_Feature_GetFieldAsIntegerList__SWIG_1(self, argc, argv);
16765 : }
16766 : }
16767 : }
16768 :
16769 0 : fail:
16770 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsIntegerList'.\n"
16771 : " Possible C/C++ prototypes are:\n"
16772 : " OGRFeatureShadow::GetFieldAsIntegerList(int,int *,int const **)\n"
16773 : " OGRFeatureShadow::GetFieldAsIntegerList(char const *,int *,int const **)\n");
16774 : return 0;
16775 : }
16776 :
16777 :
16778 331 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsInteger64List(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16779 331 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16780 331 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16781 331 : int arg2 ;
16782 331 : int *arg3 = (int *) 0 ;
16783 331 : GIntBig **arg4 = (GIntBig **) 0 ;
16784 331 : void *argp1 = 0 ;
16785 331 : int res1 = 0 ;
16786 331 : int val2 ;
16787 331 : int ecode2 = 0 ;
16788 331 : int nLen3 = 0 ;
16789 331 : GIntBig *pList3 = NULL ;
16790 331 : PyObject *swig_obj[2] ;
16791 :
16792 331 : {
16793 : /* %typemap(in,numinputs=0) (int *nLen3, const GIntBig **pList3) (int nLen3, GIntBig *pList3) */
16794 331 : arg3 = &nLen3;
16795 331 : arg4 = &pList3;
16796 : }
16797 331 : if (!SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsInteger64List", 2, 2, swig_obj)) SWIG_fail;
16798 331 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16799 331 : if (!SWIG_IsOK(res1)) {
16800 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsInteger64List" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16801 : }
16802 331 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16803 331 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
16804 331 : if (!SWIG_IsOK(ecode2)) {
16805 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsInteger64List" "', argument " "2"" of type '" "int""'");
16806 : }
16807 331 : arg2 = static_cast< int >(val2);
16808 331 : {
16809 331 : const int bLocalUseExceptions = GetUseExceptions();
16810 331 : if ( bLocalUseExceptions ) {
16811 302 : pushErrorHandler();
16812 : }
16813 331 : {
16814 331 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16815 331 : OGRFeatureShadow_GetFieldAsInteger64List(arg1,arg2,arg3,(GIntBig const **)arg4);
16816 331 : SWIG_PYTHON_THREAD_END_ALLOW;
16817 : }
16818 331 : if ( bLocalUseExceptions ) {
16819 302 : popErrorHandler();
16820 : }
16821 : #ifndef SED_HACKS
16822 : if ( bLocalUseExceptions ) {
16823 : CPLErr eclass = CPLGetLastErrorType();
16824 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16825 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16826 : }
16827 : }
16828 : #endif
16829 : }
16830 331 : resultobj = SWIG_Py_Void();
16831 331 : {
16832 : /* %typemap(argout) (int *nLen, const GIntBig **pList ) */
16833 331 : Py_DECREF(resultobj);
16834 331 : PyObject *out = PyList_New( *arg3 );
16835 331 : if( !out ) {
16836 0 : SWIG_fail;
16837 : }
16838 830 : for( int i=0; i<*arg3; i++ ) {
16839 499 : char szTmp[32];
16840 499 : snprintf(szTmp, sizeof(szTmp), CPL_FRMT_GIB, (*arg4)[i]);
16841 499 : PyObject* val;
16842 499 : val = PyLong_FromString(szTmp, NULL, 10);
16843 499 : PyList_SetItem( out, i, val );
16844 : }
16845 331 : resultobj = out;
16846 : }
16847 331 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16848 : return resultobj;
16849 : fail:
16850 : return NULL;
16851 : }
16852 :
16853 :
16854 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDoubleList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16855 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16856 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16857 : int arg2 ;
16858 : int *arg3 = (int *) 0 ;
16859 : double **arg4 = (double **) 0 ;
16860 : void *argp1 = 0 ;
16861 : int res1 = 0 ;
16862 : int val2 ;
16863 : int ecode2 = 0 ;
16864 : int nLen3 = 0 ;
16865 : double *pList3 = NULL ;
16866 :
16867 : {
16868 : /* %typemap(in,numinputs=0) (int *nLen3, const double **pList3) (int nLen3, double *pList3) */
16869 : arg3 = &nLen3;
16870 : arg4 = &pList3;
16871 : }
16872 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16873 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16874 : if (!SWIG_IsOK(res1)) {
16875 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsDoubleList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16876 : }
16877 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16878 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
16879 : if (!SWIG_IsOK(ecode2)) {
16880 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsDoubleList" "', argument " "2"" of type '" "int""'");
16881 : }
16882 : arg2 = static_cast< int >(val2);
16883 : {
16884 : const int bLocalUseExceptions = GetUseExceptions();
16885 : if ( bLocalUseExceptions ) {
16886 : pushErrorHandler();
16887 : }
16888 : {
16889 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16890 : OGRFeatureShadow_GetFieldAsDoubleList__SWIG_0(arg1,arg2,arg3,(double const **)arg4);
16891 : SWIG_PYTHON_THREAD_END_ALLOW;
16892 : }
16893 : if ( bLocalUseExceptions ) {
16894 : popErrorHandler();
16895 : }
16896 : #ifndef SED_HACKS
16897 : if ( bLocalUseExceptions ) {
16898 : CPLErr eclass = CPLGetLastErrorType();
16899 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16900 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16901 : }
16902 : }
16903 : #endif
16904 : }
16905 : resultobj = SWIG_Py_Void();
16906 : {
16907 : /* %typemap(argout) (int *nLen, const double **pList ) */
16908 : Py_DECREF(resultobj);
16909 : PyObject *out = PyList_New( *arg3 );
16910 : if( !out ) {
16911 : SWIG_fail;
16912 : }
16913 : for( int i=0; i<*arg3; i++ ) {
16914 : PyObject *val = PyFloat_FromDouble( (*arg4)[i] );
16915 : PyList_SetItem( out, i, val );
16916 : }
16917 : resultobj = out;
16918 : }
16919 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16920 : return resultobj;
16921 : fail:
16922 : return NULL;
16923 : }
16924 :
16925 :
16926 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDoubleList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16927 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16928 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16929 : char *arg2 = (char *) 0 ;
16930 : int *arg3 = (int *) 0 ;
16931 : double **arg4 = (double **) 0 ;
16932 : void *argp1 = 0 ;
16933 : int res1 = 0 ;
16934 : int bToFree2 = 0 ;
16935 : int nLen3 = 0 ;
16936 : double *pList3 = NULL ;
16937 :
16938 : {
16939 : /* %typemap(in,numinputs=0) (int *nLen3, const double **pList3) (int nLen3, double *pList3) */
16940 : arg3 = &nLen3;
16941 : arg4 = &pList3;
16942 : }
16943 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16944 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16945 : if (!SWIG_IsOK(res1)) {
16946 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsDoubleList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16947 : }
16948 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16949 : {
16950 : /* %typemap(in) (const char *utf8_path) */
16951 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
16952 : {
16953 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
16954 : }
16955 : else
16956 : {
16957 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
16958 :
16959 : }
16960 : if (arg2 == NULL)
16961 : {
16962 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
16963 : SWIG_fail;
16964 : }
16965 : }
16966 : {
16967 : const int bLocalUseExceptions = GetUseExceptions();
16968 : if ( bLocalUseExceptions ) {
16969 : pushErrorHandler();
16970 : }
16971 : {
16972 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16973 : OGRFeatureShadow_GetFieldAsDoubleList__SWIG_1(arg1,(char const *)arg2,arg3,(double const **)arg4);
16974 : SWIG_PYTHON_THREAD_END_ALLOW;
16975 : }
16976 : if ( bLocalUseExceptions ) {
16977 : popErrorHandler();
16978 : }
16979 : #ifndef SED_HACKS
16980 : if ( bLocalUseExceptions ) {
16981 : CPLErr eclass = CPLGetLastErrorType();
16982 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16983 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16984 : }
16985 : }
16986 : #endif
16987 : }
16988 : resultobj = SWIG_Py_Void();
16989 : {
16990 : /* %typemap(argout) (int *nLen, const double **pList ) */
16991 : Py_DECREF(resultobj);
16992 : PyObject *out = PyList_New( *arg3 );
16993 : if( !out ) {
16994 : SWIG_fail;
16995 : }
16996 : for( int i=0; i<*arg3; i++ ) {
16997 : PyObject *val = PyFloat_FromDouble( (*arg4)[i] );
16998 : PyList_SetItem( out, i, val );
16999 : }
17000 : resultobj = out;
17001 : }
17002 : {
17003 : /* %typemap(freearg) (const char *utf8_path) */
17004 : GDALPythonFreeCStr(arg2, bToFree2);
17005 : }
17006 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17007 : return resultobj;
17008 : fail:
17009 : {
17010 : /* %typemap(freearg) (const char *utf8_path) */
17011 : GDALPythonFreeCStr(arg2, bToFree2);
17012 : }
17013 : return NULL;
17014 : }
17015 :
17016 :
17017 659 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDoubleList(PyObject *self, PyObject *args) {
17018 659 : Py_ssize_t argc;
17019 659 : PyObject *argv[3] = {
17020 : 0
17021 : };
17022 :
17023 659 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsDoubleList", 0, 2, argv))) SWIG_fail;
17024 659 : --argc;
17025 659 : if (argc == 2) {
17026 659 : int _v;
17027 659 : void *vptr = 0;
17028 659 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17029 659 : _v = SWIG_CheckState(res);
17030 659 : if (_v) {
17031 659 : {
17032 659 : int res = SWIG_AsVal_int(argv[1], NULL);
17033 659 : _v = SWIG_CheckState(res);
17034 : }
17035 659 : if (_v) {
17036 659 : return _wrap_Feature_GetFieldAsDoubleList__SWIG_0(self, argc, argv);
17037 : }
17038 : }
17039 : }
17040 0 : if (argc == 2) {
17041 0 : int _v;
17042 0 : void *vptr = 0;
17043 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17044 0 : _v = SWIG_CheckState(res);
17045 0 : if (_v) {
17046 0 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
17047 0 : _v = SWIG_CheckState(res);
17048 0 : if (_v) {
17049 0 : return _wrap_Feature_GetFieldAsDoubleList__SWIG_1(self, argc, argv);
17050 : }
17051 : }
17052 : }
17053 :
17054 0 : fail:
17055 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsDoubleList'.\n"
17056 : " Possible C/C++ prototypes are:\n"
17057 : " OGRFeatureShadow::GetFieldAsDoubleList(int,int *,double const **)\n"
17058 : " OGRFeatureShadow::GetFieldAsDoubleList(char const *,int *,double const **)\n");
17059 : return 0;
17060 : }
17061 :
17062 :
17063 340 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsStringList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17064 340 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17065 340 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17066 340 : int arg2 ;
17067 340 : void *argp1 = 0 ;
17068 340 : int res1 = 0 ;
17069 340 : int val2 ;
17070 340 : int ecode2 = 0 ;
17071 340 : PyObject *swig_obj[2] ;
17072 340 : char **result = 0 ;
17073 :
17074 340 : if (!SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsStringList", 2, 2, swig_obj)) SWIG_fail;
17075 340 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17076 340 : if (!SWIG_IsOK(res1)) {
17077 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsStringList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17078 : }
17079 340 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17080 340 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
17081 340 : if (!SWIG_IsOK(ecode2)) {
17082 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsStringList" "', argument " "2"" of type '" "int""'");
17083 : }
17084 340 : arg2 = static_cast< int >(val2);
17085 340 : {
17086 340 : const int bLocalUseExceptions = GetUseExceptions();
17087 340 : if ( bLocalUseExceptions ) {
17088 279 : pushErrorHandler();
17089 : }
17090 340 : {
17091 340 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17092 340 : result = (char **)OGRFeatureShadow_GetFieldAsStringList(arg1,arg2);
17093 340 : SWIG_PYTHON_THREAD_END_ALLOW;
17094 : }
17095 340 : if ( bLocalUseExceptions ) {
17096 279 : popErrorHandler();
17097 : }
17098 : #ifndef SED_HACKS
17099 : if ( bLocalUseExceptions ) {
17100 : CPLErr eclass = CPLGetLastErrorType();
17101 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17102 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17103 : }
17104 : }
17105 : #endif
17106 : }
17107 340 : {
17108 : /* %typemap(out) char **options -> ( string ) */
17109 340 : bool bErr = false;
17110 340 : resultobj = CSLToList(result, &bErr);
17111 340 : if( bErr ) {
17112 0 : SWIG_fail;
17113 : }
17114 : }
17115 340 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17116 : return resultobj;
17117 : fail:
17118 : return NULL;
17119 : }
17120 :
17121 :
17122 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsBinary__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17123 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17124 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17125 : int arg2 ;
17126 : int *arg3 = (int *) 0 ;
17127 : char **arg4 = (char **) 0 ;
17128 : void *argp1 = 0 ;
17129 : int res1 = 0 ;
17130 : int val2 ;
17131 : int ecode2 = 0 ;
17132 : int nLen3 = 0 ;
17133 : char *pBuf3 = 0 ;
17134 : OGRErr result;
17135 :
17136 : {
17137 : /* %typemap(in,numinputs=0) (int *nLen3, char **pBuf3 ) */
17138 : arg3 = &nLen3;
17139 : arg4 = &pBuf3;
17140 : }
17141 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17142 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17143 : if (!SWIG_IsOK(res1)) {
17144 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsBinary" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17145 : }
17146 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17147 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
17148 : if (!SWIG_IsOK(ecode2)) {
17149 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsBinary" "', argument " "2"" of type '" "int""'");
17150 : }
17151 : arg2 = static_cast< int >(val2);
17152 : {
17153 : const int bLocalUseExceptions = GetUseExceptions();
17154 : if ( bLocalUseExceptions ) {
17155 : pushErrorHandler();
17156 : }
17157 : {
17158 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17159 : result = (OGRErr)OGRFeatureShadow_GetFieldAsBinary__SWIG_0(arg1,arg2,arg3,arg4);
17160 : SWIG_PYTHON_THREAD_END_ALLOW;
17161 : }
17162 : if ( bLocalUseExceptions ) {
17163 : popErrorHandler();
17164 : }
17165 : #ifndef SED_HACKS
17166 : if ( bLocalUseExceptions ) {
17167 : CPLErr eclass = CPLGetLastErrorType();
17168 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17169 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17170 : }
17171 : }
17172 : #endif
17173 : }
17174 : {
17175 : /* %typemap(out) OGRErr */
17176 : if ( result != 0 && GetUseExceptions()) {
17177 : const char* pszMessage = CPLGetLastErrorMsg();
17178 : if( pszMessage[0] != '\0' )
17179 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
17180 : else
17181 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
17182 : SWIG_fail;
17183 : }
17184 : }
17185 : {
17186 : /* %typemap(argout) (int *nLen, char **pBuf ) */
17187 : Py_XDECREF(resultobj);
17188 : resultobj = PyByteArray_FromStringAndSize( *arg4, *arg3 );
17189 : }
17190 : {
17191 : /* %typemap(freearg) (int *nLen, char **pBuf ) */
17192 : VSIFree( *arg4 );
17193 : }
17194 : {
17195 : /* %typemap(ret) OGRErr */
17196 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
17197 : resultobj = PyInt_FromLong( result );
17198 : }
17199 : }
17200 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17201 : return resultobj;
17202 : fail:
17203 : {
17204 : /* %typemap(freearg) (int *nLen, char **pBuf ) */
17205 : VSIFree( *arg4 );
17206 : }
17207 : return NULL;
17208 : }
17209 :
17210 :
17211 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsBinary__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17212 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17213 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17214 : char *arg2 = (char *) 0 ;
17215 : int *arg3 = (int *) 0 ;
17216 : char **arg4 = (char **) 0 ;
17217 : void *argp1 = 0 ;
17218 : int res1 = 0 ;
17219 : int bToFree2 = 0 ;
17220 : int nLen3 = 0 ;
17221 : char *pBuf3 = 0 ;
17222 : OGRErr result;
17223 :
17224 : {
17225 : /* %typemap(in,numinputs=0) (int *nLen3, char **pBuf3 ) */
17226 : arg3 = &nLen3;
17227 : arg4 = &pBuf3;
17228 : }
17229 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17230 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17231 : if (!SWIG_IsOK(res1)) {
17232 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsBinary" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17233 : }
17234 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17235 : {
17236 : /* %typemap(in) (const char *utf8_path) */
17237 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
17238 : {
17239 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
17240 : }
17241 : else
17242 : {
17243 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
17244 :
17245 : }
17246 : if (arg2 == NULL)
17247 : {
17248 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
17249 : SWIG_fail;
17250 : }
17251 : }
17252 : {
17253 : const int bLocalUseExceptions = GetUseExceptions();
17254 : if ( bLocalUseExceptions ) {
17255 : pushErrorHandler();
17256 : }
17257 : {
17258 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17259 : result = (OGRErr)OGRFeatureShadow_GetFieldAsBinary__SWIG_1(arg1,(char const *)arg2,arg3,arg4);
17260 : SWIG_PYTHON_THREAD_END_ALLOW;
17261 : }
17262 : if ( bLocalUseExceptions ) {
17263 : popErrorHandler();
17264 : }
17265 : #ifndef SED_HACKS
17266 : if ( bLocalUseExceptions ) {
17267 : CPLErr eclass = CPLGetLastErrorType();
17268 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17269 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17270 : }
17271 : }
17272 : #endif
17273 : }
17274 : {
17275 : /* %typemap(out) OGRErr */
17276 : if ( result != 0 && GetUseExceptions()) {
17277 : const char* pszMessage = CPLGetLastErrorMsg();
17278 : if( pszMessage[0] != '\0' )
17279 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
17280 : else
17281 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
17282 : SWIG_fail;
17283 : }
17284 : }
17285 : {
17286 : /* %typemap(argout) (int *nLen, char **pBuf ) */
17287 : Py_XDECREF(resultobj);
17288 : resultobj = PyByteArray_FromStringAndSize( *arg4, *arg3 );
17289 : }
17290 : {
17291 : /* %typemap(freearg) (const char *utf8_path) */
17292 : GDALPythonFreeCStr(arg2, bToFree2);
17293 : }
17294 : {
17295 : /* %typemap(freearg) (int *nLen, char **pBuf ) */
17296 : VSIFree( *arg4 );
17297 : }
17298 : {
17299 : /* %typemap(ret) OGRErr */
17300 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
17301 : resultobj = PyInt_FromLong( result );
17302 : }
17303 : }
17304 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17305 : return resultobj;
17306 : fail:
17307 : {
17308 : /* %typemap(freearg) (const char *utf8_path) */
17309 : GDALPythonFreeCStr(arg2, bToFree2);
17310 : }
17311 : {
17312 : /* %typemap(freearg) (int *nLen, char **pBuf ) */
17313 : VSIFree( *arg4 );
17314 : }
17315 : return NULL;
17316 : }
17317 :
17318 :
17319 107 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsBinary(PyObject *self, PyObject *args) {
17320 107 : Py_ssize_t argc;
17321 107 : PyObject *argv[3] = {
17322 : 0
17323 : };
17324 :
17325 107 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsBinary", 0, 2, argv))) SWIG_fail;
17326 107 : --argc;
17327 107 : if (argc == 2) {
17328 107 : int _v;
17329 107 : void *vptr = 0;
17330 107 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17331 175 : _v = SWIG_CheckState(res);
17332 107 : if (_v) {
17333 107 : {
17334 107 : int res = SWIG_AsVal_int(argv[1], NULL);
17335 107 : _v = SWIG_CheckState(res);
17336 : }
17337 39 : if (_v) {
17338 39 : return _wrap_Feature_GetFieldAsBinary__SWIG_0(self, argc, argv);
17339 : }
17340 : }
17341 : }
17342 68 : if (argc == 2) {
17343 68 : int _v;
17344 68 : void *vptr = 0;
17345 68 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17346 68 : _v = SWIG_CheckState(res);
17347 68 : if (_v) {
17348 68 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
17349 68 : _v = SWIG_CheckState(res);
17350 68 : if (_v) {
17351 68 : return _wrap_Feature_GetFieldAsBinary__SWIG_1(self, argc, argv);
17352 : }
17353 : }
17354 : }
17355 :
17356 0 : fail:
17357 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsBinary'.\n"
17358 : " Possible C/C++ prototypes are:\n"
17359 : " OGRFeatureShadow::GetFieldAsBinary(int,int *,char **)\n"
17360 : " OGRFeatureShadow::GetFieldAsBinary(char const *,int *,char **)\n");
17361 : return 0;
17362 : }
17363 :
17364 :
17365 : SWIGINTERN PyObject *_wrap_Feature_IsFieldSet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17366 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17367 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17368 : int arg2 ;
17369 : void *argp1 = 0 ;
17370 : int res1 = 0 ;
17371 : int val2 ;
17372 : int ecode2 = 0 ;
17373 : bool result;
17374 :
17375 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17376 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17377 : if (!SWIG_IsOK(res1)) {
17378 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_IsFieldSet" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17379 : }
17380 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17381 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
17382 : if (!SWIG_IsOK(ecode2)) {
17383 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_IsFieldSet" "', argument " "2"" of type '" "int""'");
17384 : }
17385 : arg2 = static_cast< int >(val2);
17386 : {
17387 : const int bLocalUseExceptions = GetUseExceptions();
17388 : if ( bLocalUseExceptions ) {
17389 : pushErrorHandler();
17390 : }
17391 : {
17392 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17393 : result = (bool)OGRFeatureShadow_IsFieldSet__SWIG_0(arg1,arg2);
17394 : SWIG_PYTHON_THREAD_END_ALLOW;
17395 : }
17396 : if ( bLocalUseExceptions ) {
17397 : popErrorHandler();
17398 : }
17399 : #ifndef SED_HACKS
17400 : if ( bLocalUseExceptions ) {
17401 : CPLErr eclass = CPLGetLastErrorType();
17402 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17403 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17404 : }
17405 : }
17406 : #endif
17407 : }
17408 : resultobj = SWIG_From_bool(static_cast< bool >(result));
17409 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17410 : return resultobj;
17411 : fail:
17412 : return NULL;
17413 : }
17414 :
17415 :
17416 : SWIGINTERN PyObject *_wrap_Feature_IsFieldSet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17417 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17418 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17419 : char *arg2 = (char *) 0 ;
17420 : void *argp1 = 0 ;
17421 : int res1 = 0 ;
17422 : int bToFree2 = 0 ;
17423 : bool result;
17424 :
17425 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17426 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17427 : if (!SWIG_IsOK(res1)) {
17428 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_IsFieldSet" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17429 : }
17430 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17431 : {
17432 : /* %typemap(in) (const char *utf8_path) */
17433 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
17434 : {
17435 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
17436 : }
17437 : else
17438 : {
17439 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
17440 :
17441 : }
17442 : if (arg2 == NULL)
17443 : {
17444 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
17445 : SWIG_fail;
17446 : }
17447 : }
17448 : {
17449 : const int bLocalUseExceptions = GetUseExceptions();
17450 : if ( bLocalUseExceptions ) {
17451 : pushErrorHandler();
17452 : }
17453 : {
17454 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17455 : result = (bool)OGRFeatureShadow_IsFieldSet__SWIG_1(arg1,(char const *)arg2);
17456 : SWIG_PYTHON_THREAD_END_ALLOW;
17457 : }
17458 : if ( bLocalUseExceptions ) {
17459 : popErrorHandler();
17460 : }
17461 : #ifndef SED_HACKS
17462 : if ( bLocalUseExceptions ) {
17463 : CPLErr eclass = CPLGetLastErrorType();
17464 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17465 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17466 : }
17467 : }
17468 : #endif
17469 : }
17470 : resultobj = SWIG_From_bool(static_cast< bool >(result));
17471 : {
17472 : /* %typemap(freearg) (const char *utf8_path) */
17473 : GDALPythonFreeCStr(arg2, bToFree2);
17474 : }
17475 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17476 : return resultobj;
17477 : fail:
17478 : {
17479 : /* %typemap(freearg) (const char *utf8_path) */
17480 : GDALPythonFreeCStr(arg2, bToFree2);
17481 : }
17482 : return NULL;
17483 : }
17484 :
17485 :
17486 101807 : SWIGINTERN PyObject *_wrap_Feature_IsFieldSet(PyObject *self, PyObject *args) {
17487 101807 : Py_ssize_t argc;
17488 101807 : PyObject *argv[3] = {
17489 : 0
17490 : };
17491 :
17492 101807 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_IsFieldSet", 0, 2, argv))) SWIG_fail;
17493 101807 : --argc;
17494 101807 : if (argc == 2) {
17495 101807 : int _v;
17496 101807 : void *vptr = 0;
17497 101807 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17498 102017 : _v = SWIG_CheckState(res);
17499 101807 : if (_v) {
17500 101807 : {
17501 101807 : int res = SWIG_AsVal_int(argv[1], NULL);
17502 101807 : _v = SWIG_CheckState(res);
17503 : }
17504 101597 : if (_v) {
17505 101597 : return _wrap_Feature_IsFieldSet__SWIG_0(self, argc, argv);
17506 : }
17507 : }
17508 : }
17509 210 : if (argc == 2) {
17510 210 : int _v;
17511 210 : void *vptr = 0;
17512 210 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17513 210 : _v = SWIG_CheckState(res);
17514 210 : if (_v) {
17515 210 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
17516 210 : _v = SWIG_CheckState(res);
17517 210 : if (_v) {
17518 210 : return _wrap_Feature_IsFieldSet__SWIG_1(self, argc, argv);
17519 : }
17520 : }
17521 : }
17522 :
17523 0 : fail:
17524 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_IsFieldSet'.\n"
17525 : " Possible C/C++ prototypes are:\n"
17526 : " OGRFeatureShadow::IsFieldSet(int)\n"
17527 : " OGRFeatureShadow::IsFieldSet(char const *)\n");
17528 : return 0;
17529 : }
17530 :
17531 :
17532 : SWIGINTERN PyObject *_wrap_Feature_IsFieldNull__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17533 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17534 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17535 : int arg2 ;
17536 : void *argp1 = 0 ;
17537 : int res1 = 0 ;
17538 : int val2 ;
17539 : int ecode2 = 0 ;
17540 : bool result;
17541 :
17542 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17543 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17544 : if (!SWIG_IsOK(res1)) {
17545 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_IsFieldNull" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17546 : }
17547 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17548 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
17549 : if (!SWIG_IsOK(ecode2)) {
17550 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_IsFieldNull" "', argument " "2"" of type '" "int""'");
17551 : }
17552 : arg2 = static_cast< int >(val2);
17553 : {
17554 : const int bLocalUseExceptions = GetUseExceptions();
17555 : if ( bLocalUseExceptions ) {
17556 : pushErrorHandler();
17557 : }
17558 : {
17559 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17560 : result = (bool)OGRFeatureShadow_IsFieldNull__SWIG_0(arg1,arg2);
17561 : SWIG_PYTHON_THREAD_END_ALLOW;
17562 : }
17563 : if ( bLocalUseExceptions ) {
17564 : popErrorHandler();
17565 : }
17566 : #ifndef SED_HACKS
17567 : if ( bLocalUseExceptions ) {
17568 : CPLErr eclass = CPLGetLastErrorType();
17569 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17570 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17571 : }
17572 : }
17573 : #endif
17574 : }
17575 : resultobj = SWIG_From_bool(static_cast< bool >(result));
17576 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17577 : return resultobj;
17578 : fail:
17579 : return NULL;
17580 : }
17581 :
17582 :
17583 : SWIGINTERN PyObject *_wrap_Feature_IsFieldNull__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17584 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17585 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17586 : char *arg2 = (char *) 0 ;
17587 : void *argp1 = 0 ;
17588 : int res1 = 0 ;
17589 : int bToFree2 = 0 ;
17590 : bool result;
17591 :
17592 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17593 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17594 : if (!SWIG_IsOK(res1)) {
17595 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_IsFieldNull" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17596 : }
17597 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17598 : {
17599 : /* %typemap(in) (const char *utf8_path) */
17600 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
17601 : {
17602 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
17603 : }
17604 : else
17605 : {
17606 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
17607 :
17608 : }
17609 : if (arg2 == NULL)
17610 : {
17611 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
17612 : SWIG_fail;
17613 : }
17614 : }
17615 : {
17616 : const int bLocalUseExceptions = GetUseExceptions();
17617 : if ( bLocalUseExceptions ) {
17618 : pushErrorHandler();
17619 : }
17620 : {
17621 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17622 : result = (bool)OGRFeatureShadow_IsFieldNull__SWIG_1(arg1,(char const *)arg2);
17623 : SWIG_PYTHON_THREAD_END_ALLOW;
17624 : }
17625 : if ( bLocalUseExceptions ) {
17626 : popErrorHandler();
17627 : }
17628 : #ifndef SED_HACKS
17629 : if ( bLocalUseExceptions ) {
17630 : CPLErr eclass = CPLGetLastErrorType();
17631 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17632 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17633 : }
17634 : }
17635 : #endif
17636 : }
17637 : resultobj = SWIG_From_bool(static_cast< bool >(result));
17638 : {
17639 : /* %typemap(freearg) (const char *utf8_path) */
17640 : GDALPythonFreeCStr(arg2, bToFree2);
17641 : }
17642 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17643 : return resultobj;
17644 : fail:
17645 : {
17646 : /* %typemap(freearg) (const char *utf8_path) */
17647 : GDALPythonFreeCStr(arg2, bToFree2);
17648 : }
17649 : return NULL;
17650 : }
17651 :
17652 :
17653 101004 : SWIGINTERN PyObject *_wrap_Feature_IsFieldNull(PyObject *self, PyObject *args) {
17654 101004 : Py_ssize_t argc;
17655 101004 : PyObject *argv[3] = {
17656 : 0
17657 : };
17658 :
17659 101004 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_IsFieldNull", 0, 2, argv))) SWIG_fail;
17660 101004 : --argc;
17661 101004 : if (argc == 2) {
17662 101004 : int _v;
17663 101004 : void *vptr = 0;
17664 101004 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17665 101059 : _v = SWIG_CheckState(res);
17666 101004 : if (_v) {
17667 101004 : {
17668 101004 : int res = SWIG_AsVal_int(argv[1], NULL);
17669 101004 : _v = SWIG_CheckState(res);
17670 : }
17671 100949 : if (_v) {
17672 100949 : return _wrap_Feature_IsFieldNull__SWIG_0(self, argc, argv);
17673 : }
17674 : }
17675 : }
17676 55 : if (argc == 2) {
17677 55 : int _v;
17678 55 : void *vptr = 0;
17679 55 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17680 55 : _v = SWIG_CheckState(res);
17681 55 : if (_v) {
17682 55 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
17683 55 : _v = SWIG_CheckState(res);
17684 55 : if (_v) {
17685 55 : return _wrap_Feature_IsFieldNull__SWIG_1(self, argc, argv);
17686 : }
17687 : }
17688 : }
17689 :
17690 0 : fail:
17691 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_IsFieldNull'.\n"
17692 : " Possible C/C++ prototypes are:\n"
17693 : " OGRFeatureShadow::IsFieldNull(int)\n"
17694 : " OGRFeatureShadow::IsFieldNull(char const *)\n");
17695 : return 0;
17696 : }
17697 :
17698 :
17699 : SWIGINTERN PyObject *_wrap_Feature_IsFieldSetAndNotNull__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17700 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17701 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17702 : int arg2 ;
17703 : void *argp1 = 0 ;
17704 : int res1 = 0 ;
17705 : int val2 ;
17706 : int ecode2 = 0 ;
17707 : bool result;
17708 :
17709 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17710 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17711 : if (!SWIG_IsOK(res1)) {
17712 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_IsFieldSetAndNotNull" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17713 : }
17714 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17715 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
17716 : if (!SWIG_IsOK(ecode2)) {
17717 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_IsFieldSetAndNotNull" "', argument " "2"" of type '" "int""'");
17718 : }
17719 : arg2 = static_cast< int >(val2);
17720 : {
17721 : const int bLocalUseExceptions = GetUseExceptions();
17722 : if ( bLocalUseExceptions ) {
17723 : pushErrorHandler();
17724 : }
17725 : {
17726 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17727 : result = (bool)OGRFeatureShadow_IsFieldSetAndNotNull__SWIG_0(arg1,arg2);
17728 : SWIG_PYTHON_THREAD_END_ALLOW;
17729 : }
17730 : if ( bLocalUseExceptions ) {
17731 : popErrorHandler();
17732 : }
17733 : #ifndef SED_HACKS
17734 : if ( bLocalUseExceptions ) {
17735 : CPLErr eclass = CPLGetLastErrorType();
17736 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17737 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17738 : }
17739 : }
17740 : #endif
17741 : }
17742 : resultobj = SWIG_From_bool(static_cast< bool >(result));
17743 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17744 : return resultobj;
17745 : fail:
17746 : return NULL;
17747 : }
17748 :
17749 :
17750 : SWIGINTERN PyObject *_wrap_Feature_IsFieldSetAndNotNull__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17751 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17752 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17753 : char *arg2 = (char *) 0 ;
17754 : void *argp1 = 0 ;
17755 : int res1 = 0 ;
17756 : int bToFree2 = 0 ;
17757 : bool result;
17758 :
17759 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17760 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17761 : if (!SWIG_IsOK(res1)) {
17762 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_IsFieldSetAndNotNull" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17763 : }
17764 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17765 : {
17766 : /* %typemap(in) (const char *utf8_path) */
17767 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
17768 : {
17769 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
17770 : }
17771 : else
17772 : {
17773 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
17774 :
17775 : }
17776 : if (arg2 == NULL)
17777 : {
17778 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
17779 : SWIG_fail;
17780 : }
17781 : }
17782 : {
17783 : const int bLocalUseExceptions = GetUseExceptions();
17784 : if ( bLocalUseExceptions ) {
17785 : pushErrorHandler();
17786 : }
17787 : {
17788 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17789 : result = (bool)OGRFeatureShadow_IsFieldSetAndNotNull__SWIG_1(arg1,(char const *)arg2);
17790 : SWIG_PYTHON_THREAD_END_ALLOW;
17791 : }
17792 : if ( bLocalUseExceptions ) {
17793 : popErrorHandler();
17794 : }
17795 : #ifndef SED_HACKS
17796 : if ( bLocalUseExceptions ) {
17797 : CPLErr eclass = CPLGetLastErrorType();
17798 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17799 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17800 : }
17801 : }
17802 : #endif
17803 : }
17804 : resultobj = SWIG_From_bool(static_cast< bool >(result));
17805 : {
17806 : /* %typemap(freearg) (const char *utf8_path) */
17807 : GDALPythonFreeCStr(arg2, bToFree2);
17808 : }
17809 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17810 : return resultobj;
17811 : fail:
17812 : {
17813 : /* %typemap(freearg) (const char *utf8_path) */
17814 : GDALPythonFreeCStr(arg2, bToFree2);
17815 : }
17816 : return NULL;
17817 : }
17818 :
17819 :
17820 827 : SWIGINTERN PyObject *_wrap_Feature_IsFieldSetAndNotNull(PyObject *self, PyObject *args) {
17821 827 : Py_ssize_t argc;
17822 827 : PyObject *argv[3] = {
17823 : 0
17824 : };
17825 :
17826 827 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_IsFieldSetAndNotNull", 0, 2, argv))) SWIG_fail;
17827 827 : --argc;
17828 827 : if (argc == 2) {
17829 827 : int _v;
17830 827 : void *vptr = 0;
17831 827 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17832 879 : _v = SWIG_CheckState(res);
17833 827 : if (_v) {
17834 827 : {
17835 827 : int res = SWIG_AsVal_int(argv[1], NULL);
17836 827 : _v = SWIG_CheckState(res);
17837 : }
17838 775 : if (_v) {
17839 775 : return _wrap_Feature_IsFieldSetAndNotNull__SWIG_0(self, argc, argv);
17840 : }
17841 : }
17842 : }
17843 52 : if (argc == 2) {
17844 52 : int _v;
17845 52 : void *vptr = 0;
17846 52 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17847 52 : _v = SWIG_CheckState(res);
17848 52 : if (_v) {
17849 52 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
17850 52 : _v = SWIG_CheckState(res);
17851 52 : if (_v) {
17852 52 : return _wrap_Feature_IsFieldSetAndNotNull__SWIG_1(self, argc, argv);
17853 : }
17854 : }
17855 : }
17856 :
17857 0 : fail:
17858 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_IsFieldSetAndNotNull'.\n"
17859 : " Possible C/C++ prototypes are:\n"
17860 : " OGRFeatureShadow::IsFieldSetAndNotNull(int)\n"
17861 : " OGRFeatureShadow::IsFieldSetAndNotNull(char const *)\n");
17862 : return 0;
17863 : }
17864 :
17865 :
17866 302 : SWIGINTERN PyObject *_wrap_Feature_GetFieldIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17867 302 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17868 302 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17869 302 : char *arg2 = (char *) 0 ;
17870 302 : void *argp1 = 0 ;
17871 302 : int res1 = 0 ;
17872 302 : int bToFree2 = 0 ;
17873 302 : PyObject *swig_obj[2] ;
17874 302 : int result;
17875 :
17876 302 : if (!SWIG_Python_UnpackTuple(args, "Feature_GetFieldIndex", 2, 2, swig_obj)) SWIG_fail;
17877 302 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17878 302 : if (!SWIG_IsOK(res1)) {
17879 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldIndex" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17880 : }
17881 302 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17882 302 : {
17883 : /* %typemap(in) (const char *utf8_path) */
17884 302 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
17885 : {
17886 302 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
17887 : }
17888 : else
17889 : {
17890 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
17891 :
17892 : }
17893 302 : if (arg2 == NULL)
17894 : {
17895 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
17896 0 : SWIG_fail;
17897 : }
17898 : }
17899 302 : {
17900 302 : const int bLocalUseExceptions = GetUseExceptions();
17901 302 : if ( bLocalUseExceptions ) {
17902 72 : pushErrorHandler();
17903 : }
17904 302 : {
17905 302 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17906 302 : result = (int)OGRFeatureShadow_GetFieldIndex(arg1,(char const *)arg2);
17907 302 : SWIG_PYTHON_THREAD_END_ALLOW;
17908 : }
17909 302 : if ( bLocalUseExceptions ) {
17910 72 : popErrorHandler();
17911 : }
17912 : #ifndef SED_HACKS
17913 : if ( bLocalUseExceptions ) {
17914 : CPLErr eclass = CPLGetLastErrorType();
17915 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17916 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17917 : }
17918 : }
17919 : #endif
17920 : }
17921 302 : resultobj = SWIG_From_int(static_cast< int >(result));
17922 302 : {
17923 : /* %typemap(freearg) (const char *utf8_path) */
17924 302 : GDALPythonFreeCStr(arg2, bToFree2);
17925 : }
17926 302 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17927 : return resultobj;
17928 0 : fail:
17929 0 : {
17930 : /* %typemap(freearg) (const char *utf8_path) */
17931 302 : GDALPythonFreeCStr(arg2, bToFree2);
17932 : }
17933 : return NULL;
17934 : }
17935 :
17936 :
17937 73 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17938 73 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17939 73 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17940 73 : char *arg2 = (char *) 0 ;
17941 73 : void *argp1 = 0 ;
17942 73 : int res1 = 0 ;
17943 73 : int bToFree2 = 0 ;
17944 73 : PyObject *swig_obj[2] ;
17945 73 : int result;
17946 :
17947 73 : if (!SWIG_Python_UnpackTuple(args, "Feature_GetGeomFieldIndex", 2, 2, swig_obj)) SWIG_fail;
17948 73 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17949 73 : if (!SWIG_IsOK(res1)) {
17950 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetGeomFieldIndex" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17951 : }
17952 73 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17953 73 : {
17954 : /* %typemap(in) (const char *utf8_path) */
17955 73 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
17956 : {
17957 73 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
17958 : }
17959 : else
17960 : {
17961 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
17962 :
17963 : }
17964 73 : if (arg2 == NULL)
17965 : {
17966 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
17967 0 : SWIG_fail;
17968 : }
17969 : }
17970 73 : {
17971 73 : const int bLocalUseExceptions = GetUseExceptions();
17972 73 : if ( bLocalUseExceptions ) {
17973 0 : pushErrorHandler();
17974 : }
17975 73 : {
17976 73 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17977 73 : result = (int)OGRFeatureShadow_GetGeomFieldIndex(arg1,(char const *)arg2);
17978 73 : SWIG_PYTHON_THREAD_END_ALLOW;
17979 : }
17980 73 : if ( bLocalUseExceptions ) {
17981 0 : popErrorHandler();
17982 : }
17983 : #ifndef SED_HACKS
17984 : if ( bLocalUseExceptions ) {
17985 : CPLErr eclass = CPLGetLastErrorType();
17986 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17987 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17988 : }
17989 : }
17990 : #endif
17991 : }
17992 73 : resultobj = SWIG_From_int(static_cast< int >(result));
17993 73 : {
17994 : /* %typemap(freearg) (const char *utf8_path) */
17995 73 : GDALPythonFreeCStr(arg2, bToFree2);
17996 : }
17997 73 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17998 : return resultobj;
17999 0 : fail:
18000 0 : {
18001 : /* %typemap(freearg) (const char *utf8_path) */
18002 73 : GDALPythonFreeCStr(arg2, bToFree2);
18003 : }
18004 : return NULL;
18005 : }
18006 :
18007 :
18008 5217 : SWIGINTERN PyObject *_wrap_Feature_GetFID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18009 5217 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18010 5217 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18011 5217 : void *argp1 = 0 ;
18012 5217 : int res1 = 0 ;
18013 5217 : PyObject *swig_obj[1] ;
18014 5217 : GIntBig result;
18015 :
18016 5217 : if (!args) SWIG_fail;
18017 5217 : swig_obj[0] = args;
18018 5217 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18019 5217 : if (!SWIG_IsOK(res1)) {
18020 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFID" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18021 : }
18022 5217 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18023 5217 : {
18024 5217 : const int bLocalUseExceptions = GetUseExceptions();
18025 5217 : if ( bLocalUseExceptions ) {
18026 3486 : pushErrorHandler();
18027 : }
18028 5217 : {
18029 5217 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18030 5217 : result = OGRFeatureShadow_GetFID(arg1);
18031 5217 : SWIG_PYTHON_THREAD_END_ALLOW;
18032 : }
18033 5217 : if ( bLocalUseExceptions ) {
18034 3486 : popErrorHandler();
18035 : }
18036 : #ifndef SED_HACKS
18037 : if ( bLocalUseExceptions ) {
18038 : CPLErr eclass = CPLGetLastErrorType();
18039 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18040 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18041 : }
18042 : }
18043 : #endif
18044 : }
18045 5217 : {
18046 5217 : resultobj = PyLong_FromLongLong(result);
18047 : }
18048 5217 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18049 : return resultobj;
18050 : fail:
18051 : return NULL;
18052 : }
18053 :
18054 :
18055 160519 : SWIGINTERN PyObject *_wrap_Feature_SetFID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18056 160519 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18057 160519 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18058 160519 : GIntBig arg2 ;
18059 160519 : void *argp1 = 0 ;
18060 160519 : int res1 = 0 ;
18061 160519 : PyObject *swig_obj[2] ;
18062 160519 : OGRErr result;
18063 :
18064 160519 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFID", 2, 2, swig_obj)) SWIG_fail;
18065 160519 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18066 160519 : if (!SWIG_IsOK(res1)) {
18067 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFID" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18068 : }
18069 160519 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18070 160519 : {
18071 160519 : arg2 = (GIntBig)PyLong_AsLongLong(swig_obj[1]);
18072 : }
18073 160519 : {
18074 160519 : const int bLocalUseExceptions = GetUseExceptions();
18075 160519 : if ( bLocalUseExceptions ) {
18076 160070 : pushErrorHandler();
18077 : }
18078 160519 : {
18079 160519 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18080 160519 : result = (OGRErr)OGRFeatureShadow_SetFID(arg1,arg2);
18081 160519 : SWIG_PYTHON_THREAD_END_ALLOW;
18082 : }
18083 160519 : if ( bLocalUseExceptions ) {
18084 160070 : popErrorHandler();
18085 : }
18086 : #ifndef SED_HACKS
18087 : if ( bLocalUseExceptions ) {
18088 : CPLErr eclass = CPLGetLastErrorType();
18089 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18090 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18091 : }
18092 : }
18093 : #endif
18094 : }
18095 160519 : {
18096 : /* %typemap(out) OGRErr */
18097 160519 : if ( result != 0 && GetUseExceptions()) {
18098 0 : const char* pszMessage = CPLGetLastErrorMsg();
18099 0 : if( pszMessage[0] != '\0' )
18100 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
18101 : else
18102 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
18103 0 : SWIG_fail;
18104 : }
18105 : }
18106 160519 : {
18107 : /* %typemap(ret) OGRErr */
18108 160519 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
18109 160519 : resultobj = PyInt_FromLong( result );
18110 : }
18111 : }
18112 160519 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18113 : return resultobj;
18114 : fail:
18115 : return NULL;
18116 : }
18117 :
18118 :
18119 1 : SWIGINTERN PyObject *_wrap_Feature_DumpReadable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18120 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18121 1 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18122 1 : void *argp1 = 0 ;
18123 1 : int res1 = 0 ;
18124 1 : PyObject *swig_obj[1] ;
18125 :
18126 1 : if (!args) SWIG_fail;
18127 1 : swig_obj[0] = args;
18128 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18129 1 : if (!SWIG_IsOK(res1)) {
18130 2 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_DumpReadable" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18131 : }
18132 0 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18133 0 : {
18134 0 : const int bLocalUseExceptions = GetUseExceptions();
18135 0 : if ( bLocalUseExceptions ) {
18136 0 : pushErrorHandler();
18137 : }
18138 0 : {
18139 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18140 0 : OGRFeatureShadow_DumpReadable(arg1);
18141 0 : SWIG_PYTHON_THREAD_END_ALLOW;
18142 : }
18143 0 : if ( bLocalUseExceptions ) {
18144 0 : popErrorHandler();
18145 : }
18146 : #ifndef SED_HACKS
18147 : if ( bLocalUseExceptions ) {
18148 : CPLErr eclass = CPLGetLastErrorType();
18149 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18150 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18151 : }
18152 : }
18153 : #endif
18154 : }
18155 0 : resultobj = SWIG_Py_Void();
18156 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18157 : return resultobj;
18158 : fail:
18159 : return NULL;
18160 : }
18161 :
18162 :
18163 92 : SWIGINTERN PyObject *_wrap_Feature_DumpReadableAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18164 92 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18165 92 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18166 92 : char **arg2 = (char **) NULL ;
18167 92 : void *argp1 = 0 ;
18168 92 : int res1 = 0 ;
18169 92 : PyObject *swig_obj[2] ;
18170 92 : retStringAndCPLFree *result = 0 ;
18171 :
18172 92 : if (!SWIG_Python_UnpackTuple(args, "Feature_DumpReadableAsString", 1, 2, swig_obj)) SWIG_fail;
18173 92 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18174 92 : if (!SWIG_IsOK(res1)) {
18175 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_DumpReadableAsString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18176 : }
18177 92 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18178 92 : if (swig_obj[1]) {
18179 3 : {
18180 : /* %typemap(in) char **dict */
18181 3 : arg2 = NULL;
18182 3 : if ( PySequence_Check( swig_obj[1] ) ) {
18183 0 : int bErr = FALSE;
18184 0 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
18185 0 : if ( bErr )
18186 : {
18187 0 : SWIG_fail;
18188 : }
18189 : }
18190 3 : else if ( PyMapping_Check( swig_obj[1] ) ) {
18191 3 : int bErr = FALSE;
18192 3 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
18193 3 : if ( bErr )
18194 : {
18195 0 : SWIG_fail;
18196 : }
18197 : }
18198 : else {
18199 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
18200 0 : SWIG_fail;
18201 : }
18202 : }
18203 : }
18204 92 : {
18205 92 : const int bLocalUseExceptions = GetUseExceptions();
18206 92 : if ( bLocalUseExceptions ) {
18207 92 : pushErrorHandler();
18208 : }
18209 92 : {
18210 92 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18211 92 : result = (retStringAndCPLFree *)OGRFeatureShadow_DumpReadableAsString(arg1,arg2);
18212 92 : SWIG_PYTHON_THREAD_END_ALLOW;
18213 : }
18214 92 : if ( bLocalUseExceptions ) {
18215 92 : popErrorHandler();
18216 : }
18217 : #ifndef SED_HACKS
18218 : if ( bLocalUseExceptions ) {
18219 : CPLErr eclass = CPLGetLastErrorType();
18220 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18221 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18222 : }
18223 : }
18224 : #endif
18225 : }
18226 92 : {
18227 : /* %typemap(out) (retStringAndCPLFree*) */
18228 92 : Py_XDECREF(resultobj);
18229 92 : if(result)
18230 : {
18231 92 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
18232 92 : CPLFree(result);
18233 : }
18234 : else
18235 : {
18236 0 : resultobj = Py_None;
18237 0 : Py_INCREF(resultobj);
18238 : }
18239 : }
18240 92 : {
18241 : /* %typemap(freearg) char **dict */
18242 92 : CSLDestroy( arg2 );
18243 : }
18244 92 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18245 : return resultobj;
18246 0 : fail:
18247 0 : {
18248 : /* %typemap(freearg) char **dict */
18249 0 : CSLDestroy( arg2 );
18250 : }
18251 : return NULL;
18252 : }
18253 :
18254 :
18255 : SWIGINTERN PyObject *_wrap_Feature_UnsetField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18256 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18257 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18258 : int arg2 ;
18259 : void *argp1 = 0 ;
18260 : int res1 = 0 ;
18261 : int val2 ;
18262 : int ecode2 = 0 ;
18263 :
18264 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
18265 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18266 : if (!SWIG_IsOK(res1)) {
18267 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_UnsetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18268 : }
18269 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18270 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
18271 : if (!SWIG_IsOK(ecode2)) {
18272 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_UnsetField" "', argument " "2"" of type '" "int""'");
18273 : }
18274 : arg2 = static_cast< int >(val2);
18275 : {
18276 : const int bLocalUseExceptions = GetUseExceptions();
18277 : if ( bLocalUseExceptions ) {
18278 : pushErrorHandler();
18279 : }
18280 : {
18281 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18282 : OGRFeatureShadow_UnsetField__SWIG_0(arg1,arg2);
18283 : SWIG_PYTHON_THREAD_END_ALLOW;
18284 : }
18285 : if ( bLocalUseExceptions ) {
18286 : popErrorHandler();
18287 : }
18288 : #ifndef SED_HACKS
18289 : if ( bLocalUseExceptions ) {
18290 : CPLErr eclass = CPLGetLastErrorType();
18291 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18292 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18293 : }
18294 : }
18295 : #endif
18296 : }
18297 : resultobj = SWIG_Py_Void();
18298 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18299 : return resultobj;
18300 : fail:
18301 : return NULL;
18302 : }
18303 :
18304 :
18305 : SWIGINTERN PyObject *_wrap_Feature_UnsetField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18306 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18307 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18308 : char *arg2 = (char *) 0 ;
18309 : void *argp1 = 0 ;
18310 : int res1 = 0 ;
18311 : int bToFree2 = 0 ;
18312 :
18313 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
18314 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18315 : if (!SWIG_IsOK(res1)) {
18316 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_UnsetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18317 : }
18318 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18319 : {
18320 : /* %typemap(in) (const char *utf8_path) */
18321 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
18322 : {
18323 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
18324 : }
18325 : else
18326 : {
18327 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
18328 :
18329 : }
18330 : if (arg2 == NULL)
18331 : {
18332 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
18333 : SWIG_fail;
18334 : }
18335 : }
18336 : {
18337 : const int bLocalUseExceptions = GetUseExceptions();
18338 : if ( bLocalUseExceptions ) {
18339 : pushErrorHandler();
18340 : }
18341 : {
18342 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18343 : OGRFeatureShadow_UnsetField__SWIG_1(arg1,(char const *)arg2);
18344 : SWIG_PYTHON_THREAD_END_ALLOW;
18345 : }
18346 : if ( bLocalUseExceptions ) {
18347 : popErrorHandler();
18348 : }
18349 : #ifndef SED_HACKS
18350 : if ( bLocalUseExceptions ) {
18351 : CPLErr eclass = CPLGetLastErrorType();
18352 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18353 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18354 : }
18355 : }
18356 : #endif
18357 : }
18358 : resultobj = SWIG_Py_Void();
18359 : {
18360 : /* %typemap(freearg) (const char *utf8_path) */
18361 : GDALPythonFreeCStr(arg2, bToFree2);
18362 : }
18363 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18364 : return resultobj;
18365 : fail:
18366 : {
18367 : /* %typemap(freearg) (const char *utf8_path) */
18368 : GDALPythonFreeCStr(arg2, bToFree2);
18369 : }
18370 : return NULL;
18371 : }
18372 :
18373 :
18374 5 : SWIGINTERN PyObject *_wrap_Feature_UnsetField(PyObject *self, PyObject *args) {
18375 5 : Py_ssize_t argc;
18376 5 : PyObject *argv[3] = {
18377 : 0
18378 : };
18379 :
18380 5 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_UnsetField", 0, 2, argv))) SWIG_fail;
18381 5 : --argc;
18382 5 : if (argc == 2) {
18383 5 : int _v;
18384 5 : void *vptr = 0;
18385 5 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
18386 9 : _v = SWIG_CheckState(res);
18387 5 : if (_v) {
18388 5 : {
18389 5 : int res = SWIG_AsVal_int(argv[1], NULL);
18390 5 : _v = SWIG_CheckState(res);
18391 : }
18392 1 : if (_v) {
18393 1 : return _wrap_Feature_UnsetField__SWIG_0(self, argc, argv);
18394 : }
18395 : }
18396 : }
18397 4 : if (argc == 2) {
18398 4 : int _v;
18399 4 : void *vptr = 0;
18400 4 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
18401 4 : _v = SWIG_CheckState(res);
18402 4 : if (_v) {
18403 4 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
18404 4 : _v = SWIG_CheckState(res);
18405 4 : if (_v) {
18406 4 : return _wrap_Feature_UnsetField__SWIG_1(self, argc, argv);
18407 : }
18408 : }
18409 : }
18410 :
18411 0 : fail:
18412 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_UnsetField'.\n"
18413 : " Possible C/C++ prototypes are:\n"
18414 : " OGRFeatureShadow::UnsetField(int)\n"
18415 : " OGRFeatureShadow::UnsetField(char const *)\n");
18416 : return 0;
18417 : }
18418 :
18419 :
18420 : SWIGINTERN PyObject *_wrap_Feature_SetFieldNull__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18421 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18422 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18423 : int arg2 ;
18424 : void *argp1 = 0 ;
18425 : int res1 = 0 ;
18426 : int val2 ;
18427 : int ecode2 = 0 ;
18428 :
18429 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
18430 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18431 : if (!SWIG_IsOK(res1)) {
18432 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldNull" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18433 : }
18434 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18435 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
18436 : if (!SWIG_IsOK(ecode2)) {
18437 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldNull" "', argument " "2"" of type '" "int""'");
18438 : }
18439 : arg2 = static_cast< int >(val2);
18440 : {
18441 : const int bLocalUseExceptions = GetUseExceptions();
18442 : if ( bLocalUseExceptions ) {
18443 : pushErrorHandler();
18444 : }
18445 : {
18446 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18447 : OGRFeatureShadow_SetFieldNull__SWIG_0(arg1,arg2);
18448 : SWIG_PYTHON_THREAD_END_ALLOW;
18449 : }
18450 : if ( bLocalUseExceptions ) {
18451 : popErrorHandler();
18452 : }
18453 : #ifndef SED_HACKS
18454 : if ( bLocalUseExceptions ) {
18455 : CPLErr eclass = CPLGetLastErrorType();
18456 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18457 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18458 : }
18459 : }
18460 : #endif
18461 : }
18462 : resultobj = SWIG_Py_Void();
18463 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18464 : return resultobj;
18465 : fail:
18466 : return NULL;
18467 : }
18468 :
18469 :
18470 : SWIGINTERN PyObject *_wrap_Feature_SetFieldNull__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18471 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18472 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18473 : char *arg2 = (char *) 0 ;
18474 : void *argp1 = 0 ;
18475 : int res1 = 0 ;
18476 : int bToFree2 = 0 ;
18477 :
18478 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
18479 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18480 : if (!SWIG_IsOK(res1)) {
18481 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldNull" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18482 : }
18483 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18484 : {
18485 : /* %typemap(in) (const char *utf8_path) */
18486 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
18487 : {
18488 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
18489 : }
18490 : else
18491 : {
18492 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
18493 :
18494 : }
18495 : if (arg2 == NULL)
18496 : {
18497 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
18498 : SWIG_fail;
18499 : }
18500 : }
18501 : {
18502 : const int bLocalUseExceptions = GetUseExceptions();
18503 : if ( bLocalUseExceptions ) {
18504 : pushErrorHandler();
18505 : }
18506 : {
18507 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18508 : OGRFeatureShadow_SetFieldNull__SWIG_1(arg1,(char const *)arg2);
18509 : SWIG_PYTHON_THREAD_END_ALLOW;
18510 : }
18511 : if ( bLocalUseExceptions ) {
18512 : popErrorHandler();
18513 : }
18514 : #ifndef SED_HACKS
18515 : if ( bLocalUseExceptions ) {
18516 : CPLErr eclass = CPLGetLastErrorType();
18517 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18518 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18519 : }
18520 : }
18521 : #endif
18522 : }
18523 : resultobj = SWIG_Py_Void();
18524 : {
18525 : /* %typemap(freearg) (const char *utf8_path) */
18526 : GDALPythonFreeCStr(arg2, bToFree2);
18527 : }
18528 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18529 : return resultobj;
18530 : fail:
18531 : {
18532 : /* %typemap(freearg) (const char *utf8_path) */
18533 : GDALPythonFreeCStr(arg2, bToFree2);
18534 : }
18535 : return NULL;
18536 : }
18537 :
18538 :
18539 47 : SWIGINTERN PyObject *_wrap_Feature_SetFieldNull(PyObject *self, PyObject *args) {
18540 47 : Py_ssize_t argc;
18541 47 : PyObject *argv[3] = {
18542 : 0
18543 : };
18544 :
18545 47 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_SetFieldNull", 0, 2, argv))) SWIG_fail;
18546 47 : --argc;
18547 47 : if (argc == 2) {
18548 47 : int _v;
18549 47 : void *vptr = 0;
18550 47 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
18551 66 : _v = SWIG_CheckState(res);
18552 47 : if (_v) {
18553 47 : {
18554 47 : int res = SWIG_AsVal_int(argv[1], NULL);
18555 47 : _v = SWIG_CheckState(res);
18556 : }
18557 28 : if (_v) {
18558 28 : return _wrap_Feature_SetFieldNull__SWIG_0(self, argc, argv);
18559 : }
18560 : }
18561 : }
18562 19 : if (argc == 2) {
18563 19 : int _v;
18564 19 : void *vptr = 0;
18565 19 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
18566 19 : _v = SWIG_CheckState(res);
18567 19 : if (_v) {
18568 19 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
18569 19 : _v = SWIG_CheckState(res);
18570 19 : if (_v) {
18571 19 : return _wrap_Feature_SetFieldNull__SWIG_1(self, argc, argv);
18572 : }
18573 : }
18574 : }
18575 :
18576 0 : fail:
18577 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_SetFieldNull'.\n"
18578 : " Possible C/C++ prototypes are:\n"
18579 : " OGRFeatureShadow::SetFieldNull(int)\n"
18580 : " OGRFeatureShadow::SetFieldNull(char const *)\n");
18581 : return 0;
18582 : }
18583 :
18584 :
18585 : SWIGINTERN PyObject *_wrap_Feature_SetField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18586 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18587 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18588 : int arg2 ;
18589 : char *arg3 = (char *) 0 ;
18590 : void *argp1 = 0 ;
18591 : int res1 = 0 ;
18592 : int val2 ;
18593 : int ecode2 = 0 ;
18594 : PyObject *str3 = 0 ;
18595 : int bToFree3 = 0 ;
18596 :
18597 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
18598 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18599 : if (!SWIG_IsOK(res1)) {
18600 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18601 : }
18602 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18603 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
18604 : if (!SWIG_IsOK(ecode2)) {
18605 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetField" "', argument " "2"" of type '" "int""'");
18606 : }
18607 : arg2 = static_cast< int >(val2);
18608 : {
18609 : /* %typemap(in) (tostring argin) */
18610 : str3 = PyObject_Str( swig_obj[2] );
18611 : if ( str3 == 0 ) {
18612 : PyErr_SetString( PyExc_RuntimeError, "Unable to format argument as string");
18613 : SWIG_fail;
18614 : }
18615 :
18616 : arg3 = GDALPythonObjectToCStr(str3, &bToFree3);
18617 : }
18618 : {
18619 : const int bLocalUseExceptions = GetUseExceptions();
18620 : if ( bLocalUseExceptions ) {
18621 : pushErrorHandler();
18622 : }
18623 : {
18624 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18625 : OGRFeatureShadow_SetField__SWIG_0(arg1,arg2,(char const *)arg3);
18626 : SWIG_PYTHON_THREAD_END_ALLOW;
18627 : }
18628 : if ( bLocalUseExceptions ) {
18629 : popErrorHandler();
18630 : }
18631 : #ifndef SED_HACKS
18632 : if ( bLocalUseExceptions ) {
18633 : CPLErr eclass = CPLGetLastErrorType();
18634 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18635 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18636 : }
18637 : }
18638 : #endif
18639 : }
18640 : resultobj = SWIG_Py_Void();
18641 : {
18642 : /* %typemap(freearg) (tostring argin) */
18643 : if ( str3 != NULL)
18644 : {
18645 : Py_DECREF(str3);
18646 : }
18647 : GDALPythonFreeCStr(arg3, bToFree3);
18648 : }
18649 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18650 : return resultobj;
18651 : fail:
18652 : {
18653 : /* %typemap(freearg) (tostring argin) */
18654 : if ( str3 != NULL)
18655 : {
18656 : Py_DECREF(str3);
18657 : }
18658 : GDALPythonFreeCStr(arg3, bToFree3);
18659 : }
18660 : return NULL;
18661 : }
18662 :
18663 :
18664 : SWIGINTERN PyObject *_wrap_Feature_SetField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18665 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18666 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18667 : char *arg2 = (char *) 0 ;
18668 : char *arg3 = (char *) 0 ;
18669 : void *argp1 = 0 ;
18670 : int res1 = 0 ;
18671 : int bToFree2 = 0 ;
18672 : PyObject *str3 = 0 ;
18673 : int bToFree3 = 0 ;
18674 :
18675 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
18676 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18677 : if (!SWIG_IsOK(res1)) {
18678 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18679 : }
18680 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18681 : {
18682 : /* %typemap(in) (const char *utf8_path) */
18683 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
18684 : {
18685 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
18686 : }
18687 : else
18688 : {
18689 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
18690 :
18691 : }
18692 : if (arg2 == NULL)
18693 : {
18694 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
18695 : SWIG_fail;
18696 : }
18697 : }
18698 : {
18699 : /* %typemap(in) (tostring argin) */
18700 : str3 = PyObject_Str( swig_obj[2] );
18701 : if ( str3 == 0 ) {
18702 : PyErr_SetString( PyExc_RuntimeError, "Unable to format argument as string");
18703 : SWIG_fail;
18704 : }
18705 :
18706 : arg3 = GDALPythonObjectToCStr(str3, &bToFree3);
18707 : }
18708 : {
18709 : const int bLocalUseExceptions = GetUseExceptions();
18710 : if ( bLocalUseExceptions ) {
18711 : pushErrorHandler();
18712 : }
18713 : {
18714 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18715 : OGRFeatureShadow_SetField__SWIG_1(arg1,(char const *)arg2,(char const *)arg3);
18716 : SWIG_PYTHON_THREAD_END_ALLOW;
18717 : }
18718 : if ( bLocalUseExceptions ) {
18719 : popErrorHandler();
18720 : }
18721 : #ifndef SED_HACKS
18722 : if ( bLocalUseExceptions ) {
18723 : CPLErr eclass = CPLGetLastErrorType();
18724 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18725 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18726 : }
18727 : }
18728 : #endif
18729 : }
18730 : resultobj = SWIG_Py_Void();
18731 : {
18732 : /* %typemap(freearg) (const char *utf8_path) */
18733 : GDALPythonFreeCStr(arg2, bToFree2);
18734 : }
18735 : {
18736 : /* %typemap(freearg) (tostring argin) */
18737 : if ( str3 != NULL)
18738 : {
18739 : Py_DECREF(str3);
18740 : }
18741 : GDALPythonFreeCStr(arg3, bToFree3);
18742 : }
18743 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18744 : return resultobj;
18745 : fail:
18746 : {
18747 : /* %typemap(freearg) (const char *utf8_path) */
18748 : GDALPythonFreeCStr(arg2, bToFree2);
18749 : }
18750 : {
18751 : /* %typemap(freearg) (tostring argin) */
18752 : if ( str3 != NULL)
18753 : {
18754 : Py_DECREF(str3);
18755 : }
18756 : GDALPythonFreeCStr(arg3, bToFree3);
18757 : }
18758 : return NULL;
18759 : }
18760 :
18761 :
18762 84445 : SWIGINTERN PyObject *_wrap_Feature_SetFieldInteger64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18763 84445 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18764 84445 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18765 84445 : int arg2 ;
18766 84445 : GIntBig arg3 ;
18767 84445 : void *argp1 = 0 ;
18768 84445 : int res1 = 0 ;
18769 84445 : int val2 ;
18770 84445 : int ecode2 = 0 ;
18771 84445 : PyObject *swig_obj[3] ;
18772 :
18773 84445 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFieldInteger64", 3, 3, swig_obj)) SWIG_fail;
18774 84445 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18775 84445 : if (!SWIG_IsOK(res1)) {
18776 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldInteger64" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18777 : }
18778 84445 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18779 84445 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
18780 84445 : if (!SWIG_IsOK(ecode2)) {
18781 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldInteger64" "', argument " "2"" of type '" "int""'");
18782 : }
18783 84445 : arg2 = static_cast< int >(val2);
18784 84445 : {
18785 84445 : arg3 = (GIntBig)PyLong_AsLongLong(swig_obj[2]);
18786 : }
18787 84445 : {
18788 84445 : const int bLocalUseExceptions = GetUseExceptions();
18789 84445 : if ( bLocalUseExceptions ) {
18790 68440 : pushErrorHandler();
18791 : }
18792 84445 : {
18793 84445 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18794 84445 : OGRFeatureShadow_SetFieldInteger64(arg1,arg2,arg3);
18795 84445 : SWIG_PYTHON_THREAD_END_ALLOW;
18796 : }
18797 84445 : if ( bLocalUseExceptions ) {
18798 68440 : popErrorHandler();
18799 : }
18800 : #ifndef SED_HACKS
18801 : if ( bLocalUseExceptions ) {
18802 : CPLErr eclass = CPLGetLastErrorType();
18803 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18804 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18805 : }
18806 : }
18807 : #endif
18808 : }
18809 84445 : resultobj = SWIG_Py_Void();
18810 84445 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18811 : return resultobj;
18812 : fail:
18813 : return NULL;
18814 : }
18815 :
18816 :
18817 : SWIGINTERN PyObject *_wrap_Feature_SetField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18818 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18819 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18820 : int arg2 ;
18821 : double arg3 ;
18822 : void *argp1 = 0 ;
18823 : int res1 = 0 ;
18824 : int val2 ;
18825 : int ecode2 = 0 ;
18826 : double val3 ;
18827 : int ecode3 = 0 ;
18828 :
18829 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
18830 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18831 : if (!SWIG_IsOK(res1)) {
18832 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18833 : }
18834 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18835 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
18836 : if (!SWIG_IsOK(ecode2)) {
18837 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetField" "', argument " "2"" of type '" "int""'");
18838 : }
18839 : arg2 = static_cast< int >(val2);
18840 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
18841 : if (!SWIG_IsOK(ecode3)) {
18842 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Feature_SetField" "', argument " "3"" of type '" "double""'");
18843 : }
18844 : arg3 = static_cast< double >(val3);
18845 : {
18846 : const int bLocalUseExceptions = GetUseExceptions();
18847 : if ( bLocalUseExceptions ) {
18848 : pushErrorHandler();
18849 : }
18850 : {
18851 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18852 : OGRFeatureShadow_SetField__SWIG_2(arg1,arg2,arg3);
18853 : SWIG_PYTHON_THREAD_END_ALLOW;
18854 : }
18855 : if ( bLocalUseExceptions ) {
18856 : popErrorHandler();
18857 : }
18858 : #ifndef SED_HACKS
18859 : if ( bLocalUseExceptions ) {
18860 : CPLErr eclass = CPLGetLastErrorType();
18861 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18862 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18863 : }
18864 : }
18865 : #endif
18866 : }
18867 : resultobj = SWIG_Py_Void();
18868 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18869 : return resultobj;
18870 : fail:
18871 : return NULL;
18872 : }
18873 :
18874 :
18875 : SWIGINTERN PyObject *_wrap_Feature_SetField__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18876 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18877 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18878 : char *arg2 = (char *) 0 ;
18879 : double arg3 ;
18880 : void *argp1 = 0 ;
18881 : int res1 = 0 ;
18882 : int bToFree2 = 0 ;
18883 : double val3 ;
18884 : int ecode3 = 0 ;
18885 :
18886 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
18887 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18888 : if (!SWIG_IsOK(res1)) {
18889 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18890 : }
18891 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18892 : {
18893 : /* %typemap(in) (const char *utf8_path) */
18894 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
18895 : {
18896 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
18897 : }
18898 : else
18899 : {
18900 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
18901 :
18902 : }
18903 : if (arg2 == NULL)
18904 : {
18905 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
18906 : SWIG_fail;
18907 : }
18908 : }
18909 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
18910 : if (!SWIG_IsOK(ecode3)) {
18911 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Feature_SetField" "', argument " "3"" of type '" "double""'");
18912 : }
18913 : arg3 = static_cast< double >(val3);
18914 : {
18915 : const int bLocalUseExceptions = GetUseExceptions();
18916 : if ( bLocalUseExceptions ) {
18917 : pushErrorHandler();
18918 : }
18919 : {
18920 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18921 : OGRFeatureShadow_SetField__SWIG_3(arg1,(char const *)arg2,arg3);
18922 : SWIG_PYTHON_THREAD_END_ALLOW;
18923 : }
18924 : if ( bLocalUseExceptions ) {
18925 : popErrorHandler();
18926 : }
18927 : #ifndef SED_HACKS
18928 : if ( bLocalUseExceptions ) {
18929 : CPLErr eclass = CPLGetLastErrorType();
18930 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18931 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18932 : }
18933 : }
18934 : #endif
18935 : }
18936 : resultobj = SWIG_Py_Void();
18937 : {
18938 : /* %typemap(freearg) (const char *utf8_path) */
18939 : GDALPythonFreeCStr(arg2, bToFree2);
18940 : }
18941 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18942 : return resultobj;
18943 : fail:
18944 : {
18945 : /* %typemap(freearg) (const char *utf8_path) */
18946 : GDALPythonFreeCStr(arg2, bToFree2);
18947 : }
18948 : return NULL;
18949 : }
18950 :
18951 :
18952 : SWIGINTERN PyObject *_wrap_Feature_SetField__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18953 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18954 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18955 : int arg2 ;
18956 : int arg3 ;
18957 : int arg4 ;
18958 : int arg5 ;
18959 : int arg6 ;
18960 : int arg7 ;
18961 : float arg8 ;
18962 : int arg9 ;
18963 : void *argp1 = 0 ;
18964 : int res1 = 0 ;
18965 : int val2 ;
18966 : int ecode2 = 0 ;
18967 : int val3 ;
18968 : int ecode3 = 0 ;
18969 : int val4 ;
18970 : int ecode4 = 0 ;
18971 : int val5 ;
18972 : int ecode5 = 0 ;
18973 : int val6 ;
18974 : int ecode6 = 0 ;
18975 : int val7 ;
18976 : int ecode7 = 0 ;
18977 : float val8 ;
18978 : int ecode8 = 0 ;
18979 : int val9 ;
18980 : int ecode9 = 0 ;
18981 :
18982 : if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
18983 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18984 : if (!SWIG_IsOK(res1)) {
18985 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18986 : }
18987 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18988 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
18989 : if (!SWIG_IsOK(ecode2)) {
18990 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetField" "', argument " "2"" of type '" "int""'");
18991 : }
18992 : arg2 = static_cast< int >(val2);
18993 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
18994 : if (!SWIG_IsOK(ecode3)) {
18995 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Feature_SetField" "', argument " "3"" of type '" "int""'");
18996 : }
18997 : arg3 = static_cast< int >(val3);
18998 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
18999 : if (!SWIG_IsOK(ecode4)) {
19000 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Feature_SetField" "', argument " "4"" of type '" "int""'");
19001 : }
19002 : arg4 = static_cast< int >(val4);
19003 : ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
19004 : if (!SWIG_IsOK(ecode5)) {
19005 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Feature_SetField" "', argument " "5"" of type '" "int""'");
19006 : }
19007 : arg5 = static_cast< int >(val5);
19008 : ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
19009 : if (!SWIG_IsOK(ecode6)) {
19010 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Feature_SetField" "', argument " "6"" of type '" "int""'");
19011 : }
19012 : arg6 = static_cast< int >(val6);
19013 : ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
19014 : if (!SWIG_IsOK(ecode7)) {
19015 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Feature_SetField" "', argument " "7"" of type '" "int""'");
19016 : }
19017 : arg7 = static_cast< int >(val7);
19018 : ecode8 = SWIG_AsVal_float(swig_obj[7], &val8);
19019 : if (!SWIG_IsOK(ecode8)) {
19020 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Feature_SetField" "', argument " "8"" of type '" "float""'");
19021 : }
19022 : arg8 = static_cast< float >(val8);
19023 : ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
19024 : if (!SWIG_IsOK(ecode9)) {
19025 : SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Feature_SetField" "', argument " "9"" of type '" "int""'");
19026 : }
19027 : arg9 = static_cast< int >(val9);
19028 : {
19029 : const int bLocalUseExceptions = GetUseExceptions();
19030 : if ( bLocalUseExceptions ) {
19031 : pushErrorHandler();
19032 : }
19033 : {
19034 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19035 : OGRFeatureShadow_SetField__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
19036 : SWIG_PYTHON_THREAD_END_ALLOW;
19037 : }
19038 : if ( bLocalUseExceptions ) {
19039 : popErrorHandler();
19040 : }
19041 : #ifndef SED_HACKS
19042 : if ( bLocalUseExceptions ) {
19043 : CPLErr eclass = CPLGetLastErrorType();
19044 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19045 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19046 : }
19047 : }
19048 : #endif
19049 : }
19050 : resultobj = SWIG_Py_Void();
19051 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19052 : return resultobj;
19053 : fail:
19054 : return NULL;
19055 : }
19056 :
19057 :
19058 : SWIGINTERN PyObject *_wrap_Feature_SetField__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
19059 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19060 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19061 : char *arg2 = (char *) 0 ;
19062 : int arg3 ;
19063 : int arg4 ;
19064 : int arg5 ;
19065 : int arg6 ;
19066 : int arg7 ;
19067 : float arg8 ;
19068 : int arg9 ;
19069 : void *argp1 = 0 ;
19070 : int res1 = 0 ;
19071 : int bToFree2 = 0 ;
19072 : int val3 ;
19073 : int ecode3 = 0 ;
19074 : int val4 ;
19075 : int ecode4 = 0 ;
19076 : int val5 ;
19077 : int ecode5 = 0 ;
19078 : int val6 ;
19079 : int ecode6 = 0 ;
19080 : int val7 ;
19081 : int ecode7 = 0 ;
19082 : float val8 ;
19083 : int ecode8 = 0 ;
19084 : int val9 ;
19085 : int ecode9 = 0 ;
19086 :
19087 : if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
19088 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19089 : if (!SWIG_IsOK(res1)) {
19090 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19091 : }
19092 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19093 : {
19094 : /* %typemap(in) (const char *utf8_path) */
19095 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
19096 : {
19097 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
19098 : }
19099 : else
19100 : {
19101 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
19102 :
19103 : }
19104 : if (arg2 == NULL)
19105 : {
19106 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
19107 : SWIG_fail;
19108 : }
19109 : }
19110 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
19111 : if (!SWIG_IsOK(ecode3)) {
19112 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Feature_SetField" "', argument " "3"" of type '" "int""'");
19113 : }
19114 : arg3 = static_cast< int >(val3);
19115 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
19116 : if (!SWIG_IsOK(ecode4)) {
19117 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Feature_SetField" "', argument " "4"" of type '" "int""'");
19118 : }
19119 : arg4 = static_cast< int >(val4);
19120 : ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
19121 : if (!SWIG_IsOK(ecode5)) {
19122 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Feature_SetField" "', argument " "5"" of type '" "int""'");
19123 : }
19124 : arg5 = static_cast< int >(val5);
19125 : ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
19126 : if (!SWIG_IsOK(ecode6)) {
19127 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Feature_SetField" "', argument " "6"" of type '" "int""'");
19128 : }
19129 : arg6 = static_cast< int >(val6);
19130 : ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
19131 : if (!SWIG_IsOK(ecode7)) {
19132 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Feature_SetField" "', argument " "7"" of type '" "int""'");
19133 : }
19134 : arg7 = static_cast< int >(val7);
19135 : ecode8 = SWIG_AsVal_float(swig_obj[7], &val8);
19136 : if (!SWIG_IsOK(ecode8)) {
19137 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Feature_SetField" "', argument " "8"" of type '" "float""'");
19138 : }
19139 : arg8 = static_cast< float >(val8);
19140 : ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
19141 : if (!SWIG_IsOK(ecode9)) {
19142 : SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Feature_SetField" "', argument " "9"" of type '" "int""'");
19143 : }
19144 : arg9 = static_cast< int >(val9);
19145 : {
19146 : const int bLocalUseExceptions = GetUseExceptions();
19147 : if ( bLocalUseExceptions ) {
19148 : pushErrorHandler();
19149 : }
19150 : {
19151 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19152 : OGRFeatureShadow_SetField__SWIG_5(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
19153 : SWIG_PYTHON_THREAD_END_ALLOW;
19154 : }
19155 : if ( bLocalUseExceptions ) {
19156 : popErrorHandler();
19157 : }
19158 : #ifndef SED_HACKS
19159 : if ( bLocalUseExceptions ) {
19160 : CPLErr eclass = CPLGetLastErrorType();
19161 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19162 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19163 : }
19164 : }
19165 : #endif
19166 : }
19167 : resultobj = SWIG_Py_Void();
19168 : {
19169 : /* %typemap(freearg) (const char *utf8_path) */
19170 : GDALPythonFreeCStr(arg2, bToFree2);
19171 : }
19172 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19173 : return resultobj;
19174 : fail:
19175 : {
19176 : /* %typemap(freearg) (const char *utf8_path) */
19177 : GDALPythonFreeCStr(arg2, bToFree2);
19178 : }
19179 : return NULL;
19180 : }
19181 :
19182 :
19183 1593 : SWIGINTERN PyObject *_wrap_Feature_SetField(PyObject *self, PyObject *args) {
19184 1593 : Py_ssize_t argc;
19185 1593 : PyObject *argv[10] = {
19186 : 0
19187 : };
19188 :
19189 1593 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_SetField", 0, 9, argv))) SWIG_fail;
19190 1593 : --argc;
19191 1593 : if (argc == 3) {
19192 1549 : int _v;
19193 1549 : void *vptr = 0;
19194 1549 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19195 2831 : _v = SWIG_CheckState(res);
19196 1549 : if (_v) {
19197 1549 : {
19198 1549 : int res = SWIG_AsVal_int(argv[1], NULL);
19199 1549 : _v = SWIG_CheckState(res);
19200 : }
19201 267 : if (_v) {
19202 267 : {
19203 267 : int res = SWIG_AsVal_double(argv[2], NULL);
19204 267 : _v = SWIG_CheckState(res);
19205 : }
19206 267 : if (_v) {
19207 267 : return _wrap_Feature_SetField__SWIG_2(self, argc, argv);
19208 : }
19209 : }
19210 : }
19211 : }
19212 1326 : if (argc == 3) {
19213 1282 : int _v;
19214 1282 : void *vptr = 0;
19215 1282 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19216 2564 : _v = SWIG_CheckState(res);
19217 1282 : if (_v) {
19218 1282 : {
19219 1282 : int res = SWIG_AsVal_int(argv[1], NULL);
19220 1282 : _v = SWIG_CheckState(res);
19221 : }
19222 0 : if (_v) {
19223 0 : int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
19224 0 : _v = SWIG_CheckState(res);
19225 0 : if (_v) {
19226 0 : return _wrap_Feature_SetField__SWIG_0(self, argc, argv);
19227 : }
19228 : }
19229 : }
19230 : }
19231 1326 : if (argc == 3) {
19232 1282 : int _v;
19233 1282 : void *vptr = 0;
19234 1282 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19235 1282 : _v = SWIG_CheckState(res);
19236 1282 : if (_v) {
19237 1282 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
19238 1282 : _v = SWIG_CheckState(res);
19239 1282 : if (_v) {
19240 1282 : {
19241 1282 : int res = SWIG_AsVal_double(argv[2], NULL);
19242 1282 : _v = SWIG_CheckState(res);
19243 : }
19244 1282 : if (_v) {
19245 1282 : return _wrap_Feature_SetField__SWIG_3(self, argc, argv);
19246 : }
19247 : }
19248 : }
19249 : }
19250 44 : if (argc == 3) {
19251 0 : int _v;
19252 0 : void *vptr = 0;
19253 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19254 0 : _v = SWIG_CheckState(res);
19255 0 : if (_v) {
19256 0 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
19257 0 : _v = SWIG_CheckState(res);
19258 0 : if (_v) {
19259 0 : int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
19260 0 : _v = SWIG_CheckState(res);
19261 0 : if (_v) {
19262 0 : return _wrap_Feature_SetField__SWIG_1(self, argc, argv);
19263 : }
19264 : }
19265 : }
19266 : }
19267 44 : if (argc == 9) {
19268 44 : int _v;
19269 44 : void *vptr = 0;
19270 44 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19271 64 : _v = SWIG_CheckState(res);
19272 44 : if (_v) {
19273 44 : {
19274 44 : int res = SWIG_AsVal_int(argv[1], NULL);
19275 44 : _v = SWIG_CheckState(res);
19276 : }
19277 24 : if (_v) {
19278 24 : {
19279 24 : int res = SWIG_AsVal_int(argv[2], NULL);
19280 24 : _v = SWIG_CheckState(res);
19281 : }
19282 24 : if (_v) {
19283 24 : {
19284 24 : int res = SWIG_AsVal_int(argv[3], NULL);
19285 24 : _v = SWIG_CheckState(res);
19286 : }
19287 24 : if (_v) {
19288 24 : {
19289 24 : int res = SWIG_AsVal_int(argv[4], NULL);
19290 24 : _v = SWIG_CheckState(res);
19291 : }
19292 24 : if (_v) {
19293 24 : {
19294 24 : int res = SWIG_AsVal_int(argv[5], NULL);
19295 24 : _v = SWIG_CheckState(res);
19296 : }
19297 24 : if (_v) {
19298 24 : {
19299 24 : int res = SWIG_AsVal_int(argv[6], NULL);
19300 24 : _v = SWIG_CheckState(res);
19301 : }
19302 24 : if (_v) {
19303 24 : {
19304 24 : int res = SWIG_AsVal_float(argv[7], NULL);
19305 24 : _v = SWIG_CheckState(res);
19306 : }
19307 24 : if (_v) {
19308 24 : {
19309 24 : int res = SWIG_AsVal_int(argv[8], NULL);
19310 24 : _v = SWIG_CheckState(res);
19311 : }
19312 24 : if (_v) {
19313 24 : return _wrap_Feature_SetField__SWIG_4(self, argc, argv);
19314 : }
19315 : }
19316 : }
19317 : }
19318 : }
19319 : }
19320 : }
19321 : }
19322 : }
19323 : }
19324 20 : if (argc == 9) {
19325 20 : int _v;
19326 20 : void *vptr = 0;
19327 20 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19328 20 : _v = SWIG_CheckState(res);
19329 20 : if (_v) {
19330 20 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
19331 20 : _v = SWIG_CheckState(res);
19332 20 : if (_v) {
19333 20 : {
19334 20 : int res = SWIG_AsVal_int(argv[2], NULL);
19335 20 : _v = SWIG_CheckState(res);
19336 : }
19337 20 : if (_v) {
19338 20 : {
19339 20 : int res = SWIG_AsVal_int(argv[3], NULL);
19340 20 : _v = SWIG_CheckState(res);
19341 : }
19342 20 : if (_v) {
19343 20 : {
19344 20 : int res = SWIG_AsVal_int(argv[4], NULL);
19345 20 : _v = SWIG_CheckState(res);
19346 : }
19347 20 : if (_v) {
19348 20 : {
19349 20 : int res = SWIG_AsVal_int(argv[5], NULL);
19350 20 : _v = SWIG_CheckState(res);
19351 : }
19352 20 : if (_v) {
19353 20 : {
19354 20 : int res = SWIG_AsVal_int(argv[6], NULL);
19355 20 : _v = SWIG_CheckState(res);
19356 : }
19357 20 : if (_v) {
19358 20 : {
19359 20 : int res = SWIG_AsVal_float(argv[7], NULL);
19360 20 : _v = SWIG_CheckState(res);
19361 : }
19362 20 : if (_v) {
19363 20 : {
19364 20 : int res = SWIG_AsVal_int(argv[8], NULL);
19365 20 : _v = SWIG_CheckState(res);
19366 : }
19367 20 : if (_v) {
19368 20 : return _wrap_Feature_SetField__SWIG_5(self, argc, argv);
19369 : }
19370 : }
19371 : }
19372 : }
19373 : }
19374 : }
19375 : }
19376 : }
19377 : }
19378 : }
19379 :
19380 0 : fail:
19381 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_SetField'.\n"
19382 : " Possible C/C++ prototypes are:\n"
19383 : " OGRFeatureShadow::SetField(int,char const *)\n"
19384 : " OGRFeatureShadow::SetField(char const *,char const *)\n"
19385 : " OGRFeatureShadow::SetField(int,double)\n"
19386 : " OGRFeatureShadow::SetField(char const *,double)\n"
19387 : " OGRFeatureShadow::SetField(int,int,int,int,int,int,float,int)\n"
19388 : " OGRFeatureShadow::SetField(char const *,int,int,int,int,int,float,int)\n");
19389 : return 0;
19390 : }
19391 :
19392 :
19393 9 : SWIGINTERN PyObject *_wrap_Feature_SetFieldIntegerList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19394 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19395 9 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19396 9 : int arg2 ;
19397 9 : int arg3 ;
19398 9 : int *arg4 = (int *) 0 ;
19399 9 : void *argp1 = 0 ;
19400 9 : int res1 = 0 ;
19401 9 : int val2 ;
19402 9 : int ecode2 = 0 ;
19403 9 : PyObject *swig_obj[3] ;
19404 :
19405 9 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFieldIntegerList", 3, 3, swig_obj)) SWIG_fail;
19406 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19407 9 : if (!SWIG_IsOK(res1)) {
19408 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldIntegerList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19409 : }
19410 9 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19411 9 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
19412 9 : if (!SWIG_IsOK(ecode2)) {
19413 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldIntegerList" "', argument " "2"" of type '" "int""'");
19414 : }
19415 9 : arg2 = static_cast< int >(val2);
19416 9 : {
19417 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
19418 9 : arg4 = CreateCIntListFromSequence(swig_obj[2], &arg3);
19419 9 : if( arg3 < 0 ) {
19420 0 : SWIG_fail;
19421 : }
19422 : }
19423 9 : {
19424 9 : const int bLocalUseExceptions = GetUseExceptions();
19425 9 : if ( bLocalUseExceptions ) {
19426 6 : pushErrorHandler();
19427 : }
19428 9 : {
19429 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19430 9 : OGRFeatureShadow_SetFieldIntegerList(arg1,arg2,arg3,arg4);
19431 9 : SWIG_PYTHON_THREAD_END_ALLOW;
19432 : }
19433 9 : if ( bLocalUseExceptions ) {
19434 6 : popErrorHandler();
19435 : }
19436 : #ifndef SED_HACKS
19437 : if ( bLocalUseExceptions ) {
19438 : CPLErr eclass = CPLGetLastErrorType();
19439 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19440 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19441 : }
19442 : }
19443 : #endif
19444 : }
19445 9 : resultobj = SWIG_Py_Void();
19446 9 : {
19447 : /* %typemap(freearg) (int nList, int* pList) */
19448 9 : free(arg4);
19449 : }
19450 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19451 : return resultobj;
19452 0 : fail:
19453 0 : {
19454 : /* %typemap(freearg) (int nList, int* pList) */
19455 0 : free(arg4);
19456 : }
19457 0 : return NULL;
19458 : }
19459 :
19460 :
19461 122 : SWIGINTERN PyObject *_wrap_Feature_SetFieldInteger64List(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19462 122 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19463 122 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19464 122 : int arg2 ;
19465 122 : int arg3 ;
19466 122 : GIntBig *arg4 = (GIntBig *) 0 ;
19467 122 : void *argp1 = 0 ;
19468 122 : int res1 = 0 ;
19469 122 : int val2 ;
19470 122 : int ecode2 = 0 ;
19471 122 : PyObject *swig_obj[3] ;
19472 :
19473 122 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFieldInteger64List", 3, 3, swig_obj)) SWIG_fail;
19474 122 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19475 122 : if (!SWIG_IsOK(res1)) {
19476 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldInteger64List" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19477 : }
19478 122 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19479 122 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
19480 122 : if (!SWIG_IsOK(ecode2)) {
19481 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldInteger64List" "', argument " "2"" of type '" "int""'");
19482 : }
19483 122 : arg2 = static_cast< int >(val2);
19484 122 : {
19485 : /* %typemap(in,numinputs=1) (int nList, GIntBig* pList)*/
19486 122 : arg4 = CreateCGIntBigListFromSequence(swig_obj[2], &arg3);
19487 122 : if( arg3 < 0 ) {
19488 0 : SWIG_fail;
19489 : }
19490 : }
19491 122 : {
19492 122 : const int bLocalUseExceptions = GetUseExceptions();
19493 122 : if ( bLocalUseExceptions ) {
19494 114 : pushErrorHandler();
19495 : }
19496 122 : {
19497 122 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19498 122 : OGRFeatureShadow_SetFieldInteger64List(arg1,arg2,arg3,arg4);
19499 122 : SWIG_PYTHON_THREAD_END_ALLOW;
19500 : }
19501 122 : if ( bLocalUseExceptions ) {
19502 114 : popErrorHandler();
19503 : }
19504 : #ifndef SED_HACKS
19505 : if ( bLocalUseExceptions ) {
19506 : CPLErr eclass = CPLGetLastErrorType();
19507 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19508 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19509 : }
19510 : }
19511 : #endif
19512 : }
19513 122 : resultobj = SWIG_Py_Void();
19514 122 : {
19515 : /* %typemap(freearg) (int nList, GIntBig* pList) */
19516 122 : free(arg4);
19517 : }
19518 122 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19519 : return resultobj;
19520 0 : fail:
19521 0 : {
19522 : /* %typemap(freearg) (int nList, GIntBig* pList) */
19523 0 : free(arg4);
19524 : }
19525 0 : return NULL;
19526 : }
19527 :
19528 :
19529 90 : SWIGINTERN PyObject *_wrap_Feature_SetFieldDoubleList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19530 90 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19531 90 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19532 90 : int arg2 ;
19533 90 : int arg3 ;
19534 90 : double *arg4 = (double *) 0 ;
19535 90 : void *argp1 = 0 ;
19536 90 : int res1 = 0 ;
19537 90 : int val2 ;
19538 90 : int ecode2 = 0 ;
19539 90 : PyObject *swig_obj[3] ;
19540 :
19541 90 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFieldDoubleList", 3, 3, swig_obj)) SWIG_fail;
19542 90 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19543 90 : if (!SWIG_IsOK(res1)) {
19544 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldDoubleList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19545 : }
19546 90 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19547 90 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
19548 90 : if (!SWIG_IsOK(ecode2)) {
19549 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldDoubleList" "', argument " "2"" of type '" "int""'");
19550 : }
19551 90 : arg2 = static_cast< int >(val2);
19552 90 : {
19553 : /* %typemap(in,numinputs=1) (int nList, double* pList)*/
19554 90 : arg4 = CreateCDoubleListFromSequence(swig_obj[2], &arg3);
19555 90 : if( arg3 < 0 ) {
19556 0 : SWIG_fail;
19557 : }
19558 : }
19559 90 : {
19560 90 : const int bLocalUseExceptions = GetUseExceptions();
19561 90 : if ( bLocalUseExceptions ) {
19562 74 : pushErrorHandler();
19563 : }
19564 90 : {
19565 90 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19566 90 : OGRFeatureShadow_SetFieldDoubleList(arg1,arg2,arg3,arg4);
19567 90 : SWIG_PYTHON_THREAD_END_ALLOW;
19568 : }
19569 90 : if ( bLocalUseExceptions ) {
19570 74 : popErrorHandler();
19571 : }
19572 : #ifndef SED_HACKS
19573 : if ( bLocalUseExceptions ) {
19574 : CPLErr eclass = CPLGetLastErrorType();
19575 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19576 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19577 : }
19578 : }
19579 : #endif
19580 : }
19581 90 : resultobj = SWIG_Py_Void();
19582 90 : {
19583 : /* %typemap(freearg) (int nList, double* pList) */
19584 90 : free(arg4);
19585 : }
19586 90 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19587 : return resultobj;
19588 0 : fail:
19589 0 : {
19590 : /* %typemap(freearg) (int nList, double* pList) */
19591 0 : free(arg4);
19592 : }
19593 0 : return NULL;
19594 : }
19595 :
19596 :
19597 42 : SWIGINTERN PyObject *_wrap_Feature_SetFieldStringList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19598 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19599 42 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19600 42 : int arg2 ;
19601 42 : char **arg3 = (char **) 0 ;
19602 42 : void *argp1 = 0 ;
19603 42 : int res1 = 0 ;
19604 42 : int val2 ;
19605 42 : int ecode2 = 0 ;
19606 42 : PyObject *swig_obj[3] ;
19607 :
19608 42 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFieldStringList", 3, 3, swig_obj)) SWIG_fail;
19609 42 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19610 42 : if (!SWIG_IsOK(res1)) {
19611 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldStringList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19612 : }
19613 42 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19614 42 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
19615 42 : if (!SWIG_IsOK(ecode2)) {
19616 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldStringList" "', argument " "2"" of type '" "int""'");
19617 : }
19618 42 : arg2 = static_cast< int >(val2);
19619 42 : {
19620 : /* %typemap(in) char **dict */
19621 42 : arg3 = NULL;
19622 42 : if ( PySequence_Check( swig_obj[2] ) ) {
19623 42 : int bErr = FALSE;
19624 42 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
19625 42 : if ( bErr )
19626 : {
19627 0 : SWIG_fail;
19628 : }
19629 : }
19630 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
19631 0 : int bErr = FALSE;
19632 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
19633 0 : if ( bErr )
19634 : {
19635 0 : SWIG_fail;
19636 : }
19637 : }
19638 : else {
19639 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
19640 0 : SWIG_fail;
19641 : }
19642 : }
19643 42 : {
19644 42 : const int bLocalUseExceptions = GetUseExceptions();
19645 42 : if ( bLocalUseExceptions ) {
19646 38 : pushErrorHandler();
19647 : }
19648 42 : {
19649 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19650 42 : OGRFeatureShadow_SetFieldStringList(arg1,arg2,arg3);
19651 42 : SWIG_PYTHON_THREAD_END_ALLOW;
19652 : }
19653 42 : if ( bLocalUseExceptions ) {
19654 38 : popErrorHandler();
19655 : }
19656 : #ifndef SED_HACKS
19657 : if ( bLocalUseExceptions ) {
19658 : CPLErr eclass = CPLGetLastErrorType();
19659 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19660 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19661 : }
19662 : }
19663 : #endif
19664 : }
19665 42 : resultobj = SWIG_Py_Void();
19666 42 : {
19667 : /* %typemap(freearg) char **dict */
19668 42 : CSLDestroy( arg3 );
19669 : }
19670 42 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19671 : return resultobj;
19672 0 : fail:
19673 0 : {
19674 : /* %typemap(freearg) char **dict */
19675 0 : CSLDestroy( arg3 );
19676 : }
19677 : return NULL;
19678 : }
19679 :
19680 :
19681 515 : SWIGINTERN PyObject *_wrap_Feature__SetFieldBinary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19682 515 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19683 515 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19684 515 : int arg2 ;
19685 515 : int arg3 ;
19686 515 : char *arg4 = (char *) 0 ;
19687 515 : void *argp1 = 0 ;
19688 515 : int res1 = 0 ;
19689 515 : int val2 ;
19690 515 : int ecode2 = 0 ;
19691 515 : int alloc3 = 0 ;
19692 515 : bool viewIsValid3 = false ;
19693 515 : Py_buffer view3 ;
19694 515 : PyObject *swig_obj[3] ;
19695 :
19696 515 : if (!SWIG_Python_UnpackTuple(args, "Feature__SetFieldBinary", 3, 3, swig_obj)) SWIG_fail;
19697 515 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19698 515 : if (!SWIG_IsOK(res1)) {
19699 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature__SetFieldBinary" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19700 : }
19701 515 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19702 515 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
19703 515 : if (!SWIG_IsOK(ecode2)) {
19704 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature__SetFieldBinary" "', argument " "2"" of type '" "int""'");
19705 : }
19706 515 : arg2 = static_cast< int >(val2);
19707 515 : {
19708 : /* %typemap(in,numinputs=1) (int nLen, char *pBuf ) */
19709 515 : char* ptr = NULL;
19710 515 : if( !GetBufferAsCharPtrIntSize(swig_obj[2], &arg3, &ptr, &alloc3, &viewIsValid3, &view3) ) {
19711 0 : SWIG_fail;
19712 : }
19713 515 : arg4 = (char *)ptr;
19714 : }
19715 515 : {
19716 515 : const int bLocalUseExceptions = GetUseExceptions();
19717 515 : if ( bLocalUseExceptions ) {
19718 54 : pushErrorHandler();
19719 : }
19720 515 : {
19721 515 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19722 515 : OGRFeatureShadow__SetFieldBinary(arg1,arg2,arg3,arg4);
19723 515 : SWIG_PYTHON_THREAD_END_ALLOW;
19724 : }
19725 515 : if ( bLocalUseExceptions ) {
19726 54 : popErrorHandler();
19727 : }
19728 : #ifndef SED_HACKS
19729 : if ( bLocalUseExceptions ) {
19730 : CPLErr eclass = CPLGetLastErrorType();
19731 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19732 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19733 : }
19734 : }
19735 : #endif
19736 : }
19737 515 : resultobj = SWIG_Py_Void();
19738 515 : {
19739 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
19740 515 : if( viewIsValid3 ) {
19741 515 : PyBuffer_Release(&view3);
19742 : }
19743 0 : else if (ReturnSame(alloc3) == SWIG_NEWOBJ ) {
19744 0 : delete[] arg4;
19745 : }
19746 : }
19747 515 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19748 : return resultobj;
19749 0 : fail:
19750 0 : {
19751 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
19752 0 : if( viewIsValid3 ) {
19753 0 : PyBuffer_Release(&view3);
19754 : }
19755 515 : else if (ReturnSame(alloc3) == SWIG_NEWOBJ ) {
19756 : delete[] arg4;
19757 : }
19758 : }
19759 : return NULL;
19760 : }
19761 :
19762 :
19763 : SWIGINTERN PyObject *_wrap_Feature_SetFieldBinaryFromHexString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
19764 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19765 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19766 : int arg2 ;
19767 : char *arg3 = (char *) 0 ;
19768 : void *argp1 = 0 ;
19769 : int res1 = 0 ;
19770 : int val2 ;
19771 : int ecode2 = 0 ;
19772 : int res3 ;
19773 : char *buf3 = 0 ;
19774 : int alloc3 = 0 ;
19775 :
19776 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
19777 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19778 : if (!SWIG_IsOK(res1)) {
19779 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldBinaryFromHexString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19780 : }
19781 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19782 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
19783 : if (!SWIG_IsOK(ecode2)) {
19784 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldBinaryFromHexString" "', argument " "2"" of type '" "int""'");
19785 : }
19786 : arg2 = static_cast< int >(val2);
19787 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
19788 : if (!SWIG_IsOK(res3)) {
19789 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Feature_SetFieldBinaryFromHexString" "', argument " "3"" of type '" "char const *""'");
19790 : }
19791 : arg3 = reinterpret_cast< char * >(buf3);
19792 : {
19793 : const int bLocalUseExceptions = GetUseExceptions();
19794 : if ( bLocalUseExceptions ) {
19795 : pushErrorHandler();
19796 : }
19797 : {
19798 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19799 : OGRFeatureShadow_SetFieldBinaryFromHexString__SWIG_0(arg1,arg2,(char const *)arg3);
19800 : SWIG_PYTHON_THREAD_END_ALLOW;
19801 : }
19802 : if ( bLocalUseExceptions ) {
19803 : popErrorHandler();
19804 : }
19805 : #ifndef SED_HACKS
19806 : if ( bLocalUseExceptions ) {
19807 : CPLErr eclass = CPLGetLastErrorType();
19808 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19809 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19810 : }
19811 : }
19812 : #endif
19813 : }
19814 : resultobj = SWIG_Py_Void();
19815 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19816 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19817 : return resultobj;
19818 : fail:
19819 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19820 : return NULL;
19821 : }
19822 :
19823 :
19824 : SWIGINTERN PyObject *_wrap_Feature_SetFieldBinaryFromHexString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
19825 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19826 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19827 : char *arg2 = (char *) 0 ;
19828 : char *arg3 = (char *) 0 ;
19829 : void *argp1 = 0 ;
19830 : int res1 = 0 ;
19831 : int bToFree2 = 0 ;
19832 : int res3 ;
19833 : char *buf3 = 0 ;
19834 : int alloc3 = 0 ;
19835 :
19836 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
19837 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19838 : if (!SWIG_IsOK(res1)) {
19839 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldBinaryFromHexString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19840 : }
19841 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19842 : {
19843 : /* %typemap(in) (const char *utf8_path) */
19844 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
19845 : {
19846 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
19847 : }
19848 : else
19849 : {
19850 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
19851 :
19852 : }
19853 : if (arg2 == NULL)
19854 : {
19855 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
19856 : SWIG_fail;
19857 : }
19858 : }
19859 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
19860 : if (!SWIG_IsOK(res3)) {
19861 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Feature_SetFieldBinaryFromHexString" "', argument " "3"" of type '" "char const *""'");
19862 : }
19863 : arg3 = reinterpret_cast< char * >(buf3);
19864 : {
19865 : const int bLocalUseExceptions = GetUseExceptions();
19866 : if ( bLocalUseExceptions ) {
19867 : pushErrorHandler();
19868 : }
19869 : {
19870 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19871 : OGRFeatureShadow_SetFieldBinaryFromHexString__SWIG_1(arg1,(char const *)arg2,(char const *)arg3);
19872 : SWIG_PYTHON_THREAD_END_ALLOW;
19873 : }
19874 : if ( bLocalUseExceptions ) {
19875 : popErrorHandler();
19876 : }
19877 : #ifndef SED_HACKS
19878 : if ( bLocalUseExceptions ) {
19879 : CPLErr eclass = CPLGetLastErrorType();
19880 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19881 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19882 : }
19883 : }
19884 : #endif
19885 : }
19886 : resultobj = SWIG_Py_Void();
19887 : {
19888 : /* %typemap(freearg) (const char *utf8_path) */
19889 : GDALPythonFreeCStr(arg2, bToFree2);
19890 : }
19891 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19892 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19893 : return resultobj;
19894 : fail:
19895 : {
19896 : /* %typemap(freearg) (const char *utf8_path) */
19897 : GDALPythonFreeCStr(arg2, bToFree2);
19898 : }
19899 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19900 : return NULL;
19901 : }
19902 :
19903 :
19904 6 : SWIGINTERN PyObject *_wrap_Feature_SetFieldBinaryFromHexString(PyObject *self, PyObject *args) {
19905 6 : Py_ssize_t argc;
19906 6 : PyObject *argv[4] = {
19907 : 0
19908 : };
19909 :
19910 6 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_SetFieldBinaryFromHexString", 0, 3, argv))) SWIG_fail;
19911 6 : --argc;
19912 6 : if (argc == 3) {
19913 6 : int _v;
19914 6 : void *vptr = 0;
19915 6 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19916 8 : _v = SWIG_CheckState(res);
19917 6 : if (_v) {
19918 6 : {
19919 6 : int res = SWIG_AsVal_int(argv[1], NULL);
19920 6 : _v = SWIG_CheckState(res);
19921 : }
19922 4 : if (_v) {
19923 4 : int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
19924 4 : _v = SWIG_CheckState(res);
19925 4 : if (_v) {
19926 4 : return _wrap_Feature_SetFieldBinaryFromHexString__SWIG_0(self, argc, argv);
19927 : }
19928 : }
19929 : }
19930 : }
19931 2 : if (argc == 3) {
19932 2 : int _v;
19933 2 : void *vptr = 0;
19934 2 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19935 2 : _v = SWIG_CheckState(res);
19936 2 : if (_v) {
19937 2 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
19938 2 : _v = SWIG_CheckState(res);
19939 2 : if (_v) {
19940 2 : int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
19941 2 : _v = SWIG_CheckState(res);
19942 2 : if (_v) {
19943 2 : return _wrap_Feature_SetFieldBinaryFromHexString__SWIG_1(self, argc, argv);
19944 : }
19945 : }
19946 : }
19947 : }
19948 :
19949 0 : fail:
19950 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_SetFieldBinaryFromHexString'.\n"
19951 : " Possible C/C++ prototypes are:\n"
19952 : " OGRFeatureShadow::SetFieldBinaryFromHexString(int,char const *)\n"
19953 : " OGRFeatureShadow::SetFieldBinaryFromHexString(char const *,char const *)\n");
19954 : return 0;
19955 : }
19956 :
19957 :
19958 1734 : SWIGINTERN PyObject *_wrap_Feature_SetFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19959 1734 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19960 1734 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19961 1734 : OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
19962 1734 : int arg3 = (int) 1 ;
19963 1734 : void *argp1 = 0 ;
19964 1734 : int res1 = 0 ;
19965 1734 : void *argp2 = 0 ;
19966 1734 : int res2 = 0 ;
19967 1734 : int val3 ;
19968 1734 : int ecode3 = 0 ;
19969 1734 : PyObject * obj0 = 0 ;
19970 1734 : PyObject * obj1 = 0 ;
19971 1734 : PyObject * obj2 = 0 ;
19972 1734 : char * kwnames[] = {
19973 : (char *)"self", (char *)"other", (char *)"forgiving", NULL
19974 : };
19975 1734 : OGRErr result;
19976 :
19977 1734 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Feature_SetFrom", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
19978 1734 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19979 1734 : if (!SWIG_IsOK(res1)) {
19980 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFrom" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19981 : }
19982 1734 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19983 1734 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19984 1734 : if (!SWIG_IsOK(res2)) {
19985 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_SetFrom" "', argument " "2"" of type '" "OGRFeatureShadow *""'");
19986 : }
19987 1734 : arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
19988 1734 : if (obj2) {
19989 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
19990 0 : if (!SWIG_IsOK(ecode3)) {
19991 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Feature_SetFrom" "', argument " "3"" of type '" "int""'");
19992 : }
19993 : arg3 = static_cast< int >(val3);
19994 : }
19995 1734 : {
19996 1734 : if (!arg2) {
19997 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
19998 : }
19999 : }
20000 1734 : {
20001 1734 : const int bLocalUseExceptions = GetUseExceptions();
20002 1734 : if ( bLocalUseExceptions ) {
20003 75 : pushErrorHandler();
20004 : }
20005 1734 : {
20006 1734 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20007 1734 : result = (OGRErr)OGRFeatureShadow_SetFrom(arg1,arg2,arg3);
20008 1734 : SWIG_PYTHON_THREAD_END_ALLOW;
20009 : }
20010 1734 : if ( bLocalUseExceptions ) {
20011 75 : popErrorHandler();
20012 : }
20013 : #ifndef SED_HACKS
20014 : if ( bLocalUseExceptions ) {
20015 : CPLErr eclass = CPLGetLastErrorType();
20016 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20017 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20018 : }
20019 : }
20020 : #endif
20021 : }
20022 1734 : {
20023 : /* %typemap(out) OGRErr */
20024 1734 : if ( result != 0 && GetUseExceptions()) {
20025 0 : const char* pszMessage = CPLGetLastErrorMsg();
20026 0 : if( pszMessage[0] != '\0' )
20027 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
20028 : else
20029 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
20030 0 : SWIG_fail;
20031 : }
20032 : }
20033 1734 : {
20034 : /* %typemap(ret) OGRErr */
20035 1734 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
20036 1734 : resultobj = PyInt_FromLong( result );
20037 : }
20038 : }
20039 1734 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20040 : return resultobj;
20041 : fail:
20042 : return NULL;
20043 : }
20044 :
20045 :
20046 0 : SWIGINTERN PyObject *_wrap_Feature_SetFromWithMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20047 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20048 0 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20049 0 : OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
20050 0 : int arg3 ;
20051 0 : int arg4 ;
20052 0 : int *arg5 = (int *) 0 ;
20053 0 : void *argp1 = 0 ;
20054 0 : int res1 = 0 ;
20055 0 : void *argp2 = 0 ;
20056 0 : int res2 = 0 ;
20057 0 : int val3 ;
20058 0 : int ecode3 = 0 ;
20059 0 : PyObject *swig_obj[4] ;
20060 0 : OGRErr result;
20061 :
20062 0 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFromWithMap", 4, 4, swig_obj)) SWIG_fail;
20063 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20064 0 : if (!SWIG_IsOK(res1)) {
20065 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFromWithMap" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20066 : }
20067 0 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20068 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20069 0 : if (!SWIG_IsOK(res2)) {
20070 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_SetFromWithMap" "', argument " "2"" of type '" "OGRFeatureShadow *""'");
20071 : }
20072 0 : arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
20073 0 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
20074 0 : if (!SWIG_IsOK(ecode3)) {
20075 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Feature_SetFromWithMap" "', argument " "3"" of type '" "int""'");
20076 : }
20077 0 : arg3 = static_cast< int >(val3);
20078 0 : {
20079 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
20080 0 : arg5 = CreateCIntListFromSequence(swig_obj[3], &arg4);
20081 0 : if( arg4 < 0 ) {
20082 0 : SWIG_fail;
20083 : }
20084 : }
20085 0 : {
20086 0 : if (!arg2) {
20087 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
20088 : }
20089 : }
20090 0 : {
20091 0 : const int bLocalUseExceptions = GetUseExceptions();
20092 0 : if ( bLocalUseExceptions ) {
20093 0 : pushErrorHandler();
20094 : }
20095 0 : {
20096 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20097 0 : result = (OGRErr)OGRFeatureShadow_SetFromWithMap(arg1,arg2,arg3,arg4,arg5);
20098 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20099 : }
20100 0 : if ( bLocalUseExceptions ) {
20101 0 : popErrorHandler();
20102 : }
20103 : #ifndef SED_HACKS
20104 : if ( bLocalUseExceptions ) {
20105 : CPLErr eclass = CPLGetLastErrorType();
20106 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20107 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20108 : }
20109 : }
20110 : #endif
20111 : }
20112 0 : {
20113 : /* %typemap(out) OGRErr */
20114 0 : if ( result != 0 && GetUseExceptions()) {
20115 0 : const char* pszMessage = CPLGetLastErrorMsg();
20116 0 : if( pszMessage[0] != '\0' )
20117 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
20118 : else
20119 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
20120 0 : SWIG_fail;
20121 : }
20122 : }
20123 0 : {
20124 : /* %typemap(freearg) (int nList, int* pList) */
20125 0 : free(arg5);
20126 : }
20127 0 : {
20128 : /* %typemap(ret) OGRErr */
20129 0 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
20130 0 : resultobj = PyInt_FromLong( result );
20131 : }
20132 : }
20133 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20134 : return resultobj;
20135 0 : fail:
20136 0 : {
20137 : /* %typemap(freearg) (int nList, int* pList) */
20138 0 : free(arg5);
20139 : }
20140 0 : return NULL;
20141 : }
20142 :
20143 :
20144 746 : SWIGINTERN PyObject *_wrap_Feature_GetStyleString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20145 746 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20146 746 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20147 746 : void *argp1 = 0 ;
20148 746 : int res1 = 0 ;
20149 746 : PyObject *swig_obj[1] ;
20150 746 : char *result = 0 ;
20151 :
20152 746 : if (!args) SWIG_fail;
20153 746 : swig_obj[0] = args;
20154 746 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20155 746 : if (!SWIG_IsOK(res1)) {
20156 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetStyleString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20157 : }
20158 746 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20159 746 : {
20160 746 : const int bLocalUseExceptions = GetUseExceptions();
20161 746 : if ( bLocalUseExceptions ) {
20162 37 : pushErrorHandler();
20163 : }
20164 746 : {
20165 746 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20166 746 : result = (char *)OGRFeatureShadow_GetStyleString(arg1);
20167 746 : SWIG_PYTHON_THREAD_END_ALLOW;
20168 : }
20169 746 : if ( bLocalUseExceptions ) {
20170 37 : popErrorHandler();
20171 : }
20172 : #ifndef SED_HACKS
20173 : if ( bLocalUseExceptions ) {
20174 : CPLErr eclass = CPLGetLastErrorType();
20175 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20176 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20177 : }
20178 : }
20179 : #endif
20180 : }
20181 746 : resultobj = SWIG_FromCharPtr((const char *)result);
20182 746 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20183 : return resultobj;
20184 : fail:
20185 : return NULL;
20186 : }
20187 :
20188 :
20189 104 : SWIGINTERN PyObject *_wrap_Feature_SetStyleString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20190 104 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20191 104 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20192 104 : char *arg2 = (char *) 0 ;
20193 104 : void *argp1 = 0 ;
20194 104 : int res1 = 0 ;
20195 104 : int res2 ;
20196 104 : char *buf2 = 0 ;
20197 104 : int alloc2 = 0 ;
20198 104 : PyObject *swig_obj[2] ;
20199 :
20200 104 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetStyleString", 2, 2, swig_obj)) SWIG_fail;
20201 104 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20202 104 : if (!SWIG_IsOK(res1)) {
20203 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetStyleString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20204 : }
20205 104 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20206 104 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
20207 104 : if (!SWIG_IsOK(res2)) {
20208 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_SetStyleString" "', argument " "2"" of type '" "char const *""'");
20209 : }
20210 104 : arg2 = reinterpret_cast< char * >(buf2);
20211 104 : {
20212 104 : const int bLocalUseExceptions = GetUseExceptions();
20213 104 : if ( bLocalUseExceptions ) {
20214 79 : pushErrorHandler();
20215 : }
20216 104 : {
20217 104 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20218 104 : OGRFeatureShadow_SetStyleString(arg1,(char const *)arg2);
20219 104 : SWIG_PYTHON_THREAD_END_ALLOW;
20220 : }
20221 104 : if ( bLocalUseExceptions ) {
20222 79 : popErrorHandler();
20223 : }
20224 : #ifndef SED_HACKS
20225 : if ( bLocalUseExceptions ) {
20226 : CPLErr eclass = CPLGetLastErrorType();
20227 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20228 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20229 : }
20230 : }
20231 : #endif
20232 : }
20233 104 : resultobj = SWIG_Py_Void();
20234 104 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20235 104 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20236 : return resultobj;
20237 0 : fail:
20238 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20239 : return NULL;
20240 : }
20241 :
20242 :
20243 : SWIGINTERN PyObject *_wrap_Feature_GetFieldType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
20244 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20245 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20246 : int arg2 ;
20247 : void *argp1 = 0 ;
20248 : int res1 = 0 ;
20249 : int val2 ;
20250 : int ecode2 = 0 ;
20251 : OGRFieldType result;
20252 :
20253 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
20254 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20255 : if (!SWIG_IsOK(res1)) {
20256 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldType" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20257 : }
20258 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20259 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20260 : if (!SWIG_IsOK(ecode2)) {
20261 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldType" "', argument " "2"" of type '" "int""'");
20262 : }
20263 : arg2 = static_cast< int >(val2);
20264 : {
20265 : const int bLocalUseExceptions = GetUseExceptions();
20266 : if ( bLocalUseExceptions ) {
20267 : pushErrorHandler();
20268 : }
20269 : {
20270 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20271 : result = (OGRFieldType)OGRFeatureShadow_GetFieldType__SWIG_0(arg1,arg2);
20272 : SWIG_PYTHON_THREAD_END_ALLOW;
20273 : }
20274 : if ( bLocalUseExceptions ) {
20275 : popErrorHandler();
20276 : }
20277 : #ifndef SED_HACKS
20278 : if ( bLocalUseExceptions ) {
20279 : CPLErr eclass = CPLGetLastErrorType();
20280 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20281 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20282 : }
20283 : }
20284 : #endif
20285 : }
20286 : resultobj = SWIG_From_int(static_cast< int >(result));
20287 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20288 : return resultobj;
20289 : fail:
20290 : return NULL;
20291 : }
20292 :
20293 :
20294 : SWIGINTERN PyObject *_wrap_Feature_GetFieldType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
20295 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20296 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20297 : char *arg2 = (char *) 0 ;
20298 : void *argp1 = 0 ;
20299 : int res1 = 0 ;
20300 : int bToFree2 = 0 ;
20301 : OGRFieldType result;
20302 :
20303 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
20304 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20305 : if (!SWIG_IsOK(res1)) {
20306 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldType" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20307 : }
20308 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20309 : {
20310 : /* %typemap(in) (const char *utf8_path) */
20311 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
20312 : {
20313 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
20314 : }
20315 : else
20316 : {
20317 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
20318 :
20319 : }
20320 : if (arg2 == NULL)
20321 : {
20322 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
20323 : SWIG_fail;
20324 : }
20325 : }
20326 : {
20327 : const int bLocalUseExceptions = GetUseExceptions();
20328 : if ( bLocalUseExceptions ) {
20329 : pushErrorHandler();
20330 : }
20331 : {
20332 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20333 : result = (OGRFieldType)OGRFeatureShadow_GetFieldType__SWIG_1(arg1,(char const *)arg2);
20334 : SWIG_PYTHON_THREAD_END_ALLOW;
20335 : }
20336 : if ( bLocalUseExceptions ) {
20337 : popErrorHandler();
20338 : }
20339 : #ifndef SED_HACKS
20340 : if ( bLocalUseExceptions ) {
20341 : CPLErr eclass = CPLGetLastErrorType();
20342 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20343 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20344 : }
20345 : }
20346 : #endif
20347 : }
20348 : resultobj = SWIG_From_int(static_cast< int >(result));
20349 : {
20350 : /* %typemap(freearg) (const char *utf8_path) */
20351 : GDALPythonFreeCStr(arg2, bToFree2);
20352 : }
20353 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20354 : return resultobj;
20355 : fail:
20356 : {
20357 : /* %typemap(freearg) (const char *utf8_path) */
20358 : GDALPythonFreeCStr(arg2, bToFree2);
20359 : }
20360 : return NULL;
20361 : }
20362 :
20363 :
20364 100648 : SWIGINTERN PyObject *_wrap_Feature_GetFieldType(PyObject *self, PyObject *args) {
20365 100648 : Py_ssize_t argc;
20366 100648 : PyObject *argv[3] = {
20367 : 0
20368 : };
20369 :
20370 100648 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldType", 0, 2, argv))) SWIG_fail;
20371 100648 : --argc;
20372 100648 : if (argc == 2) {
20373 100648 : int _v;
20374 100648 : void *vptr = 0;
20375 100648 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
20376 100648 : _v = SWIG_CheckState(res);
20377 100648 : if (_v) {
20378 100648 : {
20379 100648 : int res = SWIG_AsVal_int(argv[1], NULL);
20380 100648 : _v = SWIG_CheckState(res);
20381 : }
20382 100648 : if (_v) {
20383 100648 : return _wrap_Feature_GetFieldType__SWIG_0(self, argc, argv);
20384 : }
20385 : }
20386 : }
20387 0 : if (argc == 2) {
20388 0 : int _v;
20389 0 : void *vptr = 0;
20390 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
20391 0 : _v = SWIG_CheckState(res);
20392 0 : if (_v) {
20393 0 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
20394 0 : _v = SWIG_CheckState(res);
20395 0 : if (_v) {
20396 0 : return _wrap_Feature_GetFieldType__SWIG_1(self, argc, argv);
20397 : }
20398 : }
20399 : }
20400 :
20401 0 : fail:
20402 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldType'.\n"
20403 : " Possible C/C++ prototypes are:\n"
20404 : " OGRFeatureShadow::GetFieldType(int)\n"
20405 : " OGRFeatureShadow::GetFieldType(char const *)\n");
20406 : return 0;
20407 : }
20408 :
20409 :
20410 10 : SWIGINTERN PyObject *_wrap_Feature_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20411 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20412 10 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20413 10 : int arg2 = (int) OGR_F_VAL_ALL ;
20414 10 : int arg3 = (int) TRUE ;
20415 10 : void *argp1 = 0 ;
20416 10 : int res1 = 0 ;
20417 10 : int val2 ;
20418 10 : int ecode2 = 0 ;
20419 10 : int val3 ;
20420 10 : int ecode3 = 0 ;
20421 10 : PyObject *swig_obj[3] ;
20422 10 : int result;
20423 :
20424 10 : if (!SWIG_Python_UnpackTuple(args, "Feature_Validate", 1, 3, swig_obj)) SWIG_fail;
20425 10 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20426 10 : if (!SWIG_IsOK(res1)) {
20427 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_Validate" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20428 : }
20429 10 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20430 10 : if (swig_obj[1]) {
20431 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20432 0 : if (!SWIG_IsOK(ecode2)) {
20433 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_Validate" "', argument " "2"" of type '" "int""'");
20434 : }
20435 : arg2 = static_cast< int >(val2);
20436 : }
20437 10 : if (swig_obj[2]) {
20438 0 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
20439 0 : if (!SWIG_IsOK(ecode3)) {
20440 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Feature_Validate" "', argument " "3"" of type '" "int""'");
20441 : }
20442 : arg3 = static_cast< int >(val3);
20443 : }
20444 10 : {
20445 10 : const int bLocalUseExceptions = GetUseExceptions();
20446 10 : if ( bLocalUseExceptions ) {
20447 10 : pushErrorHandler();
20448 : }
20449 10 : {
20450 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20451 10 : result = (int)OGRFeatureShadow_Validate(arg1,arg2,arg3);
20452 10 : SWIG_PYTHON_THREAD_END_ALLOW;
20453 : }
20454 10 : if ( bLocalUseExceptions ) {
20455 10 : popErrorHandler();
20456 : }
20457 : #ifndef SED_HACKS
20458 : if ( bLocalUseExceptions ) {
20459 : CPLErr eclass = CPLGetLastErrorType();
20460 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20461 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20462 : }
20463 : }
20464 : #endif
20465 : }
20466 10 : resultobj = SWIG_From_int(static_cast< int >(result));
20467 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20468 : return resultobj;
20469 : fail:
20470 : return NULL;
20471 : }
20472 :
20473 :
20474 2 : SWIGINTERN PyObject *_wrap_Feature_FillUnsetWithDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20475 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20476 2 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20477 2 : int arg2 = (int) FALSE ;
20478 2 : char **arg3 = (char **) NULL ;
20479 2 : void *argp1 = 0 ;
20480 2 : int res1 = 0 ;
20481 2 : int val2 ;
20482 2 : int ecode2 = 0 ;
20483 2 : PyObject *swig_obj[3] ;
20484 :
20485 2 : if (!SWIG_Python_UnpackTuple(args, "Feature_FillUnsetWithDefault", 1, 3, swig_obj)) SWIG_fail;
20486 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20487 2 : if (!SWIG_IsOK(res1)) {
20488 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_FillUnsetWithDefault" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20489 : }
20490 2 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20491 2 : if (swig_obj[1]) {
20492 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20493 0 : if (!SWIG_IsOK(ecode2)) {
20494 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_FillUnsetWithDefault" "', argument " "2"" of type '" "int""'");
20495 : }
20496 : arg2 = static_cast< int >(val2);
20497 : }
20498 2 : if (swig_obj[2]) {
20499 0 : {
20500 : /* %typemap(in) char **dict */
20501 0 : arg3 = NULL;
20502 0 : if ( PySequence_Check( swig_obj[2] ) ) {
20503 0 : int bErr = FALSE;
20504 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
20505 0 : if ( bErr )
20506 : {
20507 0 : SWIG_fail;
20508 : }
20509 : }
20510 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
20511 0 : int bErr = FALSE;
20512 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
20513 0 : if ( bErr )
20514 : {
20515 0 : SWIG_fail;
20516 : }
20517 : }
20518 : else {
20519 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
20520 0 : SWIG_fail;
20521 : }
20522 : }
20523 : }
20524 2 : {
20525 2 : const int bLocalUseExceptions = GetUseExceptions();
20526 2 : if ( bLocalUseExceptions ) {
20527 2 : pushErrorHandler();
20528 : }
20529 2 : {
20530 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20531 2 : OGRFeatureShadow_FillUnsetWithDefault(arg1,arg2,arg3);
20532 2 : SWIG_PYTHON_THREAD_END_ALLOW;
20533 : }
20534 2 : if ( bLocalUseExceptions ) {
20535 2 : popErrorHandler();
20536 : }
20537 : #ifndef SED_HACKS
20538 : if ( bLocalUseExceptions ) {
20539 : CPLErr eclass = CPLGetLastErrorType();
20540 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20541 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20542 : }
20543 : }
20544 : #endif
20545 : }
20546 2 : resultobj = SWIG_Py_Void();
20547 2 : {
20548 : /* %typemap(freearg) char **dict */
20549 2 : CSLDestroy( arg3 );
20550 : }
20551 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20552 : return resultobj;
20553 0 : fail:
20554 0 : {
20555 : /* %typemap(freearg) char **dict */
20556 0 : CSLDestroy( arg3 );
20557 : }
20558 : return NULL;
20559 : }
20560 :
20561 :
20562 9 : SWIGINTERN PyObject *_wrap_Feature_GetNativeData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20563 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20564 9 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20565 9 : void *argp1 = 0 ;
20566 9 : int res1 = 0 ;
20567 9 : PyObject *swig_obj[1] ;
20568 9 : char *result = 0 ;
20569 :
20570 9 : if (!args) SWIG_fail;
20571 9 : swig_obj[0] = args;
20572 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20573 9 : if (!SWIG_IsOK(res1)) {
20574 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetNativeData" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20575 : }
20576 9 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20577 9 : {
20578 9 : const int bLocalUseExceptions = GetUseExceptions();
20579 9 : if ( bLocalUseExceptions ) {
20580 9 : pushErrorHandler();
20581 : }
20582 9 : {
20583 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20584 9 : result = (char *)OGRFeatureShadow_GetNativeData(arg1);
20585 9 : SWIG_PYTHON_THREAD_END_ALLOW;
20586 : }
20587 9 : if ( bLocalUseExceptions ) {
20588 9 : popErrorHandler();
20589 : }
20590 : #ifndef SED_HACKS
20591 : if ( bLocalUseExceptions ) {
20592 : CPLErr eclass = CPLGetLastErrorType();
20593 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20594 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20595 : }
20596 : }
20597 : #endif
20598 : }
20599 9 : resultobj = SWIG_FromCharPtr((const char *)result);
20600 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20601 : return resultobj;
20602 : fail:
20603 : return NULL;
20604 : }
20605 :
20606 :
20607 9 : SWIGINTERN PyObject *_wrap_Feature_GetNativeMediaType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20608 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20609 9 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20610 9 : void *argp1 = 0 ;
20611 9 : int res1 = 0 ;
20612 9 : PyObject *swig_obj[1] ;
20613 9 : char *result = 0 ;
20614 :
20615 9 : if (!args) SWIG_fail;
20616 9 : swig_obj[0] = args;
20617 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20618 9 : if (!SWIG_IsOK(res1)) {
20619 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetNativeMediaType" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20620 : }
20621 9 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20622 9 : {
20623 9 : const int bLocalUseExceptions = GetUseExceptions();
20624 9 : if ( bLocalUseExceptions ) {
20625 9 : pushErrorHandler();
20626 : }
20627 9 : {
20628 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20629 9 : result = (char *)OGRFeatureShadow_GetNativeMediaType(arg1);
20630 9 : SWIG_PYTHON_THREAD_END_ALLOW;
20631 : }
20632 9 : if ( bLocalUseExceptions ) {
20633 9 : popErrorHandler();
20634 : }
20635 : #ifndef SED_HACKS
20636 : if ( bLocalUseExceptions ) {
20637 : CPLErr eclass = CPLGetLastErrorType();
20638 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20639 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20640 : }
20641 : }
20642 : #endif
20643 : }
20644 9 : resultobj = SWIG_FromCharPtr((const char *)result);
20645 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20646 : return resultobj;
20647 : fail:
20648 : return NULL;
20649 : }
20650 :
20651 :
20652 4 : SWIGINTERN PyObject *_wrap_Feature_SetNativeData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20653 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20654 4 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20655 4 : char *arg2 = (char *) 0 ;
20656 4 : void *argp1 = 0 ;
20657 4 : int res1 = 0 ;
20658 4 : int res2 ;
20659 4 : char *buf2 = 0 ;
20660 4 : int alloc2 = 0 ;
20661 4 : PyObject *swig_obj[2] ;
20662 :
20663 4 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetNativeData", 2, 2, swig_obj)) SWIG_fail;
20664 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20665 4 : if (!SWIG_IsOK(res1)) {
20666 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetNativeData" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20667 : }
20668 4 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20669 4 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
20670 4 : if (!SWIG_IsOK(res2)) {
20671 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_SetNativeData" "', argument " "2"" of type '" "char const *""'");
20672 : }
20673 4 : arg2 = reinterpret_cast< char * >(buf2);
20674 4 : {
20675 4 : const int bLocalUseExceptions = GetUseExceptions();
20676 4 : if ( bLocalUseExceptions ) {
20677 4 : pushErrorHandler();
20678 : }
20679 4 : {
20680 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20681 4 : OGRFeatureShadow_SetNativeData(arg1,(char const *)arg2);
20682 4 : SWIG_PYTHON_THREAD_END_ALLOW;
20683 : }
20684 4 : if ( bLocalUseExceptions ) {
20685 4 : popErrorHandler();
20686 : }
20687 : #ifndef SED_HACKS
20688 : if ( bLocalUseExceptions ) {
20689 : CPLErr eclass = CPLGetLastErrorType();
20690 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20691 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20692 : }
20693 : }
20694 : #endif
20695 : }
20696 4 : resultobj = SWIG_Py_Void();
20697 4 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20698 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20699 : return resultobj;
20700 0 : fail:
20701 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20702 : return NULL;
20703 : }
20704 :
20705 :
20706 4 : SWIGINTERN PyObject *_wrap_Feature_SetNativeMediaType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20707 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20708 4 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20709 4 : char *arg2 = (char *) 0 ;
20710 4 : void *argp1 = 0 ;
20711 4 : int res1 = 0 ;
20712 4 : int res2 ;
20713 4 : char *buf2 = 0 ;
20714 4 : int alloc2 = 0 ;
20715 4 : PyObject *swig_obj[2] ;
20716 :
20717 4 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetNativeMediaType", 2, 2, swig_obj)) SWIG_fail;
20718 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20719 4 : if (!SWIG_IsOK(res1)) {
20720 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetNativeMediaType" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20721 : }
20722 4 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20723 4 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
20724 4 : if (!SWIG_IsOK(res2)) {
20725 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_SetNativeMediaType" "', argument " "2"" of type '" "char const *""'");
20726 : }
20727 4 : arg2 = reinterpret_cast< char * >(buf2);
20728 4 : {
20729 4 : const int bLocalUseExceptions = GetUseExceptions();
20730 4 : if ( bLocalUseExceptions ) {
20731 4 : pushErrorHandler();
20732 : }
20733 4 : {
20734 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20735 4 : OGRFeatureShadow_SetNativeMediaType(arg1,(char const *)arg2);
20736 4 : SWIG_PYTHON_THREAD_END_ALLOW;
20737 : }
20738 4 : if ( bLocalUseExceptions ) {
20739 4 : popErrorHandler();
20740 : }
20741 : #ifndef SED_HACKS
20742 : if ( bLocalUseExceptions ) {
20743 : CPLErr eclass = CPLGetLastErrorType();
20744 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20745 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20746 : }
20747 : }
20748 : #endif
20749 : }
20750 4 : resultobj = SWIG_Py_Void();
20751 4 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20752 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20753 : return resultobj;
20754 0 : fail:
20755 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20756 : return NULL;
20757 : }
20758 :
20759 :
20760 11975 : SWIGINTERN PyObject *_wrap_Feature_SetFieldString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20761 11975 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20762 11975 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20763 11975 : int arg2 ;
20764 11975 : char *arg3 = (char *) 0 ;
20765 11975 : void *argp1 = 0 ;
20766 11975 : int res1 = 0 ;
20767 11975 : int val2 ;
20768 11975 : int ecode2 = 0 ;
20769 11975 : int bToFree3 = 0 ;
20770 11975 : PyObject *swig_obj[3] ;
20771 :
20772 11975 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFieldString", 3, 3, swig_obj)) SWIG_fail;
20773 11975 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20774 11975 : if (!SWIG_IsOK(res1)) {
20775 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20776 : }
20777 11975 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20778 11975 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20779 11975 : if (!SWIG_IsOK(ecode2)) {
20780 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldString" "', argument " "2"" of type '" "int""'");
20781 : }
20782 11975 : arg2 = static_cast< int >(val2);
20783 11975 : {
20784 : /* %typemap(in) (const char *utf8_path) */
20785 11975 : if (PyUnicode_Check(swig_obj[2]) || PyBytes_Check(swig_obj[2]))
20786 : {
20787 11975 : arg3 = GDALPythonObjectToCStr( swig_obj[2], &bToFree3 );
20788 : }
20789 : else
20790 : {
20791 0 : arg3 = GDALPythonPathToCStr(swig_obj[2], &bToFree3);
20792 :
20793 : }
20794 11975 : if (arg3 == NULL)
20795 : {
20796 1 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
20797 1 : SWIG_fail;
20798 : }
20799 : }
20800 11974 : {
20801 11974 : const int bLocalUseExceptions = GetUseExceptions();
20802 11974 : if ( bLocalUseExceptions ) {
20803 1804 : pushErrorHandler();
20804 : }
20805 11974 : OGRFeatureShadow_SetFieldString(arg1,arg2,(char const *)arg3);
20806 11974 : if ( bLocalUseExceptions ) {
20807 1804 : popErrorHandler();
20808 : }
20809 : #ifndef SED_HACKS
20810 : if ( bLocalUseExceptions ) {
20811 : CPLErr eclass = CPLGetLastErrorType();
20812 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20813 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20814 : }
20815 : }
20816 : #endif
20817 : }
20818 11974 : resultobj = SWIG_Py_Void();
20819 11974 : {
20820 : /* %typemap(freearg) (const char *utf8_path) */
20821 11974 : GDALPythonFreeCStr(arg3, bToFree3);
20822 : }
20823 11974 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20824 : return resultobj;
20825 1 : fail:
20826 1 : {
20827 : /* %typemap(freearg) (const char *utf8_path) */
20828 11975 : GDALPythonFreeCStr(arg3, bToFree3);
20829 : }
20830 : return NULL;
20831 : }
20832 :
20833 :
20834 273 : SWIGINTERN PyObject *Feature_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20835 273 : PyObject *obj;
20836 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
20837 273 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRFeatureShadow, SWIG_NewClientData(obj));
20838 273 : return SWIG_Py_Void();
20839 : }
20840 :
20841 120637 : SWIGINTERN PyObject *Feature_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20842 120637 : return SWIG_Python_InitShadowInstance(args);
20843 : }
20844 :
20845 126843 : SWIGINTERN PyObject *_wrap_delete_FeatureDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20846 126843 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20847 126843 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
20848 126843 : void *argp1 = 0 ;
20849 126843 : int res1 = 0 ;
20850 126843 : PyObject *swig_obj[1] ;
20851 :
20852 126843 : if (!args) SWIG_fail;
20853 126843 : swig_obj[0] = args;
20854 126843 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, SWIG_POINTER_DISOWN | 0 );
20855 126843 : if (!SWIG_IsOK(res1)) {
20856 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FeatureDefn" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
20857 : }
20858 126843 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
20859 126843 : {
20860 126843 : const int bLocalUseExceptions = GetUseExceptions();
20861 126843 : if ( bLocalUseExceptions ) {
20862 64490 : pushErrorHandler();
20863 : }
20864 126843 : {
20865 126843 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20866 126843 : delete_OGRFeatureDefnShadow(arg1);
20867 126843 : SWIG_PYTHON_THREAD_END_ALLOW;
20868 : }
20869 126843 : if ( bLocalUseExceptions ) {
20870 64490 : popErrorHandler();
20871 : }
20872 : #ifndef SED_HACKS
20873 : if ( bLocalUseExceptions ) {
20874 : CPLErr eclass = CPLGetLastErrorType();
20875 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20876 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20877 : }
20878 : }
20879 : #endif
20880 : }
20881 126843 : resultobj = SWIG_Py_Void();
20882 126843 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20883 : return resultobj;
20884 : fail:
20885 : return NULL;
20886 : }
20887 :
20888 :
20889 110 : SWIGINTERN PyObject *_wrap_new_FeatureDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20890 110 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20891 110 : char *arg1 = (char *) NULL ;
20892 110 : int res1 ;
20893 110 : char *buf1 = 0 ;
20894 110 : int alloc1 = 0 ;
20895 110 : PyObject * obj0 = 0 ;
20896 110 : char * kwnames[] = {
20897 : (char *)"name_null_ok", NULL
20898 : };
20899 110 : OGRFeatureDefnShadow *result = 0 ;
20900 :
20901 110 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_FeatureDefn", kwnames, &obj0)) SWIG_fail;
20902 110 : if (obj0) {
20903 84 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20904 84 : if (!SWIG_IsOK(res1)) {
20905 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FeatureDefn" "', argument " "1"" of type '" "char const *""'");
20906 : }
20907 84 : arg1 = reinterpret_cast< char * >(buf1);
20908 : }
20909 110 : {
20910 110 : const int bLocalUseExceptions = GetUseExceptions();
20911 110 : if ( bLocalUseExceptions ) {
20912 99 : pushErrorHandler();
20913 : }
20914 110 : {
20915 110 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20916 110 : result = (OGRFeatureDefnShadow *)new_OGRFeatureDefnShadow((char const *)arg1);
20917 110 : SWIG_PYTHON_THREAD_END_ALLOW;
20918 : }
20919 110 : if ( bLocalUseExceptions ) {
20920 99 : popErrorHandler();
20921 : }
20922 : #ifndef SED_HACKS
20923 : if ( bLocalUseExceptions ) {
20924 : CPLErr eclass = CPLGetLastErrorType();
20925 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20926 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20927 : }
20928 : }
20929 : #endif
20930 : }
20931 110 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureDefnShadow, SWIG_POINTER_NEW | 0 );
20932 110 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20933 110 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20934 : return resultobj;
20935 0 : fail:
20936 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20937 : return NULL;
20938 : }
20939 :
20940 :
20941 103 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20942 103 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20943 103 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
20944 103 : void *argp1 = 0 ;
20945 103 : int res1 = 0 ;
20946 103 : PyObject *swig_obj[1] ;
20947 103 : char *result = 0 ;
20948 :
20949 103 : if (!args) SWIG_fail;
20950 103 : swig_obj[0] = args;
20951 103 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
20952 103 : if (!SWIG_IsOK(res1)) {
20953 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetName" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
20954 : }
20955 103 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
20956 103 : {
20957 103 : const int bLocalUseExceptions = GetUseExceptions();
20958 103 : if ( bLocalUseExceptions ) {
20959 9 : pushErrorHandler();
20960 : }
20961 103 : {
20962 103 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20963 103 : result = (char *)OGRFeatureDefnShadow_GetName(arg1);
20964 103 : SWIG_PYTHON_THREAD_END_ALLOW;
20965 : }
20966 103 : if ( bLocalUseExceptions ) {
20967 9 : popErrorHandler();
20968 : }
20969 : #ifndef SED_HACKS
20970 : if ( bLocalUseExceptions ) {
20971 : CPLErr eclass = CPLGetLastErrorType();
20972 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20973 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20974 : }
20975 : }
20976 : #endif
20977 : }
20978 103 : resultobj = SWIG_FromCharPtr((const char *)result);
20979 103 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20980 : return resultobj;
20981 : fail:
20982 : return NULL;
20983 : }
20984 :
20985 :
20986 46237 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetFieldCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20987 46237 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20988 46237 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
20989 46237 : void *argp1 = 0 ;
20990 46237 : int res1 = 0 ;
20991 46237 : PyObject *swig_obj[1] ;
20992 46237 : int result;
20993 :
20994 46237 : if (!args) SWIG_fail;
20995 46237 : swig_obj[0] = args;
20996 46237 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
20997 46237 : if (!SWIG_IsOK(res1)) {
20998 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetFieldCount" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
20999 : }
21000 46237 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21001 46237 : {
21002 46237 : const int bLocalUseExceptions = GetUseExceptions();
21003 46237 : if ( bLocalUseExceptions ) {
21004 21998 : pushErrorHandler();
21005 : }
21006 46237 : {
21007 46237 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21008 46237 : result = (int)OGRFeatureDefnShadow_GetFieldCount(arg1);
21009 46237 : SWIG_PYTHON_THREAD_END_ALLOW;
21010 : }
21011 46237 : if ( bLocalUseExceptions ) {
21012 21998 : popErrorHandler();
21013 : }
21014 : #ifndef SED_HACKS
21015 : if ( bLocalUseExceptions ) {
21016 : CPLErr eclass = CPLGetLastErrorType();
21017 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21018 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21019 : }
21020 : }
21021 : #endif
21022 : }
21023 46237 : resultobj = SWIG_From_int(static_cast< int >(result));
21024 46237 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21025 : return resultobj;
21026 : fail:
21027 : return NULL;
21028 : }
21029 :
21030 :
21031 202332 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21032 202332 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21033 202332 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21034 202332 : int arg2 ;
21035 202332 : void *argp1 = 0 ;
21036 202332 : int res1 = 0 ;
21037 202332 : int val2 ;
21038 202332 : int ecode2 = 0 ;
21039 202332 : PyObject *swig_obj[2] ;
21040 202332 : OGRFieldDefnShadow *result = 0 ;
21041 :
21042 202332 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_GetFieldDefn", 2, 2, swig_obj)) SWIG_fail;
21043 202332 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21044 202332 : if (!SWIG_IsOK(res1)) {
21045 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetFieldDefn" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21046 : }
21047 202332 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21048 202332 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21049 202332 : if (!SWIG_IsOK(ecode2)) {
21050 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FeatureDefn_GetFieldDefn" "', argument " "2"" of type '" "int""'");
21051 : }
21052 202332 : arg2 = static_cast< int >(val2);
21053 202332 : {
21054 202332 : const int bLocalUseExceptions = GetUseExceptions();
21055 202332 : if ( bLocalUseExceptions ) {
21056 137977 : pushErrorHandler();
21057 : }
21058 202332 : {
21059 202332 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21060 202332 : result = (OGRFieldDefnShadow *)OGRFeatureDefnShadow_GetFieldDefn(arg1,arg2);
21061 202332 : SWIG_PYTHON_THREAD_END_ALLOW;
21062 : }
21063 202332 : if ( bLocalUseExceptions ) {
21064 137977 : popErrorHandler();
21065 : }
21066 : #ifndef SED_HACKS
21067 : if ( bLocalUseExceptions ) {
21068 : CPLErr eclass = CPLGetLastErrorType();
21069 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21070 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21071 : }
21072 : }
21073 : #endif
21074 : }
21075 202332 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
21076 202334 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21077 : return resultobj;
21078 : fail:
21079 : return NULL;
21080 : }
21081 :
21082 :
21083 1732 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetFieldIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21084 1732 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21085 1732 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21086 1732 : char *arg2 = (char *) 0 ;
21087 1732 : void *argp1 = 0 ;
21088 1732 : int res1 = 0 ;
21089 1732 : int bToFree2 = 0 ;
21090 1732 : PyObject *swig_obj[2] ;
21091 1732 : int result;
21092 :
21093 1732 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_GetFieldIndex", 2, 2, swig_obj)) SWIG_fail;
21094 1732 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21095 1732 : if (!SWIG_IsOK(res1)) {
21096 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetFieldIndex" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21097 : }
21098 1732 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21099 1732 : {
21100 : /* %typemap(in) (const char *utf8_path) */
21101 1732 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
21102 : {
21103 1732 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
21104 : }
21105 : else
21106 : {
21107 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
21108 :
21109 : }
21110 1732 : if (arg2 == NULL)
21111 : {
21112 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
21113 0 : SWIG_fail;
21114 : }
21115 : }
21116 1732 : {
21117 1732 : const int bLocalUseExceptions = GetUseExceptions();
21118 1732 : if ( bLocalUseExceptions ) {
21119 318 : pushErrorHandler();
21120 : }
21121 1732 : {
21122 1732 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21123 1732 : result = (int)OGRFeatureDefnShadow_GetFieldIndex(arg1,(char const *)arg2);
21124 1732 : SWIG_PYTHON_THREAD_END_ALLOW;
21125 : }
21126 1732 : if ( bLocalUseExceptions ) {
21127 318 : popErrorHandler();
21128 : }
21129 : #ifndef SED_HACKS
21130 : if ( bLocalUseExceptions ) {
21131 : CPLErr eclass = CPLGetLastErrorType();
21132 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21133 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21134 : }
21135 : }
21136 : #endif
21137 : }
21138 1732 : resultobj = SWIG_From_int(static_cast< int >(result));
21139 1732 : {
21140 : /* %typemap(freearg) (const char *utf8_path) */
21141 1732 : GDALPythonFreeCStr(arg2, bToFree2);
21142 : }
21143 1732 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21144 : return resultobj;
21145 0 : fail:
21146 0 : {
21147 : /* %typemap(freearg) (const char *utf8_path) */
21148 1732 : GDALPythonFreeCStr(arg2, bToFree2);
21149 : }
21150 : return NULL;
21151 : }
21152 :
21153 :
21154 397 : SWIGINTERN PyObject *_wrap_FeatureDefn_AddFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21155 397 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21156 397 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21157 397 : OGRFieldDefnShadow *arg2 = (OGRFieldDefnShadow *) 0 ;
21158 397 : void *argp1 = 0 ;
21159 397 : int res1 = 0 ;
21160 397 : void *argp2 = 0 ;
21161 397 : int res2 = 0 ;
21162 397 : PyObject *swig_obj[2] ;
21163 :
21164 397 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_AddFieldDefn", 2, 2, swig_obj)) SWIG_fail;
21165 397 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21166 397 : if (!SWIG_IsOK(res1)) {
21167 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_AddFieldDefn" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21168 : }
21169 397 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21170 397 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
21171 397 : if (!SWIG_IsOK(res2)) {
21172 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FeatureDefn_AddFieldDefn" "', argument " "2"" of type '" "OGRFieldDefnShadow *""'");
21173 : }
21174 397 : arg2 = reinterpret_cast< OGRFieldDefnShadow * >(argp2);
21175 397 : {
21176 397 : if (!arg2) {
21177 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21178 : }
21179 : }
21180 397 : {
21181 397 : const int bLocalUseExceptions = GetUseExceptions();
21182 397 : if ( bLocalUseExceptions ) {
21183 396 : pushErrorHandler();
21184 : }
21185 397 : {
21186 397 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21187 397 : OGRFeatureDefnShadow_AddFieldDefn(arg1,arg2);
21188 397 : SWIG_PYTHON_THREAD_END_ALLOW;
21189 : }
21190 397 : if ( bLocalUseExceptions ) {
21191 396 : popErrorHandler();
21192 : }
21193 : #ifndef SED_HACKS
21194 : if ( bLocalUseExceptions ) {
21195 : CPLErr eclass = CPLGetLastErrorType();
21196 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21197 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21198 : }
21199 : }
21200 : #endif
21201 : }
21202 397 : resultobj = SWIG_Py_Void();
21203 398 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21204 : return resultobj;
21205 : fail:
21206 : return NULL;
21207 : }
21208 :
21209 :
21210 408 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetGeomFieldCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21211 408 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21212 408 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21213 408 : void *argp1 = 0 ;
21214 408 : int res1 = 0 ;
21215 408 : PyObject *swig_obj[1] ;
21216 408 : int result;
21217 :
21218 408 : if (!args) SWIG_fail;
21219 408 : swig_obj[0] = args;
21220 408 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21221 408 : if (!SWIG_IsOK(res1)) {
21222 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetGeomFieldCount" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21223 : }
21224 408 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21225 408 : {
21226 408 : const int bLocalUseExceptions = GetUseExceptions();
21227 408 : if ( bLocalUseExceptions ) {
21228 217 : pushErrorHandler();
21229 : }
21230 408 : {
21231 408 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21232 408 : result = (int)OGRFeatureDefnShadow_GetGeomFieldCount(arg1);
21233 408 : SWIG_PYTHON_THREAD_END_ALLOW;
21234 : }
21235 408 : if ( bLocalUseExceptions ) {
21236 217 : popErrorHandler();
21237 : }
21238 : #ifndef SED_HACKS
21239 : if ( bLocalUseExceptions ) {
21240 : CPLErr eclass = CPLGetLastErrorType();
21241 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21242 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21243 : }
21244 : }
21245 : #endif
21246 : }
21247 408 : resultobj = SWIG_From_int(static_cast< int >(result));
21248 408 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21249 : return resultobj;
21250 : fail:
21251 : return NULL;
21252 : }
21253 :
21254 :
21255 577 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetGeomFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21256 577 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21257 577 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21258 577 : int arg2 ;
21259 577 : void *argp1 = 0 ;
21260 577 : int res1 = 0 ;
21261 577 : int val2 ;
21262 577 : int ecode2 = 0 ;
21263 577 : PyObject *swig_obj[2] ;
21264 577 : OGRGeomFieldDefnShadow *result = 0 ;
21265 :
21266 577 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_GetGeomFieldDefn", 2, 2, swig_obj)) SWIG_fail;
21267 577 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21268 577 : if (!SWIG_IsOK(res1)) {
21269 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetGeomFieldDefn" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21270 : }
21271 577 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21272 577 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21273 577 : if (!SWIG_IsOK(ecode2)) {
21274 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FeatureDefn_GetGeomFieldDefn" "', argument " "2"" of type '" "int""'");
21275 : }
21276 577 : arg2 = static_cast< int >(val2);
21277 577 : {
21278 577 : const int bLocalUseExceptions = GetUseExceptions();
21279 577 : if ( bLocalUseExceptions ) {
21280 253 : pushErrorHandler();
21281 : }
21282 577 : {
21283 577 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21284 577 : result = (OGRGeomFieldDefnShadow *)OGRFeatureDefnShadow_GetGeomFieldDefn(arg1,arg2);
21285 577 : SWIG_PYTHON_THREAD_END_ALLOW;
21286 : }
21287 577 : if ( bLocalUseExceptions ) {
21288 253 : popErrorHandler();
21289 : }
21290 : #ifndef SED_HACKS
21291 : if ( bLocalUseExceptions ) {
21292 : CPLErr eclass = CPLGetLastErrorType();
21293 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21294 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21295 : }
21296 : }
21297 : #endif
21298 : }
21299 577 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
21300 577 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21301 : return resultobj;
21302 : fail:
21303 : return NULL;
21304 : }
21305 :
21306 :
21307 37 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetGeomFieldIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21308 37 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21309 37 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21310 37 : char *arg2 = (char *) 0 ;
21311 37 : void *argp1 = 0 ;
21312 37 : int res1 = 0 ;
21313 37 : int bToFree2 = 0 ;
21314 37 : PyObject *swig_obj[2] ;
21315 37 : int result;
21316 :
21317 37 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_GetGeomFieldIndex", 2, 2, swig_obj)) SWIG_fail;
21318 37 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21319 37 : if (!SWIG_IsOK(res1)) {
21320 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetGeomFieldIndex" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21321 : }
21322 37 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21323 37 : {
21324 : /* %typemap(in) (const char *utf8_path) */
21325 37 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
21326 : {
21327 37 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
21328 : }
21329 : else
21330 : {
21331 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
21332 :
21333 : }
21334 37 : if (arg2 == NULL)
21335 : {
21336 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
21337 0 : SWIG_fail;
21338 : }
21339 : }
21340 37 : {
21341 37 : const int bLocalUseExceptions = GetUseExceptions();
21342 37 : if ( bLocalUseExceptions ) {
21343 0 : pushErrorHandler();
21344 : }
21345 37 : {
21346 37 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21347 37 : result = (int)OGRFeatureDefnShadow_GetGeomFieldIndex(arg1,(char const *)arg2);
21348 37 : SWIG_PYTHON_THREAD_END_ALLOW;
21349 : }
21350 37 : if ( bLocalUseExceptions ) {
21351 0 : popErrorHandler();
21352 : }
21353 : #ifndef SED_HACKS
21354 : if ( bLocalUseExceptions ) {
21355 : CPLErr eclass = CPLGetLastErrorType();
21356 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21357 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21358 : }
21359 : }
21360 : #endif
21361 : }
21362 37 : resultobj = SWIG_From_int(static_cast< int >(result));
21363 37 : {
21364 : /* %typemap(freearg) (const char *utf8_path) */
21365 37 : GDALPythonFreeCStr(arg2, bToFree2);
21366 : }
21367 37 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21368 : return resultobj;
21369 0 : fail:
21370 0 : {
21371 : /* %typemap(freearg) (const char *utf8_path) */
21372 37 : GDALPythonFreeCStr(arg2, bToFree2);
21373 : }
21374 : return NULL;
21375 : }
21376 :
21377 :
21378 11 : SWIGINTERN PyObject *_wrap_FeatureDefn_AddGeomFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21379 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21380 11 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21381 11 : OGRGeomFieldDefnShadow *arg2 = (OGRGeomFieldDefnShadow *) 0 ;
21382 11 : void *argp1 = 0 ;
21383 11 : int res1 = 0 ;
21384 11 : void *argp2 = 0 ;
21385 11 : int res2 = 0 ;
21386 11 : PyObject *swig_obj[2] ;
21387 :
21388 11 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_AddGeomFieldDefn", 2, 2, swig_obj)) SWIG_fail;
21389 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21390 11 : if (!SWIG_IsOK(res1)) {
21391 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_AddGeomFieldDefn" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21392 : }
21393 11 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21394 11 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
21395 11 : if (!SWIG_IsOK(res2)) {
21396 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FeatureDefn_AddGeomFieldDefn" "', argument " "2"" of type '" "OGRGeomFieldDefnShadow *""'");
21397 : }
21398 11 : arg2 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp2);
21399 11 : {
21400 11 : if (!arg2) {
21401 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21402 : }
21403 : }
21404 11 : {
21405 11 : const int bLocalUseExceptions = GetUseExceptions();
21406 11 : if ( bLocalUseExceptions ) {
21407 8 : pushErrorHandler();
21408 : }
21409 11 : {
21410 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21411 11 : OGRFeatureDefnShadow_AddGeomFieldDefn(arg1,arg2);
21412 11 : SWIG_PYTHON_THREAD_END_ALLOW;
21413 : }
21414 11 : if ( bLocalUseExceptions ) {
21415 8 : popErrorHandler();
21416 : }
21417 : #ifndef SED_HACKS
21418 : if ( bLocalUseExceptions ) {
21419 : CPLErr eclass = CPLGetLastErrorType();
21420 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21421 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21422 : }
21423 : }
21424 : #endif
21425 : }
21426 11 : resultobj = SWIG_Py_Void();
21427 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21428 : return resultobj;
21429 : fail:
21430 : return NULL;
21431 : }
21432 :
21433 :
21434 4 : SWIGINTERN PyObject *_wrap_FeatureDefn_DeleteGeomFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21435 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21436 4 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21437 4 : int arg2 ;
21438 4 : void *argp1 = 0 ;
21439 4 : int res1 = 0 ;
21440 4 : int val2 ;
21441 4 : int ecode2 = 0 ;
21442 4 : PyObject *swig_obj[2] ;
21443 4 : OGRErr result;
21444 :
21445 4 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_DeleteGeomFieldDefn", 2, 2, swig_obj)) SWIG_fail;
21446 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21447 4 : if (!SWIG_IsOK(res1)) {
21448 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_DeleteGeomFieldDefn" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21449 : }
21450 4 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21451 4 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21452 4 : if (!SWIG_IsOK(ecode2)) {
21453 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FeatureDefn_DeleteGeomFieldDefn" "', argument " "2"" of type '" "int""'");
21454 : }
21455 4 : arg2 = static_cast< int >(val2);
21456 4 : {
21457 4 : const int bLocalUseExceptions = GetUseExceptions();
21458 4 : if ( bLocalUseExceptions ) {
21459 0 : pushErrorHandler();
21460 : }
21461 4 : {
21462 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21463 4 : result = (OGRErr)OGRFeatureDefnShadow_DeleteGeomFieldDefn(arg1,arg2);
21464 4 : SWIG_PYTHON_THREAD_END_ALLOW;
21465 : }
21466 4 : if ( bLocalUseExceptions ) {
21467 0 : popErrorHandler();
21468 : }
21469 : #ifndef SED_HACKS
21470 : if ( bLocalUseExceptions ) {
21471 : CPLErr eclass = CPLGetLastErrorType();
21472 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21473 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21474 : }
21475 : }
21476 : #endif
21477 : }
21478 4 : {
21479 : /* %typemap(out) OGRErr */
21480 6 : if ( result != 0 && GetUseExceptions()) {
21481 0 : const char* pszMessage = CPLGetLastErrorMsg();
21482 0 : if( pszMessage[0] != '\0' )
21483 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
21484 : else
21485 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
21486 0 : SWIG_fail;
21487 : }
21488 : }
21489 4 : {
21490 : /* %typemap(ret) OGRErr */
21491 4 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
21492 4 : resultobj = PyInt_FromLong( result );
21493 : }
21494 : }
21495 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21496 : return resultobj;
21497 : fail:
21498 : return NULL;
21499 : }
21500 :
21501 :
21502 91 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetGeomType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21503 91 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21504 91 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21505 91 : void *argp1 = 0 ;
21506 91 : int res1 = 0 ;
21507 91 : PyObject *swig_obj[1] ;
21508 91 : OGRwkbGeometryType result;
21509 :
21510 91 : if (!args) SWIG_fail;
21511 91 : swig_obj[0] = args;
21512 91 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21513 91 : if (!SWIG_IsOK(res1)) {
21514 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetGeomType" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21515 : }
21516 91 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21517 91 : {
21518 91 : const int bLocalUseExceptions = GetUseExceptions();
21519 91 : if ( bLocalUseExceptions ) {
21520 28 : pushErrorHandler();
21521 : }
21522 91 : {
21523 91 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21524 91 : result = (OGRwkbGeometryType)OGRFeatureDefnShadow_GetGeomType(arg1);
21525 91 : SWIG_PYTHON_THREAD_END_ALLOW;
21526 : }
21527 91 : if ( bLocalUseExceptions ) {
21528 28 : popErrorHandler();
21529 : }
21530 : #ifndef SED_HACKS
21531 : if ( bLocalUseExceptions ) {
21532 : CPLErr eclass = CPLGetLastErrorType();
21533 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21534 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21535 : }
21536 : }
21537 : #endif
21538 : }
21539 91 : resultobj = SWIG_From_int(static_cast< int >(result));
21540 91 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21541 : return resultobj;
21542 : fail:
21543 : return NULL;
21544 : }
21545 :
21546 :
21547 12 : SWIGINTERN PyObject *_wrap_FeatureDefn_SetGeomType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21548 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21549 12 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21550 12 : OGRwkbGeometryType arg2 ;
21551 12 : void *argp1 = 0 ;
21552 12 : int res1 = 0 ;
21553 12 : int val2 ;
21554 12 : int ecode2 = 0 ;
21555 12 : PyObject *swig_obj[2] ;
21556 :
21557 12 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_SetGeomType", 2, 2, swig_obj)) SWIG_fail;
21558 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21559 12 : if (!SWIG_IsOK(res1)) {
21560 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_SetGeomType" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21561 : }
21562 12 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21563 12 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21564 12 : if (!SWIG_IsOK(ecode2)) {
21565 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FeatureDefn_SetGeomType" "', argument " "2"" of type '" "OGRwkbGeometryType""'");
21566 : }
21567 12 : arg2 = static_cast< OGRwkbGeometryType >(val2);
21568 12 : {
21569 12 : const int bLocalUseExceptions = GetUseExceptions();
21570 12 : if ( bLocalUseExceptions ) {
21571 4 : pushErrorHandler();
21572 : }
21573 12 : {
21574 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21575 12 : OGRFeatureDefnShadow_SetGeomType(arg1,arg2);
21576 12 : SWIG_PYTHON_THREAD_END_ALLOW;
21577 : }
21578 12 : if ( bLocalUseExceptions ) {
21579 4 : popErrorHandler();
21580 : }
21581 : #ifndef SED_HACKS
21582 : if ( bLocalUseExceptions ) {
21583 : CPLErr eclass = CPLGetLastErrorType();
21584 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21585 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21586 : }
21587 : }
21588 : #endif
21589 : }
21590 12 : resultobj = SWIG_Py_Void();
21591 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21592 : return resultobj;
21593 : fail:
21594 : return NULL;
21595 : }
21596 :
21597 :
21598 3 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetReferenceCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21599 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21600 3 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21601 3 : void *argp1 = 0 ;
21602 3 : int res1 = 0 ;
21603 3 : PyObject *swig_obj[1] ;
21604 3 : int result;
21605 :
21606 3 : if (!args) SWIG_fail;
21607 3 : swig_obj[0] = args;
21608 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21609 3 : if (!SWIG_IsOK(res1)) {
21610 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetReferenceCount" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21611 : }
21612 3 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21613 3 : {
21614 3 : const int bLocalUseExceptions = GetUseExceptions();
21615 3 : if ( bLocalUseExceptions ) {
21616 3 : pushErrorHandler();
21617 : }
21618 3 : {
21619 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21620 3 : result = (int)OGRFeatureDefnShadow_GetReferenceCount(arg1);
21621 3 : SWIG_PYTHON_THREAD_END_ALLOW;
21622 : }
21623 3 : if ( bLocalUseExceptions ) {
21624 3 : popErrorHandler();
21625 : }
21626 : #ifndef SED_HACKS
21627 : if ( bLocalUseExceptions ) {
21628 : CPLErr eclass = CPLGetLastErrorType();
21629 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21630 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21631 : }
21632 : }
21633 : #endif
21634 : }
21635 3 : resultobj = SWIG_From_int(static_cast< int >(result));
21636 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21637 : return resultobj;
21638 : fail:
21639 : return NULL;
21640 : }
21641 :
21642 :
21643 6 : SWIGINTERN PyObject *_wrap_FeatureDefn_IsGeometryIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21644 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21645 6 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21646 6 : void *argp1 = 0 ;
21647 6 : int res1 = 0 ;
21648 6 : PyObject *swig_obj[1] ;
21649 6 : int result;
21650 :
21651 6 : if (!args) SWIG_fail;
21652 6 : swig_obj[0] = args;
21653 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21654 6 : if (!SWIG_IsOK(res1)) {
21655 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_IsGeometryIgnored" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21656 : }
21657 6 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21658 6 : {
21659 6 : const int bLocalUseExceptions = GetUseExceptions();
21660 6 : if ( bLocalUseExceptions ) {
21661 0 : pushErrorHandler();
21662 : }
21663 6 : {
21664 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21665 6 : result = (int)OGRFeatureDefnShadow_IsGeometryIgnored(arg1);
21666 6 : SWIG_PYTHON_THREAD_END_ALLOW;
21667 : }
21668 6 : if ( bLocalUseExceptions ) {
21669 0 : popErrorHandler();
21670 : }
21671 : #ifndef SED_HACKS
21672 : if ( bLocalUseExceptions ) {
21673 : CPLErr eclass = CPLGetLastErrorType();
21674 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21675 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21676 : }
21677 : }
21678 : #endif
21679 : }
21680 6 : resultobj = SWIG_From_int(static_cast< int >(result));
21681 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21682 : return resultobj;
21683 : fail:
21684 : return NULL;
21685 : }
21686 :
21687 :
21688 3 : SWIGINTERN PyObject *_wrap_FeatureDefn_SetGeometryIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21689 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21690 3 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21691 3 : int arg2 ;
21692 3 : void *argp1 = 0 ;
21693 3 : int res1 = 0 ;
21694 3 : int val2 ;
21695 3 : int ecode2 = 0 ;
21696 3 : PyObject *swig_obj[2] ;
21697 :
21698 3 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_SetGeometryIgnored", 2, 2, swig_obj)) SWIG_fail;
21699 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21700 3 : if (!SWIG_IsOK(res1)) {
21701 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_SetGeometryIgnored" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21702 : }
21703 3 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21704 3 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21705 3 : if (!SWIG_IsOK(ecode2)) {
21706 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FeatureDefn_SetGeometryIgnored" "', argument " "2"" of type '" "int""'");
21707 : }
21708 3 : arg2 = static_cast< int >(val2);
21709 3 : {
21710 3 : const int bLocalUseExceptions = GetUseExceptions();
21711 3 : if ( bLocalUseExceptions ) {
21712 0 : pushErrorHandler();
21713 : }
21714 3 : {
21715 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21716 3 : OGRFeatureDefnShadow_SetGeometryIgnored(arg1,arg2);
21717 3 : SWIG_PYTHON_THREAD_END_ALLOW;
21718 : }
21719 3 : if ( bLocalUseExceptions ) {
21720 0 : popErrorHandler();
21721 : }
21722 : #ifndef SED_HACKS
21723 : if ( bLocalUseExceptions ) {
21724 : CPLErr eclass = CPLGetLastErrorType();
21725 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21726 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21727 : }
21728 : }
21729 : #endif
21730 : }
21731 3 : resultobj = SWIG_Py_Void();
21732 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21733 : return resultobj;
21734 : fail:
21735 : return NULL;
21736 : }
21737 :
21738 :
21739 2 : SWIGINTERN PyObject *_wrap_FeatureDefn_IsStyleIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21740 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21741 2 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21742 2 : void *argp1 = 0 ;
21743 2 : int res1 = 0 ;
21744 2 : PyObject *swig_obj[1] ;
21745 2 : int result;
21746 :
21747 2 : if (!args) SWIG_fail;
21748 2 : swig_obj[0] = args;
21749 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21750 2 : if (!SWIG_IsOK(res1)) {
21751 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_IsStyleIgnored" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21752 : }
21753 2 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21754 2 : {
21755 2 : const int bLocalUseExceptions = GetUseExceptions();
21756 2 : if ( bLocalUseExceptions ) {
21757 0 : pushErrorHandler();
21758 : }
21759 2 : {
21760 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21761 2 : result = (int)OGRFeatureDefnShadow_IsStyleIgnored(arg1);
21762 2 : SWIG_PYTHON_THREAD_END_ALLOW;
21763 : }
21764 2 : if ( bLocalUseExceptions ) {
21765 0 : popErrorHandler();
21766 : }
21767 : #ifndef SED_HACKS
21768 : if ( bLocalUseExceptions ) {
21769 : CPLErr eclass = CPLGetLastErrorType();
21770 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21771 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21772 : }
21773 : }
21774 : #endif
21775 : }
21776 2 : resultobj = SWIG_From_int(static_cast< int >(result));
21777 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21778 : return resultobj;
21779 : fail:
21780 : return NULL;
21781 : }
21782 :
21783 :
21784 0 : SWIGINTERN PyObject *_wrap_FeatureDefn_SetStyleIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21785 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21786 0 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21787 0 : int arg2 ;
21788 0 : void *argp1 = 0 ;
21789 0 : int res1 = 0 ;
21790 0 : int val2 ;
21791 0 : int ecode2 = 0 ;
21792 0 : PyObject *swig_obj[2] ;
21793 :
21794 0 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_SetStyleIgnored", 2, 2, swig_obj)) SWIG_fail;
21795 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21796 0 : if (!SWIG_IsOK(res1)) {
21797 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_SetStyleIgnored" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21798 : }
21799 0 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21800 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21801 0 : if (!SWIG_IsOK(ecode2)) {
21802 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FeatureDefn_SetStyleIgnored" "', argument " "2"" of type '" "int""'");
21803 : }
21804 0 : arg2 = static_cast< int >(val2);
21805 0 : {
21806 0 : const int bLocalUseExceptions = GetUseExceptions();
21807 0 : if ( bLocalUseExceptions ) {
21808 0 : pushErrorHandler();
21809 : }
21810 0 : {
21811 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21812 0 : OGRFeatureDefnShadow_SetStyleIgnored(arg1,arg2);
21813 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21814 : }
21815 0 : if ( bLocalUseExceptions ) {
21816 0 : popErrorHandler();
21817 : }
21818 : #ifndef SED_HACKS
21819 : if ( bLocalUseExceptions ) {
21820 : CPLErr eclass = CPLGetLastErrorType();
21821 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21822 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21823 : }
21824 : }
21825 : #endif
21826 : }
21827 0 : resultobj = SWIG_Py_Void();
21828 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21829 : return resultobj;
21830 : fail:
21831 : return NULL;
21832 : }
21833 :
21834 :
21835 11 : SWIGINTERN PyObject *_wrap_FeatureDefn_IsSame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21836 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21837 11 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21838 11 : OGRFeatureDefnShadow *arg2 = (OGRFeatureDefnShadow *) 0 ;
21839 11 : void *argp1 = 0 ;
21840 11 : int res1 = 0 ;
21841 11 : void *argp2 = 0 ;
21842 11 : int res2 = 0 ;
21843 11 : PyObject *swig_obj[2] ;
21844 11 : int result;
21845 :
21846 11 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_IsSame", 2, 2, swig_obj)) SWIG_fail;
21847 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21848 11 : if (!SWIG_IsOK(res1)) {
21849 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_IsSame" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21850 : }
21851 11 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21852 11 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21853 11 : if (!SWIG_IsOK(res2)) {
21854 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FeatureDefn_IsSame" "', argument " "2"" of type '" "OGRFeatureDefnShadow *""'");
21855 : }
21856 11 : arg2 = reinterpret_cast< OGRFeatureDefnShadow * >(argp2);
21857 11 : {
21858 11 : if (!arg2) {
21859 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21860 : }
21861 : }
21862 11 : {
21863 11 : const int bLocalUseExceptions = GetUseExceptions();
21864 11 : if ( bLocalUseExceptions ) {
21865 4 : pushErrorHandler();
21866 : }
21867 11 : {
21868 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21869 11 : result = (int)OGRFeatureDefnShadow_IsSame(arg1,arg2);
21870 11 : SWIG_PYTHON_THREAD_END_ALLOW;
21871 : }
21872 11 : if ( bLocalUseExceptions ) {
21873 4 : popErrorHandler();
21874 : }
21875 : #ifndef SED_HACKS
21876 : if ( bLocalUseExceptions ) {
21877 : CPLErr eclass = CPLGetLastErrorType();
21878 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21879 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21880 : }
21881 : }
21882 : #endif
21883 : }
21884 11 : resultobj = SWIG_From_int(static_cast< int >(result));
21885 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21886 : return resultobj;
21887 : fail:
21888 : return NULL;
21889 : }
21890 :
21891 :
21892 273 : SWIGINTERN PyObject *FeatureDefn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21893 273 : PyObject *obj;
21894 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
21895 273 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRFeatureDefnShadow, SWIG_NewClientData(obj));
21896 273 : return SWIG_Py_Void();
21897 : }
21898 :
21899 110 : SWIGINTERN PyObject *FeatureDefn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21900 110 : return SWIG_Python_InitShadowInstance(args);
21901 : }
21902 :
21903 77484 : SWIGINTERN PyObject *_wrap_delete_FieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21904 77484 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21905 77484 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
21906 77484 : void *argp1 = 0 ;
21907 77484 : int res1 = 0 ;
21908 77484 : PyObject *swig_obj[1] ;
21909 :
21910 77484 : if (!args) SWIG_fail;
21911 77484 : swig_obj[0] = args;
21912 77484 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, SWIG_POINTER_DISOWN | 0 );
21913 77484 : if (!SWIG_IsOK(res1)) {
21914 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FieldDefn" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
21915 : }
21916 77484 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
21917 77484 : {
21918 77484 : const int bLocalUseExceptions = GetUseExceptions();
21919 77484 : if ( bLocalUseExceptions ) {
21920 69633 : pushErrorHandler();
21921 : }
21922 77484 : {
21923 77484 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21924 77484 : delete_OGRFieldDefnShadow(arg1);
21925 77484 : SWIG_PYTHON_THREAD_END_ALLOW;
21926 : }
21927 77484 : if ( bLocalUseExceptions ) {
21928 69633 : popErrorHandler();
21929 : }
21930 : #ifndef SED_HACKS
21931 : if ( bLocalUseExceptions ) {
21932 : CPLErr eclass = CPLGetLastErrorType();
21933 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21934 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21935 : }
21936 : }
21937 : #endif
21938 : }
21939 77484 : resultobj = SWIG_Py_Void();
21940 77484 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21941 : return resultobj;
21942 : fail:
21943 : return NULL;
21944 : }
21945 :
21946 :
21947 77497 : SWIGINTERN PyObject *_wrap_new_FieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21948 77497 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21949 77497 : char *arg1 = (char *) "unnamed" ;
21950 77497 : OGRFieldType arg2 = (OGRFieldType) OFTString ;
21951 77497 : int res1 ;
21952 77497 : char *buf1 = 0 ;
21953 77497 : int alloc1 = 0 ;
21954 77497 : int val2 ;
21955 77497 : int ecode2 = 0 ;
21956 77497 : PyObject * obj0 = 0 ;
21957 77497 : PyObject * obj1 = 0 ;
21958 77497 : char * kwnames[] = {
21959 : (char *)"name_null_ok", (char *)"field_type", NULL
21960 : };
21961 77497 : OGRFieldDefnShadow *result = 0 ;
21962 :
21963 77497 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:new_FieldDefn", kwnames, &obj0, &obj1)) SWIG_fail;
21964 77497 : if (obj0) {
21965 77497 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
21966 77497 : if (!SWIG_IsOK(res1)) {
21967 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FieldDefn" "', argument " "1"" of type '" "char const *""'");
21968 : }
21969 77497 : arg1 = reinterpret_cast< char * >(buf1);
21970 : }
21971 77497 : if (obj1) {
21972 74847 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21973 74847 : if (!SWIG_IsOK(ecode2)) {
21974 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FieldDefn" "', argument " "2"" of type '" "OGRFieldType""'");
21975 : }
21976 74847 : arg2 = static_cast< OGRFieldType >(val2);
21977 : }
21978 77497 : {
21979 77497 : const int bLocalUseExceptions = GetUseExceptions();
21980 77497 : if ( bLocalUseExceptions ) {
21981 69646 : pushErrorHandler();
21982 : }
21983 77497 : {
21984 77497 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21985 77497 : result = (OGRFieldDefnShadow *)new_OGRFieldDefnShadow((char const *)arg1,arg2);
21986 77497 : SWIG_PYTHON_THREAD_END_ALLOW;
21987 : }
21988 77497 : if ( bLocalUseExceptions ) {
21989 69646 : popErrorHandler();
21990 : }
21991 : #ifndef SED_HACKS
21992 : if ( bLocalUseExceptions ) {
21993 : CPLErr eclass = CPLGetLastErrorType();
21994 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21995 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21996 : }
21997 : }
21998 : #endif
21999 : }
22000 77497 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDefnShadow, SWIG_POINTER_NEW | 0 );
22001 77497 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22002 77497 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22003 : return resultobj;
22004 0 : fail:
22005 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22006 : return NULL;
22007 : }
22008 :
22009 :
22010 192754 : SWIGINTERN PyObject *_wrap_FieldDefn_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22011 192754 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22012 192754 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22013 192754 : void *argp1 = 0 ;
22014 192754 : int res1 = 0 ;
22015 192754 : PyObject *swig_obj[1] ;
22016 192754 : char *result = 0 ;
22017 :
22018 192754 : if (!args) SWIG_fail;
22019 192754 : swig_obj[0] = args;
22020 192754 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22021 192754 : if (!SWIG_IsOK(res1)) {
22022 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22023 : }
22024 192754 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22025 192754 : {
22026 192754 : const int bLocalUseExceptions = GetUseExceptions();
22027 192754 : if ( bLocalUseExceptions ) {
22028 131559 : pushErrorHandler();
22029 : }
22030 192754 : {
22031 192754 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22032 192754 : result = (char *)OGRFieldDefnShadow_GetName(arg1);
22033 192754 : SWIG_PYTHON_THREAD_END_ALLOW;
22034 : }
22035 192754 : if ( bLocalUseExceptions ) {
22036 131559 : popErrorHandler();
22037 : }
22038 : #ifndef SED_HACKS
22039 : if ( bLocalUseExceptions ) {
22040 : CPLErr eclass = CPLGetLastErrorType();
22041 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22042 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22043 : }
22044 : }
22045 : #endif
22046 : }
22047 192754 : resultobj = SWIG_FromCharPtr((const char *)result);
22048 192754 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22049 : return resultobj;
22050 : fail:
22051 : return NULL;
22052 : }
22053 :
22054 :
22055 1537 : SWIGINTERN PyObject *_wrap_FieldDefn_GetNameRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22056 1537 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22057 1537 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22058 1537 : void *argp1 = 0 ;
22059 1537 : int res1 = 0 ;
22060 1537 : PyObject *swig_obj[1] ;
22061 1537 : char *result = 0 ;
22062 :
22063 1537 : if (!args) SWIG_fail;
22064 1537 : swig_obj[0] = args;
22065 1537 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22066 1537 : if (!SWIG_IsOK(res1)) {
22067 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetNameRef" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22068 : }
22069 1537 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22070 1537 : {
22071 1537 : const int bLocalUseExceptions = GetUseExceptions();
22072 1537 : if ( bLocalUseExceptions ) {
22073 950 : pushErrorHandler();
22074 : }
22075 1537 : {
22076 1537 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22077 1537 : result = (char *)OGRFieldDefnShadow_GetNameRef(arg1);
22078 1537 : SWIG_PYTHON_THREAD_END_ALLOW;
22079 : }
22080 1537 : if ( bLocalUseExceptions ) {
22081 950 : popErrorHandler();
22082 : }
22083 : #ifndef SED_HACKS
22084 : if ( bLocalUseExceptions ) {
22085 : CPLErr eclass = CPLGetLastErrorType();
22086 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22087 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22088 : }
22089 : }
22090 : #endif
22091 : }
22092 1537 : resultobj = SWIG_FromCharPtr((const char *)result);
22093 1537 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22094 : return resultobj;
22095 : fail:
22096 : return NULL;
22097 : }
22098 :
22099 :
22100 2 : SWIGINTERN PyObject *_wrap_FieldDefn_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22101 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22102 2 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22103 2 : char *arg2 = (char *) 0 ;
22104 2 : void *argp1 = 0 ;
22105 2 : int res1 = 0 ;
22106 2 : int res2 ;
22107 2 : char *buf2 = 0 ;
22108 2 : int alloc2 = 0 ;
22109 2 : PyObject *swig_obj[2] ;
22110 :
22111 2 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetName", 2, 2, swig_obj)) SWIG_fail;
22112 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22113 2 : if (!SWIG_IsOK(res1)) {
22114 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22115 : }
22116 2 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22117 2 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
22118 2 : if (!SWIG_IsOK(res2)) {
22119 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldDefn_SetName" "', argument " "2"" of type '" "char const *""'");
22120 : }
22121 2 : arg2 = reinterpret_cast< char * >(buf2);
22122 2 : {
22123 2 : if (!arg2) {
22124 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
22125 : }
22126 : }
22127 2 : {
22128 2 : const int bLocalUseExceptions = GetUseExceptions();
22129 2 : if ( bLocalUseExceptions ) {
22130 0 : pushErrorHandler();
22131 : }
22132 2 : {
22133 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22134 2 : OGRFieldDefnShadow_SetName(arg1,(char const *)arg2);
22135 2 : SWIG_PYTHON_THREAD_END_ALLOW;
22136 : }
22137 2 : if ( bLocalUseExceptions ) {
22138 0 : popErrorHandler();
22139 : }
22140 : #ifndef SED_HACKS
22141 : if ( bLocalUseExceptions ) {
22142 : CPLErr eclass = CPLGetLastErrorType();
22143 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22144 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22145 : }
22146 : }
22147 : #endif
22148 : }
22149 2 : resultobj = SWIG_Py_Void();
22150 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22151 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22152 : return resultobj;
22153 0 : fail:
22154 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22155 : return NULL;
22156 : }
22157 :
22158 :
22159 47 : SWIGINTERN PyObject *_wrap_FieldDefn_GetAlternativeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22160 47 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22161 47 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22162 47 : void *argp1 = 0 ;
22163 47 : int res1 = 0 ;
22164 47 : PyObject *swig_obj[1] ;
22165 47 : char *result = 0 ;
22166 :
22167 47 : if (!args) SWIG_fail;
22168 47 : swig_obj[0] = args;
22169 47 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22170 47 : if (!SWIG_IsOK(res1)) {
22171 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetAlternativeName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22172 : }
22173 47 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22174 47 : {
22175 47 : const int bLocalUseExceptions = GetUseExceptions();
22176 47 : if ( bLocalUseExceptions ) {
22177 18 : pushErrorHandler();
22178 : }
22179 47 : {
22180 47 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22181 47 : result = (char *)OGRFieldDefnShadow_GetAlternativeName(arg1);
22182 47 : SWIG_PYTHON_THREAD_END_ALLOW;
22183 : }
22184 47 : if ( bLocalUseExceptions ) {
22185 18 : popErrorHandler();
22186 : }
22187 : #ifndef SED_HACKS
22188 : if ( bLocalUseExceptions ) {
22189 : CPLErr eclass = CPLGetLastErrorType();
22190 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22191 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22192 : }
22193 : }
22194 : #endif
22195 : }
22196 47 : resultobj = SWIG_FromCharPtr((const char *)result);
22197 47 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22198 : return resultobj;
22199 : fail:
22200 : return NULL;
22201 : }
22202 :
22203 :
22204 9 : SWIGINTERN PyObject *_wrap_FieldDefn_GetAlternativeNameRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22205 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22206 9 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22207 9 : void *argp1 = 0 ;
22208 9 : int res1 = 0 ;
22209 9 : PyObject *swig_obj[1] ;
22210 9 : char *result = 0 ;
22211 :
22212 9 : if (!args) SWIG_fail;
22213 9 : swig_obj[0] = args;
22214 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22215 9 : if (!SWIG_IsOK(res1)) {
22216 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetAlternativeNameRef" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22217 : }
22218 9 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22219 9 : {
22220 9 : const int bLocalUseExceptions = GetUseExceptions();
22221 9 : if ( bLocalUseExceptions ) {
22222 9 : pushErrorHandler();
22223 : }
22224 9 : {
22225 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22226 9 : result = (char *)OGRFieldDefnShadow_GetAlternativeNameRef(arg1);
22227 9 : SWIG_PYTHON_THREAD_END_ALLOW;
22228 : }
22229 9 : if ( bLocalUseExceptions ) {
22230 9 : popErrorHandler();
22231 : }
22232 : #ifndef SED_HACKS
22233 : if ( bLocalUseExceptions ) {
22234 : CPLErr eclass = CPLGetLastErrorType();
22235 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22236 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22237 : }
22238 : }
22239 : #endif
22240 : }
22241 9 : resultobj = SWIG_FromCharPtr((const char *)result);
22242 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22243 : return resultobj;
22244 : fail:
22245 : return NULL;
22246 : }
22247 :
22248 :
22249 17 : SWIGINTERN PyObject *_wrap_FieldDefn_SetAlternativeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22250 17 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22251 17 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22252 17 : char *arg2 = (char *) 0 ;
22253 17 : void *argp1 = 0 ;
22254 17 : int res1 = 0 ;
22255 17 : int res2 ;
22256 17 : char *buf2 = 0 ;
22257 17 : int alloc2 = 0 ;
22258 17 : PyObject *swig_obj[2] ;
22259 :
22260 17 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetAlternativeName", 2, 2, swig_obj)) SWIG_fail;
22261 17 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22262 17 : if (!SWIG_IsOK(res1)) {
22263 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetAlternativeName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22264 : }
22265 17 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22266 17 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
22267 17 : if (!SWIG_IsOK(res2)) {
22268 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldDefn_SetAlternativeName" "', argument " "2"" of type '" "char const *""'");
22269 : }
22270 17 : arg2 = reinterpret_cast< char * >(buf2);
22271 17 : {
22272 17 : const int bLocalUseExceptions = GetUseExceptions();
22273 17 : if ( bLocalUseExceptions ) {
22274 6 : pushErrorHandler();
22275 : }
22276 17 : {
22277 17 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22278 17 : OGRFieldDefnShadow_SetAlternativeName(arg1,(char const *)arg2);
22279 17 : SWIG_PYTHON_THREAD_END_ALLOW;
22280 : }
22281 17 : if ( bLocalUseExceptions ) {
22282 6 : popErrorHandler();
22283 : }
22284 : #ifndef SED_HACKS
22285 : if ( bLocalUseExceptions ) {
22286 : CPLErr eclass = CPLGetLastErrorType();
22287 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22288 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22289 : }
22290 : }
22291 : #endif
22292 : }
22293 17 : resultobj = SWIG_Py_Void();
22294 17 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22295 17 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22296 : return resultobj;
22297 0 : fail:
22298 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22299 : return NULL;
22300 : }
22301 :
22302 :
22303 4218 : SWIGINTERN PyObject *_wrap_FieldDefn_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22304 4218 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22305 4218 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22306 4218 : void *argp1 = 0 ;
22307 4218 : int res1 = 0 ;
22308 4218 : PyObject *swig_obj[1] ;
22309 4218 : OGRFieldType result;
22310 :
22311 4218 : if (!args) SWIG_fail;
22312 4218 : swig_obj[0] = args;
22313 4218 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22314 4218 : if (!SWIG_IsOK(res1)) {
22315 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetType" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22316 : }
22317 4218 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22318 4218 : {
22319 4218 : const int bLocalUseExceptions = GetUseExceptions();
22320 4218 : if ( bLocalUseExceptions ) {
22321 2767 : pushErrorHandler();
22322 : }
22323 4218 : {
22324 4218 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22325 4218 : result = (OGRFieldType)OGRFieldDefnShadow_GetType(arg1);
22326 4218 : SWIG_PYTHON_THREAD_END_ALLOW;
22327 : }
22328 4218 : if ( bLocalUseExceptions ) {
22329 2767 : popErrorHandler();
22330 : }
22331 : #ifndef SED_HACKS
22332 : if ( bLocalUseExceptions ) {
22333 : CPLErr eclass = CPLGetLastErrorType();
22334 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22335 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22336 : }
22337 : }
22338 : #endif
22339 : }
22340 4218 : resultobj = SWIG_From_int(static_cast< int >(result));
22341 4218 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22342 : return resultobj;
22343 : fail:
22344 : return NULL;
22345 : }
22346 :
22347 :
22348 0 : SWIGINTERN PyObject *_wrap_FieldDefn_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22349 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22350 0 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22351 0 : OGRFieldType arg2 ;
22352 0 : void *argp1 = 0 ;
22353 0 : int res1 = 0 ;
22354 0 : int val2 ;
22355 0 : int ecode2 = 0 ;
22356 0 : PyObject *swig_obj[2] ;
22357 :
22358 0 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetType", 2, 2, swig_obj)) SWIG_fail;
22359 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22360 0 : if (!SWIG_IsOK(res1)) {
22361 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetType" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22362 : }
22363 0 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22364 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22365 0 : if (!SWIG_IsOK(ecode2)) {
22366 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetType" "', argument " "2"" of type '" "OGRFieldType""'");
22367 : }
22368 0 : arg2 = static_cast< OGRFieldType >(val2);
22369 0 : {
22370 0 : const int bLocalUseExceptions = GetUseExceptions();
22371 0 : if ( bLocalUseExceptions ) {
22372 0 : pushErrorHandler();
22373 : }
22374 0 : {
22375 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22376 0 : OGRFieldDefnShadow_SetType(arg1,arg2);
22377 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22378 : }
22379 0 : if ( bLocalUseExceptions ) {
22380 0 : popErrorHandler();
22381 : }
22382 : #ifndef SED_HACKS
22383 : if ( bLocalUseExceptions ) {
22384 : CPLErr eclass = CPLGetLastErrorType();
22385 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22386 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22387 : }
22388 : }
22389 : #endif
22390 : }
22391 0 : resultobj = SWIG_Py_Void();
22392 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22393 : return resultobj;
22394 : fail:
22395 : return NULL;
22396 : }
22397 :
22398 :
22399 88534 : SWIGINTERN PyObject *_wrap_FieldDefn_GetSubType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22400 88534 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22401 88534 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22402 88534 : void *argp1 = 0 ;
22403 88534 : int res1 = 0 ;
22404 88534 : PyObject *swig_obj[1] ;
22405 88534 : OGRFieldSubType result;
22406 :
22407 88534 : if (!args) SWIG_fail;
22408 88534 : swig_obj[0] = args;
22409 88534 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22410 88534 : if (!SWIG_IsOK(res1)) {
22411 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetSubType" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22412 : }
22413 88534 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22414 88534 : {
22415 88534 : const int bLocalUseExceptions = GetUseExceptions();
22416 88534 : if ( bLocalUseExceptions ) {
22417 81785 : pushErrorHandler();
22418 : }
22419 88534 : {
22420 88534 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22421 88534 : result = (OGRFieldSubType)OGRFieldDefnShadow_GetSubType(arg1);
22422 88534 : SWIG_PYTHON_THREAD_END_ALLOW;
22423 : }
22424 88534 : if ( bLocalUseExceptions ) {
22425 81785 : popErrorHandler();
22426 : }
22427 : #ifndef SED_HACKS
22428 : if ( bLocalUseExceptions ) {
22429 : CPLErr eclass = CPLGetLastErrorType();
22430 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22431 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22432 : }
22433 : }
22434 : #endif
22435 : }
22436 88534 : resultobj = SWIG_From_int(static_cast< int >(result));
22437 88534 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22438 : return resultobj;
22439 : fail:
22440 : return NULL;
22441 : }
22442 :
22443 :
22444 419 : SWIGINTERN PyObject *_wrap_FieldDefn_SetSubType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22445 419 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22446 419 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22447 419 : OGRFieldSubType arg2 ;
22448 419 : void *argp1 = 0 ;
22449 419 : int res1 = 0 ;
22450 419 : int val2 ;
22451 419 : int ecode2 = 0 ;
22452 419 : PyObject *swig_obj[2] ;
22453 :
22454 419 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetSubType", 2, 2, swig_obj)) SWIG_fail;
22455 419 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22456 419 : if (!SWIG_IsOK(res1)) {
22457 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetSubType" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22458 : }
22459 419 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22460 419 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22461 419 : if (!SWIG_IsOK(ecode2)) {
22462 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetSubType" "', argument " "2"" of type '" "OGRFieldSubType""'");
22463 : }
22464 419 : arg2 = static_cast< OGRFieldSubType >(val2);
22465 419 : {
22466 419 : const int bLocalUseExceptions = GetUseExceptions();
22467 419 : if ( bLocalUseExceptions ) {
22468 150 : pushErrorHandler();
22469 : }
22470 419 : {
22471 419 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22472 419 : OGRFieldDefnShadow_SetSubType(arg1,arg2);
22473 419 : SWIG_PYTHON_THREAD_END_ALLOW;
22474 : }
22475 419 : if ( bLocalUseExceptions ) {
22476 150 : popErrorHandler();
22477 : }
22478 : #ifndef SED_HACKS
22479 : if ( bLocalUseExceptions ) {
22480 : CPLErr eclass = CPLGetLastErrorType();
22481 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22482 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22483 : }
22484 : }
22485 : #endif
22486 : }
22487 419 : resultobj = SWIG_Py_Void();
22488 419 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22489 : return resultobj;
22490 : fail:
22491 : return NULL;
22492 : }
22493 :
22494 :
22495 0 : SWIGINTERN PyObject *_wrap_FieldDefn_GetJustify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22496 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22497 0 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22498 0 : void *argp1 = 0 ;
22499 0 : int res1 = 0 ;
22500 0 : PyObject *swig_obj[1] ;
22501 0 : OGRJustification result;
22502 :
22503 0 : if (!args) SWIG_fail;
22504 0 : swig_obj[0] = args;
22505 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22506 0 : if (!SWIG_IsOK(res1)) {
22507 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetJustify" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22508 : }
22509 0 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22510 0 : {
22511 0 : const int bLocalUseExceptions = GetUseExceptions();
22512 0 : if ( bLocalUseExceptions ) {
22513 0 : pushErrorHandler();
22514 : }
22515 0 : {
22516 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22517 0 : result = (OGRJustification)OGRFieldDefnShadow_GetJustify(arg1);
22518 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22519 : }
22520 0 : if ( bLocalUseExceptions ) {
22521 0 : popErrorHandler();
22522 : }
22523 : #ifndef SED_HACKS
22524 : if ( bLocalUseExceptions ) {
22525 : CPLErr eclass = CPLGetLastErrorType();
22526 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22527 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22528 : }
22529 : }
22530 : #endif
22531 : }
22532 0 : resultobj = SWIG_From_int(static_cast< int >(result));
22533 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22534 : return resultobj;
22535 : fail:
22536 : return NULL;
22537 : }
22538 :
22539 :
22540 0 : SWIGINTERN PyObject *_wrap_FieldDefn_SetJustify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22541 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22542 0 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22543 0 : OGRJustification arg2 ;
22544 0 : void *argp1 = 0 ;
22545 0 : int res1 = 0 ;
22546 0 : int val2 ;
22547 0 : int ecode2 = 0 ;
22548 0 : PyObject *swig_obj[2] ;
22549 :
22550 0 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetJustify", 2, 2, swig_obj)) SWIG_fail;
22551 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22552 0 : if (!SWIG_IsOK(res1)) {
22553 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetJustify" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22554 : }
22555 0 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22556 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22557 0 : if (!SWIG_IsOK(ecode2)) {
22558 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetJustify" "', argument " "2"" of type '" "OGRJustification""'");
22559 : }
22560 0 : arg2 = static_cast< OGRJustification >(val2);
22561 0 : {
22562 0 : const int bLocalUseExceptions = GetUseExceptions();
22563 0 : if ( bLocalUseExceptions ) {
22564 0 : pushErrorHandler();
22565 : }
22566 0 : {
22567 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22568 0 : OGRFieldDefnShadow_SetJustify(arg1,arg2);
22569 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22570 : }
22571 0 : if ( bLocalUseExceptions ) {
22572 0 : popErrorHandler();
22573 : }
22574 : #ifndef SED_HACKS
22575 : if ( bLocalUseExceptions ) {
22576 : CPLErr eclass = CPLGetLastErrorType();
22577 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22578 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22579 : }
22580 : }
22581 : #endif
22582 : }
22583 0 : resultobj = SWIG_Py_Void();
22584 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22585 : return resultobj;
22586 : fail:
22587 : return NULL;
22588 : }
22589 :
22590 :
22591 2732 : SWIGINTERN PyObject *_wrap_FieldDefn_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22592 2732 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22593 2732 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22594 2732 : void *argp1 = 0 ;
22595 2732 : int res1 = 0 ;
22596 2732 : PyObject *swig_obj[1] ;
22597 2732 : int result;
22598 :
22599 2732 : if (!args) SWIG_fail;
22600 2732 : swig_obj[0] = args;
22601 2732 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22602 2732 : if (!SWIG_IsOK(res1)) {
22603 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetWidth" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22604 : }
22605 2732 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22606 2732 : {
22607 2732 : const int bLocalUseExceptions = GetUseExceptions();
22608 2732 : if ( bLocalUseExceptions ) {
22609 1492 : pushErrorHandler();
22610 : }
22611 2732 : {
22612 2732 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22613 2732 : result = (int)OGRFieldDefnShadow_GetWidth(arg1);
22614 2732 : SWIG_PYTHON_THREAD_END_ALLOW;
22615 : }
22616 2732 : if ( bLocalUseExceptions ) {
22617 1492 : popErrorHandler();
22618 : }
22619 : #ifndef SED_HACKS
22620 : if ( bLocalUseExceptions ) {
22621 : CPLErr eclass = CPLGetLastErrorType();
22622 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22623 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22624 : }
22625 : }
22626 : #endif
22627 : }
22628 2732 : resultobj = SWIG_From_int(static_cast< int >(result));
22629 2732 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22630 : return resultobj;
22631 : fail:
22632 : return NULL;
22633 : }
22634 :
22635 :
22636 320 : SWIGINTERN PyObject *_wrap_FieldDefn_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22637 320 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22638 320 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22639 320 : int arg2 ;
22640 320 : void *argp1 = 0 ;
22641 320 : int res1 = 0 ;
22642 320 : int val2 ;
22643 320 : int ecode2 = 0 ;
22644 320 : PyObject *swig_obj[2] ;
22645 :
22646 320 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetWidth", 2, 2, swig_obj)) SWIG_fail;
22647 320 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22648 320 : if (!SWIG_IsOK(res1)) {
22649 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetWidth" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22650 : }
22651 320 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22652 320 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22653 320 : if (!SWIG_IsOK(ecode2)) {
22654 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetWidth" "', argument " "2"" of type '" "int""'");
22655 : }
22656 320 : arg2 = static_cast< int >(val2);
22657 320 : {
22658 320 : const int bLocalUseExceptions = GetUseExceptions();
22659 320 : if ( bLocalUseExceptions ) {
22660 67 : pushErrorHandler();
22661 : }
22662 320 : {
22663 320 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22664 320 : OGRFieldDefnShadow_SetWidth(arg1,arg2);
22665 320 : SWIG_PYTHON_THREAD_END_ALLOW;
22666 : }
22667 320 : if ( bLocalUseExceptions ) {
22668 67 : popErrorHandler();
22669 : }
22670 : #ifndef SED_HACKS
22671 : if ( bLocalUseExceptions ) {
22672 : CPLErr eclass = CPLGetLastErrorType();
22673 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22674 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22675 : }
22676 : }
22677 : #endif
22678 : }
22679 320 : resultobj = SWIG_Py_Void();
22680 320 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22681 : return resultobj;
22682 : fail:
22683 : return NULL;
22684 : }
22685 :
22686 :
22687 1608 : SWIGINTERN PyObject *_wrap_FieldDefn_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22688 1608 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22689 1608 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22690 1608 : void *argp1 = 0 ;
22691 1608 : int res1 = 0 ;
22692 1608 : PyObject *swig_obj[1] ;
22693 1608 : int result;
22694 :
22695 1608 : if (!args) SWIG_fail;
22696 1608 : swig_obj[0] = args;
22697 1608 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22698 1608 : if (!SWIG_IsOK(res1)) {
22699 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetPrecision" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22700 : }
22701 1608 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22702 1608 : {
22703 1608 : const int bLocalUseExceptions = GetUseExceptions();
22704 1608 : if ( bLocalUseExceptions ) {
22705 1480 : pushErrorHandler();
22706 : }
22707 1608 : {
22708 1608 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22709 1608 : result = (int)OGRFieldDefnShadow_GetPrecision(arg1);
22710 1608 : SWIG_PYTHON_THREAD_END_ALLOW;
22711 : }
22712 1608 : if ( bLocalUseExceptions ) {
22713 1480 : popErrorHandler();
22714 : }
22715 : #ifndef SED_HACKS
22716 : if ( bLocalUseExceptions ) {
22717 : CPLErr eclass = CPLGetLastErrorType();
22718 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22719 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22720 : }
22721 : }
22722 : #endif
22723 : }
22724 1608 : resultobj = SWIG_From_int(static_cast< int >(result));
22725 1608 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22726 : return resultobj;
22727 : fail:
22728 : return NULL;
22729 : }
22730 :
22731 :
22732 24 : SWIGINTERN PyObject *_wrap_FieldDefn_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22733 24 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22734 24 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22735 24 : int arg2 ;
22736 24 : void *argp1 = 0 ;
22737 24 : int res1 = 0 ;
22738 24 : int val2 ;
22739 24 : int ecode2 = 0 ;
22740 24 : PyObject *swig_obj[2] ;
22741 :
22742 24 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetPrecision", 2, 2, swig_obj)) SWIG_fail;
22743 24 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22744 24 : if (!SWIG_IsOK(res1)) {
22745 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetPrecision" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22746 : }
22747 24 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22748 24 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22749 24 : if (!SWIG_IsOK(ecode2)) {
22750 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetPrecision" "', argument " "2"" of type '" "int""'");
22751 : }
22752 24 : arg2 = static_cast< int >(val2);
22753 24 : {
22754 24 : const int bLocalUseExceptions = GetUseExceptions();
22755 24 : if ( bLocalUseExceptions ) {
22756 13 : pushErrorHandler();
22757 : }
22758 24 : {
22759 24 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22760 24 : OGRFieldDefnShadow_SetPrecision(arg1,arg2);
22761 24 : SWIG_PYTHON_THREAD_END_ALLOW;
22762 : }
22763 24 : if ( bLocalUseExceptions ) {
22764 13 : popErrorHandler();
22765 : }
22766 : #ifndef SED_HACKS
22767 : if ( bLocalUseExceptions ) {
22768 : CPLErr eclass = CPLGetLastErrorType();
22769 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22770 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22771 : }
22772 : }
22773 : #endif
22774 : }
22775 24 : resultobj = SWIG_Py_Void();
22776 24 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22777 : return resultobj;
22778 : fail:
22779 : return NULL;
22780 : }
22781 :
22782 :
22783 0 : SWIGINTERN PyObject *_wrap_FieldDefn_GetTZFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22784 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22785 0 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22786 0 : void *argp1 = 0 ;
22787 0 : int res1 = 0 ;
22788 0 : PyObject *swig_obj[1] ;
22789 0 : int result;
22790 :
22791 0 : if (!args) SWIG_fail;
22792 0 : swig_obj[0] = args;
22793 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22794 0 : if (!SWIG_IsOK(res1)) {
22795 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetTZFlag" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22796 : }
22797 0 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22798 0 : {
22799 0 : const int bLocalUseExceptions = GetUseExceptions();
22800 0 : if ( bLocalUseExceptions ) {
22801 0 : pushErrorHandler();
22802 : }
22803 0 : {
22804 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22805 0 : result = (int)OGRFieldDefnShadow_GetTZFlag(arg1);
22806 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22807 : }
22808 0 : if ( bLocalUseExceptions ) {
22809 0 : popErrorHandler();
22810 : }
22811 : #ifndef SED_HACKS
22812 : if ( bLocalUseExceptions ) {
22813 : CPLErr eclass = CPLGetLastErrorType();
22814 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22815 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22816 : }
22817 : }
22818 : #endif
22819 : }
22820 0 : resultobj = SWIG_From_int(static_cast< int >(result));
22821 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22822 : return resultobj;
22823 : fail:
22824 : return NULL;
22825 : }
22826 :
22827 :
22828 6 : SWIGINTERN PyObject *_wrap_FieldDefn_SetTZFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22829 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22830 6 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22831 6 : int arg2 ;
22832 6 : void *argp1 = 0 ;
22833 6 : int res1 = 0 ;
22834 6 : int val2 ;
22835 6 : int ecode2 = 0 ;
22836 6 : PyObject *swig_obj[2] ;
22837 :
22838 6 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetTZFlag", 2, 2, swig_obj)) SWIG_fail;
22839 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22840 6 : if (!SWIG_IsOK(res1)) {
22841 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetTZFlag" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22842 : }
22843 6 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22844 6 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22845 6 : if (!SWIG_IsOK(ecode2)) {
22846 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetTZFlag" "', argument " "2"" of type '" "int""'");
22847 : }
22848 6 : arg2 = static_cast< int >(val2);
22849 6 : {
22850 6 : const int bLocalUseExceptions = GetUseExceptions();
22851 6 : if ( bLocalUseExceptions ) {
22852 6 : pushErrorHandler();
22853 : }
22854 6 : {
22855 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22856 6 : OGRFieldDefnShadow_SetTZFlag(arg1,arg2);
22857 6 : SWIG_PYTHON_THREAD_END_ALLOW;
22858 : }
22859 6 : if ( bLocalUseExceptions ) {
22860 6 : popErrorHandler();
22861 : }
22862 : #ifndef SED_HACKS
22863 : if ( bLocalUseExceptions ) {
22864 : CPLErr eclass = CPLGetLastErrorType();
22865 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22866 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22867 : }
22868 : }
22869 : #endif
22870 : }
22871 6 : resultobj = SWIG_Py_Void();
22872 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22873 : return resultobj;
22874 : fail:
22875 : return NULL;
22876 : }
22877 :
22878 :
22879 13 : SWIGINTERN PyObject *_wrap_FieldDefn_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22880 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22881 13 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22882 13 : void *argp1 = 0 ;
22883 13 : int res1 = 0 ;
22884 13 : PyObject *swig_obj[1] ;
22885 13 : char *result = 0 ;
22886 :
22887 13 : if (!args) SWIG_fail;
22888 13 : swig_obj[0] = args;
22889 13 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22890 13 : if (!SWIG_IsOK(res1)) {
22891 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetTypeName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22892 : }
22893 13 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22894 13 : {
22895 13 : const int bLocalUseExceptions = GetUseExceptions();
22896 13 : if ( bLocalUseExceptions ) {
22897 13 : pushErrorHandler();
22898 : }
22899 13 : {
22900 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22901 13 : result = (char *)OGRFieldDefnShadow_GetTypeName(arg1);
22902 13 : SWIG_PYTHON_THREAD_END_ALLOW;
22903 : }
22904 13 : if ( bLocalUseExceptions ) {
22905 13 : popErrorHandler();
22906 : }
22907 : #ifndef SED_HACKS
22908 : if ( bLocalUseExceptions ) {
22909 : CPLErr eclass = CPLGetLastErrorType();
22910 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22911 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22912 : }
22913 : }
22914 : #endif
22915 : }
22916 13 : resultobj = SWIG_FromCharPtr((const char *)result);
22917 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22918 : return resultobj;
22919 : fail:
22920 : return NULL;
22921 : }
22922 :
22923 :
22924 36 : SWIGINTERN PyObject *_wrap_FieldDefn_GetFieldTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22925 36 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22926 36 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22927 36 : OGRFieldType arg2 ;
22928 36 : void *argp1 = 0 ;
22929 36 : int res1 = 0 ;
22930 36 : int val2 ;
22931 36 : int ecode2 = 0 ;
22932 36 : PyObject *swig_obj[2] ;
22933 36 : char *result = 0 ;
22934 :
22935 36 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_GetFieldTypeName", 2, 2, swig_obj)) SWIG_fail;
22936 36 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22937 36 : if (!SWIG_IsOK(res1)) {
22938 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetFieldTypeName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22939 : }
22940 36 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22941 36 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22942 36 : if (!SWIG_IsOK(ecode2)) {
22943 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_GetFieldTypeName" "', argument " "2"" of type '" "OGRFieldType""'");
22944 : }
22945 36 : arg2 = static_cast< OGRFieldType >(val2);
22946 36 : {
22947 36 : const int bLocalUseExceptions = GetUseExceptions();
22948 36 : if ( bLocalUseExceptions ) {
22949 0 : pushErrorHandler();
22950 : }
22951 36 : {
22952 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22953 36 : result = (char *)OGRFieldDefnShadow_GetFieldTypeName(arg1,arg2);
22954 36 : SWIG_PYTHON_THREAD_END_ALLOW;
22955 : }
22956 36 : if ( bLocalUseExceptions ) {
22957 0 : popErrorHandler();
22958 : }
22959 : #ifndef SED_HACKS
22960 : if ( bLocalUseExceptions ) {
22961 : CPLErr eclass = CPLGetLastErrorType();
22962 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22963 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22964 : }
22965 : }
22966 : #endif
22967 : }
22968 36 : resultobj = SWIG_FromCharPtr((const char *)result);
22969 36 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22970 : return resultobj;
22971 : fail:
22972 : return NULL;
22973 : }
22974 :
22975 :
22976 6 : SWIGINTERN PyObject *_wrap_FieldDefn_IsIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22977 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22978 6 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22979 6 : void *argp1 = 0 ;
22980 6 : int res1 = 0 ;
22981 6 : PyObject *swig_obj[1] ;
22982 6 : int result;
22983 :
22984 6 : if (!args) SWIG_fail;
22985 6 : swig_obj[0] = args;
22986 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22987 6 : if (!SWIG_IsOK(res1)) {
22988 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_IsIgnored" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22989 : }
22990 6 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22991 6 : {
22992 6 : const int bLocalUseExceptions = GetUseExceptions();
22993 6 : if ( bLocalUseExceptions ) {
22994 2 : pushErrorHandler();
22995 : }
22996 6 : {
22997 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22998 6 : result = (int)OGRFieldDefnShadow_IsIgnored(arg1);
22999 6 : SWIG_PYTHON_THREAD_END_ALLOW;
23000 : }
23001 6 : if ( bLocalUseExceptions ) {
23002 2 : popErrorHandler();
23003 : }
23004 : #ifndef SED_HACKS
23005 : if ( bLocalUseExceptions ) {
23006 : CPLErr eclass = CPLGetLastErrorType();
23007 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23008 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23009 : }
23010 : }
23011 : #endif
23012 : }
23013 6 : resultobj = SWIG_From_int(static_cast< int >(result));
23014 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23015 : return resultobj;
23016 : fail:
23017 : return NULL;
23018 : }
23019 :
23020 :
23021 0 : SWIGINTERN PyObject *_wrap_FieldDefn_SetIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23022 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23023 0 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23024 0 : int arg2 ;
23025 0 : void *argp1 = 0 ;
23026 0 : int res1 = 0 ;
23027 0 : int val2 ;
23028 0 : int ecode2 = 0 ;
23029 0 : PyObject *swig_obj[2] ;
23030 :
23031 0 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetIgnored", 2, 2, swig_obj)) SWIG_fail;
23032 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23033 0 : if (!SWIG_IsOK(res1)) {
23034 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetIgnored" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23035 : }
23036 0 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23037 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23038 0 : if (!SWIG_IsOK(ecode2)) {
23039 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetIgnored" "', argument " "2"" of type '" "int""'");
23040 : }
23041 0 : arg2 = static_cast< int >(val2);
23042 0 : {
23043 0 : const int bLocalUseExceptions = GetUseExceptions();
23044 0 : if ( bLocalUseExceptions ) {
23045 0 : pushErrorHandler();
23046 : }
23047 0 : {
23048 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23049 0 : OGRFieldDefnShadow_SetIgnored(arg1,arg2);
23050 0 : SWIG_PYTHON_THREAD_END_ALLOW;
23051 : }
23052 0 : if ( bLocalUseExceptions ) {
23053 0 : popErrorHandler();
23054 : }
23055 : #ifndef SED_HACKS
23056 : if ( bLocalUseExceptions ) {
23057 : CPLErr eclass = CPLGetLastErrorType();
23058 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23059 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23060 : }
23061 : }
23062 : #endif
23063 : }
23064 0 : resultobj = SWIG_Py_Void();
23065 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23066 : return resultobj;
23067 : fail:
23068 : return NULL;
23069 : }
23070 :
23071 :
23072 80 : SWIGINTERN PyObject *_wrap_FieldDefn_IsNullable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23073 80 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23074 80 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23075 80 : void *argp1 = 0 ;
23076 80 : int res1 = 0 ;
23077 80 : PyObject *swig_obj[1] ;
23078 80 : int result;
23079 :
23080 80 : if (!args) SWIG_fail;
23081 80 : swig_obj[0] = args;
23082 80 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23083 80 : if (!SWIG_IsOK(res1)) {
23084 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_IsNullable" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23085 : }
23086 80 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23087 80 : {
23088 80 : const int bLocalUseExceptions = GetUseExceptions();
23089 80 : if ( bLocalUseExceptions ) {
23090 45 : pushErrorHandler();
23091 : }
23092 80 : {
23093 80 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23094 80 : result = (int)OGRFieldDefnShadow_IsNullable(arg1);
23095 80 : SWIG_PYTHON_THREAD_END_ALLOW;
23096 : }
23097 80 : if ( bLocalUseExceptions ) {
23098 45 : popErrorHandler();
23099 : }
23100 : #ifndef SED_HACKS
23101 : if ( bLocalUseExceptions ) {
23102 : CPLErr eclass = CPLGetLastErrorType();
23103 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23104 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23105 : }
23106 : }
23107 : #endif
23108 : }
23109 80 : resultobj = SWIG_From_int(static_cast< int >(result));
23110 80 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23111 : return resultobj;
23112 : fail:
23113 : return NULL;
23114 : }
23115 :
23116 :
23117 190 : SWIGINTERN PyObject *_wrap_FieldDefn_SetNullable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23118 190 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23119 190 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23120 190 : int arg2 ;
23121 190 : void *argp1 = 0 ;
23122 190 : int res1 = 0 ;
23123 190 : int val2 ;
23124 190 : int ecode2 = 0 ;
23125 190 : PyObject *swig_obj[2] ;
23126 :
23127 190 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetNullable", 2, 2, swig_obj)) SWIG_fail;
23128 190 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23129 190 : if (!SWIG_IsOK(res1)) {
23130 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetNullable" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23131 : }
23132 190 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23133 190 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23134 190 : if (!SWIG_IsOK(ecode2)) {
23135 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetNullable" "', argument " "2"" of type '" "int""'");
23136 : }
23137 190 : arg2 = static_cast< int >(val2);
23138 190 : {
23139 190 : const int bLocalUseExceptions = GetUseExceptions();
23140 190 : if ( bLocalUseExceptions ) {
23141 119 : pushErrorHandler();
23142 : }
23143 190 : {
23144 190 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23145 190 : OGRFieldDefnShadow_SetNullable(arg1,arg2);
23146 190 : SWIG_PYTHON_THREAD_END_ALLOW;
23147 : }
23148 190 : if ( bLocalUseExceptions ) {
23149 119 : popErrorHandler();
23150 : }
23151 : #ifndef SED_HACKS
23152 : if ( bLocalUseExceptions ) {
23153 : CPLErr eclass = CPLGetLastErrorType();
23154 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23155 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23156 : }
23157 : }
23158 : #endif
23159 : }
23160 190 : resultobj = SWIG_Py_Void();
23161 190 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23162 : return resultobj;
23163 : fail:
23164 : return NULL;
23165 : }
23166 :
23167 :
23168 80 : SWIGINTERN PyObject *_wrap_FieldDefn_IsUnique(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23169 80 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23170 80 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23171 80 : void *argp1 = 0 ;
23172 80 : int res1 = 0 ;
23173 80 : PyObject *swig_obj[1] ;
23174 80 : int result;
23175 :
23176 80 : if (!args) SWIG_fail;
23177 80 : swig_obj[0] = args;
23178 80 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23179 80 : if (!SWIG_IsOK(res1)) {
23180 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_IsUnique" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23181 : }
23182 80 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23183 80 : {
23184 80 : const int bLocalUseExceptions = GetUseExceptions();
23185 80 : if ( bLocalUseExceptions ) {
23186 4 : pushErrorHandler();
23187 : }
23188 80 : {
23189 80 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23190 80 : result = (int)OGRFieldDefnShadow_IsUnique(arg1);
23191 80 : SWIG_PYTHON_THREAD_END_ALLOW;
23192 : }
23193 80 : if ( bLocalUseExceptions ) {
23194 4 : popErrorHandler();
23195 : }
23196 : #ifndef SED_HACKS
23197 : if ( bLocalUseExceptions ) {
23198 : CPLErr eclass = CPLGetLastErrorType();
23199 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23200 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23201 : }
23202 : }
23203 : #endif
23204 : }
23205 80 : resultobj = SWIG_From_int(static_cast< int >(result));
23206 80 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23207 : return resultobj;
23208 : fail:
23209 : return NULL;
23210 : }
23211 :
23212 :
23213 28 : SWIGINTERN PyObject *_wrap_FieldDefn_SetUnique(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23214 28 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23215 28 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23216 28 : int arg2 ;
23217 28 : void *argp1 = 0 ;
23218 28 : int res1 = 0 ;
23219 28 : int val2 ;
23220 28 : int ecode2 = 0 ;
23221 28 : PyObject *swig_obj[2] ;
23222 :
23223 28 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetUnique", 2, 2, swig_obj)) SWIG_fail;
23224 28 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23225 28 : if (!SWIG_IsOK(res1)) {
23226 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetUnique" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23227 : }
23228 28 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23229 28 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23230 28 : if (!SWIG_IsOK(ecode2)) {
23231 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetUnique" "', argument " "2"" of type '" "int""'");
23232 : }
23233 28 : arg2 = static_cast< int >(val2);
23234 28 : {
23235 28 : const int bLocalUseExceptions = GetUseExceptions();
23236 28 : if ( bLocalUseExceptions ) {
23237 5 : pushErrorHandler();
23238 : }
23239 28 : {
23240 28 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23241 28 : OGRFieldDefnShadow_SetUnique(arg1,arg2);
23242 28 : SWIG_PYTHON_THREAD_END_ALLOW;
23243 : }
23244 28 : if ( bLocalUseExceptions ) {
23245 5 : popErrorHandler();
23246 : }
23247 : #ifndef SED_HACKS
23248 : if ( bLocalUseExceptions ) {
23249 : CPLErr eclass = CPLGetLastErrorType();
23250 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23251 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23252 : }
23253 : }
23254 : #endif
23255 : }
23256 28 : resultobj = SWIG_Py_Void();
23257 28 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23258 : return resultobj;
23259 : fail:
23260 : return NULL;
23261 : }
23262 :
23263 :
23264 4 : SWIGINTERN PyObject *_wrap_FieldDefn_IsGenerated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23265 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23266 4 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23267 4 : void *argp1 = 0 ;
23268 4 : int res1 = 0 ;
23269 4 : PyObject *swig_obj[1] ;
23270 4 : int result;
23271 :
23272 4 : if (!args) SWIG_fail;
23273 4 : swig_obj[0] = args;
23274 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23275 4 : if (!SWIG_IsOK(res1)) {
23276 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_IsGenerated" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23277 : }
23278 4 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23279 4 : {
23280 4 : const int bLocalUseExceptions = GetUseExceptions();
23281 4 : if ( bLocalUseExceptions ) {
23282 0 : pushErrorHandler();
23283 : }
23284 4 : {
23285 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23286 4 : result = (int)OGRFieldDefnShadow_IsGenerated(arg1);
23287 4 : SWIG_PYTHON_THREAD_END_ALLOW;
23288 : }
23289 4 : if ( bLocalUseExceptions ) {
23290 0 : popErrorHandler();
23291 : }
23292 : #ifndef SED_HACKS
23293 : if ( bLocalUseExceptions ) {
23294 : CPLErr eclass = CPLGetLastErrorType();
23295 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23296 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23297 : }
23298 : }
23299 : #endif
23300 : }
23301 4 : resultobj = SWIG_From_int(static_cast< int >(result));
23302 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23303 : return resultobj;
23304 : fail:
23305 : return NULL;
23306 : }
23307 :
23308 :
23309 0 : SWIGINTERN PyObject *_wrap_FieldDefn_SetGenerated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23310 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23311 0 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23312 0 : int arg2 ;
23313 0 : void *argp1 = 0 ;
23314 0 : int res1 = 0 ;
23315 0 : int val2 ;
23316 0 : int ecode2 = 0 ;
23317 0 : PyObject *swig_obj[2] ;
23318 :
23319 0 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetGenerated", 2, 2, swig_obj)) SWIG_fail;
23320 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23321 0 : if (!SWIG_IsOK(res1)) {
23322 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetGenerated" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23323 : }
23324 0 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23325 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23326 0 : if (!SWIG_IsOK(ecode2)) {
23327 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetGenerated" "', argument " "2"" of type '" "int""'");
23328 : }
23329 0 : arg2 = static_cast< int >(val2);
23330 0 : {
23331 0 : const int bLocalUseExceptions = GetUseExceptions();
23332 0 : if ( bLocalUseExceptions ) {
23333 0 : pushErrorHandler();
23334 : }
23335 0 : {
23336 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23337 0 : OGRFieldDefnShadow_SetGenerated(arg1,arg2);
23338 0 : SWIG_PYTHON_THREAD_END_ALLOW;
23339 : }
23340 0 : if ( bLocalUseExceptions ) {
23341 0 : popErrorHandler();
23342 : }
23343 : #ifndef SED_HACKS
23344 : if ( bLocalUseExceptions ) {
23345 : CPLErr eclass = CPLGetLastErrorType();
23346 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23347 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23348 : }
23349 : }
23350 : #endif
23351 : }
23352 0 : resultobj = SWIG_Py_Void();
23353 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23354 : return resultobj;
23355 : fail:
23356 : return NULL;
23357 : }
23358 :
23359 :
23360 137 : SWIGINTERN PyObject *_wrap_FieldDefn_GetDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23361 137 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23362 137 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23363 137 : void *argp1 = 0 ;
23364 137 : int res1 = 0 ;
23365 137 : PyObject *swig_obj[1] ;
23366 137 : char *result = 0 ;
23367 :
23368 137 : if (!args) SWIG_fail;
23369 137 : swig_obj[0] = args;
23370 137 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23371 137 : if (!SWIG_IsOK(res1)) {
23372 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetDefault" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23373 : }
23374 137 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23375 137 : {
23376 137 : const int bLocalUseExceptions = GetUseExceptions();
23377 137 : if ( bLocalUseExceptions ) {
23378 27 : pushErrorHandler();
23379 : }
23380 137 : {
23381 137 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23382 137 : result = (char *)OGRFieldDefnShadow_GetDefault(arg1);
23383 137 : SWIG_PYTHON_THREAD_END_ALLOW;
23384 : }
23385 137 : if ( bLocalUseExceptions ) {
23386 27 : popErrorHandler();
23387 : }
23388 : #ifndef SED_HACKS
23389 : if ( bLocalUseExceptions ) {
23390 : CPLErr eclass = CPLGetLastErrorType();
23391 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23392 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23393 : }
23394 : }
23395 : #endif
23396 : }
23397 137 : resultobj = SWIG_FromCharPtr((const char *)result);
23398 137 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23399 : return resultobj;
23400 : fail:
23401 : return NULL;
23402 : }
23403 :
23404 :
23405 149 : SWIGINTERN PyObject *_wrap_FieldDefn_SetDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23406 149 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23407 149 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23408 149 : char *arg2 = (char *) 0 ;
23409 149 : void *argp1 = 0 ;
23410 149 : int res1 = 0 ;
23411 149 : int res2 ;
23412 149 : char *buf2 = 0 ;
23413 149 : int alloc2 = 0 ;
23414 149 : PyObject *swig_obj[2] ;
23415 :
23416 149 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetDefault", 2, 2, swig_obj)) SWIG_fail;
23417 149 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23418 149 : if (!SWIG_IsOK(res1)) {
23419 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetDefault" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23420 : }
23421 149 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23422 149 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
23423 149 : if (!SWIG_IsOK(res2)) {
23424 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldDefn_SetDefault" "', argument " "2"" of type '" "char const *""'");
23425 : }
23426 149 : arg2 = reinterpret_cast< char * >(buf2);
23427 149 : {
23428 149 : const int bLocalUseExceptions = GetUseExceptions();
23429 149 : if ( bLocalUseExceptions ) {
23430 11 : pushErrorHandler();
23431 : }
23432 149 : {
23433 149 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23434 149 : OGRFieldDefnShadow_SetDefault(arg1,(char const *)arg2);
23435 149 : SWIG_PYTHON_THREAD_END_ALLOW;
23436 : }
23437 149 : if ( bLocalUseExceptions ) {
23438 11 : popErrorHandler();
23439 : }
23440 : #ifndef SED_HACKS
23441 : if ( bLocalUseExceptions ) {
23442 : CPLErr eclass = CPLGetLastErrorType();
23443 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23444 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23445 : }
23446 : }
23447 : #endif
23448 : }
23449 149 : resultobj = SWIG_Py_Void();
23450 149 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23451 151 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23452 : return resultobj;
23453 0 : fail:
23454 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23455 : return NULL;
23456 : }
23457 :
23458 :
23459 3 : SWIGINTERN PyObject *_wrap_FieldDefn_IsDefaultDriverSpecific(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23460 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23461 3 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23462 3 : void *argp1 = 0 ;
23463 3 : int res1 = 0 ;
23464 3 : PyObject *swig_obj[1] ;
23465 3 : int result;
23466 :
23467 3 : if (!args) SWIG_fail;
23468 3 : swig_obj[0] = args;
23469 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23470 3 : if (!SWIG_IsOK(res1)) {
23471 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_IsDefaultDriverSpecific" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23472 : }
23473 3 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23474 3 : {
23475 3 : const int bLocalUseExceptions = GetUseExceptions();
23476 3 : if ( bLocalUseExceptions ) {
23477 3 : pushErrorHandler();
23478 : }
23479 3 : {
23480 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23481 3 : result = (int)OGRFieldDefnShadow_IsDefaultDriverSpecific(arg1);
23482 3 : SWIG_PYTHON_THREAD_END_ALLOW;
23483 : }
23484 3 : if ( bLocalUseExceptions ) {
23485 3 : popErrorHandler();
23486 : }
23487 : #ifndef SED_HACKS
23488 : if ( bLocalUseExceptions ) {
23489 : CPLErr eclass = CPLGetLastErrorType();
23490 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23491 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23492 : }
23493 : }
23494 : #endif
23495 : }
23496 3 : resultobj = SWIG_From_int(static_cast< int >(result));
23497 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23498 : return resultobj;
23499 : fail:
23500 : return NULL;
23501 : }
23502 :
23503 :
23504 32 : SWIGINTERN PyObject *_wrap_FieldDefn_GetDomainName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23505 32 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23506 32 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23507 32 : void *argp1 = 0 ;
23508 32 : int res1 = 0 ;
23509 32 : PyObject *swig_obj[1] ;
23510 32 : char *result = 0 ;
23511 :
23512 32 : if (!args) SWIG_fail;
23513 32 : swig_obj[0] = args;
23514 32 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23515 32 : if (!SWIG_IsOK(res1)) {
23516 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetDomainName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23517 : }
23518 32 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23519 32 : {
23520 32 : const int bLocalUseExceptions = GetUseExceptions();
23521 32 : if ( bLocalUseExceptions ) {
23522 23 : pushErrorHandler();
23523 : }
23524 32 : {
23525 32 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23526 32 : result = (char *)OGRFieldDefnShadow_GetDomainName(arg1);
23527 32 : SWIG_PYTHON_THREAD_END_ALLOW;
23528 : }
23529 32 : if ( bLocalUseExceptions ) {
23530 23 : popErrorHandler();
23531 : }
23532 : #ifndef SED_HACKS
23533 : if ( bLocalUseExceptions ) {
23534 : CPLErr eclass = CPLGetLastErrorType();
23535 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23536 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23537 : }
23538 : }
23539 : #endif
23540 : }
23541 32 : resultobj = SWIG_FromCharPtr((const char *)result);
23542 32 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23543 : return resultobj;
23544 : fail:
23545 : return NULL;
23546 : }
23547 :
23548 :
23549 21 : SWIGINTERN PyObject *_wrap_FieldDefn_SetDomainName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23550 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23551 21 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23552 21 : char *arg2 = (char *) 0 ;
23553 21 : void *argp1 = 0 ;
23554 21 : int res1 = 0 ;
23555 21 : int res2 ;
23556 21 : char *buf2 = 0 ;
23557 21 : int alloc2 = 0 ;
23558 21 : PyObject *swig_obj[2] ;
23559 :
23560 21 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetDomainName", 2, 2, swig_obj)) SWIG_fail;
23561 21 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23562 21 : if (!SWIG_IsOK(res1)) {
23563 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetDomainName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23564 : }
23565 21 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23566 21 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
23567 21 : if (!SWIG_IsOK(res2)) {
23568 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldDefn_SetDomainName" "', argument " "2"" of type '" "char const *""'");
23569 : }
23570 21 : arg2 = reinterpret_cast< char * >(buf2);
23571 21 : {
23572 21 : if (!arg2) {
23573 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
23574 : }
23575 : }
23576 21 : {
23577 21 : const int bLocalUseExceptions = GetUseExceptions();
23578 21 : if ( bLocalUseExceptions ) {
23579 9 : pushErrorHandler();
23580 : }
23581 21 : {
23582 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23583 21 : OGRFieldDefnShadow_SetDomainName(arg1,(char const *)arg2);
23584 21 : SWIG_PYTHON_THREAD_END_ALLOW;
23585 : }
23586 21 : if ( bLocalUseExceptions ) {
23587 9 : popErrorHandler();
23588 : }
23589 : #ifndef SED_HACKS
23590 : if ( bLocalUseExceptions ) {
23591 : CPLErr eclass = CPLGetLastErrorType();
23592 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23593 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23594 : }
23595 : }
23596 : #endif
23597 : }
23598 21 : resultobj = SWIG_Py_Void();
23599 21 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23600 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23601 : return resultobj;
23602 0 : fail:
23603 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23604 : return NULL;
23605 : }
23606 :
23607 :
23608 58 : SWIGINTERN PyObject *_wrap_FieldDefn_GetComment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23609 58 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23610 58 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23611 58 : void *argp1 = 0 ;
23612 58 : int res1 = 0 ;
23613 58 : PyObject *swig_obj[1] ;
23614 58 : char *result = 0 ;
23615 :
23616 58 : if (!args) SWIG_fail;
23617 58 : swig_obj[0] = args;
23618 58 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23619 58 : if (!SWIG_IsOK(res1)) {
23620 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetComment" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23621 : }
23622 58 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23623 58 : {
23624 58 : const int bLocalUseExceptions = GetUseExceptions();
23625 58 : if ( bLocalUseExceptions ) {
23626 5 : pushErrorHandler();
23627 : }
23628 58 : {
23629 58 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23630 58 : result = (char *)OGRFieldDefnShadow_GetComment(arg1);
23631 58 : SWIG_PYTHON_THREAD_END_ALLOW;
23632 : }
23633 58 : if ( bLocalUseExceptions ) {
23634 5 : popErrorHandler();
23635 : }
23636 : #ifndef SED_HACKS
23637 : if ( bLocalUseExceptions ) {
23638 : CPLErr eclass = CPLGetLastErrorType();
23639 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23640 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23641 : }
23642 : }
23643 : #endif
23644 : }
23645 58 : resultobj = SWIG_FromCharPtr((const char *)result);
23646 58 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23647 : return resultobj;
23648 : fail:
23649 : return NULL;
23650 : }
23651 :
23652 :
23653 32 : SWIGINTERN PyObject *_wrap_FieldDefn_SetComment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23654 32 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23655 32 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23656 32 : char *arg2 = (char *) 0 ;
23657 32 : void *argp1 = 0 ;
23658 32 : int res1 = 0 ;
23659 32 : int res2 ;
23660 32 : char *buf2 = 0 ;
23661 32 : int alloc2 = 0 ;
23662 32 : PyObject *swig_obj[2] ;
23663 :
23664 32 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetComment", 2, 2, swig_obj)) SWIG_fail;
23665 32 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23666 32 : if (!SWIG_IsOK(res1)) {
23667 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetComment" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23668 : }
23669 32 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23670 32 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
23671 32 : if (!SWIG_IsOK(res2)) {
23672 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldDefn_SetComment" "', argument " "2"" of type '" "char const *""'");
23673 : }
23674 32 : arg2 = reinterpret_cast< char * >(buf2);
23675 32 : {
23676 32 : const int bLocalUseExceptions = GetUseExceptions();
23677 32 : if ( bLocalUseExceptions ) {
23678 6 : pushErrorHandler();
23679 : }
23680 32 : {
23681 32 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23682 32 : OGRFieldDefnShadow_SetComment(arg1,(char const *)arg2);
23683 32 : SWIG_PYTHON_THREAD_END_ALLOW;
23684 : }
23685 32 : if ( bLocalUseExceptions ) {
23686 6 : popErrorHandler();
23687 : }
23688 : #ifndef SED_HACKS
23689 : if ( bLocalUseExceptions ) {
23690 : CPLErr eclass = CPLGetLastErrorType();
23691 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23692 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23693 : }
23694 : }
23695 : #endif
23696 : }
23697 32 : resultobj = SWIG_Py_Void();
23698 32 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23699 32 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23700 : return resultobj;
23701 0 : fail:
23702 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23703 : return NULL;
23704 : }
23705 :
23706 :
23707 273 : SWIGINTERN PyObject *FieldDefn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23708 273 : PyObject *obj;
23709 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
23710 273 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRFieldDefnShadow, SWIG_NewClientData(obj));
23711 273 : return SWIG_Py_Void();
23712 : }
23713 :
23714 77497 : SWIGINTERN PyObject *FieldDefn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23715 77497 : return SWIG_Python_InitShadowInstance(args);
23716 : }
23717 :
23718 171 : SWIGINTERN PyObject *_wrap_delete_GeomFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23719 171 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23720 171 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
23721 171 : void *argp1 = 0 ;
23722 171 : int res1 = 0 ;
23723 171 : PyObject *swig_obj[1] ;
23724 :
23725 171 : if (!args) SWIG_fail;
23726 171 : swig_obj[0] = args;
23727 171 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, SWIG_POINTER_DISOWN | 0 );
23728 171 : if (!SWIG_IsOK(res1)) {
23729 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeomFieldDefn" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
23730 : }
23731 171 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
23732 171 : {
23733 171 : const int bLocalUseExceptions = GetUseExceptions();
23734 171 : if ( bLocalUseExceptions ) {
23735 60 : pushErrorHandler();
23736 : }
23737 171 : {
23738 171 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23739 171 : delete_OGRGeomFieldDefnShadow(arg1);
23740 171 : SWIG_PYTHON_THREAD_END_ALLOW;
23741 : }
23742 171 : if ( bLocalUseExceptions ) {
23743 60 : popErrorHandler();
23744 : }
23745 : #ifndef SED_HACKS
23746 : if ( bLocalUseExceptions ) {
23747 : CPLErr eclass = CPLGetLastErrorType();
23748 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23749 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23750 : }
23751 : }
23752 : #endif
23753 : }
23754 171 : resultobj = SWIG_Py_Void();
23755 171 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23756 : return resultobj;
23757 : fail:
23758 : return NULL;
23759 : }
23760 :
23761 :
23762 171 : SWIGINTERN PyObject *_wrap_new_GeomFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23763 171 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23764 171 : char *arg1 = (char *) "" ;
23765 171 : OGRwkbGeometryType arg2 = (OGRwkbGeometryType) wkbUnknown ;
23766 171 : int res1 ;
23767 171 : char *buf1 = 0 ;
23768 171 : int alloc1 = 0 ;
23769 171 : int val2 ;
23770 171 : int ecode2 = 0 ;
23771 171 : PyObject * obj0 = 0 ;
23772 171 : PyObject * obj1 = 0 ;
23773 171 : char * kwnames[] = {
23774 : (char *)"name_null_ok", (char *)"field_type", NULL
23775 : };
23776 171 : OGRGeomFieldDefnShadow *result = 0 ;
23777 :
23778 171 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:new_GeomFieldDefn", kwnames, &obj0, &obj1)) SWIG_fail;
23779 171 : if (obj0) {
23780 168 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
23781 168 : if (!SWIG_IsOK(res1)) {
23782 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GeomFieldDefn" "', argument " "1"" of type '" "char const *""'");
23783 : }
23784 168 : arg1 = reinterpret_cast< char * >(buf1);
23785 : }
23786 171 : if (obj1) {
23787 153 : ecode2 = SWIG_AsVal_int(obj1, &val2);
23788 153 : if (!SWIG_IsOK(ecode2)) {
23789 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GeomFieldDefn" "', argument " "2"" of type '" "OGRwkbGeometryType""'");
23790 : }
23791 153 : arg2 = static_cast< OGRwkbGeometryType >(val2);
23792 : }
23793 171 : {
23794 171 : const int bLocalUseExceptions = GetUseExceptions();
23795 171 : if ( bLocalUseExceptions ) {
23796 60 : pushErrorHandler();
23797 : }
23798 171 : {
23799 171 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23800 171 : result = (OGRGeomFieldDefnShadow *)new_OGRGeomFieldDefnShadow((char const *)arg1,arg2);
23801 171 : SWIG_PYTHON_THREAD_END_ALLOW;
23802 : }
23803 171 : if ( bLocalUseExceptions ) {
23804 60 : popErrorHandler();
23805 : }
23806 : #ifndef SED_HACKS
23807 : if ( bLocalUseExceptions ) {
23808 : CPLErr eclass = CPLGetLastErrorType();
23809 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23810 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23811 : }
23812 : }
23813 : #endif
23814 : }
23815 171 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeomFieldDefnShadow, SWIG_POINTER_NEW | 0 );
23816 171 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23817 171 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23818 : return resultobj;
23819 0 : fail:
23820 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23821 : return NULL;
23822 : }
23823 :
23824 :
23825 229 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23826 229 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23827 229 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
23828 229 : void *argp1 = 0 ;
23829 229 : int res1 = 0 ;
23830 229 : PyObject *swig_obj[1] ;
23831 229 : char *result = 0 ;
23832 :
23833 229 : if (!args) SWIG_fail;
23834 229 : swig_obj[0] = args;
23835 229 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
23836 229 : if (!SWIG_IsOK(res1)) {
23837 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_GetName" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
23838 : }
23839 229 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
23840 229 : {
23841 229 : const int bLocalUseExceptions = GetUseExceptions();
23842 229 : if ( bLocalUseExceptions ) {
23843 183 : pushErrorHandler();
23844 : }
23845 229 : {
23846 229 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23847 229 : result = (char *)OGRGeomFieldDefnShadow_GetName(arg1);
23848 229 : SWIG_PYTHON_THREAD_END_ALLOW;
23849 : }
23850 229 : if ( bLocalUseExceptions ) {
23851 183 : popErrorHandler();
23852 : }
23853 : #ifndef SED_HACKS
23854 : if ( bLocalUseExceptions ) {
23855 : CPLErr eclass = CPLGetLastErrorType();
23856 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23857 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23858 : }
23859 : }
23860 : #endif
23861 : }
23862 229 : resultobj = SWIG_FromCharPtr((const char *)result);
23863 229 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23864 : return resultobj;
23865 : fail:
23866 : return NULL;
23867 : }
23868 :
23869 :
23870 82 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_GetNameRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23871 82 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23872 82 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
23873 82 : void *argp1 = 0 ;
23874 82 : int res1 = 0 ;
23875 82 : PyObject *swig_obj[1] ;
23876 82 : char *result = 0 ;
23877 :
23878 82 : if (!args) SWIG_fail;
23879 82 : swig_obj[0] = args;
23880 82 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
23881 82 : if (!SWIG_IsOK(res1)) {
23882 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_GetNameRef" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
23883 : }
23884 82 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
23885 82 : {
23886 82 : const int bLocalUseExceptions = GetUseExceptions();
23887 82 : if ( bLocalUseExceptions ) {
23888 0 : pushErrorHandler();
23889 : }
23890 82 : {
23891 82 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23892 82 : result = (char *)OGRGeomFieldDefnShadow_GetNameRef(arg1);
23893 82 : SWIG_PYTHON_THREAD_END_ALLOW;
23894 : }
23895 82 : if ( bLocalUseExceptions ) {
23896 0 : popErrorHandler();
23897 : }
23898 : #ifndef SED_HACKS
23899 : if ( bLocalUseExceptions ) {
23900 : CPLErr eclass = CPLGetLastErrorType();
23901 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23902 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23903 : }
23904 : }
23905 : #endif
23906 : }
23907 82 : resultobj = SWIG_FromCharPtr((const char *)result);
23908 82 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23909 : return resultobj;
23910 : fail:
23911 : return NULL;
23912 : }
23913 :
23914 :
23915 4 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23916 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23917 4 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
23918 4 : char *arg2 = (char *) 0 ;
23919 4 : void *argp1 = 0 ;
23920 4 : int res1 = 0 ;
23921 4 : int res2 ;
23922 4 : char *buf2 = 0 ;
23923 4 : int alloc2 = 0 ;
23924 4 : PyObject *swig_obj[2] ;
23925 :
23926 4 : if (!SWIG_Python_UnpackTuple(args, "GeomFieldDefn_SetName", 2, 2, swig_obj)) SWIG_fail;
23927 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
23928 4 : if (!SWIG_IsOK(res1)) {
23929 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_SetName" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
23930 : }
23931 4 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
23932 4 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
23933 4 : if (!SWIG_IsOK(res2)) {
23934 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomFieldDefn_SetName" "', argument " "2"" of type '" "char const *""'");
23935 : }
23936 4 : arg2 = reinterpret_cast< char * >(buf2);
23937 4 : {
23938 4 : if (!arg2) {
23939 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
23940 : }
23941 : }
23942 4 : {
23943 4 : const int bLocalUseExceptions = GetUseExceptions();
23944 4 : if ( bLocalUseExceptions ) {
23945 2 : pushErrorHandler();
23946 : }
23947 4 : {
23948 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23949 4 : OGRGeomFieldDefnShadow_SetName(arg1,(char const *)arg2);
23950 4 : SWIG_PYTHON_THREAD_END_ALLOW;
23951 : }
23952 4 : if ( bLocalUseExceptions ) {
23953 2 : popErrorHandler();
23954 : }
23955 : #ifndef SED_HACKS
23956 : if ( bLocalUseExceptions ) {
23957 : CPLErr eclass = CPLGetLastErrorType();
23958 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23959 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23960 : }
23961 : }
23962 : #endif
23963 : }
23964 4 : resultobj = SWIG_Py_Void();
23965 4 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23966 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23967 : return resultobj;
23968 0 : fail:
23969 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23970 : return NULL;
23971 : }
23972 :
23973 :
23974 85 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23975 85 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23976 85 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
23977 85 : void *argp1 = 0 ;
23978 85 : int res1 = 0 ;
23979 85 : PyObject *swig_obj[1] ;
23980 85 : OGRwkbGeometryType result;
23981 :
23982 85 : if (!args) SWIG_fail;
23983 85 : swig_obj[0] = args;
23984 85 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
23985 85 : if (!SWIG_IsOK(res1)) {
23986 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_GetType" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
23987 : }
23988 85 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
23989 85 : {
23990 85 : const int bLocalUseExceptions = GetUseExceptions();
23991 85 : if ( bLocalUseExceptions ) {
23992 17 : pushErrorHandler();
23993 : }
23994 85 : {
23995 85 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23996 85 : result = (OGRwkbGeometryType)OGRGeomFieldDefnShadow_GetType(arg1);
23997 85 : SWIG_PYTHON_THREAD_END_ALLOW;
23998 : }
23999 85 : if ( bLocalUseExceptions ) {
24000 17 : popErrorHandler();
24001 : }
24002 : #ifndef SED_HACKS
24003 : if ( bLocalUseExceptions ) {
24004 : CPLErr eclass = CPLGetLastErrorType();
24005 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24006 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24007 : }
24008 : }
24009 : #endif
24010 : }
24011 85 : resultobj = SWIG_From_int(static_cast< int >(result));
24012 85 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24013 : return resultobj;
24014 : fail:
24015 : return NULL;
24016 : }
24017 :
24018 :
24019 2 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24020 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24021 2 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24022 2 : OGRwkbGeometryType arg2 ;
24023 2 : void *argp1 = 0 ;
24024 2 : int res1 = 0 ;
24025 2 : int val2 ;
24026 2 : int ecode2 = 0 ;
24027 2 : PyObject *swig_obj[2] ;
24028 :
24029 2 : if (!SWIG_Python_UnpackTuple(args, "GeomFieldDefn_SetType", 2, 2, swig_obj)) SWIG_fail;
24030 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24031 2 : if (!SWIG_IsOK(res1)) {
24032 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_SetType" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24033 : }
24034 2 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24035 2 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24036 2 : if (!SWIG_IsOK(ecode2)) {
24037 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeomFieldDefn_SetType" "', argument " "2"" of type '" "OGRwkbGeometryType""'");
24038 : }
24039 2 : arg2 = static_cast< OGRwkbGeometryType >(val2);
24040 2 : {
24041 2 : const int bLocalUseExceptions = GetUseExceptions();
24042 2 : if ( bLocalUseExceptions ) {
24043 0 : pushErrorHandler();
24044 : }
24045 2 : {
24046 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24047 2 : OGRGeomFieldDefnShadow_SetType(arg1,arg2);
24048 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24049 : }
24050 2 : if ( bLocalUseExceptions ) {
24051 0 : popErrorHandler();
24052 : }
24053 : #ifndef SED_HACKS
24054 : if ( bLocalUseExceptions ) {
24055 : CPLErr eclass = CPLGetLastErrorType();
24056 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24057 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24058 : }
24059 : }
24060 : #endif
24061 : }
24062 2 : resultobj = SWIG_Py_Void();
24063 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24064 : return resultobj;
24065 : fail:
24066 : return NULL;
24067 : }
24068 :
24069 :
24070 81 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_GetSpatialRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24071 81 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24072 81 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24073 81 : void *argp1 = 0 ;
24074 81 : int res1 = 0 ;
24075 81 : PyObject *swig_obj[1] ;
24076 81 : OSRSpatialReferenceShadow *result = 0 ;
24077 :
24078 81 : if (!args) SWIG_fail;
24079 81 : swig_obj[0] = args;
24080 81 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24081 81 : if (!SWIG_IsOK(res1)) {
24082 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_GetSpatialRef" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24083 : }
24084 81 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24085 81 : {
24086 81 : const int bLocalUseExceptions = GetUseExceptions();
24087 81 : if ( bLocalUseExceptions ) {
24088 18 : pushErrorHandler();
24089 : }
24090 81 : {
24091 81 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24092 81 : result = (OSRSpatialReferenceShadow *)OGRGeomFieldDefnShadow_GetSpatialRef(arg1);
24093 81 : SWIG_PYTHON_THREAD_END_ALLOW;
24094 : }
24095 81 : if ( bLocalUseExceptions ) {
24096 18 : popErrorHandler();
24097 : }
24098 : #ifndef SED_HACKS
24099 : if ( bLocalUseExceptions ) {
24100 : CPLErr eclass = CPLGetLastErrorType();
24101 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24102 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24103 : }
24104 : }
24105 : #endif
24106 : }
24107 81 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_OWN | 0 );
24108 81 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24109 : return resultobj;
24110 : fail:
24111 : return NULL;
24112 : }
24113 :
24114 :
24115 48 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_SetSpatialRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24116 48 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24117 48 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24118 48 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
24119 48 : void *argp1 = 0 ;
24120 48 : int res1 = 0 ;
24121 48 : void *argp2 = 0 ;
24122 48 : int res2 = 0 ;
24123 48 : PyObject *swig_obj[2] ;
24124 :
24125 48 : if (!SWIG_Python_UnpackTuple(args, "GeomFieldDefn_SetSpatialRef", 2, 2, swig_obj)) SWIG_fail;
24126 48 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24127 48 : if (!SWIG_IsOK(res1)) {
24128 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_SetSpatialRef" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24129 : }
24130 48 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24131 48 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
24132 48 : if (!SWIG_IsOK(res2)) {
24133 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomFieldDefn_SetSpatialRef" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
24134 : }
24135 48 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
24136 48 : {
24137 48 : const int bLocalUseExceptions = GetUseExceptions();
24138 48 : if ( bLocalUseExceptions ) {
24139 5 : pushErrorHandler();
24140 : }
24141 48 : {
24142 48 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24143 48 : OGRGeomFieldDefnShadow_SetSpatialRef(arg1,arg2);
24144 48 : SWIG_PYTHON_THREAD_END_ALLOW;
24145 : }
24146 48 : if ( bLocalUseExceptions ) {
24147 5 : popErrorHandler();
24148 : }
24149 : #ifndef SED_HACKS
24150 : if ( bLocalUseExceptions ) {
24151 : CPLErr eclass = CPLGetLastErrorType();
24152 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24153 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24154 : }
24155 : }
24156 : #endif
24157 : }
24158 48 : resultobj = SWIG_Py_Void();
24159 48 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24160 : return resultobj;
24161 : fail:
24162 : return NULL;
24163 : }
24164 :
24165 :
24166 6 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_IsIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24167 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24168 6 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24169 6 : void *argp1 = 0 ;
24170 6 : int res1 = 0 ;
24171 6 : PyObject *swig_obj[1] ;
24172 6 : int result;
24173 :
24174 6 : if (!args) SWIG_fail;
24175 6 : swig_obj[0] = args;
24176 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24177 6 : if (!SWIG_IsOK(res1)) {
24178 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_IsIgnored" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24179 : }
24180 6 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24181 6 : {
24182 6 : const int bLocalUseExceptions = GetUseExceptions();
24183 6 : if ( bLocalUseExceptions ) {
24184 2 : pushErrorHandler();
24185 : }
24186 6 : {
24187 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24188 6 : result = (int)OGRGeomFieldDefnShadow_IsIgnored(arg1);
24189 6 : SWIG_PYTHON_THREAD_END_ALLOW;
24190 : }
24191 6 : if ( bLocalUseExceptions ) {
24192 2 : popErrorHandler();
24193 : }
24194 : #ifndef SED_HACKS
24195 : if ( bLocalUseExceptions ) {
24196 : CPLErr eclass = CPLGetLastErrorType();
24197 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24198 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24199 : }
24200 : }
24201 : #endif
24202 : }
24203 6 : resultobj = SWIG_From_int(static_cast< int >(result));
24204 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24205 : return resultobj;
24206 : fail:
24207 : return NULL;
24208 : }
24209 :
24210 :
24211 1 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_SetIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24212 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24213 1 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24214 1 : int arg2 ;
24215 1 : void *argp1 = 0 ;
24216 1 : int res1 = 0 ;
24217 1 : int val2 ;
24218 1 : int ecode2 = 0 ;
24219 1 : PyObject *swig_obj[2] ;
24220 :
24221 1 : if (!SWIG_Python_UnpackTuple(args, "GeomFieldDefn_SetIgnored", 2, 2, swig_obj)) SWIG_fail;
24222 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24223 1 : if (!SWIG_IsOK(res1)) {
24224 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_SetIgnored" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24225 : }
24226 1 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24227 1 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24228 1 : if (!SWIG_IsOK(ecode2)) {
24229 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeomFieldDefn_SetIgnored" "', argument " "2"" of type '" "int""'");
24230 : }
24231 1 : arg2 = static_cast< int >(val2);
24232 1 : {
24233 1 : const int bLocalUseExceptions = GetUseExceptions();
24234 1 : if ( bLocalUseExceptions ) {
24235 0 : pushErrorHandler();
24236 : }
24237 1 : {
24238 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24239 1 : OGRGeomFieldDefnShadow_SetIgnored(arg1,arg2);
24240 1 : SWIG_PYTHON_THREAD_END_ALLOW;
24241 : }
24242 1 : if ( bLocalUseExceptions ) {
24243 0 : popErrorHandler();
24244 : }
24245 : #ifndef SED_HACKS
24246 : if ( bLocalUseExceptions ) {
24247 : CPLErr eclass = CPLGetLastErrorType();
24248 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24249 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24250 : }
24251 : }
24252 : #endif
24253 : }
24254 1 : resultobj = SWIG_Py_Void();
24255 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24256 : return resultobj;
24257 : fail:
24258 : return NULL;
24259 : }
24260 :
24261 :
24262 85 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_IsNullable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24263 85 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24264 85 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24265 85 : void *argp1 = 0 ;
24266 85 : int res1 = 0 ;
24267 85 : PyObject *swig_obj[1] ;
24268 85 : int result;
24269 :
24270 85 : if (!args) SWIG_fail;
24271 85 : swig_obj[0] = args;
24272 85 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24273 85 : if (!SWIG_IsOK(res1)) {
24274 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_IsNullable" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24275 : }
24276 85 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24277 85 : {
24278 85 : const int bLocalUseExceptions = GetUseExceptions();
24279 85 : if ( bLocalUseExceptions ) {
24280 3 : pushErrorHandler();
24281 : }
24282 85 : {
24283 85 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24284 85 : result = (int)OGRGeomFieldDefnShadow_IsNullable(arg1);
24285 85 : SWIG_PYTHON_THREAD_END_ALLOW;
24286 : }
24287 85 : if ( bLocalUseExceptions ) {
24288 3 : popErrorHandler();
24289 : }
24290 : #ifndef SED_HACKS
24291 : if ( bLocalUseExceptions ) {
24292 : CPLErr eclass = CPLGetLastErrorType();
24293 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24294 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24295 : }
24296 : }
24297 : #endif
24298 : }
24299 85 : resultobj = SWIG_From_int(static_cast< int >(result));
24300 85 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24301 : return resultobj;
24302 : fail:
24303 : return NULL;
24304 : }
24305 :
24306 :
24307 23 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_SetNullable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24308 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24309 23 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24310 23 : int arg2 ;
24311 23 : void *argp1 = 0 ;
24312 23 : int res1 = 0 ;
24313 23 : int val2 ;
24314 23 : int ecode2 = 0 ;
24315 23 : PyObject *swig_obj[2] ;
24316 :
24317 23 : if (!SWIG_Python_UnpackTuple(args, "GeomFieldDefn_SetNullable", 2, 2, swig_obj)) SWIG_fail;
24318 23 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24319 23 : if (!SWIG_IsOK(res1)) {
24320 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_SetNullable" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24321 : }
24322 23 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24323 23 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24324 23 : if (!SWIG_IsOK(ecode2)) {
24325 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeomFieldDefn_SetNullable" "', argument " "2"" of type '" "int""'");
24326 : }
24327 23 : arg2 = static_cast< int >(val2);
24328 23 : {
24329 23 : const int bLocalUseExceptions = GetUseExceptions();
24330 23 : if ( bLocalUseExceptions ) {
24331 10 : pushErrorHandler();
24332 : }
24333 23 : {
24334 23 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24335 23 : OGRGeomFieldDefnShadow_SetNullable(arg1,arg2);
24336 23 : SWIG_PYTHON_THREAD_END_ALLOW;
24337 : }
24338 23 : if ( bLocalUseExceptions ) {
24339 10 : popErrorHandler();
24340 : }
24341 : #ifndef SED_HACKS
24342 : if ( bLocalUseExceptions ) {
24343 : CPLErr eclass = CPLGetLastErrorType();
24344 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24345 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24346 : }
24347 : }
24348 : #endif
24349 : }
24350 23 : resultobj = SWIG_Py_Void();
24351 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24352 : return resultobj;
24353 : fail:
24354 : return NULL;
24355 : }
24356 :
24357 :
24358 42 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_GetCoordinatePrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24359 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24360 42 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24361 42 : void *argp1 = 0 ;
24362 42 : int res1 = 0 ;
24363 42 : PyObject *swig_obj[1] ;
24364 42 : OGRGeomCoordinatePrecisionShadow *result = 0 ;
24365 :
24366 42 : if (!args) SWIG_fail;
24367 42 : swig_obj[0] = args;
24368 42 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24369 42 : if (!SWIG_IsOK(res1)) {
24370 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_GetCoordinatePrecision" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24371 : }
24372 42 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24373 42 : {
24374 42 : const int bLocalUseExceptions = GetUseExceptions();
24375 42 : if ( bLocalUseExceptions ) {
24376 35 : pushErrorHandler();
24377 : }
24378 42 : {
24379 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24380 42 : result = (OGRGeomCoordinatePrecisionShadow *)OGRGeomFieldDefnShadow_GetCoordinatePrecision(arg1);
24381 42 : SWIG_PYTHON_THREAD_END_ALLOW;
24382 : }
24383 42 : if ( bLocalUseExceptions ) {
24384 35 : popErrorHandler();
24385 : }
24386 : #ifndef SED_HACKS
24387 : if ( bLocalUseExceptions ) {
24388 : CPLErr eclass = CPLGetLastErrorType();
24389 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24390 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24391 : }
24392 : }
24393 : #endif
24394 : }
24395 42 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
24396 42 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24397 : return resultobj;
24398 : fail:
24399 : return NULL;
24400 : }
24401 :
24402 :
24403 18 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_SetCoordinatePrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24404 18 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24405 18 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24406 18 : OGRGeomCoordinatePrecisionShadow *arg2 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
24407 18 : void *argp1 = 0 ;
24408 18 : int res1 = 0 ;
24409 18 : void *argp2 = 0 ;
24410 18 : int res2 = 0 ;
24411 18 : PyObject *swig_obj[2] ;
24412 :
24413 18 : if (!SWIG_Python_UnpackTuple(args, "GeomFieldDefn_SetCoordinatePrecision", 2, 2, swig_obj)) SWIG_fail;
24414 18 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24415 18 : if (!SWIG_IsOK(res1)) {
24416 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_SetCoordinatePrecision" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24417 : }
24418 18 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24419 18 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
24420 18 : if (!SWIG_IsOK(res2)) {
24421 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomFieldDefn_SetCoordinatePrecision" "', argument " "2"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
24422 : }
24423 18 : arg2 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp2);
24424 18 : {
24425 18 : const int bLocalUseExceptions = GetUseExceptions();
24426 18 : if ( bLocalUseExceptions ) {
24427 13 : pushErrorHandler();
24428 : }
24429 18 : {
24430 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24431 18 : OGRGeomFieldDefnShadow_SetCoordinatePrecision(arg1,arg2);
24432 18 : SWIG_PYTHON_THREAD_END_ALLOW;
24433 : }
24434 18 : if ( bLocalUseExceptions ) {
24435 13 : popErrorHandler();
24436 : }
24437 : #ifndef SED_HACKS
24438 : if ( bLocalUseExceptions ) {
24439 : CPLErr eclass = CPLGetLastErrorType();
24440 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24441 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24442 : }
24443 : }
24444 : #endif
24445 : }
24446 18 : resultobj = SWIG_Py_Void();
24447 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24448 : return resultobj;
24449 : fail:
24450 : return NULL;
24451 : }
24452 :
24453 :
24454 273 : SWIGINTERN PyObject *GeomFieldDefn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24455 273 : PyObject *obj;
24456 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
24457 273 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRGeomFieldDefnShadow, SWIG_NewClientData(obj));
24458 273 : return SWIG_Py_Void();
24459 : }
24460 :
24461 171 : SWIGINTERN PyObject *GeomFieldDefn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24462 171 : return SWIG_Python_InitShadowInstance(args);
24463 : }
24464 :
24465 31028 : SWIGINTERN PyObject *_wrap_CreateGeometryFromWkb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24466 31028 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24467 31028 : size_t arg1 ;
24468 31028 : char *arg2 = (char *) 0 ;
24469 31028 : OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) NULL ;
24470 31028 : int alloc1 = 0 ;
24471 31028 : bool viewIsValid1 = false ;
24472 31028 : Py_buffer view1 ;
24473 31028 : void *argp3 = 0 ;
24474 31028 : int res3 = 0 ;
24475 31028 : PyObject * obj0 = 0 ;
24476 31028 : PyObject * obj1 = 0 ;
24477 31028 : char * kwnames[] = {
24478 : (char *)"len", (char *)"reference", NULL
24479 : };
24480 31028 : OGRGeometryShadow *result = 0 ;
24481 :
24482 31028 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:CreateGeometryFromWkb", kwnames, &obj0, &obj1)) SWIG_fail;
24483 31028 : {
24484 : /* %typemap(in,numinputs=1) (size_t nLen, char *pBuf ) */
24485 31028 : char* ptr = NULL;
24486 31028 : if( !GetBufferAsCharPtrSizetSize(obj0, &arg1, &ptr, &alloc1, &viewIsValid1, &view1) ) {
24487 0 : SWIG_fail;
24488 : }
24489 31028 : arg2 = (char *)ptr;
24490 : }
24491 31028 : if (obj1) {
24492 0 : res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
24493 0 : if (!SWIG_IsOK(res3)) {
24494 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CreateGeometryFromWkb" "', argument " "3"" of type '" "OSRSpatialReferenceShadow *""'");
24495 : }
24496 0 : arg3 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp3);
24497 : }
24498 31028 : {
24499 31028 : const int bLocalUseExceptions = GetUseExceptions();
24500 31028 : if ( bLocalUseExceptions ) {
24501 336 : pushErrorHandler();
24502 : }
24503 31028 : {
24504 31028 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24505 31028 : result = (OGRGeometryShadow *)CreateGeometryFromWkb(arg1,arg2,arg3);
24506 31028 : SWIG_PYTHON_THREAD_END_ALLOW;
24507 : }
24508 31028 : if ( bLocalUseExceptions ) {
24509 336 : popErrorHandler();
24510 : }
24511 : #ifndef SED_HACKS
24512 : if ( bLocalUseExceptions ) {
24513 : CPLErr eclass = CPLGetLastErrorType();
24514 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24515 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24516 : }
24517 : }
24518 : #endif
24519 : }
24520 31028 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24521 31028 : {
24522 : /* %typemap(freearg) (size_t *nLen, char *pBuf ) */
24523 31028 : if( viewIsValid1 ) {
24524 31021 : PyBuffer_Release(&view1);
24525 : }
24526 7 : else if (ReturnSame(alloc1) == SWIG_NEWOBJ ) {
24527 7 : delete[] arg2;
24528 : }
24529 : }
24530 31030 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24531 : return resultobj;
24532 0 : fail:
24533 0 : {
24534 : /* %typemap(freearg) (size_t *nLen, char *pBuf ) */
24535 0 : if( viewIsValid1 ) {
24536 0 : PyBuffer_Release(&view1);
24537 : }
24538 31028 : else if (ReturnSame(alloc1) == SWIG_NEWOBJ ) {
24539 0 : delete[] arg2;
24540 : }
24541 : }
24542 : return NULL;
24543 : }
24544 :
24545 :
24546 115161 : SWIGINTERN PyObject *_wrap_CreateGeometryFromWkt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24547 115161 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24548 115161 : char **arg1 = (char **) 0 ;
24549 115161 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) NULL ;
24550 115161 : char *val1 ;
24551 115161 : void *argp2 = 0 ;
24552 115161 : int res2 = 0 ;
24553 115161 : PyObject * obj0 = 0 ;
24554 115161 : PyObject * obj1 = 0 ;
24555 115161 : char * kwnames[] = {
24556 : (char *)"val", (char *)"reference", NULL
24557 : };
24558 115161 : OGRGeometryShadow *result = 0 ;
24559 :
24560 115161 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:CreateGeometryFromWkt", kwnames, &obj0, &obj1)) SWIG_fail;
24561 115161 : {
24562 : /* %typemap(in) (char **ignorechange) */
24563 115161 : if( !PyArg_Parse( obj0, "s", &val1 ) ) {
24564 0 : PyErr_SetString( PyExc_TypeError, "not a string" );
24565 0 : SWIG_fail;
24566 : }
24567 115161 : arg1 = &val1;
24568 : }
24569 115161 : if (obj1) {
24570 187 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
24571 187 : if (!SWIG_IsOK(res2)) {
24572 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateGeometryFromWkt" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
24573 : }
24574 187 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
24575 : }
24576 115161 : {
24577 115161 : const int bLocalUseExceptions = GetUseExceptions();
24578 115161 : if ( bLocalUseExceptions ) {
24579 59440 : pushErrorHandler();
24580 : }
24581 115161 : {
24582 115161 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24583 115161 : result = (OGRGeometryShadow *)CreateGeometryFromWkt(arg1,arg2);
24584 115161 : SWIG_PYTHON_THREAD_END_ALLOW;
24585 : }
24586 115161 : if ( bLocalUseExceptions ) {
24587 59440 : popErrorHandler();
24588 : }
24589 : #ifndef SED_HACKS
24590 : if ( bLocalUseExceptions ) {
24591 : CPLErr eclass = CPLGetLastErrorType();
24592 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24593 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24594 : }
24595 : }
24596 : #endif
24597 : }
24598 115161 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24599 115163 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24600 : return resultobj;
24601 : fail:
24602 : return NULL;
24603 : }
24604 :
24605 :
24606 287 : SWIGINTERN PyObject *_wrap_CreateGeometryFromGML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24607 287 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24608 287 : char *arg1 = (char *) 0 ;
24609 287 : int res1 ;
24610 287 : char *buf1 = 0 ;
24611 287 : int alloc1 = 0 ;
24612 287 : PyObject *swig_obj[1] ;
24613 287 : OGRGeometryShadow *result = 0 ;
24614 :
24615 287 : if (!args) SWIG_fail;
24616 287 : swig_obj[0] = args;
24617 287 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
24618 287 : if (!SWIG_IsOK(res1)) {
24619 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateGeometryFromGML" "', argument " "1"" of type '" "char const *""'");
24620 : }
24621 287 : arg1 = reinterpret_cast< char * >(buf1);
24622 287 : {
24623 287 : const int bLocalUseExceptions = GetUseExceptions();
24624 287 : if ( bLocalUseExceptions ) {
24625 139 : pushErrorHandler();
24626 : }
24627 287 : {
24628 287 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24629 287 : result = (OGRGeometryShadow *)CreateGeometryFromGML((char const *)arg1);
24630 287 : SWIG_PYTHON_THREAD_END_ALLOW;
24631 : }
24632 287 : if ( bLocalUseExceptions ) {
24633 139 : popErrorHandler();
24634 : }
24635 : #ifndef SED_HACKS
24636 : if ( bLocalUseExceptions ) {
24637 : CPLErr eclass = CPLGetLastErrorType();
24638 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24639 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24640 : }
24641 : }
24642 : #endif
24643 : }
24644 287 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24645 287 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24646 289 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24647 : return resultobj;
24648 0 : fail:
24649 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24650 : return NULL;
24651 : }
24652 :
24653 :
24654 42 : SWIGINTERN PyObject *_wrap_CreateGeometryFromJson(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24655 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24656 42 : char *arg1 = (char *) 0 ;
24657 42 : int res1 ;
24658 42 : char *buf1 = 0 ;
24659 42 : int alloc1 = 0 ;
24660 42 : PyObject *swig_obj[1] ;
24661 42 : OGRGeometryShadow *result = 0 ;
24662 :
24663 42 : if (!args) SWIG_fail;
24664 42 : swig_obj[0] = args;
24665 42 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
24666 42 : if (!SWIG_IsOK(res1)) {
24667 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateGeometryFromJson" "', argument " "1"" of type '" "char const *""'");
24668 : }
24669 42 : arg1 = reinterpret_cast< char * >(buf1);
24670 42 : {
24671 42 : const int bLocalUseExceptions = GetUseExceptions();
24672 42 : if ( bLocalUseExceptions ) {
24673 42 : pushErrorHandler();
24674 : }
24675 42 : {
24676 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24677 42 : result = (OGRGeometryShadow *)CreateGeometryFromJson((char const *)arg1);
24678 42 : SWIG_PYTHON_THREAD_END_ALLOW;
24679 : }
24680 42 : if ( bLocalUseExceptions ) {
24681 42 : popErrorHandler();
24682 : }
24683 : #ifndef SED_HACKS
24684 : if ( bLocalUseExceptions ) {
24685 : CPLErr eclass = CPLGetLastErrorType();
24686 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24687 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24688 : }
24689 : }
24690 : #endif
24691 : }
24692 42 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24693 42 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24694 42 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24695 : return resultobj;
24696 0 : fail:
24697 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24698 : return NULL;
24699 : }
24700 :
24701 :
24702 2 : SWIGINTERN PyObject *_wrap_CreateGeometryFromEsriJson(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24703 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24704 2 : char *arg1 = (char *) 0 ;
24705 2 : int res1 ;
24706 2 : char *buf1 = 0 ;
24707 2 : int alloc1 = 0 ;
24708 2 : PyObject *swig_obj[1] ;
24709 2 : OGRGeometryShadow *result = 0 ;
24710 :
24711 2 : if (!args) SWIG_fail;
24712 2 : swig_obj[0] = args;
24713 2 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
24714 2 : if (!SWIG_IsOK(res1)) {
24715 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateGeometryFromEsriJson" "', argument " "1"" of type '" "char const *""'");
24716 : }
24717 2 : arg1 = reinterpret_cast< char * >(buf1);
24718 2 : {
24719 2 : const int bLocalUseExceptions = GetUseExceptions();
24720 2 : if ( bLocalUseExceptions ) {
24721 2 : pushErrorHandler();
24722 : }
24723 2 : {
24724 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24725 2 : result = (OGRGeometryShadow *)CreateGeometryFromEsriJson((char const *)arg1);
24726 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24727 : }
24728 2 : if ( bLocalUseExceptions ) {
24729 2 : popErrorHandler();
24730 : }
24731 : #ifndef SED_HACKS
24732 : if ( bLocalUseExceptions ) {
24733 : CPLErr eclass = CPLGetLastErrorType();
24734 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24735 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24736 : }
24737 : }
24738 : #endif
24739 : }
24740 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24741 2 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24742 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24743 : return resultobj;
24744 0 : fail:
24745 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24746 : return NULL;
24747 : }
24748 :
24749 :
24750 5 : SWIGINTERN PyObject *_wrap_BuildPolygonFromEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24751 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24752 5 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
24753 5 : int arg2 = (int) 0 ;
24754 5 : int arg3 = (int) 0 ;
24755 5 : double arg4 = (double) 0 ;
24756 5 : void *argp1 = 0 ;
24757 5 : int res1 = 0 ;
24758 5 : int val2 ;
24759 5 : int ecode2 = 0 ;
24760 5 : int val3 ;
24761 5 : int ecode3 = 0 ;
24762 5 : double val4 ;
24763 5 : int ecode4 = 0 ;
24764 5 : PyObject * obj0 = 0 ;
24765 5 : PyObject * obj1 = 0 ;
24766 5 : PyObject * obj2 = 0 ;
24767 5 : PyObject * obj3 = 0 ;
24768 5 : char * kwnames[] = {
24769 : (char *)"hLineCollection", (char *)"bBestEffort", (char *)"bAutoClose", (char *)"dfTolerance", NULL
24770 : };
24771 5 : OGRGeometryShadow *result = 0 ;
24772 :
24773 5 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:BuildPolygonFromEdges", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
24774 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
24775 5 : if (!SWIG_IsOK(res1)) {
24776 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BuildPolygonFromEdges" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
24777 : }
24778 5 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
24779 5 : if (obj1) {
24780 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24781 0 : if (!SWIG_IsOK(ecode2)) {
24782 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BuildPolygonFromEdges" "', argument " "2"" of type '" "int""'");
24783 : }
24784 : arg2 = static_cast< int >(val2);
24785 : }
24786 5 : if (obj2) {
24787 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
24788 0 : if (!SWIG_IsOK(ecode3)) {
24789 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BuildPolygonFromEdges" "', argument " "3"" of type '" "int""'");
24790 : }
24791 : arg3 = static_cast< int >(val3);
24792 : }
24793 5 : if (obj3) {
24794 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
24795 0 : if (!SWIG_IsOK(ecode4)) {
24796 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BuildPolygonFromEdges" "', argument " "4"" of type '" "double""'");
24797 : }
24798 0 : arg4 = static_cast< double >(val4);
24799 : }
24800 5 : {
24801 5 : const int bLocalUseExceptions = GetUseExceptions();
24802 5 : if ( bLocalUseExceptions ) {
24803 0 : pushErrorHandler();
24804 : }
24805 5 : {
24806 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24807 5 : result = (OGRGeometryShadow *)BuildPolygonFromEdges(arg1,arg2,arg3,arg4);
24808 5 : SWIG_PYTHON_THREAD_END_ALLOW;
24809 : }
24810 5 : if ( bLocalUseExceptions ) {
24811 0 : popErrorHandler();
24812 : }
24813 : #ifndef SED_HACKS
24814 : if ( bLocalUseExceptions ) {
24815 : CPLErr eclass = CPLGetLastErrorType();
24816 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24817 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24818 : }
24819 : }
24820 : #endif
24821 : }
24822 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24823 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24824 : return resultobj;
24825 : fail:
24826 : return NULL;
24827 : }
24828 :
24829 :
24830 1 : SWIGINTERN PyObject *_wrap_ApproximateArcAngles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24831 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24832 1 : double arg1 ;
24833 1 : double arg2 ;
24834 1 : double arg3 ;
24835 1 : double arg4 ;
24836 1 : double arg5 ;
24837 1 : double arg6 ;
24838 1 : double arg7 ;
24839 1 : double arg8 ;
24840 1 : double arg9 ;
24841 1 : double val1 ;
24842 1 : int ecode1 = 0 ;
24843 1 : double val2 ;
24844 1 : int ecode2 = 0 ;
24845 1 : double val3 ;
24846 1 : int ecode3 = 0 ;
24847 1 : double val4 ;
24848 1 : int ecode4 = 0 ;
24849 1 : double val5 ;
24850 1 : int ecode5 = 0 ;
24851 1 : double val6 ;
24852 1 : int ecode6 = 0 ;
24853 1 : double val7 ;
24854 1 : int ecode7 = 0 ;
24855 1 : double val8 ;
24856 1 : int ecode8 = 0 ;
24857 1 : double val9 ;
24858 1 : int ecode9 = 0 ;
24859 1 : PyObject * obj0 = 0 ;
24860 1 : PyObject * obj1 = 0 ;
24861 1 : PyObject * obj2 = 0 ;
24862 1 : PyObject * obj3 = 0 ;
24863 1 : PyObject * obj4 = 0 ;
24864 1 : PyObject * obj5 = 0 ;
24865 1 : PyObject * obj6 = 0 ;
24866 1 : PyObject * obj7 = 0 ;
24867 1 : PyObject * obj8 = 0 ;
24868 1 : char * kwnames[] = {
24869 : (char *)"dfCenterX", (char *)"dfCenterY", (char *)"dfZ", (char *)"dfPrimaryRadius", (char *)"dfSecondaryAxis", (char *)"dfRotation", (char *)"dfStartAngle", (char *)"dfEndAngle", (char *)"dfMaxAngleStepSizeDegrees", NULL
24870 : };
24871 1 : OGRGeometryShadow *result = 0 ;
24872 :
24873 1 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOO:ApproximateArcAngles", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
24874 1 : ecode1 = SWIG_AsVal_double(obj0, &val1);
24875 1 : if (!SWIG_IsOK(ecode1)) {
24876 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ApproximateArcAngles" "', argument " "1"" of type '" "double""'");
24877 : }
24878 1 : arg1 = static_cast< double >(val1);
24879 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
24880 1 : if (!SWIG_IsOK(ecode2)) {
24881 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ApproximateArcAngles" "', argument " "2"" of type '" "double""'");
24882 : }
24883 1 : arg2 = static_cast< double >(val2);
24884 1 : ecode3 = SWIG_AsVal_double(obj2, &val3);
24885 1 : if (!SWIG_IsOK(ecode3)) {
24886 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ApproximateArcAngles" "', argument " "3"" of type '" "double""'");
24887 : }
24888 1 : arg3 = static_cast< double >(val3);
24889 1 : ecode4 = SWIG_AsVal_double(obj3, &val4);
24890 1 : if (!SWIG_IsOK(ecode4)) {
24891 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ApproximateArcAngles" "', argument " "4"" of type '" "double""'");
24892 : }
24893 1 : arg4 = static_cast< double >(val4);
24894 1 : ecode5 = SWIG_AsVal_double(obj4, &val5);
24895 1 : if (!SWIG_IsOK(ecode5)) {
24896 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ApproximateArcAngles" "', argument " "5"" of type '" "double""'");
24897 : }
24898 1 : arg5 = static_cast< double >(val5);
24899 1 : ecode6 = SWIG_AsVal_double(obj5, &val6);
24900 1 : if (!SWIG_IsOK(ecode6)) {
24901 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ApproximateArcAngles" "', argument " "6"" of type '" "double""'");
24902 : }
24903 1 : arg6 = static_cast< double >(val6);
24904 1 : ecode7 = SWIG_AsVal_double(obj6, &val7);
24905 1 : if (!SWIG_IsOK(ecode7)) {
24906 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ApproximateArcAngles" "', argument " "7"" of type '" "double""'");
24907 : }
24908 1 : arg7 = static_cast< double >(val7);
24909 1 : ecode8 = SWIG_AsVal_double(obj7, &val8);
24910 1 : if (!SWIG_IsOK(ecode8)) {
24911 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ApproximateArcAngles" "', argument " "8"" of type '" "double""'");
24912 : }
24913 1 : arg8 = static_cast< double >(val8);
24914 1 : ecode9 = SWIG_AsVal_double(obj8, &val9);
24915 1 : if (!SWIG_IsOK(ecode9)) {
24916 0 : SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ApproximateArcAngles" "', argument " "9"" of type '" "double""'");
24917 : }
24918 1 : arg9 = static_cast< double >(val9);
24919 1 : {
24920 1 : const int bLocalUseExceptions = GetUseExceptions();
24921 1 : if ( bLocalUseExceptions ) {
24922 1 : pushErrorHandler();
24923 : }
24924 1 : {
24925 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24926 1 : result = (OGRGeometryShadow *)ApproximateArcAngles(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
24927 1 : SWIG_PYTHON_THREAD_END_ALLOW;
24928 : }
24929 1 : if ( bLocalUseExceptions ) {
24930 1 : popErrorHandler();
24931 : }
24932 : #ifndef SED_HACKS
24933 : if ( bLocalUseExceptions ) {
24934 : CPLErr eclass = CPLGetLastErrorType();
24935 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24936 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24937 : }
24938 : }
24939 : #endif
24940 : }
24941 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24942 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24943 : return resultobj;
24944 : fail:
24945 : return NULL;
24946 : }
24947 :
24948 :
24949 46 : SWIGINTERN PyObject *_wrap_ForceToPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24950 46 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24951 46 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
24952 46 : void *argp1 = 0 ;
24953 46 : int res1 = 0 ;
24954 46 : PyObject *swig_obj[1] ;
24955 46 : OGRGeometryShadow *result = 0 ;
24956 :
24957 46 : if (!args) SWIG_fail;
24958 46 : swig_obj[0] = args;
24959 46 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
24960 46 : if (!SWIG_IsOK(res1)) {
24961 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForceToPolygon" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
24962 : }
24963 46 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
24964 46 : {
24965 46 : const int bLocalUseExceptions = GetUseExceptions();
24966 46 : if ( bLocalUseExceptions ) {
24967 4 : pushErrorHandler();
24968 : }
24969 46 : {
24970 46 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24971 46 : result = (OGRGeometryShadow *)ForceToPolygon(arg1);
24972 46 : SWIG_PYTHON_THREAD_END_ALLOW;
24973 : }
24974 46 : if ( bLocalUseExceptions ) {
24975 4 : popErrorHandler();
24976 : }
24977 : #ifndef SED_HACKS
24978 : if ( bLocalUseExceptions ) {
24979 : CPLErr eclass = CPLGetLastErrorType();
24980 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24981 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24982 : }
24983 : }
24984 : #endif
24985 : }
24986 46 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24987 46 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24988 : return resultobj;
24989 : fail:
24990 : return NULL;
24991 : }
24992 :
24993 :
24994 60 : SWIGINTERN PyObject *_wrap_ForceToLineString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24995 60 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24996 60 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
24997 60 : void *argp1 = 0 ;
24998 60 : int res1 = 0 ;
24999 60 : PyObject *swig_obj[1] ;
25000 60 : OGRGeometryShadow *result = 0 ;
25001 :
25002 60 : if (!args) SWIG_fail;
25003 60 : swig_obj[0] = args;
25004 60 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25005 60 : if (!SWIG_IsOK(res1)) {
25006 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForceToLineString" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25007 : }
25008 60 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25009 60 : {
25010 60 : const int bLocalUseExceptions = GetUseExceptions();
25011 60 : if ( bLocalUseExceptions ) {
25012 16 : pushErrorHandler();
25013 : }
25014 60 : {
25015 60 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25016 60 : result = (OGRGeometryShadow *)ForceToLineString(arg1);
25017 60 : SWIG_PYTHON_THREAD_END_ALLOW;
25018 : }
25019 60 : if ( bLocalUseExceptions ) {
25020 16 : popErrorHandler();
25021 : }
25022 : #ifndef SED_HACKS
25023 : if ( bLocalUseExceptions ) {
25024 : CPLErr eclass = CPLGetLastErrorType();
25025 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25026 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25027 : }
25028 : }
25029 : #endif
25030 : }
25031 60 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
25032 60 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25033 : return resultobj;
25034 : fail:
25035 : return NULL;
25036 : }
25037 :
25038 :
25039 47 : SWIGINTERN PyObject *_wrap_ForceToMultiPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25040 47 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25041 47 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25042 47 : void *argp1 = 0 ;
25043 47 : int res1 = 0 ;
25044 47 : PyObject *swig_obj[1] ;
25045 47 : OGRGeometryShadow *result = 0 ;
25046 :
25047 47 : if (!args) SWIG_fail;
25048 47 : swig_obj[0] = args;
25049 47 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25050 47 : if (!SWIG_IsOK(res1)) {
25051 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForceToMultiPolygon" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25052 : }
25053 47 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25054 47 : {
25055 47 : const int bLocalUseExceptions = GetUseExceptions();
25056 47 : if ( bLocalUseExceptions ) {
25057 4 : pushErrorHandler();
25058 : }
25059 47 : {
25060 47 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25061 47 : result = (OGRGeometryShadow *)ForceToMultiPolygon(arg1);
25062 47 : SWIG_PYTHON_THREAD_END_ALLOW;
25063 : }
25064 47 : if ( bLocalUseExceptions ) {
25065 4 : popErrorHandler();
25066 : }
25067 : #ifndef SED_HACKS
25068 : if ( bLocalUseExceptions ) {
25069 : CPLErr eclass = CPLGetLastErrorType();
25070 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25071 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25072 : }
25073 : }
25074 : #endif
25075 : }
25076 47 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
25077 47 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25078 : return resultobj;
25079 : fail:
25080 : return NULL;
25081 : }
25082 :
25083 :
25084 42 : SWIGINTERN PyObject *_wrap_ForceToMultiPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25085 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25086 42 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25087 42 : void *argp1 = 0 ;
25088 42 : int res1 = 0 ;
25089 42 : PyObject *swig_obj[1] ;
25090 42 : OGRGeometryShadow *result = 0 ;
25091 :
25092 42 : if (!args) SWIG_fail;
25093 42 : swig_obj[0] = args;
25094 42 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25095 42 : if (!SWIG_IsOK(res1)) {
25096 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForceToMultiPoint" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25097 : }
25098 42 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25099 42 : {
25100 42 : const int bLocalUseExceptions = GetUseExceptions();
25101 42 : if ( bLocalUseExceptions ) {
25102 2 : pushErrorHandler();
25103 : }
25104 42 : {
25105 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25106 42 : result = (OGRGeometryShadow *)ForceToMultiPoint(arg1);
25107 42 : SWIG_PYTHON_THREAD_END_ALLOW;
25108 : }
25109 42 : if ( bLocalUseExceptions ) {
25110 2 : popErrorHandler();
25111 : }
25112 : #ifndef SED_HACKS
25113 : if ( bLocalUseExceptions ) {
25114 : CPLErr eclass = CPLGetLastErrorType();
25115 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25116 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25117 : }
25118 : }
25119 : #endif
25120 : }
25121 42 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
25122 42 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25123 : return resultobj;
25124 : fail:
25125 : return NULL;
25126 : }
25127 :
25128 :
25129 50 : SWIGINTERN PyObject *_wrap_ForceToMultiLineString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25130 50 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25131 50 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25132 50 : void *argp1 = 0 ;
25133 50 : int res1 = 0 ;
25134 50 : PyObject *swig_obj[1] ;
25135 50 : OGRGeometryShadow *result = 0 ;
25136 :
25137 50 : if (!args) SWIG_fail;
25138 50 : swig_obj[0] = args;
25139 50 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25140 50 : if (!SWIG_IsOK(res1)) {
25141 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForceToMultiLineString" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25142 : }
25143 50 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25144 50 : {
25145 50 : const int bLocalUseExceptions = GetUseExceptions();
25146 50 : if ( bLocalUseExceptions ) {
25147 4 : pushErrorHandler();
25148 : }
25149 50 : {
25150 50 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25151 50 : result = (OGRGeometryShadow *)ForceToMultiLineString(arg1);
25152 50 : SWIG_PYTHON_THREAD_END_ALLOW;
25153 : }
25154 50 : if ( bLocalUseExceptions ) {
25155 4 : popErrorHandler();
25156 : }
25157 : #ifndef SED_HACKS
25158 : if ( bLocalUseExceptions ) {
25159 : CPLErr eclass = CPLGetLastErrorType();
25160 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25161 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25162 : }
25163 : }
25164 : #endif
25165 : }
25166 50 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
25167 50 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25168 : return resultobj;
25169 : fail:
25170 : return NULL;
25171 : }
25172 :
25173 :
25174 831 : SWIGINTERN PyObject *_wrap_ForceTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25175 831 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25176 831 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25177 831 : OGRwkbGeometryType arg2 ;
25178 831 : char **arg3 = (char **) NULL ;
25179 831 : void *argp1 = 0 ;
25180 831 : int res1 = 0 ;
25181 831 : int val2 ;
25182 831 : int ecode2 = 0 ;
25183 831 : PyObject *swig_obj[3] ;
25184 831 : OGRGeometryShadow *result = 0 ;
25185 :
25186 831 : if (!SWIG_Python_UnpackTuple(args, "ForceTo", 2, 3, swig_obj)) SWIG_fail;
25187 831 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25188 831 : if (!SWIG_IsOK(res1)) {
25189 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForceTo" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25190 : }
25191 831 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25192 831 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25193 831 : if (!SWIG_IsOK(ecode2)) {
25194 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ForceTo" "', argument " "2"" of type '" "OGRwkbGeometryType""'");
25195 : }
25196 831 : arg2 = static_cast< OGRwkbGeometryType >(val2);
25197 831 : if (swig_obj[2]) {
25198 0 : {
25199 : /* %typemap(in) char **dict */
25200 0 : arg3 = NULL;
25201 0 : if ( PySequence_Check( swig_obj[2] ) ) {
25202 0 : int bErr = FALSE;
25203 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
25204 0 : if ( bErr )
25205 : {
25206 0 : SWIG_fail;
25207 : }
25208 : }
25209 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
25210 0 : int bErr = FALSE;
25211 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
25212 0 : if ( bErr )
25213 : {
25214 0 : SWIG_fail;
25215 : }
25216 : }
25217 : else {
25218 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
25219 0 : SWIG_fail;
25220 : }
25221 : }
25222 : }
25223 831 : {
25224 831 : const int bLocalUseExceptions = GetUseExceptions();
25225 831 : if ( bLocalUseExceptions ) {
25226 228 : pushErrorHandler();
25227 : }
25228 831 : {
25229 831 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25230 831 : result = (OGRGeometryShadow *)ForceTo(arg1,arg2,arg3);
25231 831 : SWIG_PYTHON_THREAD_END_ALLOW;
25232 : }
25233 831 : if ( bLocalUseExceptions ) {
25234 228 : popErrorHandler();
25235 : }
25236 : #ifndef SED_HACKS
25237 : if ( bLocalUseExceptions ) {
25238 : CPLErr eclass = CPLGetLastErrorType();
25239 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25240 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25241 : }
25242 : }
25243 : #endif
25244 : }
25245 831 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
25246 831 : {
25247 : /* %typemap(freearg) char **dict */
25248 831 : CSLDestroy( arg3 );
25249 : }
25250 831 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25251 : return resultobj;
25252 0 : fail:
25253 0 : {
25254 : /* %typemap(freearg) char **dict */
25255 0 : CSLDestroy( arg3 );
25256 : }
25257 : return NULL;
25258 : }
25259 :
25260 :
25261 287469 : SWIGINTERN PyObject *_wrap_delete_Geometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25262 287469 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25263 287469 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25264 287469 : void *argp1 = 0 ;
25265 287469 : int res1 = 0 ;
25266 287469 : PyObject *swig_obj[1] ;
25267 :
25268 287469 : if (!args) SWIG_fail;
25269 287469 : swig_obj[0] = args;
25270 287469 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN | 0 );
25271 287469 : if (!SWIG_IsOK(res1)) {
25272 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Geometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25273 : }
25274 287469 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25275 287469 : {
25276 287469 : const int bLocalUseExceptions = GetUseExceptions();
25277 287469 : if ( bLocalUseExceptions ) {
25278 232290 : pushErrorHandler();
25279 : }
25280 287469 : {
25281 287469 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25282 287469 : delete_OGRGeometryShadow(arg1);
25283 287469 : SWIG_PYTHON_THREAD_END_ALLOW;
25284 : }
25285 287469 : if ( bLocalUseExceptions ) {
25286 232290 : popErrorHandler();
25287 : }
25288 : #ifndef SED_HACKS
25289 : if ( bLocalUseExceptions ) {
25290 : CPLErr eclass = CPLGetLastErrorType();
25291 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25292 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25293 : }
25294 : }
25295 : #endif
25296 : }
25297 287469 : resultobj = SWIG_Py_Void();
25298 287469 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25299 : return resultobj;
25300 : fail:
25301 : return NULL;
25302 : }
25303 :
25304 :
25305 160954 : SWIGINTERN PyObject *_wrap_new_Geometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25306 160954 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25307 160954 : OGRwkbGeometryType arg1 = (OGRwkbGeometryType) wkbUnknown ;
25308 160954 : char *arg2 = (char *) 0 ;
25309 160954 : int arg3 = (int) 0 ;
25310 160954 : char *arg4 = (char *) 0 ;
25311 160954 : char *arg5 = (char *) 0 ;
25312 160954 : int val1 ;
25313 160954 : int ecode1 = 0 ;
25314 160954 : int res2 ;
25315 160954 : char *buf2 = 0 ;
25316 160954 : int alloc2 = 0 ;
25317 160954 : int alloc3 = 0 ;
25318 160954 : bool viewIsValid3 = false ;
25319 160954 : Py_buffer view3 ;
25320 160954 : int res5 ;
25321 160954 : char *buf5 = 0 ;
25322 160954 : int alloc5 = 0 ;
25323 160954 : PyObject * obj0 = 0 ;
25324 160954 : PyObject * obj1 = 0 ;
25325 160954 : PyObject * obj2 = 0 ;
25326 160954 : PyObject * obj3 = 0 ;
25327 160954 : char * kwnames[] = {
25328 : (char *)"type", (char *)"wkt", (char *)"wkb", (char *)"gml", NULL
25329 : };
25330 160954 : OGRGeometryShadow *result = 0 ;
25331 :
25332 160954 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO:new_Geometry", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
25333 160954 : if (obj0) {
25334 160791 : ecode1 = SWIG_AsVal_int(obj0, &val1);
25335 160791 : if (!SWIG_IsOK(ecode1)) {
25336 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Geometry" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
25337 : }
25338 160791 : arg1 = static_cast< OGRwkbGeometryType >(val1);
25339 : }
25340 160954 : if (obj1) {
25341 162 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
25342 162 : if (!SWIG_IsOK(res2)) {
25343 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Geometry" "', argument " "2"" of type '" "char *""'");
25344 : }
25345 162 : arg2 = reinterpret_cast< char * >(buf2);
25346 : }
25347 160954 : if (obj2) {
25348 0 : {
25349 : /* %typemap(in,numinputs=1) (int nLen, char *pBuf ) */
25350 0 : char* ptr = NULL;
25351 0 : if( !GetBufferAsCharPtrIntSize(obj2, &arg3, &ptr, &alloc3, &viewIsValid3, &view3) ) {
25352 0 : SWIG_fail;
25353 : }
25354 0 : arg4 = (char *)ptr;
25355 : }
25356 : }
25357 160954 : if (obj3) {
25358 0 : res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
25359 0 : if (!SWIG_IsOK(res5)) {
25360 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Geometry" "', argument " "5"" of type '" "char *""'");
25361 : }
25362 0 : arg5 = reinterpret_cast< char * >(buf5);
25363 : }
25364 160954 : {
25365 160954 : const int bLocalUseExceptions = GetUseExceptions();
25366 160954 : if ( bLocalUseExceptions ) {
25367 160714 : pushErrorHandler();
25368 : }
25369 160954 : {
25370 160954 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25371 160954 : result = (OGRGeometryShadow *)new_OGRGeometryShadow(arg1,arg2,arg3,arg4,arg5);
25372 160954 : SWIG_PYTHON_THREAD_END_ALLOW;
25373 : }
25374 160954 : if ( bLocalUseExceptions ) {
25375 160714 : popErrorHandler();
25376 : }
25377 : #ifndef SED_HACKS
25378 : if ( bLocalUseExceptions ) {
25379 : CPLErr eclass = CPLGetLastErrorType();
25380 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25381 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25382 : }
25383 : }
25384 : #endif
25385 : }
25386 160954 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_NEW | 0 );
25387 160954 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25388 160954 : {
25389 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
25390 160954 : if( viewIsValid3 ) {
25391 0 : PyBuffer_Release(&view3);
25392 : }
25393 160954 : else if (ReturnSame(alloc3) == SWIG_NEWOBJ ) {
25394 0 : delete[] arg4;
25395 : }
25396 : }
25397 160954 : if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25398 160954 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25399 : return resultobj;
25400 0 : fail:
25401 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25402 0 : {
25403 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
25404 0 : if( viewIsValid3 ) {
25405 0 : PyBuffer_Release(&view3);
25406 : }
25407 0 : else if (ReturnSame(alloc3) == SWIG_NEWOBJ ) {
25408 0 : delete[] arg4;
25409 : }
25410 : }
25411 0 : if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25412 : return NULL;
25413 : }
25414 :
25415 :
25416 2410 : SWIGINTERN PyObject *_wrap_Geometry_ExportToWkt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25417 2410 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25418 2410 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25419 2410 : char **arg2 = (char **) 0 ;
25420 2410 : void *argp1 = 0 ;
25421 2410 : int res1 = 0 ;
25422 2410 : char *argout2 = 0 ;
25423 2410 : PyObject *swig_obj[1] ;
25424 2410 : OGRErr result;
25425 :
25426 2410 : {
25427 : /* %typemap(in,numinputs=0) (char **argout2) */
25428 2410 : arg2 = &argout2;
25429 : }
25430 2410 : if (!args) SWIG_fail;
25431 2410 : swig_obj[0] = args;
25432 2410 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25433 2410 : if (!SWIG_IsOK(res1)) {
25434 14 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ExportToWkt" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25435 : }
25436 2403 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25437 2403 : {
25438 2403 : const int bLocalUseExceptions = GetUseExceptions();
25439 2403 : if ( bLocalUseExceptions ) {
25440 507 : pushErrorHandler();
25441 : }
25442 2403 : {
25443 2403 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25444 2403 : result = (OGRErr)OGRGeometryShadow_ExportToWkt(arg1,arg2);
25445 2403 : SWIG_PYTHON_THREAD_END_ALLOW;
25446 : }
25447 2403 : if ( bLocalUseExceptions ) {
25448 507 : popErrorHandler();
25449 : }
25450 : #ifndef SED_HACKS
25451 : if ( bLocalUseExceptions ) {
25452 : CPLErr eclass = CPLGetLastErrorType();
25453 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25454 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25455 : }
25456 : }
25457 : #endif
25458 : }
25459 2403 : {
25460 : /* %typemap(out) OGRErr */
25461 2403 : if ( result != 0 && GetUseExceptions()) {
25462 0 : const char* pszMessage = CPLGetLastErrorMsg();
25463 0 : if( pszMessage[0] != '\0' )
25464 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
25465 : else
25466 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
25467 0 : SWIG_fail;
25468 : }
25469 : }
25470 2403 : {
25471 : /* %typemap(argout) (char **argout) */
25472 2403 : PyObject *o;
25473 2403 : if ( ReturnSame(arg2) != NULL && *arg2 != NULL ) {
25474 2403 : o = GDALPythonObjectFromCStr( *arg2 );
25475 : }
25476 : else {
25477 0 : o = Py_None;
25478 0 : Py_INCREF( o );
25479 : }
25480 : #if SWIG_VERSION >= 0x040300
25481 : resultobj = SWIG_Python_AppendOutput(resultobj,o,$isvoid);
25482 : #else
25483 2403 : resultobj = SWIG_Python_AppendOutput(resultobj,o);
25484 : #endif
25485 : }
25486 2403 : {
25487 : /* %typemap(freearg) (char **argout) */
25488 2403 : if ( *arg2 )
25489 2403 : CPLFree( *arg2 );
25490 : }
25491 2403 : {
25492 : /* %typemap(ret) OGRErr */
25493 4806 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
25494 0 : resultobj = PyInt_FromLong( result );
25495 : }
25496 : }
25497 2410 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25498 : return resultobj;
25499 7 : fail:
25500 7 : {
25501 : /* %typemap(freearg) (char **argout) */
25502 7 : if ( *arg2 )
25503 0 : CPLFree( *arg2 );
25504 : }
25505 : return NULL;
25506 : }
25507 :
25508 :
25509 5407 : SWIGINTERN PyObject *_wrap_Geometry_ExportToIsoWkt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25510 5407 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25511 5407 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25512 5407 : char **arg2 = (char **) 0 ;
25513 5407 : void *argp1 = 0 ;
25514 5407 : int res1 = 0 ;
25515 5407 : char *argout2 = 0 ;
25516 5407 : PyObject *swig_obj[1] ;
25517 5407 : OGRErr result;
25518 :
25519 5407 : {
25520 : /* %typemap(in,numinputs=0) (char **argout2) */
25521 5407 : arg2 = &argout2;
25522 : }
25523 5407 : if (!args) SWIG_fail;
25524 5407 : swig_obj[0] = args;
25525 5407 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25526 5407 : if (!SWIG_IsOK(res1)) {
25527 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ExportToIsoWkt" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25528 : }
25529 5407 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25530 5407 : {
25531 5407 : const int bLocalUseExceptions = GetUseExceptions();
25532 5407 : if ( bLocalUseExceptions ) {
25533 604 : pushErrorHandler();
25534 : }
25535 5407 : {
25536 5407 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25537 5407 : result = (OGRErr)OGRGeometryShadow_ExportToIsoWkt(arg1,arg2);
25538 5407 : SWIG_PYTHON_THREAD_END_ALLOW;
25539 : }
25540 5407 : if ( bLocalUseExceptions ) {
25541 604 : popErrorHandler();
25542 : }
25543 : #ifndef SED_HACKS
25544 : if ( bLocalUseExceptions ) {
25545 : CPLErr eclass = CPLGetLastErrorType();
25546 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25547 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25548 : }
25549 : }
25550 : #endif
25551 : }
25552 5407 : {
25553 : /* %typemap(out) OGRErr */
25554 5407 : if ( result != 0 && GetUseExceptions()) {
25555 0 : const char* pszMessage = CPLGetLastErrorMsg();
25556 0 : if( pszMessage[0] != '\0' )
25557 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
25558 : else
25559 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
25560 0 : SWIG_fail;
25561 : }
25562 : }
25563 5407 : {
25564 : /* %typemap(argout) (char **argout) */
25565 5407 : PyObject *o;
25566 5407 : if ( ReturnSame(arg2) != NULL && *arg2 != NULL ) {
25567 5407 : o = GDALPythonObjectFromCStr( *arg2 );
25568 : }
25569 : else {
25570 0 : o = Py_None;
25571 0 : Py_INCREF( o );
25572 : }
25573 : #if SWIG_VERSION >= 0x040300
25574 : resultobj = SWIG_Python_AppendOutput(resultobj,o,$isvoid);
25575 : #else
25576 5407 : resultobj = SWIG_Python_AppendOutput(resultobj,o);
25577 : #endif
25578 : }
25579 5407 : {
25580 : /* %typemap(freearg) (char **argout) */
25581 5407 : if ( *arg2 )
25582 5407 : CPLFree( *arg2 );
25583 : }
25584 5407 : {
25585 : /* %typemap(ret) OGRErr */
25586 10814 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
25587 0 : resultobj = PyInt_FromLong( result );
25588 : }
25589 : }
25590 5407 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25591 : return resultobj;
25592 0 : fail:
25593 0 : {
25594 : /* %typemap(freearg) (char **argout) */
25595 0 : if ( *arg2 )
25596 0 : CPLFree( *arg2 );
25597 : }
25598 : return NULL;
25599 : }
25600 :
25601 :
25602 103 : SWIGINTERN PyObject *_wrap_Geometry_ExportToWkb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25603 103 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25604 103 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25605 103 : size_t *arg2 = (size_t *) 0 ;
25606 103 : char **arg3 = (char **) 0 ;
25607 103 : OGRwkbByteOrder arg4 = (OGRwkbByteOrder) wkbNDR ;
25608 103 : void *argp1 = 0 ;
25609 103 : int res1 = 0 ;
25610 103 : size_t nLen2 = 0 ;
25611 103 : char *pBuf2 = 0 ;
25612 103 : int val4 ;
25613 103 : int ecode4 = 0 ;
25614 103 : PyObject * obj0 = 0 ;
25615 103 : PyObject * obj1 = 0 ;
25616 103 : char * kwnames[] = {
25617 : (char *)"self", (char *)"byte_order", NULL
25618 : };
25619 103 : OGRErr result;
25620 :
25621 103 : {
25622 : /* %typemap(in,numinputs=0) (size_t *nLen2, char **pBuf2 ) */
25623 103 : arg2 = &nLen2;
25624 103 : arg3 = &pBuf2;
25625 : }
25626 103 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_ExportToWkb", kwnames, &obj0, &obj1)) SWIG_fail;
25627 103 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25628 103 : if (!SWIG_IsOK(res1)) {
25629 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ExportToWkb" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25630 : }
25631 103 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25632 103 : if (obj1) {
25633 39 : ecode4 = SWIG_AsVal_int(obj1, &val4);
25634 39 : if (!SWIG_IsOK(ecode4)) {
25635 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_ExportToWkb" "', argument " "4"" of type '" "OGRwkbByteOrder""'");
25636 : }
25637 39 : arg4 = static_cast< OGRwkbByteOrder >(val4);
25638 : }
25639 103 : {
25640 103 : const int bLocalUseExceptions = GetUseExceptions();
25641 103 : if ( bLocalUseExceptions ) {
25642 17 : pushErrorHandler();
25643 : }
25644 103 : {
25645 103 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25646 103 : result = (OGRErr)OGRGeometryShadow_ExportToWkb(arg1,arg2,arg3,arg4);
25647 103 : SWIG_PYTHON_THREAD_END_ALLOW;
25648 : }
25649 103 : if ( bLocalUseExceptions ) {
25650 17 : popErrorHandler();
25651 : }
25652 : #ifndef SED_HACKS
25653 : if ( bLocalUseExceptions ) {
25654 : CPLErr eclass = CPLGetLastErrorType();
25655 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25656 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25657 : }
25658 : }
25659 : #endif
25660 : }
25661 103 : {
25662 : /* %typemap(out) OGRErr */
25663 103 : if ( result != 0 && GetUseExceptions()) {
25664 0 : const char* pszMessage = CPLGetLastErrorMsg();
25665 0 : if( pszMessage[0] != '\0' )
25666 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
25667 : else
25668 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
25669 0 : SWIG_fail;
25670 : }
25671 : }
25672 103 : {
25673 : /* %typemap(argout) (size_t *nLen, char **pBuf ) */
25674 103 : Py_XDECREF(resultobj);
25675 103 : if( *arg3 ) {
25676 103 : resultobj = PyByteArray_FromStringAndSize( *arg3, *arg2 );
25677 : }
25678 : else {
25679 0 : resultobj = Py_None;
25680 0 : Py_INCREF(Py_None);
25681 : }
25682 : }
25683 103 : {
25684 : /* %typemap(freearg) (size_t *nLen, char **pBuf ) */
25685 103 : VSIFree( *arg3 );
25686 : }
25687 103 : {
25688 : /* %typemap(ret) OGRErr */
25689 206 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
25690 0 : resultobj = PyInt_FromLong( result );
25691 : }
25692 : }
25693 103 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25694 : return resultobj;
25695 0 : fail:
25696 0 : {
25697 : /* %typemap(freearg) (size_t *nLen, char **pBuf ) */
25698 0 : VSIFree( *arg3 );
25699 : }
25700 : return NULL;
25701 : }
25702 :
25703 :
25704 10570 : SWIGINTERN PyObject *_wrap_Geometry_ExportToIsoWkb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25705 10570 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25706 10570 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25707 10570 : size_t *arg2 = (size_t *) 0 ;
25708 10570 : char **arg3 = (char **) 0 ;
25709 10570 : OGRwkbByteOrder arg4 = (OGRwkbByteOrder) wkbNDR ;
25710 10570 : void *argp1 = 0 ;
25711 10570 : int res1 = 0 ;
25712 10570 : size_t nLen2 = 0 ;
25713 10570 : char *pBuf2 = 0 ;
25714 10570 : int val4 ;
25715 10570 : int ecode4 = 0 ;
25716 10570 : PyObject * obj0 = 0 ;
25717 10570 : PyObject * obj1 = 0 ;
25718 10570 : char * kwnames[] = {
25719 : (char *)"self", (char *)"byte_order", NULL
25720 : };
25721 10570 : OGRErr result;
25722 :
25723 10570 : {
25724 : /* %typemap(in,numinputs=0) (size_t *nLen2, char **pBuf2 ) */
25725 10570 : arg2 = &nLen2;
25726 10570 : arg3 = &pBuf2;
25727 : }
25728 10570 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_ExportToIsoWkb", kwnames, &obj0, &obj1)) SWIG_fail;
25729 10570 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25730 10570 : if (!SWIG_IsOK(res1)) {
25731 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ExportToIsoWkb" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25732 : }
25733 10570 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25734 10570 : if (obj1) {
25735 0 : ecode4 = SWIG_AsVal_int(obj1, &val4);
25736 0 : if (!SWIG_IsOK(ecode4)) {
25737 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_ExportToIsoWkb" "', argument " "4"" of type '" "OGRwkbByteOrder""'");
25738 : }
25739 0 : arg4 = static_cast< OGRwkbByteOrder >(val4);
25740 : }
25741 10570 : {
25742 10570 : const int bLocalUseExceptions = GetUseExceptions();
25743 10570 : if ( bLocalUseExceptions ) {
25744 1 : pushErrorHandler();
25745 : }
25746 10570 : {
25747 10570 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25748 10570 : result = (OGRErr)OGRGeometryShadow_ExportToIsoWkb(arg1,arg2,arg3,arg4);
25749 10570 : SWIG_PYTHON_THREAD_END_ALLOW;
25750 : }
25751 10570 : if ( bLocalUseExceptions ) {
25752 1 : popErrorHandler();
25753 : }
25754 : #ifndef SED_HACKS
25755 : if ( bLocalUseExceptions ) {
25756 : CPLErr eclass = CPLGetLastErrorType();
25757 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25758 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25759 : }
25760 : }
25761 : #endif
25762 : }
25763 10570 : {
25764 : /* %typemap(out) OGRErr */
25765 10570 : if ( result != 0 && GetUseExceptions()) {
25766 0 : const char* pszMessage = CPLGetLastErrorMsg();
25767 0 : if( pszMessage[0] != '\0' )
25768 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
25769 : else
25770 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
25771 0 : SWIG_fail;
25772 : }
25773 : }
25774 10570 : {
25775 : /* %typemap(argout) (size_t *nLen, char **pBuf ) */
25776 10570 : Py_XDECREF(resultobj);
25777 10570 : if( *arg3 ) {
25778 10570 : resultobj = PyByteArray_FromStringAndSize( *arg3, *arg2 );
25779 : }
25780 : else {
25781 0 : resultobj = Py_None;
25782 0 : Py_INCREF(Py_None);
25783 : }
25784 : }
25785 10570 : {
25786 : /* %typemap(freearg) (size_t *nLen, char **pBuf ) */
25787 10570 : VSIFree( *arg3 );
25788 : }
25789 10570 : {
25790 : /* %typemap(ret) OGRErr */
25791 21140 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
25792 0 : resultobj = PyInt_FromLong( result );
25793 : }
25794 : }
25795 10570 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25796 : return resultobj;
25797 0 : fail:
25798 0 : {
25799 : /* %typemap(freearg) (size_t *nLen, char **pBuf ) */
25800 0 : VSIFree( *arg3 );
25801 : }
25802 : return NULL;
25803 : }
25804 :
25805 :
25806 66 : SWIGINTERN PyObject *_wrap_Geometry_ExportToGML(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25807 66 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25808 66 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25809 66 : char **arg2 = (char **) 0 ;
25810 66 : void *argp1 = 0 ;
25811 66 : int res1 = 0 ;
25812 66 : PyObject * obj0 = 0 ;
25813 66 : PyObject * obj1 = 0 ;
25814 66 : char * kwnames[] = {
25815 : (char *)"self", (char *)"options", NULL
25816 : };
25817 66 : retStringAndCPLFree *result = 0 ;
25818 :
25819 66 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_ExportToGML", kwnames, &obj0, &obj1)) SWIG_fail;
25820 66 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25821 66 : if (!SWIG_IsOK(res1)) {
25822 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ExportToGML" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25823 : }
25824 66 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25825 66 : if (obj1) {
25826 42 : {
25827 : /* %typemap(in) char **dict */
25828 42 : arg2 = NULL;
25829 42 : if ( PySequence_Check( obj1 ) ) {
25830 42 : int bErr = FALSE;
25831 42 : arg2 = CSLFromPySequence(obj1, &bErr);
25832 42 : if ( bErr )
25833 : {
25834 0 : SWIG_fail;
25835 : }
25836 : }
25837 0 : else if ( PyMapping_Check( obj1 ) ) {
25838 0 : int bErr = FALSE;
25839 0 : arg2 = CSLFromPyMapping(obj1, &bErr);
25840 0 : if ( bErr )
25841 : {
25842 0 : SWIG_fail;
25843 : }
25844 : }
25845 : else {
25846 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
25847 0 : SWIG_fail;
25848 : }
25849 : }
25850 : }
25851 66 : {
25852 66 : const int bLocalUseExceptions = GetUseExceptions();
25853 66 : if ( bLocalUseExceptions ) {
25854 66 : pushErrorHandler();
25855 : }
25856 66 : {
25857 66 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25858 66 : result = (retStringAndCPLFree *)OGRGeometryShadow_ExportToGML(arg1,arg2);
25859 66 : SWIG_PYTHON_THREAD_END_ALLOW;
25860 : }
25861 66 : if ( bLocalUseExceptions ) {
25862 66 : popErrorHandler();
25863 : }
25864 : #ifndef SED_HACKS
25865 : if ( bLocalUseExceptions ) {
25866 : CPLErr eclass = CPLGetLastErrorType();
25867 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25868 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25869 : }
25870 : }
25871 : #endif
25872 : }
25873 66 : {
25874 : /* %typemap(out) (retStringAndCPLFree*) */
25875 66 : Py_XDECREF(resultobj);
25876 66 : if(result)
25877 : {
25878 66 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
25879 66 : CPLFree(result);
25880 : }
25881 : else
25882 : {
25883 0 : resultobj = Py_None;
25884 0 : Py_INCREF(resultobj);
25885 : }
25886 : }
25887 66 : {
25888 : /* %typemap(freearg) char **dict */
25889 66 : CSLDestroy( arg2 );
25890 : }
25891 66 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25892 : return resultobj;
25893 0 : fail:
25894 0 : {
25895 : /* %typemap(freearg) char **dict */
25896 0 : CSLDestroy( arg2 );
25897 : }
25898 : return NULL;
25899 : }
25900 :
25901 :
25902 0 : SWIGINTERN PyObject *_wrap_Geometry_ExportToKML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25903 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25904 0 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25905 0 : char *arg2 = (char *) NULL ;
25906 0 : void *argp1 = 0 ;
25907 0 : int res1 = 0 ;
25908 0 : int res2 ;
25909 0 : char *buf2 = 0 ;
25910 0 : int alloc2 = 0 ;
25911 0 : PyObject *swig_obj[2] ;
25912 0 : retStringAndCPLFree *result = 0 ;
25913 :
25914 0 : if (!SWIG_Python_UnpackTuple(args, "Geometry_ExportToKML", 1, 2, swig_obj)) SWIG_fail;
25915 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25916 0 : if (!SWIG_IsOK(res1)) {
25917 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ExportToKML" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25918 : }
25919 0 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25920 0 : if (swig_obj[1]) {
25921 0 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
25922 0 : if (!SWIG_IsOK(res2)) {
25923 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_ExportToKML" "', argument " "2"" of type '" "char const *""'");
25924 : }
25925 0 : arg2 = reinterpret_cast< char * >(buf2);
25926 : }
25927 0 : {
25928 0 : const int bLocalUseExceptions = GetUseExceptions();
25929 0 : if ( bLocalUseExceptions ) {
25930 0 : pushErrorHandler();
25931 : }
25932 0 : {
25933 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25934 0 : result = (retStringAndCPLFree *)OGRGeometryShadow_ExportToKML(arg1,(char const *)arg2);
25935 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25936 : }
25937 0 : if ( bLocalUseExceptions ) {
25938 0 : popErrorHandler();
25939 : }
25940 : #ifndef SED_HACKS
25941 : if ( bLocalUseExceptions ) {
25942 : CPLErr eclass = CPLGetLastErrorType();
25943 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25944 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25945 : }
25946 : }
25947 : #endif
25948 : }
25949 0 : {
25950 : /* %typemap(out) (retStringAndCPLFree*) */
25951 0 : Py_XDECREF(resultobj);
25952 0 : if(result)
25953 : {
25954 0 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
25955 0 : CPLFree(result);
25956 : }
25957 : else
25958 : {
25959 0 : resultobj = Py_None;
25960 0 : Py_INCREF(resultobj);
25961 : }
25962 : }
25963 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25964 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25965 : return resultobj;
25966 0 : fail:
25967 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25968 : return NULL;
25969 : }
25970 :
25971 :
25972 88 : SWIGINTERN PyObject *_wrap_Geometry_ExportToJson(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25973 88 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25974 88 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25975 88 : char **arg2 = (char **) 0 ;
25976 88 : void *argp1 = 0 ;
25977 88 : int res1 = 0 ;
25978 88 : PyObject * obj0 = 0 ;
25979 88 : PyObject * obj1 = 0 ;
25980 88 : char * kwnames[] = {
25981 : (char *)"self", (char *)"options", NULL
25982 : };
25983 88 : retStringAndCPLFree *result = 0 ;
25984 :
25985 88 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_ExportToJson", kwnames, &obj0, &obj1)) SWIG_fail;
25986 88 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25987 88 : if (!SWIG_IsOK(res1)) {
25988 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ExportToJson" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25989 : }
25990 88 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25991 88 : if (obj1) {
25992 34 : {
25993 : /* %typemap(in) char **dict */
25994 34 : arg2 = NULL;
25995 34 : if ( PySequence_Check( obj1 ) ) {
25996 34 : int bErr = FALSE;
25997 34 : arg2 = CSLFromPySequence(obj1, &bErr);
25998 34 : if ( bErr )
25999 : {
26000 0 : SWIG_fail;
26001 : }
26002 : }
26003 0 : else if ( PyMapping_Check( obj1 ) ) {
26004 0 : int bErr = FALSE;
26005 0 : arg2 = CSLFromPyMapping(obj1, &bErr);
26006 0 : if ( bErr )
26007 : {
26008 0 : SWIG_fail;
26009 : }
26010 : }
26011 : else {
26012 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
26013 0 : SWIG_fail;
26014 : }
26015 : }
26016 : }
26017 88 : {
26018 88 : const int bLocalUseExceptions = GetUseExceptions();
26019 88 : if ( bLocalUseExceptions ) {
26020 71 : pushErrorHandler();
26021 : }
26022 88 : {
26023 88 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26024 88 : result = (retStringAndCPLFree *)OGRGeometryShadow_ExportToJson(arg1,arg2);
26025 88 : SWIG_PYTHON_THREAD_END_ALLOW;
26026 : }
26027 88 : if ( bLocalUseExceptions ) {
26028 71 : popErrorHandler();
26029 : }
26030 : #ifndef SED_HACKS
26031 : if ( bLocalUseExceptions ) {
26032 : CPLErr eclass = CPLGetLastErrorType();
26033 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26034 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26035 : }
26036 : }
26037 : #endif
26038 : }
26039 88 : {
26040 : /* %typemap(out) (retStringAndCPLFree*) */
26041 88 : Py_XDECREF(resultobj);
26042 88 : if(result)
26043 : {
26044 85 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
26045 85 : CPLFree(result);
26046 : }
26047 : else
26048 : {
26049 3 : resultobj = Py_None;
26050 3 : Py_INCREF(resultobj);
26051 : }
26052 : }
26053 88 : {
26054 : /* %typemap(freearg) char **dict */
26055 88 : CSLDestroy( arg2 );
26056 : }
26057 88 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26058 : return resultobj;
26059 0 : fail:
26060 0 : {
26061 : /* %typemap(freearg) char **dict */
26062 0 : CSLDestroy( arg2 );
26063 : }
26064 : return NULL;
26065 : }
26066 :
26067 :
26068 254 : SWIGINTERN PyObject *_wrap_Geometry_AddPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26069 254 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26070 254 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26071 254 : double arg2 ;
26072 254 : double arg3 ;
26073 254 : double arg4 = (double) 0 ;
26074 254 : void *argp1 = 0 ;
26075 254 : int res1 = 0 ;
26076 254 : double val2 ;
26077 254 : int ecode2 = 0 ;
26078 254 : double val3 ;
26079 254 : int ecode3 = 0 ;
26080 254 : double val4 ;
26081 254 : int ecode4 = 0 ;
26082 254 : PyObject * obj0 = 0 ;
26083 254 : PyObject * obj1 = 0 ;
26084 254 : PyObject * obj2 = 0 ;
26085 254 : PyObject * obj3 = 0 ;
26086 254 : char * kwnames[] = {
26087 : (char *)"self", (char *)"x", (char *)"y", (char *)"z", NULL
26088 : };
26089 :
26090 254 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Geometry_AddPoint", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
26091 254 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26092 254 : if (!SWIG_IsOK(res1)) {
26093 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_AddPoint" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26094 : }
26095 254 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26096 254 : ecode2 = SWIG_AsVal_double(obj1, &val2);
26097 254 : if (!SWIG_IsOK(ecode2)) {
26098 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_AddPoint" "', argument " "2"" of type '" "double""'");
26099 : }
26100 254 : arg2 = static_cast< double >(val2);
26101 254 : ecode3 = SWIG_AsVal_double(obj2, &val3);
26102 254 : if (!SWIG_IsOK(ecode3)) {
26103 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_AddPoint" "', argument " "3"" of type '" "double""'");
26104 : }
26105 254 : arg3 = static_cast< double >(val3);
26106 254 : if (obj3) {
26107 153 : ecode4 = SWIG_AsVal_double(obj3, &val4);
26108 153 : if (!SWIG_IsOK(ecode4)) {
26109 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_AddPoint" "', argument " "4"" of type '" "double""'");
26110 : }
26111 153 : arg4 = static_cast< double >(val4);
26112 : }
26113 254 : {
26114 254 : const int bLocalUseExceptions = GetUseExceptions();
26115 254 : if ( bLocalUseExceptions ) {
26116 228 : pushErrorHandler();
26117 : }
26118 254 : {
26119 254 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26120 254 : OGRGeometryShadow_AddPoint(arg1,arg2,arg3,arg4);
26121 254 : SWIG_PYTHON_THREAD_END_ALLOW;
26122 : }
26123 254 : if ( bLocalUseExceptions ) {
26124 228 : popErrorHandler();
26125 : }
26126 : #ifndef SED_HACKS
26127 : if ( bLocalUseExceptions ) {
26128 : CPLErr eclass = CPLGetLastErrorType();
26129 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26130 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26131 : }
26132 : }
26133 : #endif
26134 : }
26135 254 : resultobj = SWIG_Py_Void();
26136 254 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26137 : return resultobj;
26138 : fail:
26139 : return NULL;
26140 : }
26141 :
26142 :
26143 0 : SWIGINTERN PyObject *_wrap_Geometry_AddPointM(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26144 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26145 0 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26146 0 : double arg2 ;
26147 0 : double arg3 ;
26148 0 : double arg4 ;
26149 0 : void *argp1 = 0 ;
26150 0 : int res1 = 0 ;
26151 0 : double val2 ;
26152 0 : int ecode2 = 0 ;
26153 0 : double val3 ;
26154 0 : int ecode3 = 0 ;
26155 0 : double val4 ;
26156 0 : int ecode4 = 0 ;
26157 0 : PyObject * obj0 = 0 ;
26158 0 : PyObject * obj1 = 0 ;
26159 0 : PyObject * obj2 = 0 ;
26160 0 : PyObject * obj3 = 0 ;
26161 0 : char * kwnames[] = {
26162 : (char *)"self", (char *)"x", (char *)"y", (char *)"m", NULL
26163 : };
26164 :
26165 0 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Geometry_AddPointM", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
26166 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26167 0 : if (!SWIG_IsOK(res1)) {
26168 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_AddPointM" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26169 : }
26170 0 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26171 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
26172 0 : if (!SWIG_IsOK(ecode2)) {
26173 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_AddPointM" "', argument " "2"" of type '" "double""'");
26174 : }
26175 0 : arg2 = static_cast< double >(val2);
26176 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
26177 0 : if (!SWIG_IsOK(ecode3)) {
26178 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_AddPointM" "', argument " "3"" of type '" "double""'");
26179 : }
26180 0 : arg3 = static_cast< double >(val3);
26181 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
26182 0 : if (!SWIG_IsOK(ecode4)) {
26183 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_AddPointM" "', argument " "4"" of type '" "double""'");
26184 : }
26185 0 : arg4 = static_cast< double >(val4);
26186 0 : {
26187 0 : const int bLocalUseExceptions = GetUseExceptions();
26188 0 : if ( bLocalUseExceptions ) {
26189 0 : pushErrorHandler();
26190 : }
26191 0 : {
26192 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26193 0 : OGRGeometryShadow_AddPointM(arg1,arg2,arg3,arg4);
26194 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26195 : }
26196 0 : if ( bLocalUseExceptions ) {
26197 0 : popErrorHandler();
26198 : }
26199 : #ifndef SED_HACKS
26200 : if ( bLocalUseExceptions ) {
26201 : CPLErr eclass = CPLGetLastErrorType();
26202 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26203 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26204 : }
26205 : }
26206 : #endif
26207 : }
26208 0 : resultobj = SWIG_Py_Void();
26209 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26210 : return resultobj;
26211 : fail:
26212 : return NULL;
26213 : }
26214 :
26215 :
26216 0 : SWIGINTERN PyObject *_wrap_Geometry_AddPointZM(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26217 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26218 0 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26219 0 : double arg2 ;
26220 0 : double arg3 ;
26221 0 : double arg4 ;
26222 0 : double arg5 ;
26223 0 : void *argp1 = 0 ;
26224 0 : int res1 = 0 ;
26225 0 : double val2 ;
26226 0 : int ecode2 = 0 ;
26227 0 : double val3 ;
26228 0 : int ecode3 = 0 ;
26229 0 : double val4 ;
26230 0 : int ecode4 = 0 ;
26231 0 : double val5 ;
26232 0 : int ecode5 = 0 ;
26233 0 : PyObject * obj0 = 0 ;
26234 0 : PyObject * obj1 = 0 ;
26235 0 : PyObject * obj2 = 0 ;
26236 0 : PyObject * obj3 = 0 ;
26237 0 : PyObject * obj4 = 0 ;
26238 0 : char * kwnames[] = {
26239 : (char *)"self", (char *)"x", (char *)"y", (char *)"z", (char *)"m", NULL
26240 : };
26241 :
26242 0 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:Geometry_AddPointZM", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
26243 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26244 0 : if (!SWIG_IsOK(res1)) {
26245 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_AddPointZM" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26246 : }
26247 0 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26248 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
26249 0 : if (!SWIG_IsOK(ecode2)) {
26250 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_AddPointZM" "', argument " "2"" of type '" "double""'");
26251 : }
26252 0 : arg2 = static_cast< double >(val2);
26253 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
26254 0 : if (!SWIG_IsOK(ecode3)) {
26255 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_AddPointZM" "', argument " "3"" of type '" "double""'");
26256 : }
26257 0 : arg3 = static_cast< double >(val3);
26258 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
26259 0 : if (!SWIG_IsOK(ecode4)) {
26260 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_AddPointZM" "', argument " "4"" of type '" "double""'");
26261 : }
26262 0 : arg4 = static_cast< double >(val4);
26263 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
26264 0 : if (!SWIG_IsOK(ecode5)) {
26265 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Geometry_AddPointZM" "', argument " "5"" of type '" "double""'");
26266 : }
26267 0 : arg5 = static_cast< double >(val5);
26268 0 : {
26269 0 : const int bLocalUseExceptions = GetUseExceptions();
26270 0 : if ( bLocalUseExceptions ) {
26271 0 : pushErrorHandler();
26272 : }
26273 0 : {
26274 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26275 0 : OGRGeometryShadow_AddPointZM(arg1,arg2,arg3,arg4,arg5);
26276 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26277 : }
26278 0 : if ( bLocalUseExceptions ) {
26279 0 : popErrorHandler();
26280 : }
26281 : #ifndef SED_HACKS
26282 : if ( bLocalUseExceptions ) {
26283 : CPLErr eclass = CPLGetLastErrorType();
26284 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26285 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26286 : }
26287 : }
26288 : #endif
26289 : }
26290 0 : resultobj = SWIG_Py_Void();
26291 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26292 : return resultobj;
26293 : fail:
26294 : return NULL;
26295 : }
26296 :
26297 :
26298 1249 : SWIGINTERN PyObject *_wrap_Geometry_AddPoint_2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26299 1249 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26300 1249 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26301 1249 : double arg2 ;
26302 1249 : double arg3 ;
26303 1249 : void *argp1 = 0 ;
26304 1249 : int res1 = 0 ;
26305 1249 : double val2 ;
26306 1249 : int ecode2 = 0 ;
26307 1249 : double val3 ;
26308 1249 : int ecode3 = 0 ;
26309 1249 : PyObject *swig_obj[3] ;
26310 :
26311 1249 : if (!SWIG_Python_UnpackTuple(args, "Geometry_AddPoint_2D", 3, 3, swig_obj)) SWIG_fail;
26312 1249 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26313 1249 : if (!SWIG_IsOK(res1)) {
26314 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_AddPoint_2D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26315 : }
26316 1249 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26317 1249 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
26318 1249 : if (!SWIG_IsOK(ecode2)) {
26319 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_AddPoint_2D" "', argument " "2"" of type '" "double""'");
26320 : }
26321 1249 : arg2 = static_cast< double >(val2);
26322 1249 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
26323 1249 : if (!SWIG_IsOK(ecode3)) {
26324 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_AddPoint_2D" "', argument " "3"" of type '" "double""'");
26325 : }
26326 1249 : arg3 = static_cast< double >(val3);
26327 1249 : {
26328 1249 : const int bLocalUseExceptions = GetUseExceptions();
26329 1249 : if ( bLocalUseExceptions ) {
26330 26 : pushErrorHandler();
26331 : }
26332 1249 : {
26333 1249 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26334 1249 : OGRGeometryShadow_AddPoint_2D(arg1,arg2,arg3);
26335 1249 : SWIG_PYTHON_THREAD_END_ALLOW;
26336 : }
26337 1249 : if ( bLocalUseExceptions ) {
26338 26 : popErrorHandler();
26339 : }
26340 : #ifndef SED_HACKS
26341 : if ( bLocalUseExceptions ) {
26342 : CPLErr eclass = CPLGetLastErrorType();
26343 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26344 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26345 : }
26346 : }
26347 : #endif
26348 : }
26349 1249 : resultobj = SWIG_Py_Void();
26350 1249 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26351 : return resultobj;
26352 : fail:
26353 : return NULL;
26354 : }
26355 :
26356 :
26357 9 : SWIGINTERN PyObject *_wrap_Geometry_AddGeometryDirectly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26358 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26359 9 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26360 9 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
26361 9 : void *argp1 = 0 ;
26362 9 : int res1 = 0 ;
26363 9 : int res2 = 0 ;
26364 9 : PyObject *swig_obj[2] ;
26365 9 : OGRErr result;
26366 :
26367 9 : if (!SWIG_Python_UnpackTuple(args, "Geometry_AddGeometryDirectly", 2, 2, swig_obj)) SWIG_fail;
26368 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26369 9 : if (!SWIG_IsOK(res1)) {
26370 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_AddGeometryDirectly" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26371 : }
26372 9 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26373 9 : res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN | 0 );
26374 9 : if (!SWIG_IsOK(res2)) {
26375 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_AddGeometryDirectly" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
26376 : }
26377 9 : {
26378 9 : if (!arg2) {
26379 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
26380 : }
26381 : }
26382 9 : {
26383 9 : const int bLocalUseExceptions = GetUseExceptions();
26384 9 : if ( bLocalUseExceptions ) {
26385 1 : pushErrorHandler();
26386 : }
26387 9 : {
26388 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26389 9 : result = (OGRErr)OGRGeometryShadow_AddGeometryDirectly(arg1,arg2);
26390 9 : SWIG_PYTHON_THREAD_END_ALLOW;
26391 : }
26392 9 : if ( bLocalUseExceptions ) {
26393 1 : popErrorHandler();
26394 : }
26395 : #ifndef SED_HACKS
26396 : if ( bLocalUseExceptions ) {
26397 : CPLErr eclass = CPLGetLastErrorType();
26398 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26399 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26400 : }
26401 : }
26402 : #endif
26403 : }
26404 9 : {
26405 : /* %typemap(out) OGRErr */
26406 12 : if ( result != 0 && GetUseExceptions()) {
26407 0 : const char* pszMessage = CPLGetLastErrorMsg();
26408 0 : if( pszMessage[0] != '\0' )
26409 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
26410 : else
26411 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
26412 0 : SWIG_fail;
26413 : }
26414 : }
26415 9 : {
26416 : /* %typemap(ret) OGRErr */
26417 9 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
26418 9 : resultobj = PyInt_FromLong( result );
26419 : }
26420 : }
26421 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26422 : return resultobj;
26423 : fail:
26424 : return NULL;
26425 : }
26426 :
26427 :
26428 104 : SWIGINTERN PyObject *_wrap_Geometry_AddGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26429 104 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26430 104 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26431 104 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
26432 104 : void *argp1 = 0 ;
26433 104 : int res1 = 0 ;
26434 104 : void *argp2 = 0 ;
26435 104 : int res2 = 0 ;
26436 104 : PyObject *swig_obj[2] ;
26437 104 : OGRErr result;
26438 :
26439 104 : if (!SWIG_Python_UnpackTuple(args, "Geometry_AddGeometry", 2, 2, swig_obj)) SWIG_fail;
26440 104 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26441 104 : if (!SWIG_IsOK(res1)) {
26442 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_AddGeometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26443 : }
26444 104 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26445 104 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26446 104 : if (!SWIG_IsOK(res2)) {
26447 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_AddGeometry" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
26448 : }
26449 104 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
26450 104 : {
26451 104 : if (!arg2) {
26452 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
26453 : }
26454 : }
26455 104 : {
26456 104 : const int bLocalUseExceptions = GetUseExceptions();
26457 104 : if ( bLocalUseExceptions ) {
26458 37 : pushErrorHandler();
26459 : }
26460 104 : {
26461 104 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26462 104 : result = (OGRErr)OGRGeometryShadow_AddGeometry(arg1,arg2);
26463 104 : SWIG_PYTHON_THREAD_END_ALLOW;
26464 : }
26465 104 : if ( bLocalUseExceptions ) {
26466 37 : popErrorHandler();
26467 : }
26468 : #ifndef SED_HACKS
26469 : if ( bLocalUseExceptions ) {
26470 : CPLErr eclass = CPLGetLastErrorType();
26471 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26472 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26473 : }
26474 : }
26475 : #endif
26476 : }
26477 104 : {
26478 : /* %typemap(out) OGRErr */
26479 108 : if ( result != 0 && GetUseExceptions()) {
26480 0 : const char* pszMessage = CPLGetLastErrorMsg();
26481 0 : if( pszMessage[0] != '\0' )
26482 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
26483 : else
26484 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
26485 0 : SWIG_fail;
26486 : }
26487 : }
26488 104 : {
26489 : /* %typemap(ret) OGRErr */
26490 104 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
26491 104 : resultobj = PyInt_FromLong( result );
26492 : }
26493 : }
26494 104 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26495 : return resultobj;
26496 : fail:
26497 : return NULL;
26498 : }
26499 :
26500 :
26501 87 : SWIGINTERN PyObject *_wrap_Geometry_RemoveGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26502 87 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26503 87 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26504 87 : int arg2 ;
26505 87 : void *argp1 = 0 ;
26506 87 : int res1 = 0 ;
26507 87 : int val2 ;
26508 87 : int ecode2 = 0 ;
26509 87 : PyObject *swig_obj[2] ;
26510 87 : OGRErr result;
26511 :
26512 87 : if (!SWIG_Python_UnpackTuple(args, "Geometry_RemoveGeometry", 2, 2, swig_obj)) SWIG_fail;
26513 87 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26514 87 : if (!SWIG_IsOK(res1)) {
26515 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_RemoveGeometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26516 : }
26517 87 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26518 87 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
26519 87 : if (!SWIG_IsOK(ecode2)) {
26520 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_RemoveGeometry" "', argument " "2"" of type '" "int""'");
26521 : }
26522 87 : arg2 = static_cast< int >(val2);
26523 87 : {
26524 87 : const int bLocalUseExceptions = GetUseExceptions();
26525 87 : if ( bLocalUseExceptions ) {
26526 70 : pushErrorHandler();
26527 : }
26528 87 : {
26529 87 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26530 87 : result = (OGRErr)OGRGeometryShadow_RemoveGeometry(arg1,arg2);
26531 87 : SWIG_PYTHON_THREAD_END_ALLOW;
26532 : }
26533 87 : if ( bLocalUseExceptions ) {
26534 70 : popErrorHandler();
26535 : }
26536 : #ifndef SED_HACKS
26537 : if ( bLocalUseExceptions ) {
26538 : CPLErr eclass = CPLGetLastErrorType();
26539 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26540 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26541 : }
26542 : }
26543 : #endif
26544 : }
26545 87 : {
26546 : /* %typemap(out) OGRErr */
26547 94 : if ( result != 0 && GetUseExceptions()) {
26548 0 : const char* pszMessage = CPLGetLastErrorMsg();
26549 0 : if( pszMessage[0] != '\0' )
26550 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
26551 : else
26552 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
26553 0 : SWIG_fail;
26554 : }
26555 : }
26556 87 : {
26557 : /* %typemap(ret) OGRErr */
26558 87 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
26559 87 : resultobj = PyInt_FromLong( result );
26560 : }
26561 : }
26562 87 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26563 : return resultobj;
26564 : fail:
26565 : return NULL;
26566 : }
26567 :
26568 :
26569 12445 : SWIGINTERN PyObject *_wrap_Geometry_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26570 12445 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26571 12445 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26572 12445 : void *argp1 = 0 ;
26573 12445 : int res1 = 0 ;
26574 12445 : PyObject *swig_obj[1] ;
26575 12445 : OGRGeometryShadow *result = 0 ;
26576 :
26577 12445 : if (!args) SWIG_fail;
26578 12445 : swig_obj[0] = args;
26579 12445 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26580 12445 : if (!SWIG_IsOK(res1)) {
26581 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Clone" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26582 : }
26583 12445 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26584 12445 : {
26585 12445 : const int bLocalUseExceptions = GetUseExceptions();
26586 12445 : if ( bLocalUseExceptions ) {
26587 12374 : pushErrorHandler();
26588 : }
26589 12445 : {
26590 12445 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26591 12445 : result = (OGRGeometryShadow *)OGRGeometryShadow_Clone(arg1);
26592 12445 : SWIG_PYTHON_THREAD_END_ALLOW;
26593 : }
26594 12445 : if ( bLocalUseExceptions ) {
26595 12374 : popErrorHandler();
26596 : }
26597 : #ifndef SED_HACKS
26598 : if ( bLocalUseExceptions ) {
26599 : CPLErr eclass = CPLGetLastErrorType();
26600 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26601 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26602 : }
26603 : }
26604 : #endif
26605 : }
26606 12445 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
26607 12445 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26608 : return resultobj;
26609 : fail:
26610 : return NULL;
26611 : }
26612 :
26613 :
26614 3879 : SWIGINTERN PyObject *_wrap_Geometry_GetGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26615 3879 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26616 3879 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26617 3879 : void *argp1 = 0 ;
26618 3879 : int res1 = 0 ;
26619 3879 : PyObject *swig_obj[1] ;
26620 3879 : OGRwkbGeometryType result;
26621 :
26622 3879 : if (!args) SWIG_fail;
26623 3879 : swig_obj[0] = args;
26624 3879 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26625 3879 : if (!SWIG_IsOK(res1)) {
26626 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetGeometryType" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26627 : }
26628 3879 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26629 3879 : {
26630 3879 : const int bLocalUseExceptions = GetUseExceptions();
26631 3879 : if ( bLocalUseExceptions ) {
26632 1398 : pushErrorHandler();
26633 : }
26634 3879 : {
26635 3879 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26636 3879 : result = (OGRwkbGeometryType)OGRGeometryShadow_GetGeometryType(arg1);
26637 3879 : SWIG_PYTHON_THREAD_END_ALLOW;
26638 : }
26639 3879 : if ( bLocalUseExceptions ) {
26640 1398 : popErrorHandler();
26641 : }
26642 : #ifndef SED_HACKS
26643 : if ( bLocalUseExceptions ) {
26644 : CPLErr eclass = CPLGetLastErrorType();
26645 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26646 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26647 : }
26648 : }
26649 : #endif
26650 : }
26651 3879 : resultobj = SWIG_From_int(static_cast< int >(result));
26652 3879 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26653 : return resultobj;
26654 : fail:
26655 : return NULL;
26656 : }
26657 :
26658 :
26659 16093 : SWIGINTERN PyObject *_wrap_Geometry_GetGeometryName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26660 16093 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26661 16093 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26662 16093 : void *argp1 = 0 ;
26663 16093 : int res1 = 0 ;
26664 16093 : PyObject *swig_obj[1] ;
26665 16093 : char *result = 0 ;
26666 :
26667 16093 : if (!args) SWIG_fail;
26668 16093 : swig_obj[0] = args;
26669 16093 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26670 16093 : if (!SWIG_IsOK(res1)) {
26671 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetGeometryName" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26672 : }
26673 16093 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26674 16093 : {
26675 16093 : const int bLocalUseExceptions = GetUseExceptions();
26676 16093 : if ( bLocalUseExceptions ) {
26677 3 : pushErrorHandler();
26678 : }
26679 16093 : {
26680 16093 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26681 16093 : result = (char *)OGRGeometryShadow_GetGeometryName(arg1);
26682 16093 : SWIG_PYTHON_THREAD_END_ALLOW;
26683 : }
26684 16093 : if ( bLocalUseExceptions ) {
26685 3 : popErrorHandler();
26686 : }
26687 : #ifndef SED_HACKS
26688 : if ( bLocalUseExceptions ) {
26689 : CPLErr eclass = CPLGetLastErrorType();
26690 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26691 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26692 : }
26693 : }
26694 : #endif
26695 : }
26696 16093 : resultobj = SWIG_FromCharPtr((const char *)result);
26697 16093 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26698 : return resultobj;
26699 : fail:
26700 : return NULL;
26701 : }
26702 :
26703 :
26704 28 : SWIGINTERN PyObject *_wrap_Geometry_Length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26705 28 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26706 28 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26707 28 : void *argp1 = 0 ;
26708 28 : int res1 = 0 ;
26709 28 : PyObject *swig_obj[1] ;
26710 28 : double result;
26711 :
26712 28 : if (!args) SWIG_fail;
26713 28 : swig_obj[0] = args;
26714 28 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26715 28 : if (!SWIG_IsOK(res1)) {
26716 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Length" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26717 : }
26718 28 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26719 28 : {
26720 28 : const int bLocalUseExceptions = GetUseExceptions();
26721 28 : if ( bLocalUseExceptions ) {
26722 7 : pushErrorHandler();
26723 : }
26724 28 : {
26725 28 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26726 28 : result = (double)OGRGeometryShadow_Length(arg1);
26727 28 : SWIG_PYTHON_THREAD_END_ALLOW;
26728 : }
26729 28 : if ( bLocalUseExceptions ) {
26730 7 : popErrorHandler();
26731 : }
26732 : #ifndef SED_HACKS
26733 : if ( bLocalUseExceptions ) {
26734 : CPLErr eclass = CPLGetLastErrorType();
26735 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26736 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26737 : }
26738 : }
26739 : #endif
26740 : }
26741 28 : resultobj = SWIG_From_double(static_cast< double >(result));
26742 28 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26743 : return resultobj;
26744 : fail:
26745 : return NULL;
26746 : }
26747 :
26748 :
26749 21 : SWIGINTERN PyObject *_wrap_Geometry_Area(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26750 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26751 21 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26752 21 : void *argp1 = 0 ;
26753 21 : int res1 = 0 ;
26754 21 : PyObject *swig_obj[1] ;
26755 21 : double result;
26756 :
26757 21 : if (!args) SWIG_fail;
26758 21 : swig_obj[0] = args;
26759 21 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26760 21 : if (!SWIG_IsOK(res1)) {
26761 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Area" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26762 : }
26763 21 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26764 21 : {
26765 21 : const int bLocalUseExceptions = GetUseExceptions();
26766 21 : if ( bLocalUseExceptions ) {
26767 3 : pushErrorHandler();
26768 : }
26769 21 : {
26770 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26771 21 : result = (double)OGRGeometryShadow_Area(arg1);
26772 21 : SWIG_PYTHON_THREAD_END_ALLOW;
26773 : }
26774 21 : if ( bLocalUseExceptions ) {
26775 3 : popErrorHandler();
26776 : }
26777 : #ifndef SED_HACKS
26778 : if ( bLocalUseExceptions ) {
26779 : CPLErr eclass = CPLGetLastErrorType();
26780 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26781 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26782 : }
26783 : }
26784 : #endif
26785 : }
26786 21 : resultobj = SWIG_From_double(static_cast< double >(result));
26787 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26788 : return resultobj;
26789 : fail:
26790 : return NULL;
26791 : }
26792 :
26793 :
26794 25 : SWIGINTERN PyObject *_wrap_Geometry_GeodesicLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26795 25 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26796 25 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26797 25 : void *argp1 = 0 ;
26798 25 : int res1 = 0 ;
26799 25 : PyObject *swig_obj[1] ;
26800 25 : double result;
26801 :
26802 25 : if (!args) SWIG_fail;
26803 25 : swig_obj[0] = args;
26804 25 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26805 25 : if (!SWIG_IsOK(res1)) {
26806 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GeodesicLength" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26807 : }
26808 25 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26809 25 : {
26810 25 : const int bLocalUseExceptions = GetUseExceptions();
26811 25 : if ( bLocalUseExceptions ) {
26812 25 : pushErrorHandler();
26813 : }
26814 25 : {
26815 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26816 25 : result = (double)OGRGeometryShadow_GeodesicLength(arg1);
26817 25 : SWIG_PYTHON_THREAD_END_ALLOW;
26818 : }
26819 25 : if ( bLocalUseExceptions ) {
26820 25 : popErrorHandler();
26821 : }
26822 : #ifndef SED_HACKS
26823 : if ( bLocalUseExceptions ) {
26824 : CPLErr eclass = CPLGetLastErrorType();
26825 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26826 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26827 : }
26828 : }
26829 : #endif
26830 : }
26831 25 : resultobj = SWIG_From_double(static_cast< double >(result));
26832 35 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26833 : return resultobj;
26834 : fail:
26835 : return NULL;
26836 : }
26837 :
26838 :
26839 24 : SWIGINTERN PyObject *_wrap_Geometry_GeodesicArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26840 24 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26841 24 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26842 24 : void *argp1 = 0 ;
26843 24 : int res1 = 0 ;
26844 24 : PyObject *swig_obj[1] ;
26845 24 : double result;
26846 :
26847 24 : if (!args) SWIG_fail;
26848 24 : swig_obj[0] = args;
26849 24 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26850 24 : if (!SWIG_IsOK(res1)) {
26851 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GeodesicArea" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26852 : }
26853 24 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26854 24 : {
26855 24 : const int bLocalUseExceptions = GetUseExceptions();
26856 24 : if ( bLocalUseExceptions ) {
26857 24 : pushErrorHandler();
26858 : }
26859 24 : {
26860 24 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26861 24 : result = (double)OGRGeometryShadow_GeodesicArea(arg1);
26862 24 : SWIG_PYTHON_THREAD_END_ALLOW;
26863 : }
26864 24 : if ( bLocalUseExceptions ) {
26865 24 : popErrorHandler();
26866 : }
26867 : #ifndef SED_HACKS
26868 : if ( bLocalUseExceptions ) {
26869 : CPLErr eclass = CPLGetLastErrorType();
26870 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26871 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26872 : }
26873 : }
26874 : #endif
26875 : }
26876 24 : resultobj = SWIG_From_double(static_cast< double >(result));
26877 40 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26878 : return resultobj;
26879 : fail:
26880 : return NULL;
26881 : }
26882 :
26883 :
26884 33 : SWIGINTERN PyObject *_wrap_Geometry_IsClockwise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26885 33 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26886 33 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26887 33 : void *argp1 = 0 ;
26888 33 : int res1 = 0 ;
26889 33 : PyObject *swig_obj[1] ;
26890 33 : bool result;
26891 :
26892 33 : if (!args) SWIG_fail;
26893 33 : swig_obj[0] = args;
26894 33 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26895 33 : if (!SWIG_IsOK(res1)) {
26896 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_IsClockwise" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26897 : }
26898 33 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26899 33 : {
26900 33 : const int bLocalUseExceptions = GetUseExceptions();
26901 33 : if ( bLocalUseExceptions ) {
26902 33 : pushErrorHandler();
26903 : }
26904 33 : {
26905 33 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26906 33 : result = (bool)OGRGeometryShadow_IsClockwise(arg1);
26907 33 : SWIG_PYTHON_THREAD_END_ALLOW;
26908 : }
26909 33 : if ( bLocalUseExceptions ) {
26910 33 : popErrorHandler();
26911 : }
26912 : #ifndef SED_HACKS
26913 : if ( bLocalUseExceptions ) {
26914 : CPLErr eclass = CPLGetLastErrorType();
26915 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26916 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26917 : }
26918 : }
26919 : #endif
26920 : }
26921 33 : resultobj = SWIG_From_bool(static_cast< bool >(result));
26922 35 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26923 : return resultobj;
26924 : fail:
26925 : return NULL;
26926 : }
26927 :
26928 :
26929 1386 : SWIGINTERN PyObject *_wrap_Geometry_GetArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26930 1386 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26931 1386 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26932 1386 : void *argp1 = 0 ;
26933 1386 : int res1 = 0 ;
26934 1386 : PyObject *swig_obj[1] ;
26935 1386 : double result;
26936 :
26937 1386 : if (!args) SWIG_fail;
26938 1386 : swig_obj[0] = args;
26939 1386 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26940 1386 : if (!SWIG_IsOK(res1)) {
26941 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetArea" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26942 : }
26943 1386 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26944 1386 : {
26945 1386 : const int bLocalUseExceptions = GetUseExceptions();
26946 1386 : if ( bLocalUseExceptions ) {
26947 1380 : pushErrorHandler();
26948 : }
26949 1386 : {
26950 1386 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26951 1386 : result = (double)OGRGeometryShadow_GetArea(arg1);
26952 1386 : SWIG_PYTHON_THREAD_END_ALLOW;
26953 : }
26954 1386 : if ( bLocalUseExceptions ) {
26955 1380 : popErrorHandler();
26956 : }
26957 : #ifndef SED_HACKS
26958 : if ( bLocalUseExceptions ) {
26959 : CPLErr eclass = CPLGetLastErrorType();
26960 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26961 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26962 : }
26963 : }
26964 : #endif
26965 : }
26966 1386 : resultobj = SWIG_From_double(static_cast< double >(result));
26967 1386 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26968 : return resultobj;
26969 : fail:
26970 : return NULL;
26971 : }
26972 :
26973 :
26974 12843 : SWIGINTERN PyObject *_wrap_Geometry_GetPointCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26975 12843 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26976 12843 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26977 12843 : void *argp1 = 0 ;
26978 12843 : int res1 = 0 ;
26979 12843 : PyObject *swig_obj[1] ;
26980 12843 : int result;
26981 :
26982 12843 : if (!args) SWIG_fail;
26983 12843 : swig_obj[0] = args;
26984 12843 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26985 12843 : if (!SWIG_IsOK(res1)) {
26986 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetPointCount" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26987 : }
26988 12843 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26989 12843 : {
26990 12843 : const int bLocalUseExceptions = GetUseExceptions();
26991 12843 : if ( bLocalUseExceptions ) {
26992 16 : pushErrorHandler();
26993 : }
26994 12843 : {
26995 12843 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26996 12843 : result = (int)OGRGeometryShadow_GetPointCount(arg1);
26997 12843 : SWIG_PYTHON_THREAD_END_ALLOW;
26998 : }
26999 12843 : if ( bLocalUseExceptions ) {
27000 16 : popErrorHandler();
27001 : }
27002 : #ifndef SED_HACKS
27003 : if ( bLocalUseExceptions ) {
27004 : CPLErr eclass = CPLGetLastErrorType();
27005 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27006 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27007 : }
27008 : }
27009 : #endif
27010 : }
27011 12843 : resultobj = SWIG_From_int(static_cast< int >(result));
27012 12843 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27013 : return resultobj;
27014 : fail:
27015 : return NULL;
27016 : }
27017 :
27018 :
27019 11 : SWIGINTERN PyObject *_wrap_Geometry_GetPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27020 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27021 11 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27022 11 : int *arg2 = (int *) 0 ;
27023 11 : double **arg3 = (double **) 0 ;
27024 11 : double **arg4 = (double **) 0 ;
27025 11 : int arg5 = (int) 0 ;
27026 11 : void *argp1 = 0 ;
27027 11 : int res1 = 0 ;
27028 11 : int nPoints2 = 0 ;
27029 11 : double *padfXY2 = NULL ;
27030 11 : double *padfZ2 = NULL ;
27031 11 : int val5 ;
27032 11 : int ecode5 = 0 ;
27033 11 : PyObject * obj0 = 0 ;
27034 11 : PyObject * obj1 = 0 ;
27035 11 : char * kwnames[] = {
27036 : (char *)"self", (char *)"nCoordDimension", NULL
27037 : };
27038 :
27039 11 : {
27040 : /* %typemap(in,numinputs=0) (int* pnCount, double** ppadfXY, double** ppadfZ) */
27041 11 : arg2 = &nPoints2;
27042 11 : arg3 = &padfXY2;
27043 11 : arg4 = &padfZ2;
27044 : }
27045 11 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_GetPoints", kwnames, &obj0, &obj1)) SWIG_fail;
27046 11 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27047 11 : if (!SWIG_IsOK(res1)) {
27048 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetPoints" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27049 : }
27050 11 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27051 11 : if (obj1) {
27052 4 : ecode5 = SWIG_AsVal_int(obj1, &val5);
27053 4 : if (!SWIG_IsOK(ecode5)) {
27054 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Geometry_GetPoints" "', argument " "5"" of type '" "int""'");
27055 : }
27056 : arg5 = static_cast< int >(val5);
27057 : }
27058 11 : {
27059 11 : const int bLocalUseExceptions = GetUseExceptions();
27060 11 : if ( bLocalUseExceptions ) {
27061 2 : pushErrorHandler();
27062 : }
27063 11 : {
27064 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27065 11 : OGRGeometryShadow_GetPoints(arg1,arg2,arg3,arg4,arg5);
27066 11 : SWIG_PYTHON_THREAD_END_ALLOW;
27067 : }
27068 11 : if ( bLocalUseExceptions ) {
27069 2 : popErrorHandler();
27070 : }
27071 : #ifndef SED_HACKS
27072 : if ( bLocalUseExceptions ) {
27073 : CPLErr eclass = CPLGetLastErrorType();
27074 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27075 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27076 : }
27077 : }
27078 : #endif
27079 : }
27080 11 : resultobj = SWIG_Py_Void();
27081 11 : {
27082 : /* %typemap(argout) (int* pnCount, double** ppadfXY, double** ppadfZ) */
27083 11 : Py_DECREF(resultobj);
27084 11 : int nPointCount = *(arg2);
27085 11 : if (nPointCount == 0)
27086 : {
27087 1 : Py_INCREF(Py_None);
27088 1 : resultobj = Py_None;
27089 : }
27090 : else
27091 : {
27092 10 : PyObject *xyz = PyList_New( nPointCount );
27093 10 : if( !xyz ) {
27094 0 : SWIG_fail;
27095 : }
27096 10 : int nDimensions = (*arg4 != NULL) ? 3 : 2;
27097 184 : for( int i=0; i< nPointCount; i++ ) {
27098 174 : PyObject *tuple = PyTuple_New( nDimensions );
27099 174 : PyTuple_SetItem( tuple, 0, PyFloat_FromDouble( (*arg3)[2*i] ) );
27100 174 : PyTuple_SetItem( tuple, 1, PyFloat_FromDouble( (*arg3)[2*i+1] ) );
27101 174 : if (nDimensions == 3)
27102 6 : PyTuple_SetItem( tuple, 2, PyFloat_FromDouble( (*arg4)[i] ) );
27103 174 : PyList_SetItem( xyz, i, tuple );
27104 : }
27105 : resultobj = xyz;
27106 : }
27107 : }
27108 11 : {
27109 : /* %typemap(freearg) (int* pnCount, double** ppadfXY, double** ppadfZ) */
27110 11 : VSIFree(*arg3);
27111 11 : VSIFree(*arg4);
27112 : }
27113 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27114 : return resultobj;
27115 0 : fail:
27116 0 : {
27117 : /* %typemap(freearg) (int* pnCount, double** ppadfXY, double** ppadfZ) */
27118 0 : VSIFree(*arg3);
27119 0 : VSIFree(*arg4);
27120 : }
27121 : return NULL;
27122 : }
27123 :
27124 :
27125 32008 : SWIGINTERN PyObject *_wrap_Geometry_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27126 32008 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27127 32008 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27128 32008 : int arg2 = (int) 0 ;
27129 32008 : void *argp1 = 0 ;
27130 32008 : int res1 = 0 ;
27131 32008 : int val2 ;
27132 32008 : int ecode2 = 0 ;
27133 32008 : PyObject * obj0 = 0 ;
27134 32008 : PyObject * obj1 = 0 ;
27135 32008 : char * kwnames[] = {
27136 : (char *)"self", (char *)"point", NULL
27137 : };
27138 32008 : double result;
27139 :
27140 32008 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_GetX", kwnames, &obj0, &obj1)) SWIG_fail;
27141 32008 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27142 32008 : if (!SWIG_IsOK(res1)) {
27143 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetX" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27144 : }
27145 32008 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27146 32008 : if (obj1) {
27147 30794 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27148 30794 : if (!SWIG_IsOK(ecode2)) {
27149 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetX" "', argument " "2"" of type '" "int""'");
27150 : }
27151 : arg2 = static_cast< int >(val2);
27152 : }
27153 32008 : {
27154 32008 : const int bLocalUseExceptions = GetUseExceptions();
27155 32008 : if ( bLocalUseExceptions ) {
27156 1410 : pushErrorHandler();
27157 : }
27158 32008 : {
27159 32008 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27160 32008 : result = (double)OGRGeometryShadow_GetX(arg1,arg2);
27161 32008 : SWIG_PYTHON_THREAD_END_ALLOW;
27162 : }
27163 32008 : if ( bLocalUseExceptions ) {
27164 1410 : popErrorHandler();
27165 : }
27166 : #ifndef SED_HACKS
27167 : if ( bLocalUseExceptions ) {
27168 : CPLErr eclass = CPLGetLastErrorType();
27169 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27170 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27171 : }
27172 : }
27173 : #endif
27174 : }
27175 32008 : resultobj = SWIG_From_double(static_cast< double >(result));
27176 32008 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27177 : return resultobj;
27178 : fail:
27179 : return NULL;
27180 : }
27181 :
27182 :
27183 30799 : SWIGINTERN PyObject *_wrap_Geometry_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27184 30799 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27185 30799 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27186 30799 : int arg2 = (int) 0 ;
27187 30799 : void *argp1 = 0 ;
27188 30799 : int res1 = 0 ;
27189 30799 : int val2 ;
27190 30799 : int ecode2 = 0 ;
27191 30799 : PyObject * obj0 = 0 ;
27192 30799 : PyObject * obj1 = 0 ;
27193 30799 : char * kwnames[] = {
27194 : (char *)"self", (char *)"point", NULL
27195 : };
27196 30799 : double result;
27197 :
27198 30799 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_GetY", kwnames, &obj0, &obj1)) SWIG_fail;
27199 30799 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27200 30799 : if (!SWIG_IsOK(res1)) {
27201 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetY" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27202 : }
27203 30799 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27204 30799 : if (obj1) {
27205 30786 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27206 30786 : if (!SWIG_IsOK(ecode2)) {
27207 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetY" "', argument " "2"" of type '" "int""'");
27208 : }
27209 : arg2 = static_cast< int >(val2);
27210 : }
27211 30799 : {
27212 30799 : const int bLocalUseExceptions = GetUseExceptions();
27213 30799 : if ( bLocalUseExceptions ) {
27214 202 : pushErrorHandler();
27215 : }
27216 30799 : {
27217 30799 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27218 30799 : result = (double)OGRGeometryShadow_GetY(arg1,arg2);
27219 30799 : SWIG_PYTHON_THREAD_END_ALLOW;
27220 : }
27221 30799 : if ( bLocalUseExceptions ) {
27222 202 : popErrorHandler();
27223 : }
27224 : #ifndef SED_HACKS
27225 : if ( bLocalUseExceptions ) {
27226 : CPLErr eclass = CPLGetLastErrorType();
27227 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27228 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27229 : }
27230 : }
27231 : #endif
27232 : }
27233 30799 : resultobj = SWIG_From_double(static_cast< double >(result));
27234 30799 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27235 : return resultobj;
27236 : fail:
27237 : return NULL;
27238 : }
27239 :
27240 :
27241 15322 : SWIGINTERN PyObject *_wrap_Geometry_GetZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27242 15322 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27243 15322 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27244 15322 : int arg2 = (int) 0 ;
27245 15322 : void *argp1 = 0 ;
27246 15322 : int res1 = 0 ;
27247 15322 : int val2 ;
27248 15322 : int ecode2 = 0 ;
27249 15322 : PyObject * obj0 = 0 ;
27250 15322 : PyObject * obj1 = 0 ;
27251 15322 : char * kwnames[] = {
27252 : (char *)"self", (char *)"point", NULL
27253 : };
27254 15322 : double result;
27255 :
27256 15322 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_GetZ", kwnames, &obj0, &obj1)) SWIG_fail;
27257 15322 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27258 15322 : if (!SWIG_IsOK(res1)) {
27259 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetZ" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27260 : }
27261 15322 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27262 15322 : if (obj1) {
27263 15311 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27264 15311 : if (!SWIG_IsOK(ecode2)) {
27265 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetZ" "', argument " "2"" of type '" "int""'");
27266 : }
27267 : arg2 = static_cast< int >(val2);
27268 : }
27269 15322 : {
27270 15322 : const int bLocalUseExceptions = GetUseExceptions();
27271 15322 : if ( bLocalUseExceptions ) {
27272 188 : pushErrorHandler();
27273 : }
27274 15322 : {
27275 15322 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27276 15322 : result = (double)OGRGeometryShadow_GetZ(arg1,arg2);
27277 15322 : SWIG_PYTHON_THREAD_END_ALLOW;
27278 : }
27279 15322 : if ( bLocalUseExceptions ) {
27280 188 : popErrorHandler();
27281 : }
27282 : #ifndef SED_HACKS
27283 : if ( bLocalUseExceptions ) {
27284 : CPLErr eclass = CPLGetLastErrorType();
27285 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27286 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27287 : }
27288 : }
27289 : #endif
27290 : }
27291 15322 : resultobj = SWIG_From_double(static_cast< double >(result));
27292 15322 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27293 : return resultobj;
27294 : fail:
27295 : return NULL;
27296 : }
27297 :
27298 :
27299 2264 : SWIGINTERN PyObject *_wrap_Geometry_GetM(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27300 2264 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27301 2264 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27302 2264 : int arg2 = (int) 0 ;
27303 2264 : void *argp1 = 0 ;
27304 2264 : int res1 = 0 ;
27305 2264 : int val2 ;
27306 2264 : int ecode2 = 0 ;
27307 2264 : PyObject * obj0 = 0 ;
27308 2264 : PyObject * obj1 = 0 ;
27309 2264 : char * kwnames[] = {
27310 : (char *)"self", (char *)"point", NULL
27311 : };
27312 2264 : double result;
27313 :
27314 2264 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_GetM", kwnames, &obj0, &obj1)) SWIG_fail;
27315 2264 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27316 2264 : if (!SWIG_IsOK(res1)) {
27317 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetM" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27318 : }
27319 2264 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27320 2264 : if (obj1) {
27321 2264 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27322 2264 : if (!SWIG_IsOK(ecode2)) {
27323 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetM" "', argument " "2"" of type '" "int""'");
27324 : }
27325 : arg2 = static_cast< int >(val2);
27326 : }
27327 2264 : {
27328 2264 : const int bLocalUseExceptions = GetUseExceptions();
27329 2264 : if ( bLocalUseExceptions ) {
27330 17 : pushErrorHandler();
27331 : }
27332 2264 : {
27333 2264 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27334 2264 : result = (double)OGRGeometryShadow_GetM(arg1,arg2);
27335 2264 : SWIG_PYTHON_THREAD_END_ALLOW;
27336 : }
27337 2264 : if ( bLocalUseExceptions ) {
27338 17 : popErrorHandler();
27339 : }
27340 : #ifndef SED_HACKS
27341 : if ( bLocalUseExceptions ) {
27342 : CPLErr eclass = CPLGetLastErrorType();
27343 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27344 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27345 : }
27346 : }
27347 : #endif
27348 : }
27349 2264 : resultobj = SWIG_From_double(static_cast< double >(result));
27350 2264 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27351 : return resultobj;
27352 : fail:
27353 : return NULL;
27354 : }
27355 :
27356 :
27357 217 : SWIGINTERN PyObject *_wrap_Geometry_GetPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27358 217 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27359 217 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27360 217 : int arg2 = (int) 0 ;
27361 217 : double *arg3 = (double *) (double *)NULL ;
27362 217 : void *argp1 = 0 ;
27363 217 : int res1 = 0 ;
27364 217 : int val2 ;
27365 217 : int ecode2 = 0 ;
27366 217 : double argout3[3] ;
27367 217 : PyObject *swig_obj[2] ;
27368 :
27369 217 : {
27370 : /* %typemap(in,numinputs=0) (double argout3[ANY]) */
27371 217 : memset(argout3, 0, sizeof(argout3));
27372 217 : arg3 = argout3;
27373 : }
27374 217 : if (!SWIG_Python_UnpackTuple(args, "Geometry_GetPoint", 1, 2, swig_obj)) SWIG_fail;
27375 217 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27376 217 : if (!SWIG_IsOK(res1)) {
27377 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetPoint" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27378 : }
27379 217 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27380 217 : if (swig_obj[1]) {
27381 202 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
27382 202 : if (!SWIG_IsOK(ecode2)) {
27383 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetPoint" "', argument " "2"" of type '" "int""'");
27384 : }
27385 : arg2 = static_cast< int >(val2);
27386 : }
27387 217 : {
27388 217 : const int bLocalUseExceptions = GetUseExceptions();
27389 217 : if ( bLocalUseExceptions ) {
27390 30 : pushErrorHandler();
27391 : }
27392 217 : {
27393 217 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27394 217 : OGRGeometryShadow_GetPoint(arg1,arg2,arg3);
27395 217 : SWIG_PYTHON_THREAD_END_ALLOW;
27396 : }
27397 217 : if ( bLocalUseExceptions ) {
27398 30 : popErrorHandler();
27399 : }
27400 : #ifndef SED_HACKS
27401 : if ( bLocalUseExceptions ) {
27402 : CPLErr eclass = CPLGetLastErrorType();
27403 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27404 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27405 : }
27406 : }
27407 : #endif
27408 : }
27409 217 : resultobj = SWIG_Py_Void();
27410 217 : {
27411 : /* %typemap(argout) (double argout[ANY]) */
27412 217 : PyObject *out = CreateTupleFromDoubleArray( arg3, 3 );
27413 : #if SWIG_VERSION >= 0x040300
27414 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
27415 : #else
27416 217 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
27417 : #endif
27418 : }
27419 221 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27420 : return resultobj;
27421 : fail:
27422 : return NULL;
27423 : }
27424 :
27425 :
27426 1 : SWIGINTERN PyObject *_wrap_Geometry_GetPointZM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27427 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27428 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27429 1 : int arg2 = (int) 0 ;
27430 1 : double *arg3 = (double *) (double *)NULL ;
27431 1 : void *argp1 = 0 ;
27432 1 : int res1 = 0 ;
27433 1 : int val2 ;
27434 1 : int ecode2 = 0 ;
27435 1 : double argout3[4] ;
27436 1 : PyObject *swig_obj[2] ;
27437 :
27438 1 : {
27439 : /* %typemap(in,numinputs=0) (double argout3[ANY]) */
27440 1 : memset(argout3, 0, sizeof(argout3));
27441 1 : arg3 = argout3;
27442 : }
27443 1 : if (!SWIG_Python_UnpackTuple(args, "Geometry_GetPointZM", 1, 2, swig_obj)) SWIG_fail;
27444 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27445 1 : if (!SWIG_IsOK(res1)) {
27446 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetPointZM" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27447 : }
27448 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27449 1 : if (swig_obj[1]) {
27450 1 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
27451 1 : if (!SWIG_IsOK(ecode2)) {
27452 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetPointZM" "', argument " "2"" of type '" "int""'");
27453 : }
27454 : arg2 = static_cast< int >(val2);
27455 : }
27456 1 : {
27457 1 : const int bLocalUseExceptions = GetUseExceptions();
27458 1 : if ( bLocalUseExceptions ) {
27459 0 : pushErrorHandler();
27460 : }
27461 1 : {
27462 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27463 1 : OGRGeometryShadow_GetPointZM(arg1,arg2,arg3);
27464 1 : SWIG_PYTHON_THREAD_END_ALLOW;
27465 : }
27466 1 : if ( bLocalUseExceptions ) {
27467 0 : popErrorHandler();
27468 : }
27469 : #ifndef SED_HACKS
27470 : if ( bLocalUseExceptions ) {
27471 : CPLErr eclass = CPLGetLastErrorType();
27472 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27473 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27474 : }
27475 : }
27476 : #endif
27477 : }
27478 1 : resultobj = SWIG_Py_Void();
27479 1 : {
27480 : /* %typemap(argout) (double argout[ANY]) */
27481 1 : PyObject *out = CreateTupleFromDoubleArray( arg3, 4 );
27482 : #if SWIG_VERSION >= 0x040300
27483 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
27484 : #else
27485 1 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
27486 : #endif
27487 : }
27488 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27489 : return resultobj;
27490 : fail:
27491 : return NULL;
27492 : }
27493 :
27494 :
27495 3 : SWIGINTERN PyObject *_wrap_Geometry_GetPoint_2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27496 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27497 3 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27498 3 : int arg2 = (int) 0 ;
27499 3 : double *arg3 = (double *) (double *)NULL ;
27500 3 : void *argp1 = 0 ;
27501 3 : int res1 = 0 ;
27502 3 : int val2 ;
27503 3 : int ecode2 = 0 ;
27504 3 : double argout3[2] ;
27505 3 : PyObject *swig_obj[2] ;
27506 :
27507 3 : {
27508 : /* %typemap(in,numinputs=0) (double argout3[ANY]) */
27509 3 : memset(argout3, 0, sizeof(argout3));
27510 3 : arg3 = argout3;
27511 : }
27512 3 : if (!SWIG_Python_UnpackTuple(args, "Geometry_GetPoint_2D", 1, 2, swig_obj)) SWIG_fail;
27513 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27514 3 : if (!SWIG_IsOK(res1)) {
27515 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetPoint_2D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27516 : }
27517 3 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27518 3 : if (swig_obj[1]) {
27519 3 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
27520 3 : if (!SWIG_IsOK(ecode2)) {
27521 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetPoint_2D" "', argument " "2"" of type '" "int""'");
27522 : }
27523 : arg2 = static_cast< int >(val2);
27524 : }
27525 3 : {
27526 3 : const int bLocalUseExceptions = GetUseExceptions();
27527 3 : if ( bLocalUseExceptions ) {
27528 2 : pushErrorHandler();
27529 : }
27530 3 : {
27531 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27532 3 : OGRGeometryShadow_GetPoint_2D(arg1,arg2,arg3);
27533 3 : SWIG_PYTHON_THREAD_END_ALLOW;
27534 : }
27535 3 : if ( bLocalUseExceptions ) {
27536 2 : popErrorHandler();
27537 : }
27538 : #ifndef SED_HACKS
27539 : if ( bLocalUseExceptions ) {
27540 : CPLErr eclass = CPLGetLastErrorType();
27541 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27542 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27543 : }
27544 : }
27545 : #endif
27546 : }
27547 3 : resultobj = SWIG_Py_Void();
27548 3 : {
27549 : /* %typemap(argout) (double argout[ANY]) */
27550 3 : PyObject *out = CreateTupleFromDoubleArray( arg3, 2 );
27551 : #if SWIG_VERSION >= 0x040300
27552 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
27553 : #else
27554 3 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
27555 : #endif
27556 : }
27557 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27558 : return resultobj;
27559 : fail:
27560 : return NULL;
27561 : }
27562 :
27563 :
27564 12106 : SWIGINTERN PyObject *_wrap_Geometry_GetGeometryCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27565 12106 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27566 12106 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27567 12106 : void *argp1 = 0 ;
27568 12106 : int res1 = 0 ;
27569 12106 : PyObject *swig_obj[1] ;
27570 12106 : int result;
27571 :
27572 12106 : if (!args) SWIG_fail;
27573 12106 : swig_obj[0] = args;
27574 12106 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27575 12106 : if (!SWIG_IsOK(res1)) {
27576 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetGeometryCount" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27577 : }
27578 12106 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27579 12106 : {
27580 12106 : const int bLocalUseExceptions = GetUseExceptions();
27581 12106 : if ( bLocalUseExceptions ) {
27582 438 : pushErrorHandler();
27583 : }
27584 12106 : {
27585 12106 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27586 12106 : result = (int)OGRGeometryShadow_GetGeometryCount(arg1);
27587 12106 : SWIG_PYTHON_THREAD_END_ALLOW;
27588 : }
27589 12106 : if ( bLocalUseExceptions ) {
27590 438 : popErrorHandler();
27591 : }
27592 : #ifndef SED_HACKS
27593 : if ( bLocalUseExceptions ) {
27594 : CPLErr eclass = CPLGetLastErrorType();
27595 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27596 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27597 : }
27598 : }
27599 : #endif
27600 : }
27601 12106 : resultobj = SWIG_From_int(static_cast< int >(result));
27602 12106 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27603 : return resultobj;
27604 : fail:
27605 : return NULL;
27606 : }
27607 :
27608 :
27609 168 : SWIGINTERN PyObject *_wrap_Geometry_SetPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27610 168 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27611 168 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27612 168 : int arg2 ;
27613 168 : double arg3 ;
27614 168 : double arg4 ;
27615 168 : double arg5 = (double) 0 ;
27616 168 : void *argp1 = 0 ;
27617 168 : int res1 = 0 ;
27618 168 : int val2 ;
27619 168 : int ecode2 = 0 ;
27620 168 : double val3 ;
27621 168 : int ecode3 = 0 ;
27622 168 : double val4 ;
27623 168 : int ecode4 = 0 ;
27624 168 : double val5 ;
27625 168 : int ecode5 = 0 ;
27626 168 : PyObject * obj0 = 0 ;
27627 168 : PyObject * obj1 = 0 ;
27628 168 : PyObject * obj2 = 0 ;
27629 168 : PyObject * obj3 = 0 ;
27630 168 : PyObject * obj4 = 0 ;
27631 168 : char * kwnames[] = {
27632 : (char *)"self", (char *)"point", (char *)"x", (char *)"y", (char *)"z", NULL
27633 : };
27634 :
27635 168 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:Geometry_SetPoint", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
27636 168 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27637 168 : if (!SWIG_IsOK(res1)) {
27638 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SetPoint" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27639 : }
27640 168 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27641 168 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27642 168 : if (!SWIG_IsOK(ecode2)) {
27643 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SetPoint" "', argument " "2"" of type '" "int""'");
27644 : }
27645 168 : arg2 = static_cast< int >(val2);
27646 168 : ecode3 = SWIG_AsVal_double(obj2, &val3);
27647 168 : if (!SWIG_IsOK(ecode3)) {
27648 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_SetPoint" "', argument " "3"" of type '" "double""'");
27649 : }
27650 168 : arg3 = static_cast< double >(val3);
27651 168 : ecode4 = SWIG_AsVal_double(obj3, &val4);
27652 168 : if (!SWIG_IsOK(ecode4)) {
27653 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_SetPoint" "', argument " "4"" of type '" "double""'");
27654 : }
27655 168 : arg4 = static_cast< double >(val4);
27656 168 : if (obj4) {
27657 162 : ecode5 = SWIG_AsVal_double(obj4, &val5);
27658 162 : if (!SWIG_IsOK(ecode5)) {
27659 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Geometry_SetPoint" "', argument " "5"" of type '" "double""'");
27660 : }
27661 162 : arg5 = static_cast< double >(val5);
27662 : }
27663 168 : {
27664 168 : const int bLocalUseExceptions = GetUseExceptions();
27665 168 : if ( bLocalUseExceptions ) {
27666 159 : pushErrorHandler();
27667 : }
27668 168 : {
27669 168 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27670 168 : OGRGeometryShadow_SetPoint(arg1,arg2,arg3,arg4,arg5);
27671 168 : SWIG_PYTHON_THREAD_END_ALLOW;
27672 : }
27673 168 : if ( bLocalUseExceptions ) {
27674 159 : popErrorHandler();
27675 : }
27676 : #ifndef SED_HACKS
27677 : if ( bLocalUseExceptions ) {
27678 : CPLErr eclass = CPLGetLastErrorType();
27679 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27680 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27681 : }
27682 : }
27683 : #endif
27684 : }
27685 168 : resultobj = SWIG_Py_Void();
27686 170 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27687 : return resultobj;
27688 : fail:
27689 : return NULL;
27690 : }
27691 :
27692 :
27693 0 : SWIGINTERN PyObject *_wrap_Geometry_SetPointM(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27694 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27695 0 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27696 0 : int arg2 ;
27697 0 : double arg3 ;
27698 0 : double arg4 ;
27699 0 : double arg5 ;
27700 0 : void *argp1 = 0 ;
27701 0 : int res1 = 0 ;
27702 0 : int val2 ;
27703 0 : int ecode2 = 0 ;
27704 0 : double val3 ;
27705 0 : int ecode3 = 0 ;
27706 0 : double val4 ;
27707 0 : int ecode4 = 0 ;
27708 0 : double val5 ;
27709 0 : int ecode5 = 0 ;
27710 0 : PyObject * obj0 = 0 ;
27711 0 : PyObject * obj1 = 0 ;
27712 0 : PyObject * obj2 = 0 ;
27713 0 : PyObject * obj3 = 0 ;
27714 0 : PyObject * obj4 = 0 ;
27715 0 : char * kwnames[] = {
27716 : (char *)"self", (char *)"point", (char *)"x", (char *)"y", (char *)"m", NULL
27717 : };
27718 :
27719 0 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:Geometry_SetPointM", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
27720 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27721 0 : if (!SWIG_IsOK(res1)) {
27722 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SetPointM" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27723 : }
27724 0 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27725 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27726 0 : if (!SWIG_IsOK(ecode2)) {
27727 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SetPointM" "', argument " "2"" of type '" "int""'");
27728 : }
27729 0 : arg2 = static_cast< int >(val2);
27730 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
27731 0 : if (!SWIG_IsOK(ecode3)) {
27732 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_SetPointM" "', argument " "3"" of type '" "double""'");
27733 : }
27734 0 : arg3 = static_cast< double >(val3);
27735 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
27736 0 : if (!SWIG_IsOK(ecode4)) {
27737 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_SetPointM" "', argument " "4"" of type '" "double""'");
27738 : }
27739 0 : arg4 = static_cast< double >(val4);
27740 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
27741 0 : if (!SWIG_IsOK(ecode5)) {
27742 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Geometry_SetPointM" "', argument " "5"" of type '" "double""'");
27743 : }
27744 0 : arg5 = static_cast< double >(val5);
27745 0 : {
27746 0 : const int bLocalUseExceptions = GetUseExceptions();
27747 0 : if ( bLocalUseExceptions ) {
27748 0 : pushErrorHandler();
27749 : }
27750 0 : {
27751 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27752 0 : OGRGeometryShadow_SetPointM(arg1,arg2,arg3,arg4,arg5);
27753 0 : SWIG_PYTHON_THREAD_END_ALLOW;
27754 : }
27755 0 : if ( bLocalUseExceptions ) {
27756 0 : popErrorHandler();
27757 : }
27758 : #ifndef SED_HACKS
27759 : if ( bLocalUseExceptions ) {
27760 : CPLErr eclass = CPLGetLastErrorType();
27761 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27762 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27763 : }
27764 : }
27765 : #endif
27766 : }
27767 0 : resultobj = SWIG_Py_Void();
27768 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27769 : return resultobj;
27770 : fail:
27771 : return NULL;
27772 : }
27773 :
27774 :
27775 0 : SWIGINTERN PyObject *_wrap_Geometry_SetPointZM(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27776 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27777 0 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27778 0 : int arg2 ;
27779 0 : double arg3 ;
27780 0 : double arg4 ;
27781 0 : double arg5 ;
27782 0 : double arg6 ;
27783 0 : void *argp1 = 0 ;
27784 0 : int res1 = 0 ;
27785 0 : int val2 ;
27786 0 : int ecode2 = 0 ;
27787 0 : double val3 ;
27788 0 : int ecode3 = 0 ;
27789 0 : double val4 ;
27790 0 : int ecode4 = 0 ;
27791 0 : double val5 ;
27792 0 : int ecode5 = 0 ;
27793 0 : double val6 ;
27794 0 : int ecode6 = 0 ;
27795 0 : PyObject * obj0 = 0 ;
27796 0 : PyObject * obj1 = 0 ;
27797 0 : PyObject * obj2 = 0 ;
27798 0 : PyObject * obj3 = 0 ;
27799 0 : PyObject * obj4 = 0 ;
27800 0 : PyObject * obj5 = 0 ;
27801 0 : char * kwnames[] = {
27802 : (char *)"self", (char *)"point", (char *)"x", (char *)"y", (char *)"z", (char *)"m", NULL
27803 : };
27804 :
27805 0 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:Geometry_SetPointZM", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
27806 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27807 0 : if (!SWIG_IsOK(res1)) {
27808 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SetPointZM" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27809 : }
27810 0 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27811 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27812 0 : if (!SWIG_IsOK(ecode2)) {
27813 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SetPointZM" "', argument " "2"" of type '" "int""'");
27814 : }
27815 0 : arg2 = static_cast< int >(val2);
27816 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
27817 0 : if (!SWIG_IsOK(ecode3)) {
27818 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_SetPointZM" "', argument " "3"" of type '" "double""'");
27819 : }
27820 0 : arg3 = static_cast< double >(val3);
27821 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
27822 0 : if (!SWIG_IsOK(ecode4)) {
27823 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_SetPointZM" "', argument " "4"" of type '" "double""'");
27824 : }
27825 0 : arg4 = static_cast< double >(val4);
27826 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
27827 0 : if (!SWIG_IsOK(ecode5)) {
27828 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Geometry_SetPointZM" "', argument " "5"" of type '" "double""'");
27829 : }
27830 0 : arg5 = static_cast< double >(val5);
27831 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
27832 0 : if (!SWIG_IsOK(ecode6)) {
27833 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Geometry_SetPointZM" "', argument " "6"" of type '" "double""'");
27834 : }
27835 0 : arg6 = static_cast< double >(val6);
27836 0 : {
27837 0 : const int bLocalUseExceptions = GetUseExceptions();
27838 0 : if ( bLocalUseExceptions ) {
27839 0 : pushErrorHandler();
27840 : }
27841 0 : {
27842 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27843 0 : OGRGeometryShadow_SetPointZM(arg1,arg2,arg3,arg4,arg5,arg6);
27844 0 : SWIG_PYTHON_THREAD_END_ALLOW;
27845 : }
27846 0 : if ( bLocalUseExceptions ) {
27847 0 : popErrorHandler();
27848 : }
27849 : #ifndef SED_HACKS
27850 : if ( bLocalUseExceptions ) {
27851 : CPLErr eclass = CPLGetLastErrorType();
27852 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27853 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27854 : }
27855 : }
27856 : #endif
27857 : }
27858 0 : resultobj = SWIG_Py_Void();
27859 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27860 : return resultobj;
27861 : fail:
27862 : return NULL;
27863 : }
27864 :
27865 :
27866 160062 : SWIGINTERN PyObject *_wrap_Geometry_SetPoint_2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27867 160062 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27868 160062 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27869 160062 : int arg2 ;
27870 160062 : double arg3 ;
27871 160062 : double arg4 ;
27872 160062 : void *argp1 = 0 ;
27873 160062 : int res1 = 0 ;
27874 160062 : int val2 ;
27875 160062 : int ecode2 = 0 ;
27876 160062 : double val3 ;
27877 160062 : int ecode3 = 0 ;
27878 160062 : double val4 ;
27879 160062 : int ecode4 = 0 ;
27880 160062 : PyObject * obj0 = 0 ;
27881 160062 : PyObject * obj1 = 0 ;
27882 160062 : PyObject * obj2 = 0 ;
27883 160062 : PyObject * obj3 = 0 ;
27884 160062 : char * kwnames[] = {
27885 : (char *)"self", (char *)"point", (char *)"x", (char *)"y", NULL
27886 : };
27887 :
27888 160062 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Geometry_SetPoint_2D", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
27889 160062 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27890 160062 : if (!SWIG_IsOK(res1)) {
27891 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SetPoint_2D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27892 : }
27893 160062 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27894 160062 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27895 160062 : if (!SWIG_IsOK(ecode2)) {
27896 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SetPoint_2D" "', argument " "2"" of type '" "int""'");
27897 : }
27898 160062 : arg2 = static_cast< int >(val2);
27899 160062 : ecode3 = SWIG_AsVal_double(obj2, &val3);
27900 160062 : if (!SWIG_IsOK(ecode3)) {
27901 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_SetPoint_2D" "', argument " "3"" of type '" "double""'");
27902 : }
27903 160062 : arg3 = static_cast< double >(val3);
27904 160062 : ecode4 = SWIG_AsVal_double(obj3, &val4);
27905 160062 : if (!SWIG_IsOK(ecode4)) {
27906 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_SetPoint_2D" "', argument " "4"" of type '" "double""'");
27907 : }
27908 160062 : arg4 = static_cast< double >(val4);
27909 160062 : {
27910 160062 : const int bLocalUseExceptions = GetUseExceptions();
27911 160062 : if ( bLocalUseExceptions ) {
27912 160003 : pushErrorHandler();
27913 : }
27914 160062 : {
27915 160062 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27916 160062 : OGRGeometryShadow_SetPoint_2D(arg1,arg2,arg3,arg4);
27917 160062 : SWIG_PYTHON_THREAD_END_ALLOW;
27918 : }
27919 160062 : if ( bLocalUseExceptions ) {
27920 160003 : popErrorHandler();
27921 : }
27922 : #ifndef SED_HACKS
27923 : if ( bLocalUseExceptions ) {
27924 : CPLErr eclass = CPLGetLastErrorType();
27925 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27926 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27927 : }
27928 : }
27929 : #endif
27930 : }
27931 160062 : resultobj = SWIG_Py_Void();
27932 160065 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27933 : return resultobj;
27934 : fail:
27935 : return NULL;
27936 : }
27937 :
27938 :
27939 2 : SWIGINTERN PyObject *_wrap_Geometry_SwapXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27940 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27941 2 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27942 2 : void *argp1 = 0 ;
27943 2 : int res1 = 0 ;
27944 2 : PyObject *swig_obj[1] ;
27945 :
27946 2 : if (!args) SWIG_fail;
27947 2 : swig_obj[0] = args;
27948 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27949 2 : if (!SWIG_IsOK(res1)) {
27950 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SwapXY" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27951 : }
27952 2 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27953 2 : {
27954 2 : const int bLocalUseExceptions = GetUseExceptions();
27955 2 : if ( bLocalUseExceptions ) {
27956 1 : pushErrorHandler();
27957 : }
27958 2 : {
27959 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27960 2 : OGRGeometryShadow_SwapXY(arg1);
27961 2 : SWIG_PYTHON_THREAD_END_ALLOW;
27962 : }
27963 2 : if ( bLocalUseExceptions ) {
27964 1 : popErrorHandler();
27965 : }
27966 : #ifndef SED_HACKS
27967 : if ( bLocalUseExceptions ) {
27968 : CPLErr eclass = CPLGetLastErrorType();
27969 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27970 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27971 : }
27972 : }
27973 : #endif
27974 : }
27975 2 : resultobj = SWIG_Py_Void();
27976 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27977 : return resultobj;
27978 : fail:
27979 : return NULL;
27980 : }
27981 :
27982 :
27983 2943 : SWIGINTERN PyObject *_wrap_Geometry_GetGeometryRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27984 2943 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27985 2943 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27986 2943 : int arg2 ;
27987 2943 : void *argp1 = 0 ;
27988 2943 : int res1 = 0 ;
27989 2943 : int val2 ;
27990 2943 : int ecode2 = 0 ;
27991 2943 : PyObject *swig_obj[2] ;
27992 2943 : OGRGeometryShadow *result = 0 ;
27993 :
27994 2943 : if (!SWIG_Python_UnpackTuple(args, "Geometry_GetGeometryRef", 2, 2, swig_obj)) SWIG_fail;
27995 2943 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27996 2943 : if (!SWIG_IsOK(res1)) {
27997 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetGeometryRef" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27998 : }
27999 2943 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28000 2943 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
28001 2943 : if (!SWIG_IsOK(ecode2)) {
28002 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetGeometryRef" "', argument " "2"" of type '" "int""'");
28003 : }
28004 2943 : arg2 = static_cast< int >(val2);
28005 2943 : {
28006 2943 : const int bLocalUseExceptions = GetUseExceptions();
28007 2943 : if ( bLocalUseExceptions ) {
28008 201 : pushErrorHandler();
28009 : }
28010 2943 : {
28011 2943 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28012 2943 : result = (OGRGeometryShadow *)OGRGeometryShadow_GetGeometryRef(arg1,arg2);
28013 2943 : SWIG_PYTHON_THREAD_END_ALLOW;
28014 : }
28015 2943 : if ( bLocalUseExceptions ) {
28016 201 : popErrorHandler();
28017 : }
28018 : #ifndef SED_HACKS
28019 : if ( bLocalUseExceptions ) {
28020 : CPLErr eclass = CPLGetLastErrorType();
28021 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28022 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28023 : }
28024 : }
28025 : #endif
28026 : }
28027 2943 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28028 2943 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28029 : return resultobj;
28030 : fail:
28031 : return NULL;
28032 : }
28033 :
28034 :
28035 1 : SWIGINTERN PyObject *_wrap_Geometry_Simplify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28036 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28037 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28038 1 : double arg2 ;
28039 1 : void *argp1 = 0 ;
28040 1 : int res1 = 0 ;
28041 1 : double val2 ;
28042 1 : int ecode2 = 0 ;
28043 1 : PyObject *swig_obj[2] ;
28044 1 : OGRGeometryShadow *result = 0 ;
28045 :
28046 1 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Simplify", 2, 2, swig_obj)) SWIG_fail;
28047 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28048 1 : if (!SWIG_IsOK(res1)) {
28049 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Simplify" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28050 : }
28051 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28052 1 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
28053 1 : if (!SWIG_IsOK(ecode2)) {
28054 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_Simplify" "', argument " "2"" of type '" "double""'");
28055 : }
28056 1 : arg2 = static_cast< double >(val2);
28057 1 : {
28058 1 : const int bLocalUseExceptions = GetUseExceptions();
28059 1 : if ( bLocalUseExceptions ) {
28060 1 : pushErrorHandler();
28061 : }
28062 1 : {
28063 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28064 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_Simplify(arg1,arg2);
28065 1 : SWIG_PYTHON_THREAD_END_ALLOW;
28066 : }
28067 1 : if ( bLocalUseExceptions ) {
28068 1 : popErrorHandler();
28069 : }
28070 : #ifndef SED_HACKS
28071 : if ( bLocalUseExceptions ) {
28072 : CPLErr eclass = CPLGetLastErrorType();
28073 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28074 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28075 : }
28076 : }
28077 : #endif
28078 : }
28079 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28080 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28081 : return resultobj;
28082 : fail:
28083 : return NULL;
28084 : }
28085 :
28086 :
28087 1 : SWIGINTERN PyObject *_wrap_Geometry_SimplifyPreserveTopology(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28088 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28089 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28090 1 : double arg2 ;
28091 1 : void *argp1 = 0 ;
28092 1 : int res1 = 0 ;
28093 1 : double val2 ;
28094 1 : int ecode2 = 0 ;
28095 1 : PyObject *swig_obj[2] ;
28096 1 : OGRGeometryShadow *result = 0 ;
28097 :
28098 1 : if (!SWIG_Python_UnpackTuple(args, "Geometry_SimplifyPreserveTopology", 2, 2, swig_obj)) SWIG_fail;
28099 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28100 1 : if (!SWIG_IsOK(res1)) {
28101 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SimplifyPreserveTopology" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28102 : }
28103 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28104 1 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
28105 1 : if (!SWIG_IsOK(ecode2)) {
28106 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SimplifyPreserveTopology" "', argument " "2"" of type '" "double""'");
28107 : }
28108 1 : arg2 = static_cast< double >(val2);
28109 1 : {
28110 1 : const int bLocalUseExceptions = GetUseExceptions();
28111 1 : if ( bLocalUseExceptions ) {
28112 1 : pushErrorHandler();
28113 : }
28114 1 : {
28115 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28116 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_SimplifyPreserveTopology(arg1,arg2);
28117 1 : SWIG_PYTHON_THREAD_END_ALLOW;
28118 : }
28119 1 : if ( bLocalUseExceptions ) {
28120 1 : popErrorHandler();
28121 : }
28122 : #ifndef SED_HACKS
28123 : if ( bLocalUseExceptions ) {
28124 : CPLErr eclass = CPLGetLastErrorType();
28125 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28126 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28127 : }
28128 : }
28129 : #endif
28130 : }
28131 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28132 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28133 : return resultobj;
28134 : fail:
28135 : return NULL;
28136 : }
28137 :
28138 :
28139 1 : SWIGINTERN PyObject *_wrap_Geometry_DelaunayTriangulation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28140 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28141 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28142 1 : double arg2 = (double) 0.0 ;
28143 1 : int arg3 = (int) FALSE ;
28144 1 : void *argp1 = 0 ;
28145 1 : int res1 = 0 ;
28146 1 : double val2 ;
28147 1 : int ecode2 = 0 ;
28148 1 : int val3 ;
28149 1 : int ecode3 = 0 ;
28150 1 : PyObject * obj0 = 0 ;
28151 1 : PyObject * obj1 = 0 ;
28152 1 : PyObject * obj2 = 0 ;
28153 1 : char * kwnames[] = {
28154 : (char *)"self", (char *)"dfTolerance", (char *)"bOnlyEdges", NULL
28155 : };
28156 1 : OGRGeometryShadow *result = 0 ;
28157 :
28158 1 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:Geometry_DelaunayTriangulation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
28159 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28160 1 : if (!SWIG_IsOK(res1)) {
28161 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_DelaunayTriangulation" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28162 : }
28163 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28164 1 : if (obj1) {
28165 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
28166 0 : if (!SWIG_IsOK(ecode2)) {
28167 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_DelaunayTriangulation" "', argument " "2"" of type '" "double""'");
28168 : }
28169 0 : arg2 = static_cast< double >(val2);
28170 : }
28171 1 : if (obj2) {
28172 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
28173 0 : if (!SWIG_IsOK(ecode3)) {
28174 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_DelaunayTriangulation" "', argument " "3"" of type '" "int""'");
28175 : }
28176 : arg3 = static_cast< int >(val3);
28177 : }
28178 1 : {
28179 1 : const int bLocalUseExceptions = GetUseExceptions();
28180 1 : if ( bLocalUseExceptions ) {
28181 1 : pushErrorHandler();
28182 : }
28183 1 : {
28184 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28185 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_DelaunayTriangulation(arg1,arg2,arg3);
28186 1 : SWIG_PYTHON_THREAD_END_ALLOW;
28187 : }
28188 1 : if ( bLocalUseExceptions ) {
28189 1 : popErrorHandler();
28190 : }
28191 : #ifndef SED_HACKS
28192 : if ( bLocalUseExceptions ) {
28193 : CPLErr eclass = CPLGetLastErrorType();
28194 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28195 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28196 : }
28197 : }
28198 : #endif
28199 : }
28200 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28201 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28202 : return resultobj;
28203 : fail:
28204 : return NULL;
28205 : }
28206 :
28207 :
28208 3 : SWIGINTERN PyObject *_wrap_Geometry_Polygonize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28209 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28210 3 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28211 3 : void *argp1 = 0 ;
28212 3 : int res1 = 0 ;
28213 3 : PyObject *swig_obj[1] ;
28214 3 : OGRGeometryShadow *result = 0 ;
28215 :
28216 3 : if (!args) SWIG_fail;
28217 3 : swig_obj[0] = args;
28218 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28219 3 : if (!SWIG_IsOK(res1)) {
28220 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Polygonize" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28221 : }
28222 3 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28223 3 : {
28224 3 : const int bLocalUseExceptions = GetUseExceptions();
28225 3 : if ( bLocalUseExceptions ) {
28226 3 : pushErrorHandler();
28227 : }
28228 3 : {
28229 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28230 3 : result = (OGRGeometryShadow *)OGRGeometryShadow_Polygonize(arg1);
28231 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28232 : }
28233 3 : if ( bLocalUseExceptions ) {
28234 3 : popErrorHandler();
28235 : }
28236 : #ifndef SED_HACKS
28237 : if ( bLocalUseExceptions ) {
28238 : CPLErr eclass = CPLGetLastErrorType();
28239 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28240 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28241 : }
28242 : }
28243 : #endif
28244 : }
28245 3 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28246 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28247 : return resultobj;
28248 : fail:
28249 : return NULL;
28250 : }
28251 :
28252 :
28253 0 : SWIGINTERN PyObject *_wrap_Geometry_BuildArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28254 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28255 0 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28256 0 : void *argp1 = 0 ;
28257 0 : int res1 = 0 ;
28258 0 : PyObject *swig_obj[1] ;
28259 0 : OGRGeometryShadow *result = 0 ;
28260 :
28261 0 : if (!args) SWIG_fail;
28262 0 : swig_obj[0] = args;
28263 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28264 0 : if (!SWIG_IsOK(res1)) {
28265 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_BuildArea" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28266 : }
28267 0 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28268 0 : {
28269 0 : const int bLocalUseExceptions = GetUseExceptions();
28270 0 : if ( bLocalUseExceptions ) {
28271 0 : pushErrorHandler();
28272 : }
28273 0 : {
28274 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28275 0 : result = (OGRGeometryShadow *)OGRGeometryShadow_BuildArea(arg1);
28276 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28277 : }
28278 0 : if ( bLocalUseExceptions ) {
28279 0 : popErrorHandler();
28280 : }
28281 : #ifndef SED_HACKS
28282 : if ( bLocalUseExceptions ) {
28283 : CPLErr eclass = CPLGetLastErrorType();
28284 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28285 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28286 : }
28287 : }
28288 : #endif
28289 : }
28290 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28291 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28292 : return resultobj;
28293 : fail:
28294 : return NULL;
28295 : }
28296 :
28297 :
28298 1 : SWIGINTERN PyObject *_wrap_Geometry_Boundary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28299 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28300 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28301 1 : void *argp1 = 0 ;
28302 1 : int res1 = 0 ;
28303 1 : PyObject *swig_obj[1] ;
28304 1 : OGRGeometryShadow *result = 0 ;
28305 :
28306 1 : if (!args) SWIG_fail;
28307 1 : swig_obj[0] = args;
28308 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28309 1 : if (!SWIG_IsOK(res1)) {
28310 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Boundary" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28311 : }
28312 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28313 1 : {
28314 1 : const int bLocalUseExceptions = GetUseExceptions();
28315 1 : if ( bLocalUseExceptions ) {
28316 0 : pushErrorHandler();
28317 : }
28318 1 : {
28319 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28320 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_Boundary(arg1);
28321 1 : SWIG_PYTHON_THREAD_END_ALLOW;
28322 : }
28323 1 : if ( bLocalUseExceptions ) {
28324 0 : popErrorHandler();
28325 : }
28326 : #ifndef SED_HACKS
28327 : if ( bLocalUseExceptions ) {
28328 : CPLErr eclass = CPLGetLastErrorType();
28329 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28330 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28331 : }
28332 : }
28333 : #endif
28334 : }
28335 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28336 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28337 : return resultobj;
28338 : fail:
28339 : return NULL;
28340 : }
28341 :
28342 :
28343 5 : SWIGINTERN PyObject *_wrap_Geometry_GetBoundary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28344 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28345 5 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28346 5 : void *argp1 = 0 ;
28347 5 : int res1 = 0 ;
28348 5 : PyObject *swig_obj[1] ;
28349 5 : OGRGeometryShadow *result = 0 ;
28350 :
28351 5 : if (!args) SWIG_fail;
28352 5 : swig_obj[0] = args;
28353 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28354 5 : if (!SWIG_IsOK(res1)) {
28355 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetBoundary" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28356 : }
28357 5 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28358 5 : {
28359 5 : const int bLocalUseExceptions = GetUseExceptions();
28360 5 : if ( bLocalUseExceptions ) {
28361 0 : pushErrorHandler();
28362 : }
28363 5 : {
28364 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28365 5 : result = (OGRGeometryShadow *)OGRGeometryShadow_GetBoundary(arg1);
28366 5 : SWIG_PYTHON_THREAD_END_ALLOW;
28367 : }
28368 5 : if ( bLocalUseExceptions ) {
28369 0 : popErrorHandler();
28370 : }
28371 : #ifndef SED_HACKS
28372 : if ( bLocalUseExceptions ) {
28373 : CPLErr eclass = CPLGetLastErrorType();
28374 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28375 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28376 : }
28377 : }
28378 : #endif
28379 : }
28380 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28381 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28382 : return resultobj;
28383 : fail:
28384 : return NULL;
28385 : }
28386 :
28387 :
28388 1 : SWIGINTERN PyObject *_wrap_Geometry_ConvexHull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28389 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28390 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28391 1 : void *argp1 = 0 ;
28392 1 : int res1 = 0 ;
28393 1 : PyObject *swig_obj[1] ;
28394 1 : OGRGeometryShadow *result = 0 ;
28395 :
28396 1 : if (!args) SWIG_fail;
28397 1 : swig_obj[0] = args;
28398 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28399 1 : if (!SWIG_IsOK(res1)) {
28400 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ConvexHull" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28401 : }
28402 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28403 1 : {
28404 1 : const int bLocalUseExceptions = GetUseExceptions();
28405 1 : if ( bLocalUseExceptions ) {
28406 1 : pushErrorHandler();
28407 : }
28408 1 : {
28409 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28410 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_ConvexHull(arg1);
28411 1 : SWIG_PYTHON_THREAD_END_ALLOW;
28412 : }
28413 1 : if ( bLocalUseExceptions ) {
28414 1 : popErrorHandler();
28415 : }
28416 : #ifndef SED_HACKS
28417 : if ( bLocalUseExceptions ) {
28418 : CPLErr eclass = CPLGetLastErrorType();
28419 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28420 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28421 : }
28422 : }
28423 : #endif
28424 : }
28425 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28426 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28427 : return resultobj;
28428 : fail:
28429 : return NULL;
28430 : }
28431 :
28432 :
28433 2 : SWIGINTERN PyObject *_wrap_Geometry_ConcaveHull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28434 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28435 2 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28436 2 : double arg2 ;
28437 2 : bool arg3 ;
28438 2 : void *argp1 = 0 ;
28439 2 : int res1 = 0 ;
28440 2 : double val2 ;
28441 2 : int ecode2 = 0 ;
28442 2 : bool val3 ;
28443 2 : int ecode3 = 0 ;
28444 2 : PyObject *swig_obj[3] ;
28445 2 : OGRGeometryShadow *result = 0 ;
28446 :
28447 2 : if (!SWIG_Python_UnpackTuple(args, "Geometry_ConcaveHull", 3, 3, swig_obj)) SWIG_fail;
28448 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28449 2 : if (!SWIG_IsOK(res1)) {
28450 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ConcaveHull" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28451 : }
28452 2 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28453 2 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
28454 2 : if (!SWIG_IsOK(ecode2)) {
28455 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_ConcaveHull" "', argument " "2"" of type '" "double""'");
28456 : }
28457 2 : arg2 = static_cast< double >(val2);
28458 2 : ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
28459 2 : if (!SWIG_IsOK(ecode3)) {
28460 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_ConcaveHull" "', argument " "3"" of type '" "bool""'");
28461 : }
28462 2 : arg3 = static_cast< bool >(val3);
28463 2 : {
28464 2 : const int bLocalUseExceptions = GetUseExceptions();
28465 2 : if ( bLocalUseExceptions ) {
28466 0 : pushErrorHandler();
28467 : }
28468 2 : {
28469 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28470 2 : result = (OGRGeometryShadow *)OGRGeometryShadow_ConcaveHull(arg1,arg2,arg3);
28471 2 : SWIG_PYTHON_THREAD_END_ALLOW;
28472 : }
28473 2 : if ( bLocalUseExceptions ) {
28474 0 : popErrorHandler();
28475 : }
28476 : #ifndef SED_HACKS
28477 : if ( bLocalUseExceptions ) {
28478 : CPLErr eclass = CPLGetLastErrorType();
28479 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28480 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28481 : }
28482 : }
28483 : #endif
28484 : }
28485 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28486 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28487 : return resultobj;
28488 : fail:
28489 : return NULL;
28490 : }
28491 :
28492 :
28493 11 : SWIGINTERN PyObject *_wrap_Geometry_MakeValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28494 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28495 11 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28496 11 : char **arg2 = (char **) NULL ;
28497 11 : void *argp1 = 0 ;
28498 11 : int res1 = 0 ;
28499 11 : PyObject *swig_obj[2] ;
28500 11 : OGRGeometryShadow *result = 0 ;
28501 :
28502 11 : if (!SWIG_Python_UnpackTuple(args, "Geometry_MakeValid", 1, 2, swig_obj)) SWIG_fail;
28503 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28504 11 : if (!SWIG_IsOK(res1)) {
28505 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_MakeValid" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28506 : }
28507 11 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28508 11 : if (swig_obj[1]) {
28509 5 : {
28510 : /* %typemap(in) char **dict */
28511 5 : arg2 = NULL;
28512 5 : if ( PySequence_Check( swig_obj[1] ) ) {
28513 5 : int bErr = FALSE;
28514 5 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
28515 5 : if ( bErr )
28516 : {
28517 0 : SWIG_fail;
28518 : }
28519 : }
28520 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
28521 0 : int bErr = FALSE;
28522 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
28523 0 : if ( bErr )
28524 : {
28525 0 : SWIG_fail;
28526 : }
28527 : }
28528 : else {
28529 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
28530 0 : SWIG_fail;
28531 : }
28532 : }
28533 : }
28534 11 : {
28535 11 : const int bLocalUseExceptions = GetUseExceptions();
28536 11 : if ( bLocalUseExceptions ) {
28537 0 : pushErrorHandler();
28538 : }
28539 11 : {
28540 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28541 11 : result = (OGRGeometryShadow *)OGRGeometryShadow_MakeValid(arg1,arg2);
28542 11 : SWIG_PYTHON_THREAD_END_ALLOW;
28543 : }
28544 11 : if ( bLocalUseExceptions ) {
28545 0 : popErrorHandler();
28546 : }
28547 : #ifndef SED_HACKS
28548 : if ( bLocalUseExceptions ) {
28549 : CPLErr eclass = CPLGetLastErrorType();
28550 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28551 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28552 : }
28553 : }
28554 : #endif
28555 : }
28556 11 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28557 11 : {
28558 : /* %typemap(freearg) char **dict */
28559 11 : CSLDestroy( arg2 );
28560 : }
28561 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28562 : return resultobj;
28563 0 : fail:
28564 0 : {
28565 : /* %typemap(freearg) char **dict */
28566 0 : CSLDestroy( arg2 );
28567 : }
28568 : return NULL;
28569 : }
28570 :
28571 :
28572 1 : SWIGINTERN PyObject *_wrap_Geometry_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28573 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28574 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28575 1 : double arg2 ;
28576 1 : int arg3 = (int) 0 ;
28577 1 : void *argp1 = 0 ;
28578 1 : int res1 = 0 ;
28579 1 : double val2 ;
28580 1 : int ecode2 = 0 ;
28581 1 : int val3 ;
28582 1 : int ecode3 = 0 ;
28583 1 : PyObject *swig_obj[3] ;
28584 1 : OGRGeometryShadow *result = 0 ;
28585 :
28586 1 : if (!SWIG_Python_UnpackTuple(args, "Geometry_SetPrecision", 2, 3, swig_obj)) SWIG_fail;
28587 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28588 1 : if (!SWIG_IsOK(res1)) {
28589 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SetPrecision" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28590 : }
28591 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28592 1 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
28593 1 : if (!SWIG_IsOK(ecode2)) {
28594 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SetPrecision" "', argument " "2"" of type '" "double""'");
28595 : }
28596 1 : arg2 = static_cast< double >(val2);
28597 1 : if (swig_obj[2]) {
28598 0 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
28599 0 : if (!SWIG_IsOK(ecode3)) {
28600 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_SetPrecision" "', argument " "3"" of type '" "int""'");
28601 : }
28602 : arg3 = static_cast< int >(val3);
28603 : }
28604 1 : {
28605 1 : const int bLocalUseExceptions = GetUseExceptions();
28606 1 : if ( bLocalUseExceptions ) {
28607 1 : pushErrorHandler();
28608 : }
28609 1 : {
28610 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28611 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_SetPrecision(arg1,arg2,arg3);
28612 1 : SWIG_PYTHON_THREAD_END_ALLOW;
28613 : }
28614 1 : if ( bLocalUseExceptions ) {
28615 1 : popErrorHandler();
28616 : }
28617 : #ifndef SED_HACKS
28618 : if ( bLocalUseExceptions ) {
28619 : CPLErr eclass = CPLGetLastErrorType();
28620 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28621 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28622 : }
28623 : }
28624 : #endif
28625 : }
28626 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28627 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28628 : return resultobj;
28629 : fail:
28630 : return NULL;
28631 : }
28632 :
28633 :
28634 1 : SWIGINTERN PyObject *_wrap_Geometry_Normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28635 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28636 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28637 1 : void *argp1 = 0 ;
28638 1 : int res1 = 0 ;
28639 1 : PyObject *swig_obj[1] ;
28640 1 : OGRGeometryShadow *result = 0 ;
28641 :
28642 1 : if (!args) SWIG_fail;
28643 1 : swig_obj[0] = args;
28644 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28645 1 : if (!SWIG_IsOK(res1)) {
28646 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Normalize" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28647 : }
28648 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28649 1 : {
28650 1 : const int bLocalUseExceptions = GetUseExceptions();
28651 1 : if ( bLocalUseExceptions ) {
28652 0 : pushErrorHandler();
28653 : }
28654 1 : {
28655 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28656 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_Normalize(arg1);
28657 1 : SWIG_PYTHON_THREAD_END_ALLOW;
28658 : }
28659 1 : if ( bLocalUseExceptions ) {
28660 0 : popErrorHandler();
28661 : }
28662 : #ifndef SED_HACKS
28663 : if ( bLocalUseExceptions ) {
28664 : CPLErr eclass = CPLGetLastErrorType();
28665 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28666 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28667 : }
28668 : }
28669 : #endif
28670 : }
28671 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28672 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28673 : return resultobj;
28674 : fail:
28675 : return NULL;
28676 : }
28677 :
28678 :
28679 18 : SWIGINTERN PyObject *_wrap_Geometry_RemoveLowerDimensionSubGeoms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28680 18 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28681 18 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28682 18 : void *argp1 = 0 ;
28683 18 : int res1 = 0 ;
28684 18 : PyObject *swig_obj[1] ;
28685 18 : OGRGeometryShadow *result = 0 ;
28686 :
28687 18 : if (!args) SWIG_fail;
28688 18 : swig_obj[0] = args;
28689 18 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28690 18 : if (!SWIG_IsOK(res1)) {
28691 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_RemoveLowerDimensionSubGeoms" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28692 : }
28693 18 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28694 18 : {
28695 18 : const int bLocalUseExceptions = GetUseExceptions();
28696 18 : if ( bLocalUseExceptions ) {
28697 0 : pushErrorHandler();
28698 : }
28699 18 : {
28700 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28701 18 : result = (OGRGeometryShadow *)OGRGeometryShadow_RemoveLowerDimensionSubGeoms(arg1);
28702 18 : SWIG_PYTHON_THREAD_END_ALLOW;
28703 : }
28704 18 : if ( bLocalUseExceptions ) {
28705 0 : popErrorHandler();
28706 : }
28707 : #ifndef SED_HACKS
28708 : if ( bLocalUseExceptions ) {
28709 : CPLErr eclass = CPLGetLastErrorType();
28710 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28711 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28712 : }
28713 : }
28714 : #endif
28715 : }
28716 18 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28717 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28718 : return resultobj;
28719 : fail:
28720 : return NULL;
28721 : }
28722 :
28723 :
28724 : SWIGINTERN PyObject *_wrap_Geometry_Buffer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
28725 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28726 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28727 : double arg2 ;
28728 : int arg3 = (int) 30 ;
28729 : void *argp1 = 0 ;
28730 : int res1 = 0 ;
28731 : double val2 ;
28732 : int ecode2 = 0 ;
28733 : int val3 ;
28734 : int ecode3 = 0 ;
28735 : OGRGeometryShadow *result = 0 ;
28736 :
28737 : if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
28738 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28739 : if (!SWIG_IsOK(res1)) {
28740 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Buffer" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28741 : }
28742 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28743 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
28744 : if (!SWIG_IsOK(ecode2)) {
28745 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_Buffer" "', argument " "2"" of type '" "double""'");
28746 : }
28747 : arg2 = static_cast< double >(val2);
28748 : if (swig_obj[2]) {
28749 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
28750 : if (!SWIG_IsOK(ecode3)) {
28751 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_Buffer" "', argument " "3"" of type '" "int""'");
28752 : }
28753 : arg3 = static_cast< int >(val3);
28754 : }
28755 : {
28756 : const int bLocalUseExceptions = GetUseExceptions();
28757 : if ( bLocalUseExceptions ) {
28758 : pushErrorHandler();
28759 : }
28760 : {
28761 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28762 : result = (OGRGeometryShadow *)OGRGeometryShadow_Buffer__SWIG_0(arg1,arg2,arg3);
28763 : SWIG_PYTHON_THREAD_END_ALLOW;
28764 : }
28765 : if ( bLocalUseExceptions ) {
28766 : popErrorHandler();
28767 : }
28768 : #ifndef SED_HACKS
28769 : if ( bLocalUseExceptions ) {
28770 : CPLErr eclass = CPLGetLastErrorType();
28771 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28772 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28773 : }
28774 : }
28775 : #endif
28776 : }
28777 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28778 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28779 : return resultobj;
28780 : fail:
28781 : return NULL;
28782 : }
28783 :
28784 :
28785 : SWIGINTERN PyObject *_wrap_Geometry_Buffer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
28786 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28787 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28788 : double arg2 ;
28789 : char **arg3 = (char **) 0 ;
28790 : void *argp1 = 0 ;
28791 : int res1 = 0 ;
28792 : double val2 ;
28793 : int ecode2 = 0 ;
28794 : OGRGeometryShadow *result = 0 ;
28795 :
28796 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
28797 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28798 : if (!SWIG_IsOK(res1)) {
28799 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Buffer" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28800 : }
28801 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28802 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
28803 : if (!SWIG_IsOK(ecode2)) {
28804 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_Buffer" "', argument " "2"" of type '" "double""'");
28805 : }
28806 : arg2 = static_cast< double >(val2);
28807 : {
28808 : /* %typemap(in) char **dict */
28809 : arg3 = NULL;
28810 : if ( PySequence_Check( swig_obj[2] ) ) {
28811 : int bErr = FALSE;
28812 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
28813 : if ( bErr )
28814 : {
28815 : SWIG_fail;
28816 : }
28817 : }
28818 : else if ( PyMapping_Check( swig_obj[2] ) ) {
28819 : int bErr = FALSE;
28820 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
28821 : if ( bErr )
28822 : {
28823 : SWIG_fail;
28824 : }
28825 : }
28826 : else {
28827 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
28828 : SWIG_fail;
28829 : }
28830 : }
28831 : {
28832 : const int bLocalUseExceptions = GetUseExceptions();
28833 : if ( bLocalUseExceptions ) {
28834 : pushErrorHandler();
28835 : }
28836 : {
28837 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28838 : result = (OGRGeometryShadow *)OGRGeometryShadow_Buffer__SWIG_1(arg1,arg2,arg3);
28839 : SWIG_PYTHON_THREAD_END_ALLOW;
28840 : }
28841 : if ( bLocalUseExceptions ) {
28842 : popErrorHandler();
28843 : }
28844 : #ifndef SED_HACKS
28845 : if ( bLocalUseExceptions ) {
28846 : CPLErr eclass = CPLGetLastErrorType();
28847 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28848 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28849 : }
28850 : }
28851 : #endif
28852 : }
28853 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28854 : {
28855 : /* %typemap(freearg) char **dict */
28856 : CSLDestroy( arg3 );
28857 : }
28858 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28859 : return resultobj;
28860 : fail:
28861 : {
28862 : /* %typemap(freearg) char **dict */
28863 : CSLDestroy( arg3 );
28864 : }
28865 : return NULL;
28866 : }
28867 :
28868 :
28869 16 : SWIGINTERN PyObject *_wrap_Geometry_Buffer(PyObject *self, PyObject *args) {
28870 16 : Py_ssize_t argc;
28871 16 : PyObject *argv[4] = {
28872 : 0
28873 : };
28874 :
28875 16 : if (!(argc = SWIG_Python_UnpackTuple(args, "Geometry_Buffer", 0, 3, argv))) SWIG_fail;
28876 16 : --argc;
28877 16 : if ((argc >= 2) && (argc <= 3)) {
28878 16 : int _v;
28879 16 : void *vptr = 0;
28880 16 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
28881 28 : _v = SWIG_CheckState(res);
28882 16 : if (_v) {
28883 16 : {
28884 16 : int res = SWIG_AsVal_double(argv[1], NULL);
28885 16 : _v = SWIG_CheckState(res);
28886 : }
28887 16 : if (_v) {
28888 16 : if (argc <= 2) {
28889 4 : return _wrap_Geometry_Buffer__SWIG_0(self, argc, argv);
28890 : }
28891 14 : {
28892 14 : int res = SWIG_AsVal_int(argv[2], NULL);
28893 14 : _v = SWIG_CheckState(res);
28894 : }
28895 2 : if (_v) {
28896 2 : return _wrap_Geometry_Buffer__SWIG_0(self, argc, argv);
28897 : }
28898 : }
28899 : }
28900 : }
28901 12 : if (argc == 3) {
28902 12 : int _v;
28903 12 : void *vptr = 0;
28904 12 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
28905 12 : _v = SWIG_CheckState(res);
28906 12 : if (_v) {
28907 12 : {
28908 12 : int res = SWIG_AsVal_double(argv[1], NULL);
28909 12 : _v = SWIG_CheckState(res);
28910 : }
28911 12 : if (_v) {
28912 12 : {
28913 : /* %typecheck(SWIG_TYPECHECK_POINTER) (char **dict) */
28914 : /* Note: we exclude explicitly strings, because they can be considered as a sequence of characters, */
28915 : /* which is not desirable since it makes it impossible to define bindings such as SetMetadata(string) and SetMetadata(array_of_string) */
28916 : /* (see #4816) */
28917 12 : _v = ((PyMapping_Check(argv[2]) || PySequence_Check(argv[2]) ) && !SWIG_CheckState(SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0)) ) ? 1 : 0;
28918 : }
28919 12 : if (_v) {
28920 12 : return _wrap_Geometry_Buffer__SWIG_1(self, argc, argv);
28921 : }
28922 : }
28923 : }
28924 : }
28925 :
28926 0 : fail:
28927 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Geometry_Buffer'.\n"
28928 : " Possible C/C++ prototypes are:\n"
28929 : " OGRGeometryShadow::Buffer(double,int)\n"
28930 : " OGRGeometryShadow::Buffer(double,char **)\n");
28931 : return 0;
28932 : }
28933 :
28934 :
28935 11 : SWIGINTERN PyObject *_wrap_Geometry_Intersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28936 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28937 11 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28938 11 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
28939 11 : void *argp1 = 0 ;
28940 11 : int res1 = 0 ;
28941 11 : void *argp2 = 0 ;
28942 11 : int res2 = 0 ;
28943 11 : PyObject *swig_obj[2] ;
28944 11 : OGRGeometryShadow *result = 0 ;
28945 :
28946 11 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Intersection", 2, 2, swig_obj)) SWIG_fail;
28947 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28948 11 : if (!SWIG_IsOK(res1)) {
28949 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Intersection" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28950 : }
28951 11 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28952 11 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28953 11 : if (!SWIG_IsOK(res2)) {
28954 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Intersection" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
28955 : }
28956 11 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
28957 11 : {
28958 11 : if (!arg2) {
28959 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
28960 : }
28961 : }
28962 11 : {
28963 11 : const int bLocalUseExceptions = GetUseExceptions();
28964 11 : if ( bLocalUseExceptions ) {
28965 1 : pushErrorHandler();
28966 : }
28967 11 : {
28968 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28969 11 : result = (OGRGeometryShadow *)OGRGeometryShadow_Intersection(arg1,arg2);
28970 11 : SWIG_PYTHON_THREAD_END_ALLOW;
28971 : }
28972 11 : if ( bLocalUseExceptions ) {
28973 1 : popErrorHandler();
28974 : }
28975 : #ifndef SED_HACKS
28976 : if ( bLocalUseExceptions ) {
28977 : CPLErr eclass = CPLGetLastErrorType();
28978 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28979 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28980 : }
28981 : }
28982 : #endif
28983 : }
28984 11 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28985 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28986 : return resultobj;
28987 : fail:
28988 : return NULL;
28989 : }
28990 :
28991 :
28992 7 : SWIGINTERN PyObject *_wrap_Geometry_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28993 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28994 7 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28995 7 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
28996 7 : void *argp1 = 0 ;
28997 7 : int res1 = 0 ;
28998 7 : void *argp2 = 0 ;
28999 7 : int res2 = 0 ;
29000 7 : PyObject *swig_obj[2] ;
29001 7 : OGRGeometryShadow *result = 0 ;
29002 :
29003 7 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Union", 2, 2, swig_obj)) SWIG_fail;
29004 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29005 7 : if (!SWIG_IsOK(res1)) {
29006 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Union" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29007 : }
29008 7 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29009 7 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29010 7 : if (!SWIG_IsOK(res2)) {
29011 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Union" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29012 : }
29013 7 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29014 7 : {
29015 7 : if (!arg2) {
29016 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29017 : }
29018 : }
29019 7 : {
29020 7 : const int bLocalUseExceptions = GetUseExceptions();
29021 7 : if ( bLocalUseExceptions ) {
29022 1 : pushErrorHandler();
29023 : }
29024 7 : {
29025 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29026 7 : result = (OGRGeometryShadow *)OGRGeometryShadow_Union(arg1,arg2);
29027 7 : SWIG_PYTHON_THREAD_END_ALLOW;
29028 : }
29029 7 : if ( bLocalUseExceptions ) {
29030 1 : popErrorHandler();
29031 : }
29032 : #ifndef SED_HACKS
29033 : if ( bLocalUseExceptions ) {
29034 : CPLErr eclass = CPLGetLastErrorType();
29035 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29036 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29037 : }
29038 : }
29039 : #endif
29040 : }
29041 7 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
29042 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29043 : return resultobj;
29044 : fail:
29045 : return NULL;
29046 : }
29047 :
29048 :
29049 2 : SWIGINTERN PyObject *_wrap_Geometry_UnionCascaded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29050 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29051 2 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29052 2 : void *argp1 = 0 ;
29053 2 : int res1 = 0 ;
29054 2 : PyObject *swig_obj[1] ;
29055 2 : OGRGeometryShadow *result = 0 ;
29056 :
29057 2 : if (!args) SWIG_fail;
29058 2 : swig_obj[0] = args;
29059 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29060 2 : if (!SWIG_IsOK(res1)) {
29061 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_UnionCascaded" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29062 : }
29063 2 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29064 2 : {
29065 2 : const int bLocalUseExceptions = GetUseExceptions();
29066 2 : if ( bLocalUseExceptions ) {
29067 2 : pushErrorHandler();
29068 : }
29069 2 : {
29070 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29071 2 : result = (OGRGeometryShadow *)OGRGeometryShadow_UnionCascaded(arg1);
29072 2 : SWIG_PYTHON_THREAD_END_ALLOW;
29073 : }
29074 2 : if ( bLocalUseExceptions ) {
29075 2 : popErrorHandler();
29076 : }
29077 : #ifndef SED_HACKS
29078 : if ( bLocalUseExceptions ) {
29079 : CPLErr eclass = CPLGetLastErrorType();
29080 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29081 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29082 : }
29083 : }
29084 : #endif
29085 : }
29086 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
29087 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29088 : return resultobj;
29089 : fail:
29090 : return NULL;
29091 : }
29092 :
29093 :
29094 2 : SWIGINTERN PyObject *_wrap_Geometry_UnaryUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29095 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29096 2 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29097 2 : void *argp1 = 0 ;
29098 2 : int res1 = 0 ;
29099 2 : PyObject *swig_obj[1] ;
29100 2 : OGRGeometryShadow *result = 0 ;
29101 :
29102 2 : if (!args) SWIG_fail;
29103 2 : swig_obj[0] = args;
29104 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29105 2 : if (!SWIG_IsOK(res1)) {
29106 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_UnaryUnion" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29107 : }
29108 2 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29109 2 : {
29110 2 : const int bLocalUseExceptions = GetUseExceptions();
29111 2 : if ( bLocalUseExceptions ) {
29112 2 : pushErrorHandler();
29113 : }
29114 2 : {
29115 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29116 2 : result = (OGRGeometryShadow *)OGRGeometryShadow_UnaryUnion(arg1);
29117 2 : SWIG_PYTHON_THREAD_END_ALLOW;
29118 : }
29119 2 : if ( bLocalUseExceptions ) {
29120 2 : popErrorHandler();
29121 : }
29122 : #ifndef SED_HACKS
29123 : if ( bLocalUseExceptions ) {
29124 : CPLErr eclass = CPLGetLastErrorType();
29125 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29126 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29127 : }
29128 : }
29129 : #endif
29130 : }
29131 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
29132 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29133 : return resultobj;
29134 : fail:
29135 : return NULL;
29136 : }
29137 :
29138 :
29139 5 : SWIGINTERN PyObject *_wrap_Geometry_Difference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29140 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29141 5 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29142 5 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29143 5 : void *argp1 = 0 ;
29144 5 : int res1 = 0 ;
29145 5 : void *argp2 = 0 ;
29146 5 : int res2 = 0 ;
29147 5 : PyObject *swig_obj[2] ;
29148 5 : OGRGeometryShadow *result = 0 ;
29149 :
29150 5 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Difference", 2, 2, swig_obj)) SWIG_fail;
29151 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29152 5 : if (!SWIG_IsOK(res1)) {
29153 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Difference" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29154 : }
29155 5 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29156 5 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29157 5 : if (!SWIG_IsOK(res2)) {
29158 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Difference" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29159 : }
29160 5 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29161 5 : {
29162 5 : if (!arg2) {
29163 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29164 : }
29165 : }
29166 5 : {
29167 5 : const int bLocalUseExceptions = GetUseExceptions();
29168 5 : if ( bLocalUseExceptions ) {
29169 1 : pushErrorHandler();
29170 : }
29171 5 : {
29172 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29173 5 : result = (OGRGeometryShadow *)OGRGeometryShadow_Difference(arg1,arg2);
29174 5 : SWIG_PYTHON_THREAD_END_ALLOW;
29175 : }
29176 5 : if ( bLocalUseExceptions ) {
29177 1 : popErrorHandler();
29178 : }
29179 : #ifndef SED_HACKS
29180 : if ( bLocalUseExceptions ) {
29181 : CPLErr eclass = CPLGetLastErrorType();
29182 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29183 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29184 : }
29185 : }
29186 : #endif
29187 : }
29188 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
29189 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29190 : return resultobj;
29191 : fail:
29192 : return NULL;
29193 : }
29194 :
29195 :
29196 5 : SWIGINTERN PyObject *_wrap_Geometry_SymDifference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29197 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29198 5 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29199 5 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29200 5 : void *argp1 = 0 ;
29201 5 : int res1 = 0 ;
29202 5 : void *argp2 = 0 ;
29203 5 : int res2 = 0 ;
29204 5 : PyObject *swig_obj[2] ;
29205 5 : OGRGeometryShadow *result = 0 ;
29206 :
29207 5 : if (!SWIG_Python_UnpackTuple(args, "Geometry_SymDifference", 2, 2, swig_obj)) SWIG_fail;
29208 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29209 5 : if (!SWIG_IsOK(res1)) {
29210 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SymDifference" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29211 : }
29212 5 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29213 5 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29214 5 : if (!SWIG_IsOK(res2)) {
29215 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_SymDifference" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29216 : }
29217 5 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29218 5 : {
29219 5 : if (!arg2) {
29220 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29221 : }
29222 : }
29223 5 : {
29224 5 : const int bLocalUseExceptions = GetUseExceptions();
29225 5 : if ( bLocalUseExceptions ) {
29226 1 : pushErrorHandler();
29227 : }
29228 5 : {
29229 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29230 5 : result = (OGRGeometryShadow *)OGRGeometryShadow_SymDifference(arg1,arg2);
29231 5 : SWIG_PYTHON_THREAD_END_ALLOW;
29232 : }
29233 5 : if ( bLocalUseExceptions ) {
29234 1 : popErrorHandler();
29235 : }
29236 : #ifndef SED_HACKS
29237 : if ( bLocalUseExceptions ) {
29238 : CPLErr eclass = CPLGetLastErrorType();
29239 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29240 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29241 : }
29242 : }
29243 : #endif
29244 : }
29245 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
29246 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29247 : return resultobj;
29248 : fail:
29249 : return NULL;
29250 : }
29251 :
29252 :
29253 1 : SWIGINTERN PyObject *_wrap_Geometry_SymmetricDifference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29254 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29255 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29256 1 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29257 1 : void *argp1 = 0 ;
29258 1 : int res1 = 0 ;
29259 1 : void *argp2 = 0 ;
29260 1 : int res2 = 0 ;
29261 1 : PyObject *swig_obj[2] ;
29262 1 : OGRGeometryShadow *result = 0 ;
29263 :
29264 1 : if (!SWIG_Python_UnpackTuple(args, "Geometry_SymmetricDifference", 2, 2, swig_obj)) SWIG_fail;
29265 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29266 1 : if (!SWIG_IsOK(res1)) {
29267 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SymmetricDifference" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29268 : }
29269 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29270 1 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29271 1 : if (!SWIG_IsOK(res2)) {
29272 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_SymmetricDifference" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29273 : }
29274 1 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29275 1 : {
29276 1 : if (!arg2) {
29277 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29278 : }
29279 : }
29280 1 : {
29281 1 : const int bLocalUseExceptions = GetUseExceptions();
29282 1 : if ( bLocalUseExceptions ) {
29283 1 : pushErrorHandler();
29284 : }
29285 1 : {
29286 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29287 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_SymmetricDifference(arg1,arg2);
29288 1 : SWIG_PYTHON_THREAD_END_ALLOW;
29289 : }
29290 1 : if ( bLocalUseExceptions ) {
29291 1 : popErrorHandler();
29292 : }
29293 : #ifndef SED_HACKS
29294 : if ( bLocalUseExceptions ) {
29295 : CPLErr eclass = CPLGetLastErrorType();
29296 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29297 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29298 : }
29299 : }
29300 : #endif
29301 : }
29302 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
29303 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29304 : return resultobj;
29305 : fail:
29306 : return NULL;
29307 : }
29308 :
29309 :
29310 1 : SWIGINTERN PyObject *_wrap_Geometry_Distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29311 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29312 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29313 1 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29314 1 : void *argp1 = 0 ;
29315 1 : int res1 = 0 ;
29316 1 : void *argp2 = 0 ;
29317 1 : int res2 = 0 ;
29318 1 : PyObject *swig_obj[2] ;
29319 1 : double result;
29320 :
29321 1 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Distance", 2, 2, swig_obj)) SWIG_fail;
29322 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29323 1 : if (!SWIG_IsOK(res1)) {
29324 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Distance" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29325 : }
29326 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29327 1 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29328 1 : if (!SWIG_IsOK(res2)) {
29329 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Distance" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29330 : }
29331 1 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29332 1 : {
29333 1 : if (!arg2) {
29334 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29335 : }
29336 : }
29337 1 : {
29338 1 : const int bLocalUseExceptions = GetUseExceptions();
29339 1 : if ( bLocalUseExceptions ) {
29340 1 : pushErrorHandler();
29341 : }
29342 1 : {
29343 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29344 1 : result = (double)OGRGeometryShadow_Distance(arg1,arg2);
29345 1 : SWIG_PYTHON_THREAD_END_ALLOW;
29346 : }
29347 1 : if ( bLocalUseExceptions ) {
29348 1 : popErrorHandler();
29349 : }
29350 : #ifndef SED_HACKS
29351 : if ( bLocalUseExceptions ) {
29352 : CPLErr eclass = CPLGetLastErrorType();
29353 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29354 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29355 : }
29356 : }
29357 : #endif
29358 : }
29359 1 : resultobj = SWIG_From_double(static_cast< double >(result));
29360 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29361 : return resultobj;
29362 : fail:
29363 : return NULL;
29364 : }
29365 :
29366 :
29367 1 : SWIGINTERN PyObject *_wrap_Geometry_Distance3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29368 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29369 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29370 1 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29371 1 : void *argp1 = 0 ;
29372 1 : int res1 = 0 ;
29373 1 : void *argp2 = 0 ;
29374 1 : int res2 = 0 ;
29375 1 : PyObject *swig_obj[2] ;
29376 1 : double result;
29377 :
29378 1 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Distance3D", 2, 2, swig_obj)) SWIG_fail;
29379 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29380 1 : if (!SWIG_IsOK(res1)) {
29381 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Distance3D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29382 : }
29383 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29384 1 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29385 1 : if (!SWIG_IsOK(res2)) {
29386 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Distance3D" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29387 : }
29388 1 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29389 1 : {
29390 1 : if (!arg2) {
29391 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29392 : }
29393 : }
29394 1 : {
29395 1 : const int bLocalUseExceptions = GetUseExceptions();
29396 1 : if ( bLocalUseExceptions ) {
29397 0 : pushErrorHandler();
29398 : }
29399 1 : {
29400 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29401 1 : result = (double)OGRGeometryShadow_Distance3D(arg1,arg2);
29402 1 : SWIG_PYTHON_THREAD_END_ALLOW;
29403 : }
29404 1 : if ( bLocalUseExceptions ) {
29405 0 : popErrorHandler();
29406 : }
29407 : #ifndef SED_HACKS
29408 : if ( bLocalUseExceptions ) {
29409 : CPLErr eclass = CPLGetLastErrorType();
29410 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29411 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29412 : }
29413 : }
29414 : #endif
29415 : }
29416 1 : resultobj = SWIG_From_double(static_cast< double >(result));
29417 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29418 : return resultobj;
29419 : fail:
29420 : return NULL;
29421 : }
29422 :
29423 :
29424 4 : SWIGINTERN PyObject *_wrap_Geometry_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29425 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29426 4 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29427 4 : void *argp1 = 0 ;
29428 4 : int res1 = 0 ;
29429 4 : PyObject *swig_obj[1] ;
29430 :
29431 4 : if (!args) SWIG_fail;
29432 4 : swig_obj[0] = args;
29433 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29434 4 : if (!SWIG_IsOK(res1)) {
29435 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Empty" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29436 : }
29437 4 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29438 4 : {
29439 4 : const int bLocalUseExceptions = GetUseExceptions();
29440 4 : if ( bLocalUseExceptions ) {
29441 0 : pushErrorHandler();
29442 : }
29443 4 : {
29444 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29445 4 : OGRGeometryShadow_Empty(arg1);
29446 4 : SWIG_PYTHON_THREAD_END_ALLOW;
29447 : }
29448 4 : if ( bLocalUseExceptions ) {
29449 0 : popErrorHandler();
29450 : }
29451 : #ifndef SED_HACKS
29452 : if ( bLocalUseExceptions ) {
29453 : CPLErr eclass = CPLGetLastErrorType();
29454 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29455 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29456 : }
29457 : }
29458 : #endif
29459 : }
29460 4 : resultobj = SWIG_Py_Void();
29461 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29462 : return resultobj;
29463 : fail:
29464 : return NULL;
29465 : }
29466 :
29467 :
29468 2128 : SWIGINTERN PyObject *_wrap_Geometry_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29469 2128 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29470 2128 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29471 2128 : void *argp1 = 0 ;
29472 2128 : int res1 = 0 ;
29473 2128 : PyObject *swig_obj[1] ;
29474 2128 : bool result;
29475 :
29476 2128 : if (!args) SWIG_fail;
29477 2128 : swig_obj[0] = args;
29478 2128 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29479 2128 : if (!SWIG_IsOK(res1)) {
29480 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_IsEmpty" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29481 : }
29482 2128 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29483 2128 : {
29484 2128 : const int bLocalUseExceptions = GetUseExceptions();
29485 2128 : if ( bLocalUseExceptions ) {
29486 1011 : pushErrorHandler();
29487 : }
29488 2128 : {
29489 2128 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29490 2128 : result = (bool)OGRGeometryShadow_IsEmpty(arg1);
29491 2128 : SWIG_PYTHON_THREAD_END_ALLOW;
29492 : }
29493 2128 : if ( bLocalUseExceptions ) {
29494 1011 : popErrorHandler();
29495 : }
29496 : #ifndef SED_HACKS
29497 : if ( bLocalUseExceptions ) {
29498 : CPLErr eclass = CPLGetLastErrorType();
29499 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29500 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29501 : }
29502 : }
29503 : #endif
29504 : }
29505 2128 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29506 2128 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29507 : return resultobj;
29508 : fail:
29509 : return NULL;
29510 : }
29511 :
29512 :
29513 19 : SWIGINTERN PyObject *_wrap_Geometry_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29514 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29515 19 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29516 19 : void *argp1 = 0 ;
29517 19 : int res1 = 0 ;
29518 19 : PyObject *swig_obj[1] ;
29519 19 : bool result;
29520 :
29521 19 : if (!args) SWIG_fail;
29522 19 : swig_obj[0] = args;
29523 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29524 19 : if (!SWIG_IsOK(res1)) {
29525 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_IsValid" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29526 : }
29527 19 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29528 19 : {
29529 19 : const int bLocalUseExceptions = GetUseExceptions();
29530 19 : if ( bLocalUseExceptions ) {
29531 14 : pushErrorHandler();
29532 : }
29533 19 : {
29534 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29535 19 : result = (bool)OGRGeometryShadow_IsValid(arg1);
29536 19 : SWIG_PYTHON_THREAD_END_ALLOW;
29537 : }
29538 19 : if ( bLocalUseExceptions ) {
29539 14 : popErrorHandler();
29540 : }
29541 : #ifndef SED_HACKS
29542 : if ( bLocalUseExceptions ) {
29543 : CPLErr eclass = CPLGetLastErrorType();
29544 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29545 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29546 : }
29547 : }
29548 : #endif
29549 : }
29550 19 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29551 19 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29552 : return resultobj;
29553 : fail:
29554 : return NULL;
29555 : }
29556 :
29557 :
29558 5 : SWIGINTERN PyObject *_wrap_Geometry_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29559 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29560 5 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29561 5 : void *argp1 = 0 ;
29562 5 : int res1 = 0 ;
29563 5 : PyObject *swig_obj[1] ;
29564 5 : bool result;
29565 :
29566 5 : if (!args) SWIG_fail;
29567 5 : swig_obj[0] = args;
29568 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29569 5 : if (!SWIG_IsOK(res1)) {
29570 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_IsSimple" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29571 : }
29572 5 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29573 5 : {
29574 5 : const int bLocalUseExceptions = GetUseExceptions();
29575 5 : if ( bLocalUseExceptions ) {
29576 2 : pushErrorHandler();
29577 : }
29578 5 : {
29579 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29580 5 : result = (bool)OGRGeometryShadow_IsSimple(arg1);
29581 5 : SWIG_PYTHON_THREAD_END_ALLOW;
29582 : }
29583 5 : if ( bLocalUseExceptions ) {
29584 2 : popErrorHandler();
29585 : }
29586 : #ifndef SED_HACKS
29587 : if ( bLocalUseExceptions ) {
29588 : CPLErr eclass = CPLGetLastErrorType();
29589 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29590 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29591 : }
29592 : }
29593 : #endif
29594 : }
29595 5 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29596 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29597 : return resultobj;
29598 : fail:
29599 : return NULL;
29600 : }
29601 :
29602 :
29603 1 : SWIGINTERN PyObject *_wrap_Geometry_IsRing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29604 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29605 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29606 1 : void *argp1 = 0 ;
29607 1 : int res1 = 0 ;
29608 1 : PyObject *swig_obj[1] ;
29609 1 : bool result;
29610 :
29611 1 : if (!args) SWIG_fail;
29612 1 : swig_obj[0] = args;
29613 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29614 1 : if (!SWIG_IsOK(res1)) {
29615 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_IsRing" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29616 : }
29617 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29618 1 : {
29619 1 : const int bLocalUseExceptions = GetUseExceptions();
29620 1 : if ( bLocalUseExceptions ) {
29621 1 : pushErrorHandler();
29622 : }
29623 1 : {
29624 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29625 1 : result = (bool)OGRGeometryShadow_IsRing(arg1);
29626 1 : SWIG_PYTHON_THREAD_END_ALLOW;
29627 : }
29628 1 : if ( bLocalUseExceptions ) {
29629 1 : popErrorHandler();
29630 : }
29631 : #ifndef SED_HACKS
29632 : if ( bLocalUseExceptions ) {
29633 : CPLErr eclass = CPLGetLastErrorType();
29634 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29635 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29636 : }
29637 : }
29638 : #endif
29639 : }
29640 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29641 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29642 : return resultobj;
29643 : fail:
29644 : return NULL;
29645 : }
29646 :
29647 :
29648 7 : SWIGINTERN PyObject *_wrap_Geometry_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29649 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29650 7 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29651 7 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29652 7 : void *argp1 = 0 ;
29653 7 : int res1 = 0 ;
29654 7 : void *argp2 = 0 ;
29655 7 : int res2 = 0 ;
29656 7 : PyObject *swig_obj[2] ;
29657 7 : bool result;
29658 :
29659 7 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Intersects", 2, 2, swig_obj)) SWIG_fail;
29660 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29661 7 : if (!SWIG_IsOK(res1)) {
29662 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Intersects" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29663 : }
29664 7 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29665 7 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29666 7 : if (!SWIG_IsOK(res2)) {
29667 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Intersects" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29668 : }
29669 7 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29670 7 : {
29671 7 : if (!arg2) {
29672 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29673 : }
29674 : }
29675 7 : {
29676 7 : const int bLocalUseExceptions = GetUseExceptions();
29677 7 : if ( bLocalUseExceptions ) {
29678 0 : pushErrorHandler();
29679 : }
29680 7 : {
29681 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29682 7 : result = (bool)OGRGeometryShadow_Intersects(arg1,arg2);
29683 7 : SWIG_PYTHON_THREAD_END_ALLOW;
29684 : }
29685 7 : if ( bLocalUseExceptions ) {
29686 0 : popErrorHandler();
29687 : }
29688 : #ifndef SED_HACKS
29689 : if ( bLocalUseExceptions ) {
29690 : CPLErr eclass = CPLGetLastErrorType();
29691 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29692 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29693 : }
29694 : }
29695 : #endif
29696 : }
29697 7 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29698 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29699 : return resultobj;
29700 : fail:
29701 : return NULL;
29702 : }
29703 :
29704 :
29705 2 : SWIGINTERN PyObject *_wrap_Geometry_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29706 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29707 2 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29708 2 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29709 2 : void *argp1 = 0 ;
29710 2 : int res1 = 0 ;
29711 2 : void *argp2 = 0 ;
29712 2 : int res2 = 0 ;
29713 2 : PyObject *swig_obj[2] ;
29714 2 : bool result;
29715 :
29716 2 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Intersect", 2, 2, swig_obj)) SWIG_fail;
29717 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29718 2 : if (!SWIG_IsOK(res1)) {
29719 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Intersect" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29720 : }
29721 2 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29722 2 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29723 2 : if (!SWIG_IsOK(res2)) {
29724 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Intersect" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29725 : }
29726 2 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29727 2 : {
29728 2 : if (!arg2) {
29729 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29730 : }
29731 : }
29732 2 : {
29733 2 : const int bLocalUseExceptions = GetUseExceptions();
29734 2 : if ( bLocalUseExceptions ) {
29735 2 : pushErrorHandler();
29736 : }
29737 2 : {
29738 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29739 2 : result = (bool)OGRGeometryShadow_Intersect(arg1,arg2);
29740 2 : SWIG_PYTHON_THREAD_END_ALLOW;
29741 : }
29742 2 : if ( bLocalUseExceptions ) {
29743 2 : popErrorHandler();
29744 : }
29745 : #ifndef SED_HACKS
29746 : if ( bLocalUseExceptions ) {
29747 : CPLErr eclass = CPLGetLastErrorType();
29748 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29749 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29750 : }
29751 : }
29752 : #endif
29753 : }
29754 2 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29755 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29756 : return resultobj;
29757 : fail:
29758 : return NULL;
29759 : }
29760 :
29761 :
29762 27981 : SWIGINTERN PyObject *_wrap_Geometry_Equals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29763 27981 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29764 27981 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29765 27981 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29766 27981 : void *argp1 = 0 ;
29767 27981 : int res1 = 0 ;
29768 27981 : void *argp2 = 0 ;
29769 27981 : int res2 = 0 ;
29770 27981 : PyObject *swig_obj[2] ;
29771 27981 : bool result;
29772 :
29773 27981 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Equals", 2, 2, swig_obj)) SWIG_fail;
29774 27981 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29775 27981 : if (!SWIG_IsOK(res1)) {
29776 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Equals" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29777 : }
29778 27981 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29779 27981 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29780 27981 : if (!SWIG_IsOK(res2)) {
29781 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Equals" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29782 : }
29783 27981 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29784 27981 : {
29785 27981 : if (!arg2) {
29786 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29787 : }
29788 : }
29789 27981 : {
29790 27981 : const int bLocalUseExceptions = GetUseExceptions();
29791 27981 : if ( bLocalUseExceptions ) {
29792 14331 : pushErrorHandler();
29793 : }
29794 27981 : {
29795 27981 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29796 27981 : result = (bool)OGRGeometryShadow_Equals(arg1,arg2);
29797 27981 : SWIG_PYTHON_THREAD_END_ALLOW;
29798 : }
29799 27981 : if ( bLocalUseExceptions ) {
29800 14331 : popErrorHandler();
29801 : }
29802 : #ifndef SED_HACKS
29803 : if ( bLocalUseExceptions ) {
29804 : CPLErr eclass = CPLGetLastErrorType();
29805 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29806 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29807 : }
29808 : }
29809 : #endif
29810 : }
29811 27981 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29812 27981 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29813 : return resultobj;
29814 : fail:
29815 : return NULL;
29816 : }
29817 :
29818 :
29819 170 : SWIGINTERN PyObject *_wrap_Geometry_Equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29820 170 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29821 170 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29822 170 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29823 170 : void *argp1 = 0 ;
29824 170 : int res1 = 0 ;
29825 170 : void *argp2 = 0 ;
29826 170 : int res2 = 0 ;
29827 170 : PyObject *swig_obj[2] ;
29828 170 : bool result;
29829 :
29830 170 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Equal", 2, 2, swig_obj)) SWIG_fail;
29831 170 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29832 170 : if (!SWIG_IsOK(res1)) {
29833 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Equal" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29834 : }
29835 170 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29836 170 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29837 170 : if (!SWIG_IsOK(res2)) {
29838 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Equal" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29839 : }
29840 170 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29841 170 : {
29842 170 : if (!arg2) {
29843 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29844 : }
29845 : }
29846 170 : {
29847 170 : const int bLocalUseExceptions = GetUseExceptions();
29848 170 : if ( bLocalUseExceptions ) {
29849 0 : pushErrorHandler();
29850 : }
29851 170 : {
29852 170 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29853 170 : result = (bool)OGRGeometryShadow_Equal(arg1,arg2);
29854 170 : SWIG_PYTHON_THREAD_END_ALLOW;
29855 : }
29856 170 : if ( bLocalUseExceptions ) {
29857 0 : popErrorHandler();
29858 : }
29859 : #ifndef SED_HACKS
29860 : if ( bLocalUseExceptions ) {
29861 : CPLErr eclass = CPLGetLastErrorType();
29862 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29863 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29864 : }
29865 : }
29866 : #endif
29867 : }
29868 170 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29869 170 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29870 : return resultobj;
29871 : fail:
29872 : return NULL;
29873 : }
29874 :
29875 :
29876 6 : SWIGINTERN PyObject *_wrap_Geometry_Disjoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29877 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29878 6 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29879 6 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29880 6 : void *argp1 = 0 ;
29881 6 : int res1 = 0 ;
29882 6 : void *argp2 = 0 ;
29883 6 : int res2 = 0 ;
29884 6 : PyObject *swig_obj[2] ;
29885 6 : bool result;
29886 :
29887 6 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Disjoint", 2, 2, swig_obj)) SWIG_fail;
29888 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29889 6 : if (!SWIG_IsOK(res1)) {
29890 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Disjoint" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29891 : }
29892 6 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29893 6 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29894 6 : if (!SWIG_IsOK(res2)) {
29895 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Disjoint" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29896 : }
29897 6 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29898 6 : {
29899 6 : if (!arg2) {
29900 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29901 : }
29902 : }
29903 6 : {
29904 6 : const int bLocalUseExceptions = GetUseExceptions();
29905 6 : if ( bLocalUseExceptions ) {
29906 2 : pushErrorHandler();
29907 : }
29908 6 : {
29909 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29910 6 : result = (bool)OGRGeometryShadow_Disjoint(arg1,arg2);
29911 6 : SWIG_PYTHON_THREAD_END_ALLOW;
29912 : }
29913 6 : if ( bLocalUseExceptions ) {
29914 2 : popErrorHandler();
29915 : }
29916 : #ifndef SED_HACKS
29917 : if ( bLocalUseExceptions ) {
29918 : CPLErr eclass = CPLGetLastErrorType();
29919 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29920 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29921 : }
29922 : }
29923 : #endif
29924 : }
29925 6 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29926 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29927 : return resultobj;
29928 : fail:
29929 : return NULL;
29930 : }
29931 :
29932 :
29933 6 : SWIGINTERN PyObject *_wrap_Geometry_Touches(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29934 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29935 6 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29936 6 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29937 6 : void *argp1 = 0 ;
29938 6 : int res1 = 0 ;
29939 6 : void *argp2 = 0 ;
29940 6 : int res2 = 0 ;
29941 6 : PyObject *swig_obj[2] ;
29942 6 : bool result;
29943 :
29944 6 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Touches", 2, 2, swig_obj)) SWIG_fail;
29945 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29946 6 : if (!SWIG_IsOK(res1)) {
29947 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Touches" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29948 : }
29949 6 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29950 6 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29951 6 : if (!SWIG_IsOK(res2)) {
29952 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Touches" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29953 : }
29954 6 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29955 6 : {
29956 6 : if (!arg2) {
29957 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29958 : }
29959 : }
29960 6 : {
29961 6 : const int bLocalUseExceptions = GetUseExceptions();
29962 6 : if ( bLocalUseExceptions ) {
29963 2 : pushErrorHandler();
29964 : }
29965 6 : {
29966 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29967 6 : result = (bool)OGRGeometryShadow_Touches(arg1,arg2);
29968 6 : SWIG_PYTHON_THREAD_END_ALLOW;
29969 : }
29970 6 : if ( bLocalUseExceptions ) {
29971 2 : popErrorHandler();
29972 : }
29973 : #ifndef SED_HACKS
29974 : if ( bLocalUseExceptions ) {
29975 : CPLErr eclass = CPLGetLastErrorType();
29976 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29977 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29978 : }
29979 : }
29980 : #endif
29981 : }
29982 6 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29983 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29984 : return resultobj;
29985 : fail:
29986 : return NULL;
29987 : }
29988 :
29989 :
29990 6 : SWIGINTERN PyObject *_wrap_Geometry_Crosses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29991 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29992 6 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29993 6 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29994 6 : void *argp1 = 0 ;
29995 6 : int res1 = 0 ;
29996 6 : void *argp2 = 0 ;
29997 6 : int res2 = 0 ;
29998 6 : PyObject *swig_obj[2] ;
29999 6 : bool result;
30000 :
30001 6 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Crosses", 2, 2, swig_obj)) SWIG_fail;
30002 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30003 6 : if (!SWIG_IsOK(res1)) {
30004 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Crosses" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30005 : }
30006 6 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30007 6 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30008 6 : if (!SWIG_IsOK(res2)) {
30009 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Crosses" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
30010 : }
30011 6 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
30012 6 : {
30013 6 : if (!arg2) {
30014 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
30015 : }
30016 : }
30017 6 : {
30018 6 : const int bLocalUseExceptions = GetUseExceptions();
30019 6 : if ( bLocalUseExceptions ) {
30020 2 : pushErrorHandler();
30021 : }
30022 6 : {
30023 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30024 6 : result = (bool)OGRGeometryShadow_Crosses(arg1,arg2);
30025 6 : SWIG_PYTHON_THREAD_END_ALLOW;
30026 : }
30027 6 : if ( bLocalUseExceptions ) {
30028 2 : popErrorHandler();
30029 : }
30030 : #ifndef SED_HACKS
30031 : if ( bLocalUseExceptions ) {
30032 : CPLErr eclass = CPLGetLastErrorType();
30033 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30034 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30035 : }
30036 : }
30037 : #endif
30038 : }
30039 6 : resultobj = SWIG_From_bool(static_cast< bool >(result));
30040 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30041 : return resultobj;
30042 : fail:
30043 : return NULL;
30044 : }
30045 :
30046 :
30047 6196 : SWIGINTERN PyObject *_wrap_Geometry_Within(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30048 6196 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30049 6196 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30050 6196 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
30051 6196 : void *argp1 = 0 ;
30052 6196 : int res1 = 0 ;
30053 6196 : void *argp2 = 0 ;
30054 6196 : int res2 = 0 ;
30055 6196 : PyObject *swig_obj[2] ;
30056 6196 : bool result;
30057 :
30058 6196 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Within", 2, 2, swig_obj)) SWIG_fail;
30059 6196 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30060 6196 : if (!SWIG_IsOK(res1)) {
30061 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Within" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30062 : }
30063 6196 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30064 6196 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30065 6196 : if (!SWIG_IsOK(res2)) {
30066 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Within" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
30067 : }
30068 6196 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
30069 6196 : {
30070 6196 : if (!arg2) {
30071 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
30072 : }
30073 : }
30074 6196 : {
30075 6196 : const int bLocalUseExceptions = GetUseExceptions();
30076 6196 : if ( bLocalUseExceptions ) {
30077 7 : pushErrorHandler();
30078 : }
30079 6196 : {
30080 6196 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30081 6196 : result = (bool)OGRGeometryShadow_Within(arg1,arg2);
30082 6196 : SWIG_PYTHON_THREAD_END_ALLOW;
30083 : }
30084 6196 : if ( bLocalUseExceptions ) {
30085 7 : popErrorHandler();
30086 : }
30087 : #ifndef SED_HACKS
30088 : if ( bLocalUseExceptions ) {
30089 : CPLErr eclass = CPLGetLastErrorType();
30090 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30091 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30092 : }
30093 : }
30094 : #endif
30095 : }
30096 6196 : resultobj = SWIG_From_bool(static_cast< bool >(result));
30097 6196 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30098 : return resultobj;
30099 : fail:
30100 : return NULL;
30101 : }
30102 :
30103 :
30104 9 : SWIGINTERN PyObject *_wrap_Geometry_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30105 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30106 9 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30107 9 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
30108 9 : void *argp1 = 0 ;
30109 9 : int res1 = 0 ;
30110 9 : void *argp2 = 0 ;
30111 9 : int res2 = 0 ;
30112 9 : PyObject *swig_obj[2] ;
30113 9 : bool result;
30114 :
30115 9 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Contains", 2, 2, swig_obj)) SWIG_fail;
30116 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30117 9 : if (!SWIG_IsOK(res1)) {
30118 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Contains" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30119 : }
30120 9 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30121 9 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30122 9 : if (!SWIG_IsOK(res2)) {
30123 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Contains" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
30124 : }
30125 9 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
30126 9 : {
30127 9 : if (!arg2) {
30128 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
30129 : }
30130 : }
30131 9 : {
30132 9 : const int bLocalUseExceptions = GetUseExceptions();
30133 9 : if ( bLocalUseExceptions ) {
30134 2 : pushErrorHandler();
30135 : }
30136 9 : {
30137 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30138 9 : result = (bool)OGRGeometryShadow_Contains(arg1,arg2);
30139 9 : SWIG_PYTHON_THREAD_END_ALLOW;
30140 : }
30141 9 : if ( bLocalUseExceptions ) {
30142 2 : popErrorHandler();
30143 : }
30144 : #ifndef SED_HACKS
30145 : if ( bLocalUseExceptions ) {
30146 : CPLErr eclass = CPLGetLastErrorType();
30147 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30148 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30149 : }
30150 : }
30151 : #endif
30152 : }
30153 9 : resultobj = SWIG_From_bool(static_cast< bool >(result));
30154 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30155 : return resultobj;
30156 : fail:
30157 : return NULL;
30158 : }
30159 :
30160 :
30161 6 : SWIGINTERN PyObject *_wrap_Geometry_Overlaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30162 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30163 6 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30164 6 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
30165 6 : void *argp1 = 0 ;
30166 6 : int res1 = 0 ;
30167 6 : void *argp2 = 0 ;
30168 6 : int res2 = 0 ;
30169 6 : PyObject *swig_obj[2] ;
30170 6 : bool result;
30171 :
30172 6 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Overlaps", 2, 2, swig_obj)) SWIG_fail;
30173 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30174 6 : if (!SWIG_IsOK(res1)) {
30175 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Overlaps" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30176 : }
30177 6 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30178 6 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30179 6 : if (!SWIG_IsOK(res2)) {
30180 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Overlaps" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
30181 : }
30182 6 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
30183 6 : {
30184 6 : if (!arg2) {
30185 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
30186 : }
30187 : }
30188 6 : {
30189 6 : const int bLocalUseExceptions = GetUseExceptions();
30190 6 : if ( bLocalUseExceptions ) {
30191 2 : pushErrorHandler();
30192 : }
30193 6 : {
30194 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30195 6 : result = (bool)OGRGeometryShadow_Overlaps(arg1,arg2);
30196 6 : SWIG_PYTHON_THREAD_END_ALLOW;
30197 : }
30198 6 : if ( bLocalUseExceptions ) {
30199 2 : popErrorHandler();
30200 : }
30201 : #ifndef SED_HACKS
30202 : if ( bLocalUseExceptions ) {
30203 : CPLErr eclass = CPLGetLastErrorType();
30204 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30205 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30206 : }
30207 : }
30208 : #endif
30209 : }
30210 6 : resultobj = SWIG_From_bool(static_cast< bool >(result));
30211 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30212 : return resultobj;
30213 : fail:
30214 : return NULL;
30215 : }
30216 :
30217 :
30218 9 : SWIGINTERN PyObject *_wrap_Geometry_TransformTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30219 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30220 9 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30221 9 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
30222 9 : void *argp1 = 0 ;
30223 9 : int res1 = 0 ;
30224 9 : void *argp2 = 0 ;
30225 9 : int res2 = 0 ;
30226 9 : PyObject *swig_obj[2] ;
30227 9 : OGRErr result;
30228 :
30229 9 : if (!SWIG_Python_UnpackTuple(args, "Geometry_TransformTo", 2, 2, swig_obj)) SWIG_fail;
30230 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30231 9 : if (!SWIG_IsOK(res1)) {
30232 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_TransformTo" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30233 : }
30234 9 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30235 9 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
30236 9 : if (!SWIG_IsOK(res2)) {
30237 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_TransformTo" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
30238 : }
30239 9 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
30240 9 : {
30241 9 : if (!arg2) {
30242 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
30243 : }
30244 : }
30245 9 : {
30246 9 : const int bLocalUseExceptions = GetUseExceptions();
30247 9 : if ( bLocalUseExceptions ) {
30248 2 : pushErrorHandler();
30249 : }
30250 9 : {
30251 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30252 9 : result = (OGRErr)OGRGeometryShadow_TransformTo(arg1,arg2);
30253 9 : SWIG_PYTHON_THREAD_END_ALLOW;
30254 : }
30255 9 : if ( bLocalUseExceptions ) {
30256 2 : popErrorHandler();
30257 : }
30258 : #ifndef SED_HACKS
30259 : if ( bLocalUseExceptions ) {
30260 : CPLErr eclass = CPLGetLastErrorType();
30261 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30262 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30263 : }
30264 : }
30265 : #endif
30266 : }
30267 9 : {
30268 : /* %typemap(out) OGRErr */
30269 10 : if ( result != 0 && GetUseExceptions()) {
30270 0 : const char* pszMessage = CPLGetLastErrorMsg();
30271 0 : if( pszMessage[0] != '\0' )
30272 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
30273 : else
30274 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
30275 0 : SWIG_fail;
30276 : }
30277 : }
30278 9 : {
30279 : /* %typemap(ret) OGRErr */
30280 9 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
30281 9 : resultobj = PyInt_FromLong( result );
30282 : }
30283 : }
30284 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30285 : return resultobj;
30286 : fail:
30287 : return NULL;
30288 : }
30289 :
30290 :
30291 : SWIGINTERN PyObject *_wrap_Geometry_Transform__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
30292 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30293 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30294 : OSRCoordinateTransformationShadow *arg2 = (OSRCoordinateTransformationShadow *) 0 ;
30295 : void *argp1 = 0 ;
30296 : int res1 = 0 ;
30297 : void *argp2 = 0 ;
30298 : int res2 = 0 ;
30299 : OGRErr result;
30300 :
30301 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30302 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30303 : if (!SWIG_IsOK(res1)) {
30304 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Transform" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30305 : }
30306 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30307 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OSRCoordinateTransformationShadow, 0 | 0 );
30308 : if (!SWIG_IsOK(res2)) {
30309 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Transform" "', argument " "2"" of type '" "OSRCoordinateTransformationShadow *""'");
30310 : }
30311 : arg2 = reinterpret_cast< OSRCoordinateTransformationShadow * >(argp2);
30312 : {
30313 : if (!arg2) {
30314 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
30315 : }
30316 : }
30317 : {
30318 : const int bLocalUseExceptions = GetUseExceptions();
30319 : if ( bLocalUseExceptions ) {
30320 : pushErrorHandler();
30321 : }
30322 : {
30323 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30324 : result = (OGRErr)OGRGeometryShadow_Transform__SWIG_0(arg1,arg2);
30325 : SWIG_PYTHON_THREAD_END_ALLOW;
30326 : }
30327 : if ( bLocalUseExceptions ) {
30328 : popErrorHandler();
30329 : }
30330 : #ifndef SED_HACKS
30331 : if ( bLocalUseExceptions ) {
30332 : CPLErr eclass = CPLGetLastErrorType();
30333 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30334 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30335 : }
30336 : }
30337 : #endif
30338 : }
30339 : {
30340 : /* %typemap(out) OGRErr */
30341 : if ( result != 0 && GetUseExceptions()) {
30342 : const char* pszMessage = CPLGetLastErrorMsg();
30343 : if( pszMessage[0] != '\0' )
30344 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
30345 : else
30346 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
30347 : SWIG_fail;
30348 : }
30349 : }
30350 : {
30351 : /* %typemap(ret) OGRErr */
30352 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
30353 : resultobj = PyInt_FromLong( result );
30354 : }
30355 : }
30356 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30357 : return resultobj;
30358 : fail:
30359 : return NULL;
30360 : }
30361 :
30362 :
30363 48 : SWIGINTERN PyObject *_wrap_Geometry_GetSpatialReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30364 48 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30365 48 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30366 48 : void *argp1 = 0 ;
30367 48 : int res1 = 0 ;
30368 48 : PyObject *swig_obj[1] ;
30369 48 : OSRSpatialReferenceShadow *result = 0 ;
30370 :
30371 48 : if (!args) SWIG_fail;
30372 48 : swig_obj[0] = args;
30373 48 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30374 48 : if (!SWIG_IsOK(res1)) {
30375 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetSpatialReference" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30376 : }
30377 48 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30378 48 : {
30379 48 : const int bLocalUseExceptions = GetUseExceptions();
30380 48 : if ( bLocalUseExceptions ) {
30381 25 : pushErrorHandler();
30382 : }
30383 48 : {
30384 48 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30385 48 : result = (OSRSpatialReferenceShadow *)OGRGeometryShadow_GetSpatialReference(arg1);
30386 48 : SWIG_PYTHON_THREAD_END_ALLOW;
30387 : }
30388 48 : if ( bLocalUseExceptions ) {
30389 25 : popErrorHandler();
30390 : }
30391 : #ifndef SED_HACKS
30392 : if ( bLocalUseExceptions ) {
30393 : CPLErr eclass = CPLGetLastErrorType();
30394 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30395 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30396 : }
30397 : }
30398 : #endif
30399 : }
30400 48 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_OWN | 0 );
30401 48 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30402 : return resultobj;
30403 : fail:
30404 : return NULL;
30405 : }
30406 :
30407 :
30408 74 : SWIGINTERN PyObject *_wrap_Geometry_AssignSpatialReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30409 74 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30410 74 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30411 74 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
30412 74 : void *argp1 = 0 ;
30413 74 : int res1 = 0 ;
30414 74 : void *argp2 = 0 ;
30415 74 : int res2 = 0 ;
30416 74 : PyObject *swig_obj[2] ;
30417 :
30418 74 : if (!SWIG_Python_UnpackTuple(args, "Geometry_AssignSpatialReference", 2, 2, swig_obj)) SWIG_fail;
30419 74 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30420 74 : if (!SWIG_IsOK(res1)) {
30421 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_AssignSpatialReference" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30422 : }
30423 74 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30424 74 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
30425 74 : if (!SWIG_IsOK(res2)) {
30426 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_AssignSpatialReference" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
30427 : }
30428 74 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
30429 74 : {
30430 74 : const int bLocalUseExceptions = GetUseExceptions();
30431 74 : if ( bLocalUseExceptions ) {
30432 63 : pushErrorHandler();
30433 : }
30434 74 : {
30435 74 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30436 74 : OGRGeometryShadow_AssignSpatialReference(arg1,arg2);
30437 74 : SWIG_PYTHON_THREAD_END_ALLOW;
30438 : }
30439 74 : if ( bLocalUseExceptions ) {
30440 63 : popErrorHandler();
30441 : }
30442 : #ifndef SED_HACKS
30443 : if ( bLocalUseExceptions ) {
30444 : CPLErr eclass = CPLGetLastErrorType();
30445 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30446 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30447 : }
30448 : }
30449 : #endif
30450 : }
30451 74 : resultobj = SWIG_Py_Void();
30452 74 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30453 : return resultobj;
30454 : fail:
30455 : return NULL;
30456 : }
30457 :
30458 :
30459 6 : SWIGINTERN PyObject *_wrap_Geometry_CloseRings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30460 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30461 6 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30462 6 : void *argp1 = 0 ;
30463 6 : int res1 = 0 ;
30464 6 : PyObject *swig_obj[1] ;
30465 :
30466 6 : if (!args) SWIG_fail;
30467 6 : swig_obj[0] = args;
30468 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30469 6 : if (!SWIG_IsOK(res1)) {
30470 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_CloseRings" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30471 : }
30472 6 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30473 6 : {
30474 6 : const int bLocalUseExceptions = GetUseExceptions();
30475 6 : if ( bLocalUseExceptions ) {
30476 0 : pushErrorHandler();
30477 : }
30478 6 : {
30479 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30480 6 : OGRGeometryShadow_CloseRings(arg1);
30481 6 : SWIG_PYTHON_THREAD_END_ALLOW;
30482 : }
30483 6 : if ( bLocalUseExceptions ) {
30484 0 : popErrorHandler();
30485 : }
30486 : #ifndef SED_HACKS
30487 : if ( bLocalUseExceptions ) {
30488 : CPLErr eclass = CPLGetLastErrorType();
30489 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30490 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30491 : }
30492 : }
30493 : #endif
30494 : }
30495 6 : resultobj = SWIG_Py_Void();
30496 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30497 : return resultobj;
30498 : fail:
30499 : return NULL;
30500 : }
30501 :
30502 :
30503 31 : SWIGINTERN PyObject *_wrap_Geometry_FlattenTo2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30504 31 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30505 31 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30506 31 : void *argp1 = 0 ;
30507 31 : int res1 = 0 ;
30508 31 : PyObject *swig_obj[1] ;
30509 :
30510 31 : if (!args) SWIG_fail;
30511 31 : swig_obj[0] = args;
30512 31 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30513 31 : if (!SWIG_IsOK(res1)) {
30514 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_FlattenTo2D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30515 : }
30516 31 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30517 31 : {
30518 31 : const int bLocalUseExceptions = GetUseExceptions();
30519 31 : if ( bLocalUseExceptions ) {
30520 0 : pushErrorHandler();
30521 : }
30522 31 : {
30523 31 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30524 31 : OGRGeometryShadow_FlattenTo2D(arg1);
30525 31 : SWIG_PYTHON_THREAD_END_ALLOW;
30526 : }
30527 31 : if ( bLocalUseExceptions ) {
30528 0 : popErrorHandler();
30529 : }
30530 : #ifndef SED_HACKS
30531 : if ( bLocalUseExceptions ) {
30532 : CPLErr eclass = CPLGetLastErrorType();
30533 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30534 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30535 : }
30536 : }
30537 : #endif
30538 : }
30539 31 : resultobj = SWIG_Py_Void();
30540 31 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30541 : return resultobj;
30542 : fail:
30543 : return NULL;
30544 : }
30545 :
30546 :
30547 21 : SWIGINTERN PyObject *_wrap_Geometry_Segmentize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30548 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30549 21 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30550 21 : double arg2 ;
30551 21 : void *argp1 = 0 ;
30552 21 : int res1 = 0 ;
30553 21 : double val2 ;
30554 21 : int ecode2 = 0 ;
30555 21 : PyObject *swig_obj[2] ;
30556 :
30557 21 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Segmentize", 2, 2, swig_obj)) SWIG_fail;
30558 21 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30559 21 : if (!SWIG_IsOK(res1)) {
30560 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Segmentize" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30561 : }
30562 21 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30563 21 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
30564 21 : if (!SWIG_IsOK(ecode2)) {
30565 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_Segmentize" "', argument " "2"" of type '" "double""'");
30566 : }
30567 21 : arg2 = static_cast< double >(val2);
30568 21 : {
30569 21 : const int bLocalUseExceptions = GetUseExceptions();
30570 21 : if ( bLocalUseExceptions ) {
30571 0 : pushErrorHandler();
30572 : }
30573 21 : {
30574 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30575 21 : OGRGeometryShadow_Segmentize(arg1,arg2);
30576 21 : SWIG_PYTHON_THREAD_END_ALLOW;
30577 : }
30578 21 : if ( bLocalUseExceptions ) {
30579 0 : popErrorHandler();
30580 : }
30581 : #ifndef SED_HACKS
30582 : if ( bLocalUseExceptions ) {
30583 : CPLErr eclass = CPLGetLastErrorType();
30584 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30585 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30586 : }
30587 : }
30588 : #endif
30589 : }
30590 21 : resultobj = SWIG_Py_Void();
30591 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30592 : return resultobj;
30593 : fail:
30594 : return NULL;
30595 : }
30596 :
30597 :
30598 13140 : SWIGINTERN PyObject *_wrap_Geometry_GetEnvelope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30599 13140 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30600 13140 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30601 13140 : double *arg2 ;
30602 13140 : void *argp1 = 0 ;
30603 13140 : int res1 = 0 ;
30604 13140 : double argout2[4] ;
30605 13140 : PyObject *swig_obj[1] ;
30606 :
30607 13140 : {
30608 : /* %typemap(in,numinputs=0) (double argout2[ANY]) */
30609 13140 : memset(argout2, 0, sizeof(argout2));
30610 13140 : arg2 = argout2;
30611 : }
30612 13140 : if (!args) SWIG_fail;
30613 13140 : swig_obj[0] = args;
30614 13140 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30615 13140 : if (!SWIG_IsOK(res1)) {
30616 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetEnvelope" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30617 : }
30618 13140 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30619 13140 : {
30620 13140 : const int bLocalUseExceptions = GetUseExceptions();
30621 13140 : if ( bLocalUseExceptions ) {
30622 13085 : pushErrorHandler();
30623 : }
30624 13140 : {
30625 13140 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30626 13140 : OGRGeometryShadow_GetEnvelope(arg1,arg2);
30627 13140 : SWIG_PYTHON_THREAD_END_ALLOW;
30628 : }
30629 13140 : if ( bLocalUseExceptions ) {
30630 13085 : popErrorHandler();
30631 : }
30632 : #ifndef SED_HACKS
30633 : if ( bLocalUseExceptions ) {
30634 : CPLErr eclass = CPLGetLastErrorType();
30635 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30636 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30637 : }
30638 : }
30639 : #endif
30640 : }
30641 13140 : resultobj = SWIG_Py_Void();
30642 13140 : {
30643 : /* %typemap(argout) (double argout[ANY]) */
30644 13140 : PyObject *out = CreateTupleFromDoubleArray( arg2, 4 );
30645 : #if SWIG_VERSION >= 0x040300
30646 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
30647 : #else
30648 13140 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
30649 : #endif
30650 : }
30651 13140 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30652 : return resultobj;
30653 : fail:
30654 : return NULL;
30655 : }
30656 :
30657 :
30658 10 : SWIGINTERN PyObject *_wrap_Geometry_GetEnvelope3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30659 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30660 10 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30661 10 : double *arg2 ;
30662 10 : void *argp1 = 0 ;
30663 10 : int res1 = 0 ;
30664 10 : double argout2[6] ;
30665 10 : PyObject *swig_obj[1] ;
30666 :
30667 10 : {
30668 : /* %typemap(in,numinputs=0) (double argout2[ANY]) */
30669 10 : memset(argout2, 0, sizeof(argout2));
30670 10 : arg2 = argout2;
30671 : }
30672 10 : if (!args) SWIG_fail;
30673 10 : swig_obj[0] = args;
30674 10 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30675 10 : if (!SWIG_IsOK(res1)) {
30676 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetEnvelope3D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30677 : }
30678 10 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30679 10 : {
30680 10 : const int bLocalUseExceptions = GetUseExceptions();
30681 10 : if ( bLocalUseExceptions ) {
30682 0 : pushErrorHandler();
30683 : }
30684 10 : {
30685 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30686 10 : OGRGeometryShadow_GetEnvelope3D(arg1,arg2);
30687 10 : SWIG_PYTHON_THREAD_END_ALLOW;
30688 : }
30689 10 : if ( bLocalUseExceptions ) {
30690 0 : popErrorHandler();
30691 : }
30692 : #ifndef SED_HACKS
30693 : if ( bLocalUseExceptions ) {
30694 : CPLErr eclass = CPLGetLastErrorType();
30695 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30696 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30697 : }
30698 : }
30699 : #endif
30700 : }
30701 10 : resultobj = SWIG_Py_Void();
30702 10 : {
30703 : /* %typemap(argout) (double argout[ANY]) */
30704 10 : PyObject *out = CreateTupleFromDoubleArray( arg2, 6 );
30705 : #if SWIG_VERSION >= 0x040300
30706 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
30707 : #else
30708 10 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
30709 : #endif
30710 : }
30711 10 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30712 : return resultobj;
30713 : fail:
30714 : return NULL;
30715 : }
30716 :
30717 :
30718 5 : SWIGINTERN PyObject *_wrap_Geometry_Centroid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30719 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30720 5 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30721 5 : void *argp1 = 0 ;
30722 5 : int res1 = 0 ;
30723 5 : PyObject *swig_obj[1] ;
30724 5 : OGRGeometryShadow *result = 0 ;
30725 :
30726 5 : if (!args) SWIG_fail;
30727 5 : swig_obj[0] = args;
30728 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30729 5 : if (!SWIG_IsOK(res1)) {
30730 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Centroid" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30731 : }
30732 5 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30733 5 : {
30734 5 : const int bLocalUseExceptions = GetUseExceptions();
30735 5 : if ( bLocalUseExceptions ) {
30736 5 : pushErrorHandler();
30737 : }
30738 5 : {
30739 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30740 5 : result = (OGRGeometryShadow *)OGRGeometryShadow_Centroid(arg1);
30741 5 : SWIG_PYTHON_THREAD_END_ALLOW;
30742 : }
30743 5 : if ( bLocalUseExceptions ) {
30744 5 : popErrorHandler();
30745 : }
30746 : #ifndef SED_HACKS
30747 : if ( bLocalUseExceptions ) {
30748 : CPLErr eclass = CPLGetLastErrorType();
30749 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30750 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30751 : }
30752 : }
30753 : #endif
30754 : }
30755 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
30756 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30757 : return resultobj;
30758 : fail:
30759 : return NULL;
30760 : }
30761 :
30762 :
30763 4 : SWIGINTERN PyObject *_wrap_Geometry_PointOnSurface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30764 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30765 4 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30766 4 : void *argp1 = 0 ;
30767 4 : int res1 = 0 ;
30768 4 : PyObject *swig_obj[1] ;
30769 4 : OGRGeometryShadow *result = 0 ;
30770 :
30771 4 : if (!args) SWIG_fail;
30772 4 : swig_obj[0] = args;
30773 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30774 4 : if (!SWIG_IsOK(res1)) {
30775 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_PointOnSurface" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30776 : }
30777 4 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30778 4 : {
30779 4 : const int bLocalUseExceptions = GetUseExceptions();
30780 4 : if ( bLocalUseExceptions ) {
30781 1 : pushErrorHandler();
30782 : }
30783 4 : {
30784 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30785 4 : result = (OGRGeometryShadow *)OGRGeometryShadow_PointOnSurface(arg1);
30786 4 : SWIG_PYTHON_THREAD_END_ALLOW;
30787 : }
30788 4 : if ( bLocalUseExceptions ) {
30789 1 : popErrorHandler();
30790 : }
30791 : #ifndef SED_HACKS
30792 : if ( bLocalUseExceptions ) {
30793 : CPLErr eclass = CPLGetLastErrorType();
30794 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30795 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30796 : }
30797 : }
30798 : #endif
30799 : }
30800 4 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
30801 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30802 : return resultobj;
30803 : fail:
30804 : return NULL;
30805 : }
30806 :
30807 :
30808 2 : SWIGINTERN PyObject *_wrap_Geometry_WkbSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30809 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30810 2 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30811 2 : void *argp1 = 0 ;
30812 2 : int res1 = 0 ;
30813 2 : PyObject *swig_obj[1] ;
30814 2 : size_t result;
30815 :
30816 2 : if (!args) SWIG_fail;
30817 2 : swig_obj[0] = args;
30818 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30819 2 : if (!SWIG_IsOK(res1)) {
30820 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_WkbSize" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30821 : }
30822 2 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30823 2 : {
30824 2 : const int bLocalUseExceptions = GetUseExceptions();
30825 2 : if ( bLocalUseExceptions ) {
30826 0 : pushErrorHandler();
30827 : }
30828 2 : {
30829 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30830 2 : result = OGRGeometryShadow_WkbSize(arg1);
30831 2 : SWIG_PYTHON_THREAD_END_ALLOW;
30832 : }
30833 2 : if ( bLocalUseExceptions ) {
30834 0 : popErrorHandler();
30835 : }
30836 : #ifndef SED_HACKS
30837 : if ( bLocalUseExceptions ) {
30838 : CPLErr eclass = CPLGetLastErrorType();
30839 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30840 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30841 : }
30842 : }
30843 : #endif
30844 : }
30845 2 : resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30846 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30847 : return resultobj;
30848 : fail:
30849 : return NULL;
30850 : }
30851 :
30852 :
30853 77 : SWIGINTERN PyObject *_wrap_Geometry_GetCoordinateDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30854 77 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30855 77 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30856 77 : void *argp1 = 0 ;
30857 77 : int res1 = 0 ;
30858 77 : PyObject *swig_obj[1] ;
30859 77 : int result;
30860 :
30861 77 : if (!args) SWIG_fail;
30862 77 : swig_obj[0] = args;
30863 77 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30864 77 : if (!SWIG_IsOK(res1)) {
30865 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetCoordinateDimension" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30866 : }
30867 77 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30868 77 : {
30869 77 : const int bLocalUseExceptions = GetUseExceptions();
30870 77 : if ( bLocalUseExceptions ) {
30871 15 : pushErrorHandler();
30872 : }
30873 77 : {
30874 77 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30875 77 : result = (int)OGRGeometryShadow_GetCoordinateDimension(arg1);
30876 77 : SWIG_PYTHON_THREAD_END_ALLOW;
30877 : }
30878 77 : if ( bLocalUseExceptions ) {
30879 15 : popErrorHandler();
30880 : }
30881 : #ifndef SED_HACKS
30882 : if ( bLocalUseExceptions ) {
30883 : CPLErr eclass = CPLGetLastErrorType();
30884 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30885 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30886 : }
30887 : }
30888 : #endif
30889 : }
30890 77 : resultobj = SWIG_From_int(static_cast< int >(result));
30891 77 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30892 : return resultobj;
30893 : fail:
30894 : return NULL;
30895 : }
30896 :
30897 :
30898 4 : SWIGINTERN PyObject *_wrap_Geometry_CoordinateDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30899 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30900 4 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30901 4 : void *argp1 = 0 ;
30902 4 : int res1 = 0 ;
30903 4 : PyObject *swig_obj[1] ;
30904 4 : int result;
30905 :
30906 4 : if (!args) SWIG_fail;
30907 4 : swig_obj[0] = args;
30908 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30909 4 : if (!SWIG_IsOK(res1)) {
30910 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_CoordinateDimension" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30911 : }
30912 4 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30913 4 : {
30914 4 : const int bLocalUseExceptions = GetUseExceptions();
30915 4 : if ( bLocalUseExceptions ) {
30916 0 : pushErrorHandler();
30917 : }
30918 4 : {
30919 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30920 4 : result = (int)OGRGeometryShadow_CoordinateDimension(arg1);
30921 4 : SWIG_PYTHON_THREAD_END_ALLOW;
30922 : }
30923 4 : if ( bLocalUseExceptions ) {
30924 0 : popErrorHandler();
30925 : }
30926 : #ifndef SED_HACKS
30927 : if ( bLocalUseExceptions ) {
30928 : CPLErr eclass = CPLGetLastErrorType();
30929 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30930 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30931 : }
30932 : }
30933 : #endif
30934 : }
30935 4 : resultobj = SWIG_From_int(static_cast< int >(result));
30936 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30937 : return resultobj;
30938 : fail:
30939 : return NULL;
30940 : }
30941 :
30942 :
30943 34403 : SWIGINTERN PyObject *_wrap_Geometry_Is3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30944 34403 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30945 34403 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30946 34403 : void *argp1 = 0 ;
30947 34403 : int res1 = 0 ;
30948 34403 : PyObject *swig_obj[1] ;
30949 34403 : int result;
30950 :
30951 34403 : if (!args) SWIG_fail;
30952 34403 : swig_obj[0] = args;
30953 34403 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30954 34403 : if (!SWIG_IsOK(res1)) {
30955 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Is3D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30956 : }
30957 34403 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30958 34403 : {
30959 34403 : const int bLocalUseExceptions = GetUseExceptions();
30960 34403 : if ( bLocalUseExceptions ) {
30961 0 : pushErrorHandler();
30962 : }
30963 34403 : {
30964 34403 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30965 34403 : result = (int)OGRGeometryShadow_Is3D(arg1);
30966 34403 : SWIG_PYTHON_THREAD_END_ALLOW;
30967 : }
30968 34403 : if ( bLocalUseExceptions ) {
30969 0 : popErrorHandler();
30970 : }
30971 : #ifndef SED_HACKS
30972 : if ( bLocalUseExceptions ) {
30973 : CPLErr eclass = CPLGetLastErrorType();
30974 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30975 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30976 : }
30977 : }
30978 : #endif
30979 : }
30980 34403 : resultobj = SWIG_From_int(static_cast< int >(result));
30981 34403 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30982 : return resultobj;
30983 : fail:
30984 : return NULL;
30985 : }
30986 :
30987 :
30988 37494 : SWIGINTERN PyObject *_wrap_Geometry_IsMeasured(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30989 37494 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30990 37494 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30991 37494 : void *argp1 = 0 ;
30992 37494 : int res1 = 0 ;
30993 37494 : PyObject *swig_obj[1] ;
30994 37494 : int result;
30995 :
30996 37494 : if (!args) SWIG_fail;
30997 37494 : swig_obj[0] = args;
30998 37494 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30999 37494 : if (!SWIG_IsOK(res1)) {
31000 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_IsMeasured" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31001 : }
31002 37494 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31003 37494 : {
31004 37494 : const int bLocalUseExceptions = GetUseExceptions();
31005 37494 : if ( bLocalUseExceptions ) {
31006 0 : pushErrorHandler();
31007 : }
31008 37494 : {
31009 37494 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31010 37494 : result = (int)OGRGeometryShadow_IsMeasured(arg1);
31011 37494 : SWIG_PYTHON_THREAD_END_ALLOW;
31012 : }
31013 37494 : if ( bLocalUseExceptions ) {
31014 0 : popErrorHandler();
31015 : }
31016 : #ifndef SED_HACKS
31017 : if ( bLocalUseExceptions ) {
31018 : CPLErr eclass = CPLGetLastErrorType();
31019 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31020 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31021 : }
31022 : }
31023 : #endif
31024 : }
31025 37494 : resultobj = SWIG_From_int(static_cast< int >(result));
31026 37494 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31027 : return resultobj;
31028 : fail:
31029 : return NULL;
31030 : }
31031 :
31032 :
31033 56 : SWIGINTERN PyObject *_wrap_Geometry_SetCoordinateDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31034 56 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31035 56 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31036 56 : int arg2 ;
31037 56 : void *argp1 = 0 ;
31038 56 : int res1 = 0 ;
31039 56 : int val2 ;
31040 56 : int ecode2 = 0 ;
31041 56 : PyObject *swig_obj[2] ;
31042 :
31043 56 : if (!SWIG_Python_UnpackTuple(args, "Geometry_SetCoordinateDimension", 2, 2, swig_obj)) SWIG_fail;
31044 56 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31045 56 : if (!SWIG_IsOK(res1)) {
31046 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SetCoordinateDimension" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31047 : }
31048 56 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31049 56 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31050 56 : if (!SWIG_IsOK(ecode2)) {
31051 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SetCoordinateDimension" "', argument " "2"" of type '" "int""'");
31052 : }
31053 56 : arg2 = static_cast< int >(val2);
31054 56 : {
31055 56 : const int bLocalUseExceptions = GetUseExceptions();
31056 56 : if ( bLocalUseExceptions ) {
31057 0 : pushErrorHandler();
31058 : }
31059 56 : {
31060 56 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31061 56 : OGRGeometryShadow_SetCoordinateDimension(arg1,arg2);
31062 56 : SWIG_PYTHON_THREAD_END_ALLOW;
31063 : }
31064 56 : if ( bLocalUseExceptions ) {
31065 0 : popErrorHandler();
31066 : }
31067 : #ifndef SED_HACKS
31068 : if ( bLocalUseExceptions ) {
31069 : CPLErr eclass = CPLGetLastErrorType();
31070 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31071 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31072 : }
31073 : }
31074 : #endif
31075 : }
31076 56 : resultobj = SWIG_Py_Void();
31077 56 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31078 : return resultobj;
31079 : fail:
31080 : return NULL;
31081 : }
31082 :
31083 :
31084 154 : SWIGINTERN PyObject *_wrap_Geometry_Set3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31085 154 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31086 154 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31087 154 : int arg2 ;
31088 154 : void *argp1 = 0 ;
31089 154 : int res1 = 0 ;
31090 154 : int val2 ;
31091 154 : int ecode2 = 0 ;
31092 154 : PyObject *swig_obj[2] ;
31093 :
31094 154 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Set3D", 2, 2, swig_obj)) SWIG_fail;
31095 154 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31096 154 : if (!SWIG_IsOK(res1)) {
31097 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Set3D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31098 : }
31099 154 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31100 154 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31101 154 : if (!SWIG_IsOK(ecode2)) {
31102 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_Set3D" "', argument " "2"" of type '" "int""'");
31103 : }
31104 154 : arg2 = static_cast< int >(val2);
31105 154 : {
31106 154 : const int bLocalUseExceptions = GetUseExceptions();
31107 154 : if ( bLocalUseExceptions ) {
31108 42 : pushErrorHandler();
31109 : }
31110 154 : {
31111 154 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31112 154 : OGRGeometryShadow_Set3D(arg1,arg2);
31113 154 : SWIG_PYTHON_THREAD_END_ALLOW;
31114 : }
31115 154 : if ( bLocalUseExceptions ) {
31116 42 : popErrorHandler();
31117 : }
31118 : #ifndef SED_HACKS
31119 : if ( bLocalUseExceptions ) {
31120 : CPLErr eclass = CPLGetLastErrorType();
31121 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31122 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31123 : }
31124 : }
31125 : #endif
31126 : }
31127 154 : resultobj = SWIG_Py_Void();
31128 154 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31129 : return resultobj;
31130 : fail:
31131 : return NULL;
31132 : }
31133 :
31134 :
31135 154 : SWIGINTERN PyObject *_wrap_Geometry_SetMeasured(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31136 154 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31137 154 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31138 154 : int arg2 ;
31139 154 : void *argp1 = 0 ;
31140 154 : int res1 = 0 ;
31141 154 : int val2 ;
31142 154 : int ecode2 = 0 ;
31143 154 : PyObject *swig_obj[2] ;
31144 :
31145 154 : if (!SWIG_Python_UnpackTuple(args, "Geometry_SetMeasured", 2, 2, swig_obj)) SWIG_fail;
31146 154 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31147 154 : if (!SWIG_IsOK(res1)) {
31148 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SetMeasured" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31149 : }
31150 154 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31151 154 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31152 154 : if (!SWIG_IsOK(ecode2)) {
31153 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SetMeasured" "', argument " "2"" of type '" "int""'");
31154 : }
31155 154 : arg2 = static_cast< int >(val2);
31156 154 : {
31157 154 : const int bLocalUseExceptions = GetUseExceptions();
31158 154 : if ( bLocalUseExceptions ) {
31159 42 : pushErrorHandler();
31160 : }
31161 154 : {
31162 154 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31163 154 : OGRGeometryShadow_SetMeasured(arg1,arg2);
31164 154 : SWIG_PYTHON_THREAD_END_ALLOW;
31165 : }
31166 154 : if ( bLocalUseExceptions ) {
31167 42 : popErrorHandler();
31168 : }
31169 : #ifndef SED_HACKS
31170 : if ( bLocalUseExceptions ) {
31171 : CPLErr eclass = CPLGetLastErrorType();
31172 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31173 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31174 : }
31175 : }
31176 : #endif
31177 : }
31178 154 : resultobj = SWIG_Py_Void();
31179 154 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31180 : return resultobj;
31181 : fail:
31182 : return NULL;
31183 : }
31184 :
31185 :
31186 21 : SWIGINTERN PyObject *_wrap_Geometry_GetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31187 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31188 21 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31189 21 : void *argp1 = 0 ;
31190 21 : int res1 = 0 ;
31191 21 : PyObject *swig_obj[1] ;
31192 21 : int result;
31193 :
31194 21 : if (!args) SWIG_fail;
31195 21 : swig_obj[0] = args;
31196 21 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31197 21 : if (!SWIG_IsOK(res1)) {
31198 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetDimension" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31199 : }
31200 21 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31201 21 : {
31202 21 : const int bLocalUseExceptions = GetUseExceptions();
31203 21 : if ( bLocalUseExceptions ) {
31204 0 : pushErrorHandler();
31205 : }
31206 21 : {
31207 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31208 21 : result = (int)OGRGeometryShadow_GetDimension(arg1);
31209 21 : SWIG_PYTHON_THREAD_END_ALLOW;
31210 : }
31211 21 : if ( bLocalUseExceptions ) {
31212 0 : popErrorHandler();
31213 : }
31214 : #ifndef SED_HACKS
31215 : if ( bLocalUseExceptions ) {
31216 : CPLErr eclass = CPLGetLastErrorType();
31217 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31218 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31219 : }
31220 : }
31221 : #endif
31222 : }
31223 21 : resultobj = SWIG_From_int(static_cast< int >(result));
31224 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31225 : return resultobj;
31226 : fail:
31227 : return NULL;
31228 : }
31229 :
31230 :
31231 29 : SWIGINTERN PyObject *_wrap_Geometry_HasCurveGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31232 29 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31233 29 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31234 29 : int arg2 = (int) FALSE ;
31235 29 : void *argp1 = 0 ;
31236 29 : int res1 = 0 ;
31237 29 : int val2 ;
31238 29 : int ecode2 = 0 ;
31239 29 : PyObject *swig_obj[2] ;
31240 29 : int result;
31241 :
31242 29 : if (!SWIG_Python_UnpackTuple(args, "Geometry_HasCurveGeometry", 1, 2, swig_obj)) SWIG_fail;
31243 29 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31244 29 : if (!SWIG_IsOK(res1)) {
31245 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_HasCurveGeometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31246 : }
31247 29 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31248 29 : if (swig_obj[1]) {
31249 12 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31250 12 : if (!SWIG_IsOK(ecode2)) {
31251 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_HasCurveGeometry" "', argument " "2"" of type '" "int""'");
31252 : }
31253 : arg2 = static_cast< int >(val2);
31254 : }
31255 29 : {
31256 29 : const int bLocalUseExceptions = GetUseExceptions();
31257 29 : if ( bLocalUseExceptions ) {
31258 0 : pushErrorHandler();
31259 : }
31260 29 : {
31261 29 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31262 29 : result = (int)OGRGeometryShadow_HasCurveGeometry(arg1,arg2);
31263 29 : SWIG_PYTHON_THREAD_END_ALLOW;
31264 : }
31265 29 : if ( bLocalUseExceptions ) {
31266 0 : popErrorHandler();
31267 : }
31268 : #ifndef SED_HACKS
31269 : if ( bLocalUseExceptions ) {
31270 : CPLErr eclass = CPLGetLastErrorType();
31271 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31272 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31273 : }
31274 : }
31275 : #endif
31276 : }
31277 29 : resultobj = SWIG_From_int(static_cast< int >(result));
31278 29 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31279 : return resultobj;
31280 : fail:
31281 : return NULL;
31282 : }
31283 :
31284 :
31285 3086 : SWIGINTERN PyObject *_wrap_Geometry_GetLinearGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31286 3086 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31287 3086 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31288 3086 : double arg2 = (double) 0.0 ;
31289 3086 : char **arg3 = (char **) NULL ;
31290 3086 : void *argp1 = 0 ;
31291 3086 : int res1 = 0 ;
31292 3086 : double val2 ;
31293 3086 : int ecode2 = 0 ;
31294 3086 : PyObject * obj0 = 0 ;
31295 3086 : PyObject * obj1 = 0 ;
31296 3086 : PyObject * obj2 = 0 ;
31297 3086 : char * kwnames[] = {
31298 : (char *)"self", (char *)"dfMaxAngleStepSizeDegrees", (char *)"options", NULL
31299 : };
31300 3086 : OGRGeometryShadow *result = 0 ;
31301 :
31302 3086 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:Geometry_GetLinearGeometry", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
31303 3086 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31304 3086 : if (!SWIG_IsOK(res1)) {
31305 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetLinearGeometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31306 : }
31307 3086 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31308 3086 : if (obj1) {
31309 17 : ecode2 = SWIG_AsVal_double(obj1, &val2);
31310 17 : if (!SWIG_IsOK(ecode2)) {
31311 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetLinearGeometry" "', argument " "2"" of type '" "double""'");
31312 : }
31313 17 : arg2 = static_cast< double >(val2);
31314 : }
31315 3086 : if (obj2) {
31316 4 : {
31317 : /* %typemap(in) char **dict */
31318 4 : arg3 = NULL;
31319 4 : if ( PySequence_Check( obj2 ) ) {
31320 4 : int bErr = FALSE;
31321 4 : arg3 = CSLFromPySequence(obj2, &bErr);
31322 4 : if ( bErr )
31323 : {
31324 0 : SWIG_fail;
31325 : }
31326 : }
31327 0 : else if ( PyMapping_Check( obj2 ) ) {
31328 0 : int bErr = FALSE;
31329 0 : arg3 = CSLFromPyMapping(obj2, &bErr);
31330 0 : if ( bErr )
31331 : {
31332 0 : SWIG_fail;
31333 : }
31334 : }
31335 : else {
31336 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
31337 0 : SWIG_fail;
31338 : }
31339 : }
31340 : }
31341 3086 : {
31342 3086 : const int bLocalUseExceptions = GetUseExceptions();
31343 3086 : if ( bLocalUseExceptions ) {
31344 0 : pushErrorHandler();
31345 : }
31346 3086 : {
31347 3086 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31348 3086 : result = (OGRGeometryShadow *)OGRGeometryShadow_GetLinearGeometry(arg1,arg2,arg3);
31349 3086 : SWIG_PYTHON_THREAD_END_ALLOW;
31350 : }
31351 3086 : if ( bLocalUseExceptions ) {
31352 0 : popErrorHandler();
31353 : }
31354 : #ifndef SED_HACKS
31355 : if ( bLocalUseExceptions ) {
31356 : CPLErr eclass = CPLGetLastErrorType();
31357 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31358 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31359 : }
31360 : }
31361 : #endif
31362 : }
31363 3086 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
31364 3086 : {
31365 : /* %typemap(freearg) char **dict */
31366 3086 : CSLDestroy( arg3 );
31367 : }
31368 3086 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31369 : return resultobj;
31370 0 : fail:
31371 0 : {
31372 : /* %typemap(freearg) char **dict */
31373 0 : CSLDestroy( arg3 );
31374 : }
31375 : return NULL;
31376 : }
31377 :
31378 :
31379 3067 : SWIGINTERN PyObject *_wrap_Geometry_GetCurveGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31380 3067 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31381 3067 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31382 3067 : char **arg2 = (char **) NULL ;
31383 3067 : void *argp1 = 0 ;
31384 3067 : int res1 = 0 ;
31385 3067 : PyObject * obj0 = 0 ;
31386 3067 : PyObject * obj1 = 0 ;
31387 3067 : char * kwnames[] = {
31388 : (char *)"self", (char *)"options", NULL
31389 : };
31390 3067 : OGRGeometryShadow *result = 0 ;
31391 :
31392 3067 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_GetCurveGeometry", kwnames, &obj0, &obj1)) SWIG_fail;
31393 3067 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31394 3067 : if (!SWIG_IsOK(res1)) {
31395 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetCurveGeometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31396 : }
31397 3067 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31398 3067 : if (obj1) {
31399 0 : {
31400 : /* %typemap(in) char **dict */
31401 0 : arg2 = NULL;
31402 0 : if ( PySequence_Check( obj1 ) ) {
31403 0 : int bErr = FALSE;
31404 0 : arg2 = CSLFromPySequence(obj1, &bErr);
31405 0 : if ( bErr )
31406 : {
31407 0 : SWIG_fail;
31408 : }
31409 : }
31410 0 : else if ( PyMapping_Check( obj1 ) ) {
31411 0 : int bErr = FALSE;
31412 0 : arg2 = CSLFromPyMapping(obj1, &bErr);
31413 0 : if ( bErr )
31414 : {
31415 0 : SWIG_fail;
31416 : }
31417 : }
31418 : else {
31419 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
31420 0 : SWIG_fail;
31421 : }
31422 : }
31423 : }
31424 3067 : {
31425 3067 : const int bLocalUseExceptions = GetUseExceptions();
31426 3067 : if ( bLocalUseExceptions ) {
31427 0 : pushErrorHandler();
31428 : }
31429 3067 : {
31430 3067 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31431 3067 : result = (OGRGeometryShadow *)OGRGeometryShadow_GetCurveGeometry(arg1,arg2);
31432 3067 : SWIG_PYTHON_THREAD_END_ALLOW;
31433 : }
31434 3067 : if ( bLocalUseExceptions ) {
31435 0 : popErrorHandler();
31436 : }
31437 : #ifndef SED_HACKS
31438 : if ( bLocalUseExceptions ) {
31439 : CPLErr eclass = CPLGetLastErrorType();
31440 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31441 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31442 : }
31443 : }
31444 : #endif
31445 : }
31446 3067 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
31447 3067 : {
31448 : /* %typemap(freearg) char **dict */
31449 3067 : CSLDestroy( arg2 );
31450 : }
31451 3067 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31452 : return resultobj;
31453 0 : fail:
31454 0 : {
31455 : /* %typemap(freearg) char **dict */
31456 0 : CSLDestroy( arg2 );
31457 : }
31458 : return NULL;
31459 : }
31460 :
31461 :
31462 22 : SWIGINTERN PyObject *_wrap_Geometry_Value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31463 22 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31464 22 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31465 22 : double arg2 ;
31466 22 : void *argp1 = 0 ;
31467 22 : int res1 = 0 ;
31468 22 : double val2 ;
31469 22 : int ecode2 = 0 ;
31470 22 : PyObject *swig_obj[2] ;
31471 22 : OGRGeometryShadow *result = 0 ;
31472 :
31473 22 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Value", 2, 2, swig_obj)) SWIG_fail;
31474 22 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31475 22 : if (!SWIG_IsOK(res1)) {
31476 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Value" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31477 : }
31478 22 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31479 22 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
31480 22 : if (!SWIG_IsOK(ecode2)) {
31481 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_Value" "', argument " "2"" of type '" "double""'");
31482 : }
31483 22 : arg2 = static_cast< double >(val2);
31484 22 : {
31485 22 : const int bLocalUseExceptions = GetUseExceptions();
31486 22 : if ( bLocalUseExceptions ) {
31487 0 : pushErrorHandler();
31488 : }
31489 22 : {
31490 22 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31491 22 : result = (OGRGeometryShadow *)OGRGeometryShadow_Value(arg1,arg2);
31492 22 : SWIG_PYTHON_THREAD_END_ALLOW;
31493 : }
31494 22 : if ( bLocalUseExceptions ) {
31495 0 : popErrorHandler();
31496 : }
31497 : #ifndef SED_HACKS
31498 : if ( bLocalUseExceptions ) {
31499 : CPLErr eclass = CPLGetLastErrorType();
31500 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31501 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31502 : }
31503 : }
31504 : #endif
31505 : }
31506 22 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
31507 22 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31508 : return resultobj;
31509 : fail:
31510 : return NULL;
31511 : }
31512 :
31513 :
31514 : SWIGINTERN PyObject *_wrap_Geometry_Transform__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
31515 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31516 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31517 : OGRGeomTransformerShadow *arg2 = (OGRGeomTransformerShadow *) 0 ;
31518 : void *argp1 = 0 ;
31519 : int res1 = 0 ;
31520 : void *argp2 = 0 ;
31521 : int res2 = 0 ;
31522 : OGRGeometryShadow *result = 0 ;
31523 :
31524 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31525 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31526 : if (!SWIG_IsOK(res1)) {
31527 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Transform" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31528 : }
31529 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31530 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeomTransformerShadow, 0 | 0 );
31531 : if (!SWIG_IsOK(res2)) {
31532 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Transform" "', argument " "2"" of type '" "OGRGeomTransformerShadow *""'");
31533 : }
31534 : arg2 = reinterpret_cast< OGRGeomTransformerShadow * >(argp2);
31535 : {
31536 : if (!arg2) {
31537 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
31538 : }
31539 : }
31540 : {
31541 : const int bLocalUseExceptions = GetUseExceptions();
31542 : if ( bLocalUseExceptions ) {
31543 : pushErrorHandler();
31544 : }
31545 : {
31546 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31547 : result = (OGRGeometryShadow *)OGRGeometryShadow_Transform__SWIG_1(arg1,arg2);
31548 : SWIG_PYTHON_THREAD_END_ALLOW;
31549 : }
31550 : if ( bLocalUseExceptions ) {
31551 : popErrorHandler();
31552 : }
31553 : #ifndef SED_HACKS
31554 : if ( bLocalUseExceptions ) {
31555 : CPLErr eclass = CPLGetLastErrorType();
31556 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31557 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31558 : }
31559 : }
31560 : #endif
31561 : }
31562 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
31563 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31564 : return resultobj;
31565 : fail:
31566 : return NULL;
31567 : }
31568 :
31569 :
31570 7 : SWIGINTERN PyObject *_wrap_Geometry_Transform(PyObject *self, PyObject *args) {
31571 7 : Py_ssize_t argc;
31572 7 : PyObject *argv[3] = {
31573 : 0
31574 : };
31575 :
31576 7 : if (!(argc = SWIG_Python_UnpackTuple(args, "Geometry_Transform", 0, 2, argv))) SWIG_fail;
31577 7 : --argc;
31578 7 : if (argc == 2) {
31579 7 : int _v;
31580 7 : void *vptr = 0;
31581 7 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
31582 11 : _v = SWIG_CheckState(res);
31583 7 : if (_v) {
31584 7 : void *vptr = 0;
31585 7 : int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_OSRCoordinateTransformationShadow, 0);
31586 7 : _v = SWIG_CheckState(res);
31587 4 : if (_v) {
31588 3 : return _wrap_Geometry_Transform__SWIG_0(self, argc, argv);
31589 : }
31590 : }
31591 : }
31592 4 : if (argc == 2) {
31593 4 : int _v;
31594 4 : void *vptr = 0;
31595 4 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
31596 4 : _v = SWIG_CheckState(res);
31597 4 : if (_v) {
31598 4 : void *vptr = 0;
31599 4 : int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_OGRGeomTransformerShadow, 0);
31600 4 : _v = SWIG_CheckState(res);
31601 0 : if (_v) {
31602 4 : return _wrap_Geometry_Transform__SWIG_1(self, argc, argv);
31603 : }
31604 : }
31605 : }
31606 :
31607 0 : fail:
31608 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Geometry_Transform'.\n"
31609 : " Possible C/C++ prototypes are:\n"
31610 : " OGRGeometryShadow::Transform(OSRCoordinateTransformationShadow *)\n"
31611 : " OGRGeometryShadow::Transform(OGRGeomTransformerShadow *)\n");
31612 : return 0;
31613 : }
31614 :
31615 :
31616 1 : SWIGINTERN PyObject *_wrap_Geometry_CreatePreparedGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31617 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31618 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31619 1 : void *argp1 = 0 ;
31620 1 : int res1 = 0 ;
31621 1 : PyObject *swig_obj[1] ;
31622 1 : OGRPreparedGeometryShadow *result = 0 ;
31623 :
31624 1 : if (!args) SWIG_fail;
31625 1 : swig_obj[0] = args;
31626 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31627 1 : if (!SWIG_IsOK(res1)) {
31628 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_CreatePreparedGeometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31629 : }
31630 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31631 1 : {
31632 1 : const int bLocalUseExceptions = GetUseExceptions();
31633 1 : if ( bLocalUseExceptions ) {
31634 1 : pushErrorHandler();
31635 : }
31636 1 : {
31637 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31638 1 : result = (OGRPreparedGeometryShadow *)OGRGeometryShadow_CreatePreparedGeometry(arg1);
31639 1 : SWIG_PYTHON_THREAD_END_ALLOW;
31640 : }
31641 1 : if ( bLocalUseExceptions ) {
31642 1 : popErrorHandler();
31643 : }
31644 : #ifndef SED_HACKS
31645 : if ( bLocalUseExceptions ) {
31646 : CPLErr eclass = CPLGetLastErrorType();
31647 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31648 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31649 : }
31650 : }
31651 : #endif
31652 : }
31653 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRPreparedGeometryShadow, SWIG_POINTER_OWN | 0 );
31654 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31655 : return resultobj;
31656 : fail:
31657 : return NULL;
31658 : }
31659 :
31660 :
31661 273 : SWIGINTERN PyObject *Geometry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31662 273 : PyObject *obj;
31663 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
31664 273 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRGeometryShadow, SWIG_NewClientData(obj));
31665 273 : return SWIG_Py_Void();
31666 : }
31667 :
31668 160954 : SWIGINTERN PyObject *Geometry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31669 160954 : return SWIG_Python_InitShadowInstance(args);
31670 : }
31671 :
31672 1 : SWIGINTERN PyObject *_wrap_delete_PreparedGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31673 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31674 1 : OGRPreparedGeometryShadow *arg1 = (OGRPreparedGeometryShadow *) 0 ;
31675 1 : void *argp1 = 0 ;
31676 1 : int res1 = 0 ;
31677 1 : PyObject *swig_obj[1] ;
31678 :
31679 1 : if (!args) SWIG_fail;
31680 1 : swig_obj[0] = args;
31681 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRPreparedGeometryShadow, SWIG_POINTER_DISOWN | 0 );
31682 1 : if (!SWIG_IsOK(res1)) {
31683 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PreparedGeometry" "', argument " "1"" of type '" "OGRPreparedGeometryShadow *""'");
31684 : }
31685 1 : arg1 = reinterpret_cast< OGRPreparedGeometryShadow * >(argp1);
31686 1 : {
31687 1 : const int bLocalUseExceptions = GetUseExceptions();
31688 1 : if ( bLocalUseExceptions ) {
31689 1 : pushErrorHandler();
31690 : }
31691 1 : {
31692 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31693 1 : delete_OGRPreparedGeometryShadow(arg1);
31694 1 : SWIG_PYTHON_THREAD_END_ALLOW;
31695 : }
31696 1 : if ( bLocalUseExceptions ) {
31697 1 : popErrorHandler();
31698 : }
31699 : #ifndef SED_HACKS
31700 : if ( bLocalUseExceptions ) {
31701 : CPLErr eclass = CPLGetLastErrorType();
31702 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31703 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31704 : }
31705 : }
31706 : #endif
31707 : }
31708 1 : resultobj = SWIG_Py_Void();
31709 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31710 : return resultobj;
31711 : fail:
31712 : return NULL;
31713 : }
31714 :
31715 :
31716 3 : SWIGINTERN PyObject *_wrap_PreparedGeometry_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31717 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31718 3 : OGRPreparedGeometryShadow *arg1 = (OGRPreparedGeometryShadow *) 0 ;
31719 3 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
31720 3 : void *argp1 = 0 ;
31721 3 : int res1 = 0 ;
31722 3 : void *argp2 = 0 ;
31723 3 : int res2 = 0 ;
31724 3 : PyObject *swig_obj[2] ;
31725 3 : bool result;
31726 :
31727 3 : if (!SWIG_Python_UnpackTuple(args, "PreparedGeometry_Intersects", 2, 2, swig_obj)) SWIG_fail;
31728 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRPreparedGeometryShadow, 0 | 0 );
31729 3 : if (!SWIG_IsOK(res1)) {
31730 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PreparedGeometry_Intersects" "', argument " "1"" of type '" "OGRPreparedGeometryShadow *""'");
31731 : }
31732 3 : arg1 = reinterpret_cast< OGRPreparedGeometryShadow * >(argp1);
31733 3 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31734 3 : if (!SWIG_IsOK(res2)) {
31735 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PreparedGeometry_Intersects" "', argument " "2"" of type '" "OGRGeometryShadow const *""'");
31736 : }
31737 3 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
31738 3 : {
31739 3 : if (!arg2) {
31740 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
31741 : }
31742 : }
31743 3 : {
31744 3 : const int bLocalUseExceptions = GetUseExceptions();
31745 3 : if ( bLocalUseExceptions ) {
31746 3 : pushErrorHandler();
31747 : }
31748 3 : {
31749 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31750 3 : result = (bool)OGRPreparedGeometryShadow_Intersects(arg1,(OGRGeometryShadow const *)arg2);
31751 3 : SWIG_PYTHON_THREAD_END_ALLOW;
31752 : }
31753 3 : if ( bLocalUseExceptions ) {
31754 3 : popErrorHandler();
31755 : }
31756 : #ifndef SED_HACKS
31757 : if ( bLocalUseExceptions ) {
31758 : CPLErr eclass = CPLGetLastErrorType();
31759 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31760 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31761 : }
31762 : }
31763 : #endif
31764 : }
31765 3 : resultobj = SWIG_From_bool(static_cast< bool >(result));
31766 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31767 : return resultobj;
31768 : fail:
31769 : return NULL;
31770 : }
31771 :
31772 :
31773 3 : SWIGINTERN PyObject *_wrap_PreparedGeometry_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31774 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31775 3 : OGRPreparedGeometryShadow *arg1 = (OGRPreparedGeometryShadow *) 0 ;
31776 3 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
31777 3 : void *argp1 = 0 ;
31778 3 : int res1 = 0 ;
31779 3 : void *argp2 = 0 ;
31780 3 : int res2 = 0 ;
31781 3 : PyObject *swig_obj[2] ;
31782 3 : bool result;
31783 :
31784 3 : if (!SWIG_Python_UnpackTuple(args, "PreparedGeometry_Contains", 2, 2, swig_obj)) SWIG_fail;
31785 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRPreparedGeometryShadow, 0 | 0 );
31786 3 : if (!SWIG_IsOK(res1)) {
31787 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PreparedGeometry_Contains" "', argument " "1"" of type '" "OGRPreparedGeometryShadow *""'");
31788 : }
31789 3 : arg1 = reinterpret_cast< OGRPreparedGeometryShadow * >(argp1);
31790 3 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31791 3 : if (!SWIG_IsOK(res2)) {
31792 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PreparedGeometry_Contains" "', argument " "2"" of type '" "OGRGeometryShadow const *""'");
31793 : }
31794 3 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
31795 3 : {
31796 3 : if (!arg2) {
31797 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
31798 : }
31799 : }
31800 3 : {
31801 3 : const int bLocalUseExceptions = GetUseExceptions();
31802 3 : if ( bLocalUseExceptions ) {
31803 3 : pushErrorHandler();
31804 : }
31805 3 : {
31806 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31807 3 : result = (bool)OGRPreparedGeometryShadow_Contains(arg1,(OGRGeometryShadow const *)arg2);
31808 3 : SWIG_PYTHON_THREAD_END_ALLOW;
31809 : }
31810 3 : if ( bLocalUseExceptions ) {
31811 3 : popErrorHandler();
31812 : }
31813 : #ifndef SED_HACKS
31814 : if ( bLocalUseExceptions ) {
31815 : CPLErr eclass = CPLGetLastErrorType();
31816 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31817 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31818 : }
31819 : }
31820 : #endif
31821 : }
31822 3 : resultobj = SWIG_From_bool(static_cast< bool >(result));
31823 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31824 : return resultobj;
31825 : fail:
31826 : return NULL;
31827 : }
31828 :
31829 :
31830 273 : SWIGINTERN PyObject *PreparedGeometry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31831 273 : PyObject *obj;
31832 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
31833 273 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRPreparedGeometryShadow, SWIG_NewClientData(obj));
31834 273 : return SWIG_Py_Void();
31835 : }
31836 :
31837 6 : SWIGINTERN PyObject *_wrap_new_GeomTransformer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31838 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31839 6 : OSRCoordinateTransformationShadow *arg1 = (OSRCoordinateTransformationShadow *) 0 ;
31840 6 : char **arg2 = (char **) NULL ;
31841 6 : void *argp1 = 0 ;
31842 6 : int res1 = 0 ;
31843 6 : PyObject *swig_obj[2] ;
31844 6 : OGRGeomTransformerShadow *result = 0 ;
31845 :
31846 6 : if (!SWIG_Python_UnpackTuple(args, "new_GeomTransformer", 1, 2, swig_obj)) SWIG_fail;
31847 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSRCoordinateTransformationShadow, 0 | 0 );
31848 6 : if (!SWIG_IsOK(res1)) {
31849 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GeomTransformer" "', argument " "1"" of type '" "OSRCoordinateTransformationShadow *""'");
31850 : }
31851 6 : arg1 = reinterpret_cast< OSRCoordinateTransformationShadow * >(argp1);
31852 6 : if (swig_obj[1]) {
31853 4 : {
31854 : /* %typemap(in) char **dict */
31855 4 : arg2 = NULL;
31856 4 : if ( PySequence_Check( swig_obj[1] ) ) {
31857 4 : int bErr = FALSE;
31858 4 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
31859 4 : if ( bErr )
31860 : {
31861 0 : SWIG_fail;
31862 : }
31863 : }
31864 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
31865 0 : int bErr = FALSE;
31866 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
31867 0 : if ( bErr )
31868 : {
31869 0 : SWIG_fail;
31870 : }
31871 : }
31872 : else {
31873 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
31874 0 : SWIG_fail;
31875 : }
31876 : }
31877 : }
31878 6 : {
31879 6 : const int bLocalUseExceptions = GetUseExceptions();
31880 6 : if ( bLocalUseExceptions ) {
31881 0 : pushErrorHandler();
31882 : }
31883 6 : {
31884 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31885 6 : result = (OGRGeomTransformerShadow *)new_OGRGeomTransformerShadow(arg1,arg2);
31886 6 : SWIG_PYTHON_THREAD_END_ALLOW;
31887 : }
31888 6 : if ( bLocalUseExceptions ) {
31889 0 : popErrorHandler();
31890 : }
31891 : #ifndef SED_HACKS
31892 : if ( bLocalUseExceptions ) {
31893 : CPLErr eclass = CPLGetLastErrorType();
31894 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31895 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31896 : }
31897 : }
31898 : #endif
31899 : }
31900 6 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeomTransformerShadow, SWIG_POINTER_NEW | 0 );
31901 6 : {
31902 : /* %typemap(freearg) char **dict */
31903 6 : CSLDestroy( arg2 );
31904 : }
31905 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31906 : return resultobj;
31907 0 : fail:
31908 0 : {
31909 : /* %typemap(freearg) char **dict */
31910 0 : CSLDestroy( arg2 );
31911 : }
31912 : return NULL;
31913 : }
31914 :
31915 :
31916 6 : SWIGINTERN PyObject *_wrap_delete_GeomTransformer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31917 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31918 6 : OGRGeomTransformerShadow *arg1 = (OGRGeomTransformerShadow *) 0 ;
31919 6 : void *argp1 = 0 ;
31920 6 : int res1 = 0 ;
31921 6 : PyObject *swig_obj[1] ;
31922 :
31923 6 : if (!args) SWIG_fail;
31924 6 : swig_obj[0] = args;
31925 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomTransformerShadow, SWIG_POINTER_DISOWN | 0 );
31926 6 : if (!SWIG_IsOK(res1)) {
31927 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeomTransformer" "', argument " "1"" of type '" "OGRGeomTransformerShadow *""'");
31928 : }
31929 6 : arg1 = reinterpret_cast< OGRGeomTransformerShadow * >(argp1);
31930 6 : {
31931 6 : const int bLocalUseExceptions = GetUseExceptions();
31932 6 : if ( bLocalUseExceptions ) {
31933 0 : pushErrorHandler();
31934 : }
31935 6 : {
31936 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31937 6 : delete_OGRGeomTransformerShadow(arg1);
31938 6 : SWIG_PYTHON_THREAD_END_ALLOW;
31939 : }
31940 6 : if ( bLocalUseExceptions ) {
31941 0 : popErrorHandler();
31942 : }
31943 : #ifndef SED_HACKS
31944 : if ( bLocalUseExceptions ) {
31945 : CPLErr eclass = CPLGetLastErrorType();
31946 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31947 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31948 : }
31949 : }
31950 : #endif
31951 : }
31952 6 : resultobj = SWIG_Py_Void();
31953 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31954 : return resultobj;
31955 : fail:
31956 : return NULL;
31957 : }
31958 :
31959 :
31960 2 : SWIGINTERN PyObject *_wrap_GeomTransformer_Transform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31961 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31962 2 : OGRGeomTransformerShadow *arg1 = (OGRGeomTransformerShadow *) 0 ;
31963 2 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
31964 2 : void *argp1 = 0 ;
31965 2 : int res1 = 0 ;
31966 2 : void *argp2 = 0 ;
31967 2 : int res2 = 0 ;
31968 2 : PyObject *swig_obj[2] ;
31969 2 : OGRGeometryShadow *result = 0 ;
31970 :
31971 2 : if (!SWIG_Python_UnpackTuple(args, "GeomTransformer_Transform", 2, 2, swig_obj)) SWIG_fail;
31972 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomTransformerShadow, 0 | 0 );
31973 2 : if (!SWIG_IsOK(res1)) {
31974 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomTransformer_Transform" "', argument " "1"" of type '" "OGRGeomTransformerShadow *""'");
31975 : }
31976 2 : arg1 = reinterpret_cast< OGRGeomTransformerShadow * >(argp1);
31977 2 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31978 2 : if (!SWIG_IsOK(res2)) {
31979 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomTransformer_Transform" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
31980 : }
31981 2 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
31982 2 : {
31983 2 : if (!arg2) {
31984 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
31985 : }
31986 : }
31987 2 : {
31988 2 : const int bLocalUseExceptions = GetUseExceptions();
31989 2 : if ( bLocalUseExceptions ) {
31990 0 : pushErrorHandler();
31991 : }
31992 2 : {
31993 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31994 2 : result = (OGRGeometryShadow *)OGRGeomTransformerShadow_Transform(arg1,arg2);
31995 2 : SWIG_PYTHON_THREAD_END_ALLOW;
31996 : }
31997 2 : if ( bLocalUseExceptions ) {
31998 0 : popErrorHandler();
31999 : }
32000 : #ifndef SED_HACKS
32001 : if ( bLocalUseExceptions ) {
32002 : CPLErr eclass = CPLGetLastErrorType();
32003 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32004 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32005 : }
32006 : }
32007 : #endif
32008 : }
32009 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
32010 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32011 : return resultobj;
32012 : fail:
32013 : return NULL;
32014 : }
32015 :
32016 :
32017 273 : SWIGINTERN PyObject *GeomTransformer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32018 273 : PyObject *obj;
32019 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
32020 273 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRGeomTransformerShadow, SWIG_NewClientData(obj));
32021 273 : return SWIG_Py_Void();
32022 : }
32023 :
32024 6 : SWIGINTERN PyObject *GeomTransformer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32025 6 : return SWIG_Python_InitShadowInstance(args);
32026 : }
32027 :
32028 42 : SWIGINTERN PyObject *_wrap_delete_FieldDomain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32029 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32030 42 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32031 42 : void *argp1 = 0 ;
32032 42 : int res1 = 0 ;
32033 42 : PyObject *swig_obj[1] ;
32034 :
32035 42 : if (!args) SWIG_fail;
32036 42 : swig_obj[0] = args;
32037 42 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, SWIG_POINTER_DISOWN | 0 );
32038 42 : if (!SWIG_IsOK(res1)) {
32039 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FieldDomain" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32040 : }
32041 42 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32042 42 : {
32043 42 : const int bLocalUseExceptions = GetUseExceptions();
32044 42 : if ( bLocalUseExceptions ) {
32045 23 : pushErrorHandler();
32046 : }
32047 42 : {
32048 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32049 42 : delete_OGRFieldDomainShadow(arg1);
32050 42 : SWIG_PYTHON_THREAD_END_ALLOW;
32051 : }
32052 42 : if ( bLocalUseExceptions ) {
32053 23 : popErrorHandler();
32054 : }
32055 : #ifndef SED_HACKS
32056 : if ( bLocalUseExceptions ) {
32057 : CPLErr eclass = CPLGetLastErrorType();
32058 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32059 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32060 : }
32061 : }
32062 : #endif
32063 : }
32064 42 : resultobj = SWIG_Py_Void();
32065 42 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32066 : return resultobj;
32067 : fail:
32068 : return NULL;
32069 : }
32070 :
32071 :
32072 55 : SWIGINTERN PyObject *_wrap_FieldDomain_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32073 55 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32074 55 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32075 55 : void *argp1 = 0 ;
32076 55 : int res1 = 0 ;
32077 55 : PyObject *swig_obj[1] ;
32078 55 : char *result = 0 ;
32079 :
32080 55 : if (!args) SWIG_fail;
32081 55 : swig_obj[0] = args;
32082 55 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32083 55 : if (!SWIG_IsOK(res1)) {
32084 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetName" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32085 : }
32086 55 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32087 55 : {
32088 55 : const int bLocalUseExceptions = GetUseExceptions();
32089 55 : if ( bLocalUseExceptions ) {
32090 45 : pushErrorHandler();
32091 : }
32092 55 : {
32093 55 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32094 55 : result = (char *)OGRFieldDomainShadow_GetName(arg1);
32095 55 : SWIG_PYTHON_THREAD_END_ALLOW;
32096 : }
32097 55 : if ( bLocalUseExceptions ) {
32098 45 : popErrorHandler();
32099 : }
32100 : #ifndef SED_HACKS
32101 : if ( bLocalUseExceptions ) {
32102 : CPLErr eclass = CPLGetLastErrorType();
32103 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32104 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32105 : }
32106 : }
32107 : #endif
32108 : }
32109 55 : resultobj = SWIG_FromCharPtr((const char *)result);
32110 55 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32111 : return resultobj;
32112 : fail:
32113 : return NULL;
32114 : }
32115 :
32116 :
32117 58 : SWIGINTERN PyObject *_wrap_FieldDomain_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32118 58 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32119 58 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32120 58 : void *argp1 = 0 ;
32121 58 : int res1 = 0 ;
32122 58 : PyObject *swig_obj[1] ;
32123 58 : char *result = 0 ;
32124 :
32125 58 : if (!args) SWIG_fail;
32126 58 : swig_obj[0] = args;
32127 58 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32128 58 : if (!SWIG_IsOK(res1)) {
32129 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetDescription" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32130 : }
32131 58 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32132 58 : {
32133 58 : const int bLocalUseExceptions = GetUseExceptions();
32134 58 : if ( bLocalUseExceptions ) {
32135 47 : pushErrorHandler();
32136 : }
32137 58 : {
32138 58 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32139 58 : result = (char *)OGRFieldDomainShadow_GetDescription(arg1);
32140 58 : SWIG_PYTHON_THREAD_END_ALLOW;
32141 : }
32142 58 : if ( bLocalUseExceptions ) {
32143 47 : popErrorHandler();
32144 : }
32145 : #ifndef SED_HACKS
32146 : if ( bLocalUseExceptions ) {
32147 : CPLErr eclass = CPLGetLastErrorType();
32148 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32149 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32150 : }
32151 : }
32152 : #endif
32153 : }
32154 58 : resultobj = SWIG_FromCharPtr((const char *)result);
32155 58 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32156 : return resultobj;
32157 : fail:
32158 : return NULL;
32159 : }
32160 :
32161 :
32162 58 : SWIGINTERN PyObject *_wrap_FieldDomain_GetFieldType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32163 58 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32164 58 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32165 58 : void *argp1 = 0 ;
32166 58 : int res1 = 0 ;
32167 58 : PyObject *swig_obj[1] ;
32168 58 : OGRFieldType result;
32169 :
32170 58 : if (!args) SWIG_fail;
32171 58 : swig_obj[0] = args;
32172 58 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32173 58 : if (!SWIG_IsOK(res1)) {
32174 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetFieldType" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32175 : }
32176 58 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32177 58 : {
32178 58 : const int bLocalUseExceptions = GetUseExceptions();
32179 58 : if ( bLocalUseExceptions ) {
32180 39 : pushErrorHandler();
32181 : }
32182 58 : {
32183 58 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32184 58 : result = (OGRFieldType)OGRFieldDomainShadow_GetFieldType(arg1);
32185 58 : SWIG_PYTHON_THREAD_END_ALLOW;
32186 : }
32187 58 : if ( bLocalUseExceptions ) {
32188 39 : popErrorHandler();
32189 : }
32190 : #ifndef SED_HACKS
32191 : if ( bLocalUseExceptions ) {
32192 : CPLErr eclass = CPLGetLastErrorType();
32193 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32194 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32195 : }
32196 : }
32197 : #endif
32198 : }
32199 58 : resultobj = SWIG_From_int(static_cast< int >(result));
32200 58 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32201 : return resultobj;
32202 : fail:
32203 : return NULL;
32204 : }
32205 :
32206 :
32207 38 : SWIGINTERN PyObject *_wrap_FieldDomain_GetFieldSubType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32208 38 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32209 38 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32210 38 : void *argp1 = 0 ;
32211 38 : int res1 = 0 ;
32212 38 : PyObject *swig_obj[1] ;
32213 38 : OGRFieldSubType result;
32214 :
32215 38 : if (!args) SWIG_fail;
32216 38 : swig_obj[0] = args;
32217 38 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32218 38 : if (!SWIG_IsOK(res1)) {
32219 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetFieldSubType" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32220 : }
32221 38 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32222 38 : {
32223 38 : const int bLocalUseExceptions = GetUseExceptions();
32224 38 : if ( bLocalUseExceptions ) {
32225 35 : pushErrorHandler();
32226 : }
32227 38 : {
32228 38 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32229 38 : result = (OGRFieldSubType)OGRFieldDomainShadow_GetFieldSubType(arg1);
32230 38 : SWIG_PYTHON_THREAD_END_ALLOW;
32231 : }
32232 38 : if ( bLocalUseExceptions ) {
32233 35 : popErrorHandler();
32234 : }
32235 : #ifndef SED_HACKS
32236 : if ( bLocalUseExceptions ) {
32237 : CPLErr eclass = CPLGetLastErrorType();
32238 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32239 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32240 : }
32241 : }
32242 : #endif
32243 : }
32244 38 : resultobj = SWIG_From_int(static_cast< int >(result));
32245 38 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32246 : return resultobj;
32247 : fail:
32248 : return NULL;
32249 : }
32250 :
32251 :
32252 52 : SWIGINTERN PyObject *_wrap_FieldDomain_GetDomainType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32253 52 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32254 52 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32255 52 : void *argp1 = 0 ;
32256 52 : int res1 = 0 ;
32257 52 : PyObject *swig_obj[1] ;
32258 52 : OGRFieldDomainType result;
32259 :
32260 52 : if (!args) SWIG_fail;
32261 52 : swig_obj[0] = args;
32262 52 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32263 52 : if (!SWIG_IsOK(res1)) {
32264 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetDomainType" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32265 : }
32266 52 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32267 52 : {
32268 52 : const int bLocalUseExceptions = GetUseExceptions();
32269 52 : if ( bLocalUseExceptions ) {
32270 42 : pushErrorHandler();
32271 : }
32272 52 : {
32273 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32274 52 : result = (OGRFieldDomainType)OGRFieldDomainShadow_GetDomainType(arg1);
32275 52 : SWIG_PYTHON_THREAD_END_ALLOW;
32276 : }
32277 52 : if ( bLocalUseExceptions ) {
32278 42 : popErrorHandler();
32279 : }
32280 : #ifndef SED_HACKS
32281 : if ( bLocalUseExceptions ) {
32282 : CPLErr eclass = CPLGetLastErrorType();
32283 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32284 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32285 : }
32286 : }
32287 : #endif
32288 : }
32289 52 : resultobj = SWIG_From_int(static_cast< int >(result));
32290 52 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32291 : return resultobj;
32292 : fail:
32293 : return NULL;
32294 : }
32295 :
32296 :
32297 2 : SWIGINTERN PyObject *_wrap_FieldDomain_GetSplitPolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32298 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32299 2 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32300 2 : void *argp1 = 0 ;
32301 2 : int res1 = 0 ;
32302 2 : PyObject *swig_obj[1] ;
32303 2 : OGRFieldDomainSplitPolicy result;
32304 :
32305 2 : if (!args) SWIG_fail;
32306 2 : swig_obj[0] = args;
32307 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32308 2 : if (!SWIG_IsOK(res1)) {
32309 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetSplitPolicy" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32310 : }
32311 2 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32312 2 : {
32313 2 : const int bLocalUseExceptions = GetUseExceptions();
32314 2 : if ( bLocalUseExceptions ) {
32315 2 : pushErrorHandler();
32316 : }
32317 2 : {
32318 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32319 2 : result = (OGRFieldDomainSplitPolicy)OGRFieldDomainShadow_GetSplitPolicy(arg1);
32320 2 : SWIG_PYTHON_THREAD_END_ALLOW;
32321 : }
32322 2 : if ( bLocalUseExceptions ) {
32323 2 : popErrorHandler();
32324 : }
32325 : #ifndef SED_HACKS
32326 : if ( bLocalUseExceptions ) {
32327 : CPLErr eclass = CPLGetLastErrorType();
32328 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32329 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32330 : }
32331 : }
32332 : #endif
32333 : }
32334 2 : resultobj = SWIG_From_int(static_cast< int >(result));
32335 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32336 : return resultobj;
32337 : fail:
32338 : return NULL;
32339 : }
32340 :
32341 :
32342 1 : SWIGINTERN PyObject *_wrap_FieldDomain_SetSplitPolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32343 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32344 1 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32345 1 : OGRFieldDomainSplitPolicy arg2 ;
32346 1 : void *argp1 = 0 ;
32347 1 : int res1 = 0 ;
32348 1 : int val2 ;
32349 1 : int ecode2 = 0 ;
32350 1 : PyObject *swig_obj[2] ;
32351 :
32352 1 : if (!SWIG_Python_UnpackTuple(args, "FieldDomain_SetSplitPolicy", 2, 2, swig_obj)) SWIG_fail;
32353 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32354 1 : if (!SWIG_IsOK(res1)) {
32355 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_SetSplitPolicy" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32356 : }
32357 1 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32358 1 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
32359 1 : if (!SWIG_IsOK(ecode2)) {
32360 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDomain_SetSplitPolicy" "', argument " "2"" of type '" "OGRFieldDomainSplitPolicy""'");
32361 : }
32362 1 : arg2 = static_cast< OGRFieldDomainSplitPolicy >(val2);
32363 1 : {
32364 1 : const int bLocalUseExceptions = GetUseExceptions();
32365 1 : if ( bLocalUseExceptions ) {
32366 1 : pushErrorHandler();
32367 : }
32368 1 : {
32369 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32370 1 : OGRFieldDomainShadow_SetSplitPolicy(arg1,arg2);
32371 1 : SWIG_PYTHON_THREAD_END_ALLOW;
32372 : }
32373 1 : if ( bLocalUseExceptions ) {
32374 1 : popErrorHandler();
32375 : }
32376 : #ifndef SED_HACKS
32377 : if ( bLocalUseExceptions ) {
32378 : CPLErr eclass = CPLGetLastErrorType();
32379 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32380 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32381 : }
32382 : }
32383 : #endif
32384 : }
32385 1 : resultobj = SWIG_Py_Void();
32386 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32387 : return resultobj;
32388 : fail:
32389 : return NULL;
32390 : }
32391 :
32392 :
32393 2 : SWIGINTERN PyObject *_wrap_FieldDomain_GetMergePolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32394 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32395 2 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32396 2 : void *argp1 = 0 ;
32397 2 : int res1 = 0 ;
32398 2 : PyObject *swig_obj[1] ;
32399 2 : OGRFieldDomainMergePolicy result;
32400 :
32401 2 : if (!args) SWIG_fail;
32402 2 : swig_obj[0] = args;
32403 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32404 2 : if (!SWIG_IsOK(res1)) {
32405 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetMergePolicy" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32406 : }
32407 2 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32408 2 : {
32409 2 : const int bLocalUseExceptions = GetUseExceptions();
32410 2 : if ( bLocalUseExceptions ) {
32411 2 : pushErrorHandler();
32412 : }
32413 2 : {
32414 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32415 2 : result = (OGRFieldDomainMergePolicy)OGRFieldDomainShadow_GetMergePolicy(arg1);
32416 2 : SWIG_PYTHON_THREAD_END_ALLOW;
32417 : }
32418 2 : if ( bLocalUseExceptions ) {
32419 2 : popErrorHandler();
32420 : }
32421 : #ifndef SED_HACKS
32422 : if ( bLocalUseExceptions ) {
32423 : CPLErr eclass = CPLGetLastErrorType();
32424 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32425 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32426 : }
32427 : }
32428 : #endif
32429 : }
32430 2 : resultobj = SWIG_From_int(static_cast< int >(result));
32431 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32432 : return resultobj;
32433 : fail:
32434 : return NULL;
32435 : }
32436 :
32437 :
32438 1 : SWIGINTERN PyObject *_wrap_FieldDomain_SetMergePolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32439 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32440 1 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32441 1 : OGRFieldDomainMergePolicy arg2 ;
32442 1 : void *argp1 = 0 ;
32443 1 : int res1 = 0 ;
32444 1 : int val2 ;
32445 1 : int ecode2 = 0 ;
32446 1 : PyObject *swig_obj[2] ;
32447 :
32448 1 : if (!SWIG_Python_UnpackTuple(args, "FieldDomain_SetMergePolicy", 2, 2, swig_obj)) SWIG_fail;
32449 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32450 1 : if (!SWIG_IsOK(res1)) {
32451 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_SetMergePolicy" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32452 : }
32453 1 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32454 1 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
32455 1 : if (!SWIG_IsOK(ecode2)) {
32456 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDomain_SetMergePolicy" "', argument " "2"" of type '" "OGRFieldDomainMergePolicy""'");
32457 : }
32458 1 : arg2 = static_cast< OGRFieldDomainMergePolicy >(val2);
32459 1 : {
32460 1 : const int bLocalUseExceptions = GetUseExceptions();
32461 1 : if ( bLocalUseExceptions ) {
32462 1 : pushErrorHandler();
32463 : }
32464 1 : {
32465 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32466 1 : OGRFieldDomainShadow_SetMergePolicy(arg1,arg2);
32467 1 : SWIG_PYTHON_THREAD_END_ALLOW;
32468 : }
32469 1 : if ( bLocalUseExceptions ) {
32470 1 : popErrorHandler();
32471 : }
32472 : #ifndef SED_HACKS
32473 : if ( bLocalUseExceptions ) {
32474 : CPLErr eclass = CPLGetLastErrorType();
32475 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32476 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32477 : }
32478 : }
32479 : #endif
32480 : }
32481 1 : resultobj = SWIG_Py_Void();
32482 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32483 : return resultobj;
32484 : fail:
32485 : return NULL;
32486 : }
32487 :
32488 :
32489 37 : SWIGINTERN PyObject *_wrap_FieldDomain_GetEnumeration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32490 37 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32491 37 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32492 37 : void *argp1 = 0 ;
32493 37 : int res1 = 0 ;
32494 37 : PyObject *swig_obj[1] ;
32495 37 : OGRCodedValue *result = 0 ;
32496 :
32497 37 : if (!args) SWIG_fail;
32498 37 : swig_obj[0] = args;
32499 37 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32500 37 : if (!SWIG_IsOK(res1)) {
32501 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetEnumeration" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32502 : }
32503 37 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32504 37 : {
32505 37 : const int bLocalUseExceptions = GetUseExceptions();
32506 37 : if ( bLocalUseExceptions ) {
32507 35 : pushErrorHandler();
32508 : }
32509 37 : {
32510 37 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32511 37 : result = (OGRCodedValue *)OGRFieldDomainShadow_GetEnumeration(arg1);
32512 37 : SWIG_PYTHON_THREAD_END_ALLOW;
32513 : }
32514 37 : if ( bLocalUseExceptions ) {
32515 35 : popErrorHandler();
32516 : }
32517 : #ifndef SED_HACKS
32518 : if ( bLocalUseExceptions ) {
32519 : CPLErr eclass = CPLGetLastErrorType();
32520 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32521 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32522 : }
32523 : }
32524 : #endif
32525 : }
32526 37 : {
32527 : /* %typemap(out) OGRCodedValue* */
32528 37 : if( result == NULL )
32529 : {
32530 1 : PyErr_SetString( PyExc_RuntimeError, CPLGetLastErrorMsg() );
32531 1 : SWIG_fail;
32532 : }
32533 36 : PyObject *dict = PyDict_New();
32534 136 : for( int i = 0; (result)[i].pszCode != NULL; i++ )
32535 : {
32536 100 : if( (result)[i].pszValue )
32537 : {
32538 98 : PyObject* val = GDALPythonObjectFromCStr((result)[i].pszValue);
32539 98 : PyDict_SetItemString(dict, (result)[i].pszCode, val);
32540 100 : Py_DECREF(val);
32541 : }
32542 : else
32543 : {
32544 2 : PyDict_SetItemString(dict, (result)[i].pszCode, Py_None);
32545 : }
32546 : }
32547 36 : resultobj = dict;
32548 : }
32549 37 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32550 : return resultobj;
32551 : fail:
32552 : return NULL;
32553 : }
32554 :
32555 :
32556 11 : SWIGINTERN PyObject *_wrap_FieldDomain_GetMinAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32557 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32558 11 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32559 11 : void *argp1 = 0 ;
32560 11 : int res1 = 0 ;
32561 11 : PyObject *swig_obj[1] ;
32562 11 : double result;
32563 :
32564 11 : if (!args) SWIG_fail;
32565 11 : swig_obj[0] = args;
32566 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32567 11 : if (!SWIG_IsOK(res1)) {
32568 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetMinAsDouble" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32569 : }
32570 11 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32571 11 : {
32572 11 : const int bLocalUseExceptions = GetUseExceptions();
32573 11 : if ( bLocalUseExceptions ) {
32574 4 : pushErrorHandler();
32575 : }
32576 11 : {
32577 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32578 11 : result = (double)OGRFieldDomainShadow_GetMinAsDouble(arg1);
32579 11 : SWIG_PYTHON_THREAD_END_ALLOW;
32580 : }
32581 11 : if ( bLocalUseExceptions ) {
32582 4 : popErrorHandler();
32583 : }
32584 : #ifndef SED_HACKS
32585 : if ( bLocalUseExceptions ) {
32586 : CPLErr eclass = CPLGetLastErrorType();
32587 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32588 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32589 : }
32590 : }
32591 : #endif
32592 : }
32593 11 : resultobj = SWIG_From_double(static_cast< double >(result));
32594 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32595 : return resultobj;
32596 : fail:
32597 : return NULL;
32598 : }
32599 :
32600 :
32601 2 : SWIGINTERN PyObject *_wrap_FieldDomain_GetMinAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32602 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32603 2 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32604 2 : void *argp1 = 0 ;
32605 2 : int res1 = 0 ;
32606 2 : PyObject *swig_obj[1] ;
32607 2 : char *result = 0 ;
32608 :
32609 2 : if (!args) SWIG_fail;
32610 2 : swig_obj[0] = args;
32611 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32612 2 : if (!SWIG_IsOK(res1)) {
32613 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetMinAsString" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32614 : }
32615 2 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32616 2 : {
32617 2 : const int bLocalUseExceptions = GetUseExceptions();
32618 2 : if ( bLocalUseExceptions ) {
32619 1 : pushErrorHandler();
32620 : }
32621 2 : {
32622 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32623 2 : result = (char *)OGRFieldDomainShadow_GetMinAsString(arg1);
32624 2 : SWIG_PYTHON_THREAD_END_ALLOW;
32625 : }
32626 2 : if ( bLocalUseExceptions ) {
32627 1 : popErrorHandler();
32628 : }
32629 : #ifndef SED_HACKS
32630 : if ( bLocalUseExceptions ) {
32631 : CPLErr eclass = CPLGetLastErrorType();
32632 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32633 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32634 : }
32635 : }
32636 : #endif
32637 : }
32638 2 : resultobj = SWIG_FromCharPtr((const char *)result);
32639 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32640 : return resultobj;
32641 : fail:
32642 : return NULL;
32643 : }
32644 :
32645 :
32646 7 : SWIGINTERN PyObject *_wrap_FieldDomain_IsMinInclusive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32647 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32648 7 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32649 7 : void *argp1 = 0 ;
32650 7 : int res1 = 0 ;
32651 7 : PyObject *swig_obj[1] ;
32652 7 : bool result;
32653 :
32654 7 : if (!args) SWIG_fail;
32655 7 : swig_obj[0] = args;
32656 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32657 7 : if (!SWIG_IsOK(res1)) {
32658 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_IsMinInclusive" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32659 : }
32660 7 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32661 7 : {
32662 7 : const int bLocalUseExceptions = GetUseExceptions();
32663 7 : if ( bLocalUseExceptions ) {
32664 2 : pushErrorHandler();
32665 : }
32666 7 : {
32667 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32668 7 : result = (bool)OGRFieldDomainShadow_IsMinInclusive(arg1);
32669 7 : SWIG_PYTHON_THREAD_END_ALLOW;
32670 : }
32671 7 : if ( bLocalUseExceptions ) {
32672 2 : popErrorHandler();
32673 : }
32674 : #ifndef SED_HACKS
32675 : if ( bLocalUseExceptions ) {
32676 : CPLErr eclass = CPLGetLastErrorType();
32677 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32678 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32679 : }
32680 : }
32681 : #endif
32682 : }
32683 7 : resultobj = SWIG_From_bool(static_cast< bool >(result));
32684 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32685 : return resultobj;
32686 : fail:
32687 : return NULL;
32688 : }
32689 :
32690 :
32691 11 : SWIGINTERN PyObject *_wrap_FieldDomain_GetMaxAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32692 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32693 11 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32694 11 : void *argp1 = 0 ;
32695 11 : int res1 = 0 ;
32696 11 : PyObject *swig_obj[1] ;
32697 11 : double result;
32698 :
32699 11 : if (!args) SWIG_fail;
32700 11 : swig_obj[0] = args;
32701 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32702 11 : if (!SWIG_IsOK(res1)) {
32703 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetMaxAsDouble" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32704 : }
32705 11 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32706 11 : {
32707 11 : const int bLocalUseExceptions = GetUseExceptions();
32708 11 : if ( bLocalUseExceptions ) {
32709 4 : pushErrorHandler();
32710 : }
32711 11 : {
32712 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32713 11 : result = (double)OGRFieldDomainShadow_GetMaxAsDouble(arg1);
32714 11 : SWIG_PYTHON_THREAD_END_ALLOW;
32715 : }
32716 11 : if ( bLocalUseExceptions ) {
32717 4 : popErrorHandler();
32718 : }
32719 : #ifndef SED_HACKS
32720 : if ( bLocalUseExceptions ) {
32721 : CPLErr eclass = CPLGetLastErrorType();
32722 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32723 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32724 : }
32725 : }
32726 : #endif
32727 : }
32728 11 : resultobj = SWIG_From_double(static_cast< double >(result));
32729 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32730 : return resultobj;
32731 : fail:
32732 : return NULL;
32733 : }
32734 :
32735 :
32736 2 : SWIGINTERN PyObject *_wrap_FieldDomain_GetMaxAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32737 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32738 2 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32739 2 : void *argp1 = 0 ;
32740 2 : int res1 = 0 ;
32741 2 : PyObject *swig_obj[1] ;
32742 2 : char *result = 0 ;
32743 :
32744 2 : if (!args) SWIG_fail;
32745 2 : swig_obj[0] = args;
32746 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32747 2 : if (!SWIG_IsOK(res1)) {
32748 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetMaxAsString" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32749 : }
32750 2 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32751 2 : {
32752 2 : const int bLocalUseExceptions = GetUseExceptions();
32753 2 : if ( bLocalUseExceptions ) {
32754 1 : pushErrorHandler();
32755 : }
32756 2 : {
32757 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32758 2 : result = (char *)OGRFieldDomainShadow_GetMaxAsString(arg1);
32759 2 : SWIG_PYTHON_THREAD_END_ALLOW;
32760 : }
32761 2 : if ( bLocalUseExceptions ) {
32762 1 : popErrorHandler();
32763 : }
32764 : #ifndef SED_HACKS
32765 : if ( bLocalUseExceptions ) {
32766 : CPLErr eclass = CPLGetLastErrorType();
32767 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32768 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32769 : }
32770 : }
32771 : #endif
32772 : }
32773 2 : resultobj = SWIG_FromCharPtr((const char *)result);
32774 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32775 : return resultobj;
32776 : fail:
32777 : return NULL;
32778 : }
32779 :
32780 :
32781 7 : SWIGINTERN PyObject *_wrap_FieldDomain_IsMaxInclusive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32782 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32783 7 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32784 7 : void *argp1 = 0 ;
32785 7 : int res1 = 0 ;
32786 7 : PyObject *swig_obj[1] ;
32787 7 : bool result;
32788 :
32789 7 : if (!args) SWIG_fail;
32790 7 : swig_obj[0] = args;
32791 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32792 7 : if (!SWIG_IsOK(res1)) {
32793 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_IsMaxInclusive" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32794 : }
32795 7 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32796 7 : {
32797 7 : const int bLocalUseExceptions = GetUseExceptions();
32798 7 : if ( bLocalUseExceptions ) {
32799 2 : pushErrorHandler();
32800 : }
32801 7 : {
32802 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32803 7 : result = (bool)OGRFieldDomainShadow_IsMaxInclusive(arg1);
32804 7 : SWIG_PYTHON_THREAD_END_ALLOW;
32805 : }
32806 7 : if ( bLocalUseExceptions ) {
32807 2 : popErrorHandler();
32808 : }
32809 : #ifndef SED_HACKS
32810 : if ( bLocalUseExceptions ) {
32811 : CPLErr eclass = CPLGetLastErrorType();
32812 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32813 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32814 : }
32815 : }
32816 : #endif
32817 : }
32818 7 : resultobj = SWIG_From_bool(static_cast< bool >(result));
32819 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32820 : return resultobj;
32821 : fail:
32822 : return NULL;
32823 : }
32824 :
32825 :
32826 9 : SWIGINTERN PyObject *_wrap_FieldDomain_GetGlob(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32827 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32828 9 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32829 9 : void *argp1 = 0 ;
32830 9 : int res1 = 0 ;
32831 9 : PyObject *swig_obj[1] ;
32832 9 : char *result = 0 ;
32833 :
32834 9 : if (!args) SWIG_fail;
32835 9 : swig_obj[0] = args;
32836 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32837 9 : if (!SWIG_IsOK(res1)) {
32838 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetGlob" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32839 : }
32840 9 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32841 9 : {
32842 9 : const int bLocalUseExceptions = GetUseExceptions();
32843 9 : if ( bLocalUseExceptions ) {
32844 8 : pushErrorHandler();
32845 : }
32846 9 : {
32847 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32848 9 : result = (char *)OGRFieldDomainShadow_GetGlob(arg1);
32849 9 : SWIG_PYTHON_THREAD_END_ALLOW;
32850 : }
32851 9 : if ( bLocalUseExceptions ) {
32852 8 : popErrorHandler();
32853 : }
32854 : #ifndef SED_HACKS
32855 : if ( bLocalUseExceptions ) {
32856 : CPLErr eclass = CPLGetLastErrorType();
32857 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32858 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32859 : }
32860 : }
32861 : #endif
32862 : }
32863 9 : resultobj = SWIG_FromCharPtr((const char *)result);
32864 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32865 : return resultobj;
32866 : fail:
32867 : return NULL;
32868 : }
32869 :
32870 :
32871 273 : SWIGINTERN PyObject *FieldDomain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32872 273 : PyObject *obj;
32873 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
32874 273 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRFieldDomainShadow, SWIG_NewClientData(obj));
32875 273 : return SWIG_Py_Void();
32876 : }
32877 :
32878 22 : SWIGINTERN PyObject *_wrap_CreateCodedFieldDomain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32879 22 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32880 22 : char *arg1 = (char *) 0 ;
32881 22 : char *arg2 = (char *) 0 ;
32882 22 : OGRFieldType arg3 ;
32883 22 : OGRFieldSubType arg4 ;
32884 22 : OGRCodedValue *arg5 = (OGRCodedValue *) 0 ;
32885 22 : int res1 ;
32886 22 : char *buf1 = 0 ;
32887 22 : int alloc1 = 0 ;
32888 22 : int res2 ;
32889 22 : char *buf2 = 0 ;
32890 22 : int alloc2 = 0 ;
32891 22 : int val3 ;
32892 22 : int ecode3 = 0 ;
32893 22 : int val4 ;
32894 22 : int ecode4 = 0 ;
32895 22 : PyObject *swig_obj[5] ;
32896 22 : OGRFieldDomainShadow *result = 0 ;
32897 :
32898 22 : if (!SWIG_Python_UnpackTuple(args, "CreateCodedFieldDomain", 5, 5, swig_obj)) SWIG_fail;
32899 21 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
32900 21 : if (!SWIG_IsOK(res1)) {
32901 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateCodedFieldDomain" "', argument " "1"" of type '" "char const *""'");
32902 : }
32903 21 : arg1 = reinterpret_cast< char * >(buf1);
32904 21 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
32905 21 : if (!SWIG_IsOK(res2)) {
32906 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateCodedFieldDomain" "', argument " "2"" of type '" "char const *""'");
32907 : }
32908 21 : arg2 = reinterpret_cast< char * >(buf2);
32909 21 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
32910 21 : if (!SWIG_IsOK(ecode3)) {
32911 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CreateCodedFieldDomain" "', argument " "3"" of type '" "OGRFieldType""'");
32912 : }
32913 21 : arg3 = static_cast< OGRFieldType >(val3);
32914 21 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
32915 21 : if (!SWIG_IsOK(ecode4)) {
32916 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CreateCodedFieldDomain" "', argument " "4"" of type '" "OGRFieldSubType""'");
32917 : }
32918 21 : arg4 = static_cast< OGRFieldSubType >(val4);
32919 21 : {
32920 : /* %typemap(in) OGRCodedValue* enumeration */
32921 21 : arg5 = NULL;
32922 :
32923 21 : if (swig_obj[4] == NULL || !PyMapping_Check(swig_obj[4])) {
32924 2 : SWIG_exception_fail(SWIG_ValueError,"Expected dict.");
32925 : }
32926 19 : Py_ssize_t size = PyMapping_Length( swig_obj[4] );
32927 19 : arg5 = (OGRCodedValue*)VSICalloc(size+1, sizeof(OGRCodedValue) );
32928 19 : if( !arg5 ) {
32929 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
32930 0 : SWIG_fail;
32931 : }
32932 :
32933 19 : PyObject *item_list = PyMapping_Items( swig_obj[4] );
32934 19 : if( item_list == NULL )
32935 : {
32936 0 : PyErr_SetString(PyExc_TypeError,"Cannot retrieve items");
32937 0 : SWIG_fail;
32938 : }
32939 :
32940 58 : for( Py_ssize_t i=0; i<size; i++ ) {
32941 39 : PyObject *it = PySequence_GetItem( item_list, i );
32942 39 : if( it == NULL )
32943 : {
32944 0 : Py_DECREF(item_list);
32945 0 : PyErr_SetString(PyExc_TypeError,"Cannot retrieve key/value");
32946 0 : SWIG_fail;
32947 : }
32948 :
32949 39 : PyObject *k, *v;
32950 39 : if ( ! PyArg_ParseTuple( it, "OO", &k, &v ) ) {
32951 0 : Py_DECREF(it);
32952 0 : Py_DECREF(item_list);
32953 0 : PyErr_SetString(PyExc_TypeError,"Cannot retrieve key/value");
32954 0 : SWIG_fail;
32955 : }
32956 :
32957 39 : PyObject* kStr = PyObject_Str(k);
32958 39 : if( PyErr_Occurred() )
32959 : {
32960 0 : Py_DECREF(it);
32961 0 : Py_DECREF(item_list);
32962 0 : SWIG_fail;
32963 : }
32964 :
32965 39 : PyObject* vStr = v != Py_None ? PyObject_Str(v) : Py_None;
32966 39 : if( v == Py_None )
32967 9 : Py_INCREF(Py_None);
32968 39 : if( PyErr_Occurred() )
32969 : {
32970 0 : Py_DECREF(it);
32971 0 : Py_DECREF(kStr);
32972 0 : Py_DECREF(item_list);
32973 0 : SWIG_fail;
32974 : }
32975 :
32976 39 : int bFreeK, bFreeV;
32977 39 : char* pszK = GDALPythonObjectToCStr(kStr, &bFreeK);
32978 39 : char* pszV = vStr != Py_None ? GDALPythonObjectToCStr(vStr, &bFreeV) : NULL;
32979 39 : if( pszK == NULL || (pszV == NULL && vStr != Py_None) )
32980 : {
32981 0 : GDALPythonFreeCStr(pszK, bFreeK);
32982 0 : if( pszV )
32983 0 : GDALPythonFreeCStr(pszV, bFreeV);
32984 0 : Py_DECREF(kStr);
32985 0 : Py_DECREF(vStr);
32986 0 : Py_DECREF(it);
32987 0 : Py_DECREF(item_list);
32988 0 : PyErr_SetString(PyExc_TypeError,"Cannot get key/value as string");
32989 0 : SWIG_fail;
32990 : }
32991 39 : (arg5)[i].pszCode = CPLStrdup(pszK);
32992 39 : (arg5)[i].pszValue = pszV ? CPLStrdup(pszV) : NULL;
32993 :
32994 39 : GDALPythonFreeCStr(pszK, bFreeK);
32995 39 : if( pszV )
32996 30 : GDALPythonFreeCStr(pszV, bFreeV);
32997 39 : Py_DECREF(kStr);
32998 39 : Py_DECREF(vStr);
32999 39 : Py_DECREF(it);
33000 : }
33001 19 : Py_DECREF(item_list);
33002 : }
33003 19 : {
33004 19 : if (!arg1) {
33005 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33006 : }
33007 : }
33008 19 : {
33009 19 : const int bLocalUseExceptions = GetUseExceptions();
33010 19 : if ( bLocalUseExceptions ) {
33011 7 : pushErrorHandler();
33012 : }
33013 19 : {
33014 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33015 19 : result = (OGRFieldDomainShadow *)CreateCodedFieldDomain((char const *)arg1,(char const *)arg2,arg3,arg4,(OGRCodedValue const *)arg5);
33016 19 : SWIG_PYTHON_THREAD_END_ALLOW;
33017 : }
33018 19 : if ( bLocalUseExceptions ) {
33019 7 : popErrorHandler();
33020 : }
33021 : #ifndef SED_HACKS
33022 : if ( bLocalUseExceptions ) {
33023 : CPLErr eclass = CPLGetLastErrorType();
33024 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33025 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33026 : }
33027 : }
33028 : #endif
33029 : }
33030 19 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDomainShadow, SWIG_POINTER_OWN | 0 );
33031 19 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
33032 19 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33033 : {
33034 : /* %typemap(freearg) OGRCodedValue* */
33035 : if( arg5 )
33036 : {
33037 58 : for( size_t i = 0; (arg5)[i].pszCode != NULL; ++i )
33038 : {
33039 39 : CPLFree((arg5)[i].pszCode);
33040 39 : CPLFree((arg5)[i].pszValue);
33041 : }
33042 : }
33043 19 : CPLFree( arg5 );
33044 : }
33045 22 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33046 : return resultobj;
33047 3 : fail:
33048 3 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
33049 3 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33050 3 : {
33051 : /* %typemap(freearg) OGRCodedValue* */
33052 3 : if( arg5 )
33053 : {
33054 0 : for( size_t i = 0; (arg5)[i].pszCode != NULL; ++i )
33055 : {
33056 0 : CPLFree((arg5)[i].pszCode);
33057 0 : CPLFree((arg5)[i].pszValue);
33058 : }
33059 : }
33060 3 : CPLFree( arg5 );
33061 : }
33062 : return NULL;
33063 : }
33064 :
33065 :
33066 11 : SWIGINTERN PyObject *_wrap_CreateRangeFieldDomain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33067 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33068 11 : char *arg1 = (char *) 0 ;
33069 11 : char *arg2 = (char *) 0 ;
33070 11 : OGRFieldType arg3 ;
33071 11 : OGRFieldSubType arg4 ;
33072 11 : double arg5 ;
33073 11 : bool arg6 ;
33074 11 : double arg7 ;
33075 11 : double arg8 ;
33076 11 : int res1 ;
33077 11 : char *buf1 = 0 ;
33078 11 : int alloc1 = 0 ;
33079 11 : int res2 ;
33080 11 : char *buf2 = 0 ;
33081 11 : int alloc2 = 0 ;
33082 11 : int val3 ;
33083 11 : int ecode3 = 0 ;
33084 11 : int val4 ;
33085 11 : int ecode4 = 0 ;
33086 11 : double val5 ;
33087 11 : int ecode5 = 0 ;
33088 11 : bool val6 ;
33089 11 : int ecode6 = 0 ;
33090 11 : double val7 ;
33091 11 : int ecode7 = 0 ;
33092 11 : double val8 ;
33093 11 : int ecode8 = 0 ;
33094 11 : PyObject *swig_obj[8] ;
33095 11 : OGRFieldDomainShadow *result = 0 ;
33096 :
33097 11 : if (!SWIG_Python_UnpackTuple(args, "CreateRangeFieldDomain", 8, 8, swig_obj)) SWIG_fail;
33098 11 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
33099 11 : if (!SWIG_IsOK(res1)) {
33100 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateRangeFieldDomain" "', argument " "1"" of type '" "char const *""'");
33101 : }
33102 11 : arg1 = reinterpret_cast< char * >(buf1);
33103 11 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
33104 11 : if (!SWIG_IsOK(res2)) {
33105 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateRangeFieldDomain" "', argument " "2"" of type '" "char const *""'");
33106 : }
33107 11 : arg2 = reinterpret_cast< char * >(buf2);
33108 11 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
33109 11 : if (!SWIG_IsOK(ecode3)) {
33110 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CreateRangeFieldDomain" "', argument " "3"" of type '" "OGRFieldType""'");
33111 : }
33112 11 : arg3 = static_cast< OGRFieldType >(val3);
33113 11 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
33114 11 : if (!SWIG_IsOK(ecode4)) {
33115 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CreateRangeFieldDomain" "', argument " "4"" of type '" "OGRFieldSubType""'");
33116 : }
33117 11 : arg4 = static_cast< OGRFieldSubType >(val4);
33118 11 : ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
33119 11 : if (!SWIG_IsOK(ecode5)) {
33120 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CreateRangeFieldDomain" "', argument " "5"" of type '" "double""'");
33121 : }
33122 11 : arg5 = static_cast< double >(val5);
33123 11 : ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
33124 11 : if (!SWIG_IsOK(ecode6)) {
33125 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CreateRangeFieldDomain" "', argument " "6"" of type '" "bool""'");
33126 : }
33127 11 : arg6 = static_cast< bool >(val6);
33128 11 : ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
33129 11 : if (!SWIG_IsOK(ecode7)) {
33130 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CreateRangeFieldDomain" "', argument " "7"" of type '" "double""'");
33131 : }
33132 11 : arg7 = static_cast< double >(val7);
33133 11 : ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
33134 11 : if (!SWIG_IsOK(ecode8)) {
33135 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CreateRangeFieldDomain" "', argument " "8"" of type '" "double""'");
33136 : }
33137 11 : arg8 = static_cast< double >(val8);
33138 11 : {
33139 11 : if (!arg1) {
33140 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33141 : }
33142 : }
33143 10 : {
33144 10 : const int bLocalUseExceptions = GetUseExceptions();
33145 10 : if ( bLocalUseExceptions ) {
33146 4 : pushErrorHandler();
33147 : }
33148 10 : {
33149 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33150 10 : result = (OGRFieldDomainShadow *)CreateRangeFieldDomain((char const *)arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
33151 10 : SWIG_PYTHON_THREAD_END_ALLOW;
33152 : }
33153 10 : if ( bLocalUseExceptions ) {
33154 4 : popErrorHandler();
33155 : }
33156 : #ifndef SED_HACKS
33157 : if ( bLocalUseExceptions ) {
33158 : CPLErr eclass = CPLGetLastErrorType();
33159 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33160 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33161 : }
33162 : }
33163 : #endif
33164 : }
33165 10 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDomainShadow, SWIG_POINTER_OWN | 0 );
33166 10 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
33167 10 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33168 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33169 : return resultobj;
33170 1 : fail:
33171 1 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
33172 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33173 : return NULL;
33174 : }
33175 :
33176 :
33177 2 : SWIGINTERN PyObject *_wrap_CreateRangeFieldDomainDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33178 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33179 2 : char *arg1 = (char *) 0 ;
33180 2 : char *arg2 = (char *) 0 ;
33181 2 : char *arg3 = (char *) 0 ;
33182 2 : bool arg4 ;
33183 2 : char *arg5 = (char *) 0 ;
33184 2 : double arg6 ;
33185 2 : int res1 ;
33186 2 : char *buf1 = 0 ;
33187 2 : int alloc1 = 0 ;
33188 2 : int res2 ;
33189 2 : char *buf2 = 0 ;
33190 2 : int alloc2 = 0 ;
33191 2 : int res3 ;
33192 2 : char *buf3 = 0 ;
33193 2 : int alloc3 = 0 ;
33194 2 : bool val4 ;
33195 2 : int ecode4 = 0 ;
33196 2 : int res5 ;
33197 2 : char *buf5 = 0 ;
33198 2 : int alloc5 = 0 ;
33199 2 : double val6 ;
33200 2 : int ecode6 = 0 ;
33201 2 : PyObject *swig_obj[6] ;
33202 2 : OGRFieldDomainShadow *result = 0 ;
33203 :
33204 2 : if (!SWIG_Python_UnpackTuple(args, "CreateRangeFieldDomainDateTime", 6, 6, swig_obj)) SWIG_fail;
33205 2 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
33206 2 : if (!SWIG_IsOK(res1)) {
33207 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateRangeFieldDomainDateTime" "', argument " "1"" of type '" "char const *""'");
33208 : }
33209 2 : arg1 = reinterpret_cast< char * >(buf1);
33210 2 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
33211 2 : if (!SWIG_IsOK(res2)) {
33212 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateRangeFieldDomainDateTime" "', argument " "2"" of type '" "char const *""'");
33213 : }
33214 2 : arg2 = reinterpret_cast< char * >(buf2);
33215 2 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
33216 2 : if (!SWIG_IsOK(res3)) {
33217 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CreateRangeFieldDomainDateTime" "', argument " "3"" of type '" "char const *""'");
33218 : }
33219 2 : arg3 = reinterpret_cast< char * >(buf3);
33220 2 : ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
33221 2 : if (!SWIG_IsOK(ecode4)) {
33222 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CreateRangeFieldDomainDateTime" "', argument " "4"" of type '" "bool""'");
33223 : }
33224 2 : arg4 = static_cast< bool >(val4);
33225 2 : res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
33226 2 : if (!SWIG_IsOK(res5)) {
33227 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CreateRangeFieldDomainDateTime" "', argument " "5"" of type '" "char const *""'");
33228 : }
33229 2 : arg5 = reinterpret_cast< char * >(buf5);
33230 2 : ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
33231 2 : if (!SWIG_IsOK(ecode6)) {
33232 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CreateRangeFieldDomainDateTime" "', argument " "6"" of type '" "double""'");
33233 : }
33234 2 : arg6 = static_cast< double >(val6);
33235 2 : {
33236 2 : if (!arg1) {
33237 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33238 : }
33239 : }
33240 2 : {
33241 2 : const int bLocalUseExceptions = GetUseExceptions();
33242 2 : if ( bLocalUseExceptions ) {
33243 1 : pushErrorHandler();
33244 : }
33245 2 : {
33246 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33247 2 : result = (OGRFieldDomainShadow *)CreateRangeFieldDomainDateTime((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,(char const *)arg5,arg6);
33248 2 : SWIG_PYTHON_THREAD_END_ALLOW;
33249 : }
33250 2 : if ( bLocalUseExceptions ) {
33251 1 : popErrorHandler();
33252 : }
33253 : #ifndef SED_HACKS
33254 : if ( bLocalUseExceptions ) {
33255 : CPLErr eclass = CPLGetLastErrorType();
33256 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33257 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33258 : }
33259 : }
33260 : #endif
33261 : }
33262 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
33263 2 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
33264 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33265 2 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
33266 2 : if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
33267 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33268 : return resultobj;
33269 0 : fail:
33270 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
33271 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33272 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
33273 0 : if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
33274 : return NULL;
33275 : }
33276 :
33277 :
33278 15 : SWIGINTERN PyObject *_wrap_CreateGlobFieldDomain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33279 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33280 15 : char *arg1 = (char *) 0 ;
33281 15 : char *arg2 = (char *) 0 ;
33282 15 : OGRFieldType arg3 ;
33283 15 : OGRFieldSubType arg4 ;
33284 15 : char *arg5 = (char *) 0 ;
33285 15 : int res1 ;
33286 15 : char *buf1 = 0 ;
33287 15 : int alloc1 = 0 ;
33288 15 : int res2 ;
33289 15 : char *buf2 = 0 ;
33290 15 : int alloc2 = 0 ;
33291 15 : int val3 ;
33292 15 : int ecode3 = 0 ;
33293 15 : int val4 ;
33294 15 : int ecode4 = 0 ;
33295 15 : int res5 ;
33296 15 : char *buf5 = 0 ;
33297 15 : int alloc5 = 0 ;
33298 15 : PyObject *swig_obj[5] ;
33299 15 : OGRFieldDomainShadow *result = 0 ;
33300 :
33301 15 : if (!SWIG_Python_UnpackTuple(args, "CreateGlobFieldDomain", 5, 5, swig_obj)) SWIG_fail;
33302 15 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
33303 15 : if (!SWIG_IsOK(res1)) {
33304 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateGlobFieldDomain" "', argument " "1"" of type '" "char const *""'");
33305 : }
33306 15 : arg1 = reinterpret_cast< char * >(buf1);
33307 15 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
33308 15 : if (!SWIG_IsOK(res2)) {
33309 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateGlobFieldDomain" "', argument " "2"" of type '" "char const *""'");
33310 : }
33311 15 : arg2 = reinterpret_cast< char * >(buf2);
33312 15 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
33313 15 : if (!SWIG_IsOK(ecode3)) {
33314 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CreateGlobFieldDomain" "', argument " "3"" of type '" "OGRFieldType""'");
33315 : }
33316 15 : arg3 = static_cast< OGRFieldType >(val3);
33317 15 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
33318 15 : if (!SWIG_IsOK(ecode4)) {
33319 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CreateGlobFieldDomain" "', argument " "4"" of type '" "OGRFieldSubType""'");
33320 : }
33321 15 : arg4 = static_cast< OGRFieldSubType >(val4);
33322 15 : res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
33323 15 : if (!SWIG_IsOK(res5)) {
33324 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CreateGlobFieldDomain" "', argument " "5"" of type '" "char const *""'");
33325 : }
33326 15 : arg5 = reinterpret_cast< char * >(buf5);
33327 15 : {
33328 15 : if (!arg1) {
33329 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33330 : }
33331 : }
33332 15 : {
33333 15 : if (!arg5) {
33334 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33335 : }
33336 : }
33337 14 : {
33338 14 : const int bLocalUseExceptions = GetUseExceptions();
33339 14 : if ( bLocalUseExceptions ) {
33340 13 : pushErrorHandler();
33341 : }
33342 14 : {
33343 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33344 14 : result = (OGRFieldDomainShadow *)CreateGlobFieldDomain((char const *)arg1,(char const *)arg2,arg3,arg4,(char const *)arg5);
33345 14 : SWIG_PYTHON_THREAD_END_ALLOW;
33346 : }
33347 14 : if ( bLocalUseExceptions ) {
33348 13 : popErrorHandler();
33349 : }
33350 : #ifndef SED_HACKS
33351 : if ( bLocalUseExceptions ) {
33352 : CPLErr eclass = CPLGetLastErrorType();
33353 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33354 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33355 : }
33356 : }
33357 : #endif
33358 : }
33359 14 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDomainShadow, SWIG_POINTER_OWN | 0 );
33360 14 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
33361 14 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33362 14 : if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
33363 15 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33364 : return resultobj;
33365 1 : fail:
33366 1 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
33367 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33368 1 : if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
33369 : return NULL;
33370 : }
33371 :
33372 :
33373 19 : SWIGINTERN PyObject *_wrap_delete_GeomCoordinatePrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33374 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33375 19 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33376 19 : void *argp1 = 0 ;
33377 19 : int res1 = 0 ;
33378 19 : PyObject *swig_obj[1] ;
33379 :
33380 19 : if (!args) SWIG_fail;
33381 19 : swig_obj[0] = args;
33382 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, SWIG_POINTER_DISOWN | 0 );
33383 19 : if (!SWIG_IsOK(res1)) {
33384 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeomCoordinatePrecision" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33385 : }
33386 19 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33387 19 : {
33388 19 : const int bLocalUseExceptions = GetUseExceptions();
33389 19 : if ( bLocalUseExceptions ) {
33390 14 : pushErrorHandler();
33391 : }
33392 19 : {
33393 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33394 19 : delete_OGRGeomCoordinatePrecisionShadow(arg1);
33395 19 : SWIG_PYTHON_THREAD_END_ALLOW;
33396 : }
33397 19 : if ( bLocalUseExceptions ) {
33398 14 : popErrorHandler();
33399 : }
33400 : #ifndef SED_HACKS
33401 : if ( bLocalUseExceptions ) {
33402 : CPLErr eclass = CPLGetLastErrorType();
33403 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33404 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33405 : }
33406 : }
33407 : #endif
33408 : }
33409 19 : resultobj = SWIG_Py_Void();
33410 19 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33411 : return resultobj;
33412 : fail:
33413 : return NULL;
33414 : }
33415 :
33416 :
33417 19 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33418 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33419 19 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33420 19 : double arg2 ;
33421 19 : double arg3 ;
33422 19 : double arg4 ;
33423 19 : void *argp1 = 0 ;
33424 19 : int res1 = 0 ;
33425 19 : double val2 ;
33426 19 : int ecode2 = 0 ;
33427 19 : double val3 ;
33428 19 : int ecode3 = 0 ;
33429 19 : double val4 ;
33430 19 : int ecode4 = 0 ;
33431 19 : PyObject *swig_obj[4] ;
33432 :
33433 19 : if (!SWIG_Python_UnpackTuple(args, "GeomCoordinatePrecision_Set", 4, 4, swig_obj)) SWIG_fail;
33434 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33435 19 : if (!SWIG_IsOK(res1)) {
33436 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_Set" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33437 : }
33438 19 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33439 19 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
33440 19 : if (!SWIG_IsOK(ecode2)) {
33441 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeomCoordinatePrecision_Set" "', argument " "2"" of type '" "double""'");
33442 : }
33443 19 : arg2 = static_cast< double >(val2);
33444 19 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
33445 19 : if (!SWIG_IsOK(ecode3)) {
33446 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GeomCoordinatePrecision_Set" "', argument " "3"" of type '" "double""'");
33447 : }
33448 19 : arg3 = static_cast< double >(val3);
33449 19 : ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
33450 19 : if (!SWIG_IsOK(ecode4)) {
33451 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GeomCoordinatePrecision_Set" "', argument " "4"" of type '" "double""'");
33452 : }
33453 19 : arg4 = static_cast< double >(val4);
33454 19 : {
33455 19 : const int bLocalUseExceptions = GetUseExceptions();
33456 19 : if ( bLocalUseExceptions ) {
33457 14 : pushErrorHandler();
33458 : }
33459 19 : {
33460 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33461 19 : OGRGeomCoordinatePrecisionShadow_Set(arg1,arg2,arg3,arg4);
33462 19 : SWIG_PYTHON_THREAD_END_ALLOW;
33463 : }
33464 19 : if ( bLocalUseExceptions ) {
33465 14 : popErrorHandler();
33466 : }
33467 : #ifndef SED_HACKS
33468 : if ( bLocalUseExceptions ) {
33469 : CPLErr eclass = CPLGetLastErrorType();
33470 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33471 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33472 : }
33473 : }
33474 : #endif
33475 : }
33476 19 : resultobj = SWIG_Py_Void();
33477 19 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33478 : return resultobj;
33479 : fail:
33480 : return NULL;
33481 : }
33482 :
33483 :
33484 4 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_SetFromMeter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33485 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33486 4 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33487 4 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
33488 4 : double arg3 ;
33489 4 : double arg4 ;
33490 4 : double arg5 ;
33491 4 : void *argp1 = 0 ;
33492 4 : int res1 = 0 ;
33493 4 : void *argp2 = 0 ;
33494 4 : int res2 = 0 ;
33495 4 : double val3 ;
33496 4 : int ecode3 = 0 ;
33497 4 : double val4 ;
33498 4 : int ecode4 = 0 ;
33499 4 : double val5 ;
33500 4 : int ecode5 = 0 ;
33501 4 : PyObject *swig_obj[5] ;
33502 :
33503 4 : if (!SWIG_Python_UnpackTuple(args, "GeomCoordinatePrecision_SetFromMeter", 5, 5, swig_obj)) SWIG_fail;
33504 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33505 4 : if (!SWIG_IsOK(res1)) {
33506 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_SetFromMeter" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33507 : }
33508 4 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33509 4 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
33510 4 : if (!SWIG_IsOK(res2)) {
33511 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomCoordinatePrecision_SetFromMeter" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
33512 : }
33513 4 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
33514 4 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
33515 4 : if (!SWIG_IsOK(ecode3)) {
33516 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GeomCoordinatePrecision_SetFromMeter" "', argument " "3"" of type '" "double""'");
33517 : }
33518 4 : arg3 = static_cast< double >(val3);
33519 4 : ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
33520 4 : if (!SWIG_IsOK(ecode4)) {
33521 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GeomCoordinatePrecision_SetFromMeter" "', argument " "4"" of type '" "double""'");
33522 : }
33523 4 : arg4 = static_cast< double >(val4);
33524 4 : ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
33525 4 : if (!SWIG_IsOK(ecode5)) {
33526 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GeomCoordinatePrecision_SetFromMeter" "', argument " "5"" of type '" "double""'");
33527 : }
33528 4 : arg5 = static_cast< double >(val5);
33529 4 : {
33530 4 : if (!arg2) {
33531 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33532 : }
33533 : }
33534 3 : {
33535 3 : const int bLocalUseExceptions = GetUseExceptions();
33536 3 : if ( bLocalUseExceptions ) {
33537 3 : pushErrorHandler();
33538 : }
33539 3 : {
33540 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33541 3 : OGRGeomCoordinatePrecisionShadow_SetFromMeter(arg1,arg2,arg3,arg4,arg5);
33542 3 : SWIG_PYTHON_THREAD_END_ALLOW;
33543 : }
33544 3 : if ( bLocalUseExceptions ) {
33545 3 : popErrorHandler();
33546 : }
33547 : #ifndef SED_HACKS
33548 : if ( bLocalUseExceptions ) {
33549 : CPLErr eclass = CPLGetLastErrorType();
33550 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33551 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33552 : }
33553 : }
33554 : #endif
33555 : }
33556 3 : resultobj = SWIG_Py_Void();
33557 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33558 : return resultobj;
33559 : fail:
33560 : return NULL;
33561 : }
33562 :
33563 :
33564 45 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_GetXYResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33565 45 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33566 45 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33567 45 : void *argp1 = 0 ;
33568 45 : int res1 = 0 ;
33569 45 : PyObject *swig_obj[1] ;
33570 45 : double result;
33571 :
33572 45 : if (!args) SWIG_fail;
33573 45 : swig_obj[0] = args;
33574 45 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33575 45 : if (!SWIG_IsOK(res1)) {
33576 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_GetXYResolution" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33577 : }
33578 45 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33579 45 : {
33580 45 : const int bLocalUseExceptions = GetUseExceptions();
33581 45 : if ( bLocalUseExceptions ) {
33582 38 : pushErrorHandler();
33583 : }
33584 45 : {
33585 45 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33586 45 : result = (double)OGRGeomCoordinatePrecisionShadow_GetXYResolution(arg1);
33587 45 : SWIG_PYTHON_THREAD_END_ALLOW;
33588 : }
33589 45 : if ( bLocalUseExceptions ) {
33590 38 : popErrorHandler();
33591 : }
33592 : #ifndef SED_HACKS
33593 : if ( bLocalUseExceptions ) {
33594 : CPLErr eclass = CPLGetLastErrorType();
33595 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33596 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33597 : }
33598 : }
33599 : #endif
33600 : }
33601 45 : resultobj = SWIG_From_double(static_cast< double >(result));
33602 45 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33603 : return resultobj;
33604 : fail:
33605 : return NULL;
33606 : }
33607 :
33608 :
33609 42 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_GetZResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33610 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33611 42 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33612 42 : void *argp1 = 0 ;
33613 42 : int res1 = 0 ;
33614 42 : PyObject *swig_obj[1] ;
33615 42 : double result;
33616 :
33617 42 : if (!args) SWIG_fail;
33618 42 : swig_obj[0] = args;
33619 42 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33620 42 : if (!SWIG_IsOK(res1)) {
33621 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_GetZResolution" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33622 : }
33623 42 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33624 42 : {
33625 42 : const int bLocalUseExceptions = GetUseExceptions();
33626 42 : if ( bLocalUseExceptions ) {
33627 35 : pushErrorHandler();
33628 : }
33629 42 : {
33630 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33631 42 : result = (double)OGRGeomCoordinatePrecisionShadow_GetZResolution(arg1);
33632 42 : SWIG_PYTHON_THREAD_END_ALLOW;
33633 : }
33634 42 : if ( bLocalUseExceptions ) {
33635 35 : popErrorHandler();
33636 : }
33637 : #ifndef SED_HACKS
33638 : if ( bLocalUseExceptions ) {
33639 : CPLErr eclass = CPLGetLastErrorType();
33640 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33641 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33642 : }
33643 : }
33644 : #endif
33645 : }
33646 42 : resultobj = SWIG_From_double(static_cast< double >(result));
33647 42 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33648 : return resultobj;
33649 : fail:
33650 : return NULL;
33651 : }
33652 :
33653 :
33654 27 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_GetMResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33655 27 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33656 27 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33657 27 : void *argp1 = 0 ;
33658 27 : int res1 = 0 ;
33659 27 : PyObject *swig_obj[1] ;
33660 27 : double result;
33661 :
33662 27 : if (!args) SWIG_fail;
33663 27 : swig_obj[0] = args;
33664 27 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33665 27 : if (!SWIG_IsOK(res1)) {
33666 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_GetMResolution" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33667 : }
33668 27 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33669 27 : {
33670 27 : const int bLocalUseExceptions = GetUseExceptions();
33671 27 : if ( bLocalUseExceptions ) {
33672 22 : pushErrorHandler();
33673 : }
33674 27 : {
33675 27 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33676 27 : result = (double)OGRGeomCoordinatePrecisionShadow_GetMResolution(arg1);
33677 27 : SWIG_PYTHON_THREAD_END_ALLOW;
33678 : }
33679 27 : if ( bLocalUseExceptions ) {
33680 22 : popErrorHandler();
33681 : }
33682 : #ifndef SED_HACKS
33683 : if ( bLocalUseExceptions ) {
33684 : CPLErr eclass = CPLGetLastErrorType();
33685 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33686 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33687 : }
33688 : }
33689 : #endif
33690 : }
33691 27 : resultobj = SWIG_From_double(static_cast< double >(result));
33692 27 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33693 : return resultobj;
33694 : fail:
33695 : return NULL;
33696 : }
33697 :
33698 :
33699 4 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_GetFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33700 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33701 4 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33702 4 : void *argp1 = 0 ;
33703 4 : int res1 = 0 ;
33704 4 : PyObject *swig_obj[1] ;
33705 4 : char **result = 0 ;
33706 :
33707 4 : if (!args) SWIG_fail;
33708 4 : swig_obj[0] = args;
33709 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33710 4 : if (!SWIG_IsOK(res1)) {
33711 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_GetFormats" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33712 : }
33713 4 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33714 4 : {
33715 4 : const int bLocalUseExceptions = GetUseExceptions();
33716 4 : if ( bLocalUseExceptions ) {
33717 2 : pushErrorHandler();
33718 : }
33719 4 : {
33720 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33721 4 : result = (char **)OGRGeomCoordinatePrecisionShadow_GetFormats(arg1);
33722 4 : SWIG_PYTHON_THREAD_END_ALLOW;
33723 : }
33724 4 : if ( bLocalUseExceptions ) {
33725 2 : popErrorHandler();
33726 : }
33727 : #ifndef SED_HACKS
33728 : if ( bLocalUseExceptions ) {
33729 : CPLErr eclass = CPLGetLastErrorType();
33730 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33731 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33732 : }
33733 : }
33734 : #endif
33735 : }
33736 4 : {
33737 : /* %typemap(out) char **CSL -> ( string ) */
33738 4 : bool bErr = false;
33739 4 : resultobj = CSLToList(result, &bErr);
33740 4 : CSLDestroy(result);
33741 4 : if( bErr ) {
33742 0 : SWIG_fail;
33743 : }
33744 : }
33745 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33746 : return resultobj;
33747 : fail:
33748 : return NULL;
33749 : }
33750 :
33751 :
33752 6 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_GetFormatSpecificOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33753 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33754 6 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33755 6 : char *arg2 = (char *) 0 ;
33756 6 : void *argp1 = 0 ;
33757 6 : int res1 = 0 ;
33758 6 : int res2 ;
33759 6 : char *buf2 = 0 ;
33760 6 : int alloc2 = 0 ;
33761 6 : PyObject *swig_obj[2] ;
33762 6 : char **result = 0 ;
33763 :
33764 6 : if (!SWIG_Python_UnpackTuple(args, "GeomCoordinatePrecision_GetFormatSpecificOptions", 2, 2, swig_obj)) SWIG_fail;
33765 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33766 6 : if (!SWIG_IsOK(res1)) {
33767 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_GetFormatSpecificOptions" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33768 : }
33769 6 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33770 6 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
33771 6 : if (!SWIG_IsOK(res2)) {
33772 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomCoordinatePrecision_GetFormatSpecificOptions" "', argument " "2"" of type '" "char const *""'");
33773 : }
33774 6 : arg2 = reinterpret_cast< char * >(buf2);
33775 6 : {
33776 6 : if (!arg2) {
33777 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33778 : }
33779 : }
33780 5 : {
33781 5 : const int bLocalUseExceptions = GetUseExceptions();
33782 5 : if ( bLocalUseExceptions ) {
33783 2 : pushErrorHandler();
33784 : }
33785 5 : {
33786 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33787 5 : result = (char **)OGRGeomCoordinatePrecisionShadow_GetFormatSpecificOptions(arg1,(char const *)arg2);
33788 5 : SWIG_PYTHON_THREAD_END_ALLOW;
33789 : }
33790 5 : if ( bLocalUseExceptions ) {
33791 2 : popErrorHandler();
33792 : }
33793 : #ifndef SED_HACKS
33794 : if ( bLocalUseExceptions ) {
33795 : CPLErr eclass = CPLGetLastErrorType();
33796 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33797 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33798 : }
33799 : }
33800 : #endif
33801 : }
33802 5 : {
33803 : /* %typemap(out) char **dict */
33804 5 : resultobj = GetCSLStringAsPyDict(result, false);
33805 : }
33806 5 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33807 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33808 : return resultobj;
33809 1 : fail:
33810 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33811 : return NULL;
33812 : }
33813 :
33814 :
33815 1 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_SetFormatSpecificOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33816 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33817 1 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33818 1 : char *arg2 = (char *) 0 ;
33819 1 : char **arg3 = (char **) 0 ;
33820 1 : void *argp1 = 0 ;
33821 1 : int res1 = 0 ;
33822 1 : int res2 ;
33823 1 : char *buf2 = 0 ;
33824 1 : int alloc2 = 0 ;
33825 1 : PyObject *swig_obj[3] ;
33826 :
33827 1 : if (!SWIG_Python_UnpackTuple(args, "GeomCoordinatePrecision_SetFormatSpecificOptions", 3, 3, swig_obj)) SWIG_fail;
33828 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33829 1 : if (!SWIG_IsOK(res1)) {
33830 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_SetFormatSpecificOptions" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33831 : }
33832 1 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33833 1 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
33834 1 : if (!SWIG_IsOK(res2)) {
33835 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomCoordinatePrecision_SetFormatSpecificOptions" "', argument " "2"" of type '" "char const *""'");
33836 : }
33837 1 : arg2 = reinterpret_cast< char * >(buf2);
33838 1 : {
33839 : /* %typemap(in) char **dict */
33840 1 : arg3 = NULL;
33841 1 : if ( PySequence_Check( swig_obj[2] ) ) {
33842 0 : int bErr = FALSE;
33843 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
33844 0 : if ( bErr )
33845 : {
33846 0 : SWIG_fail;
33847 : }
33848 : }
33849 1 : else if ( PyMapping_Check( swig_obj[2] ) ) {
33850 1 : int bErr = FALSE;
33851 1 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
33852 1 : if ( bErr )
33853 : {
33854 0 : SWIG_fail;
33855 : }
33856 : }
33857 : else {
33858 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
33859 0 : SWIG_fail;
33860 : }
33861 : }
33862 1 : {
33863 1 : if (!arg2) {
33864 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33865 : }
33866 : }
33867 1 : {
33868 1 : const int bLocalUseExceptions = GetUseExceptions();
33869 1 : if ( bLocalUseExceptions ) {
33870 1 : pushErrorHandler();
33871 : }
33872 1 : {
33873 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33874 1 : OGRGeomCoordinatePrecisionShadow_SetFormatSpecificOptions(arg1,(char const *)arg2,arg3);
33875 1 : SWIG_PYTHON_THREAD_END_ALLOW;
33876 : }
33877 1 : if ( bLocalUseExceptions ) {
33878 1 : popErrorHandler();
33879 : }
33880 : #ifndef SED_HACKS
33881 : if ( bLocalUseExceptions ) {
33882 : CPLErr eclass = CPLGetLastErrorType();
33883 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33884 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33885 : }
33886 : }
33887 : #endif
33888 : }
33889 1 : resultobj = SWIG_Py_Void();
33890 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33891 1 : {
33892 : /* %typemap(freearg) char **dict */
33893 1 : CSLDestroy( arg3 );
33894 : }
33895 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33896 : return resultobj;
33897 0 : fail:
33898 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33899 0 : {
33900 : /* %typemap(freearg) char **dict */
33901 0 : CSLDestroy( arg3 );
33902 : }
33903 : return NULL;
33904 : }
33905 :
33906 :
33907 273 : SWIGINTERN PyObject *GeomCoordinatePrecision_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33908 273 : PyObject *obj;
33909 273 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
33910 273 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, SWIG_NewClientData(obj));
33911 273 : return SWIG_Py_Void();
33912 : }
33913 :
33914 19 : SWIGINTERN PyObject *_wrap_CreateGeomCoordinatePrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33915 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33916 19 : OGRGeomCoordinatePrecisionShadow *result = 0 ;
33917 :
33918 19 : if (!SWIG_Python_UnpackTuple(args, "CreateGeomCoordinatePrecision", 0, 0, 0)) SWIG_fail;
33919 19 : {
33920 19 : const int bLocalUseExceptions = GetUseExceptions();
33921 19 : if ( bLocalUseExceptions ) {
33922 14 : pushErrorHandler();
33923 : }
33924 19 : {
33925 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33926 19 : result = (OGRGeomCoordinatePrecisionShadow *)CreateGeomCoordinatePrecision();
33927 19 : SWIG_PYTHON_THREAD_END_ALLOW;
33928 : }
33929 19 : if ( bLocalUseExceptions ) {
33930 14 : popErrorHandler();
33931 : }
33932 : #ifndef SED_HACKS
33933 : if ( bLocalUseExceptions ) {
33934 : CPLErr eclass = CPLGetLastErrorType();
33935 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33936 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33937 : }
33938 : }
33939 : #endif
33940 : }
33941 19 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, SWIG_POINTER_OWN | 0 );
33942 19 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33943 : return resultobj;
33944 0 : fail:
33945 0 : return NULL;
33946 : }
33947 :
33948 :
33949 0 : SWIGINTERN PyObject *_wrap_GetDriverCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33950 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33951 0 : int result;
33952 :
33953 0 : if (!SWIG_Python_UnpackTuple(args, "GetDriverCount", 0, 0, 0)) SWIG_fail;
33954 0 : {
33955 0 : const int bLocalUseExceptions = GetUseExceptions();
33956 0 : if ( bLocalUseExceptions ) {
33957 0 : pushErrorHandler();
33958 : }
33959 0 : {
33960 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33961 0 : result = (int)OGRGetDriverCount();
33962 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33963 : }
33964 0 : if ( bLocalUseExceptions ) {
33965 0 : popErrorHandler();
33966 : }
33967 : #ifndef SED_HACKS
33968 : if ( bLocalUseExceptions ) {
33969 : CPLErr eclass = CPLGetLastErrorType();
33970 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33971 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33972 : }
33973 : }
33974 : #endif
33975 : }
33976 0 : resultobj = SWIG_From_int(static_cast< int >(result));
33977 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33978 : return resultobj;
33979 0 : fail:
33980 0 : return NULL;
33981 : }
33982 :
33983 :
33984 0 : SWIGINTERN PyObject *_wrap_GetOpenDSCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33985 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33986 0 : int result;
33987 :
33988 0 : if (!SWIG_Python_UnpackTuple(args, "GetOpenDSCount", 0, 0, 0)) SWIG_fail;
33989 0 : {
33990 0 : const int bLocalUseExceptions = GetUseExceptions();
33991 0 : if ( bLocalUseExceptions ) {
33992 0 : pushErrorHandler();
33993 : }
33994 0 : {
33995 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33996 0 : result = (int)OGRGetOpenDSCount();
33997 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33998 : }
33999 0 : if ( bLocalUseExceptions ) {
34000 0 : popErrorHandler();
34001 : }
34002 : #ifndef SED_HACKS
34003 : if ( bLocalUseExceptions ) {
34004 : CPLErr eclass = CPLGetLastErrorType();
34005 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34006 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34007 : }
34008 : }
34009 : #endif
34010 : }
34011 0 : resultobj = SWIG_From_int(static_cast< int >(result));
34012 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34013 : return resultobj;
34014 0 : fail:
34015 0 : return NULL;
34016 : }
34017 :
34018 :
34019 4 : SWIGINTERN PyObject *_wrap_SetGenerate_DB2_V72_BYTE_ORDER(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34020 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34021 4 : int arg1 ;
34022 4 : int val1 ;
34023 4 : int ecode1 = 0 ;
34024 4 : PyObject *swig_obj[1] ;
34025 4 : OGRErr result;
34026 :
34027 4 : if (!args) SWIG_fail;
34028 4 : swig_obj[0] = args;
34029 4 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34030 4 : if (!SWIG_IsOK(ecode1)) {
34031 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SetGenerate_DB2_V72_BYTE_ORDER" "', argument " "1"" of type '" "int""'");
34032 : }
34033 4 : arg1 = static_cast< int >(val1);
34034 4 : {
34035 4 : const int bLocalUseExceptions = GetUseExceptions();
34036 4 : if ( bLocalUseExceptions ) {
34037 4 : pushErrorHandler();
34038 : }
34039 4 : {
34040 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34041 4 : result = (OGRErr)OGRSetGenerate_DB2_V72_BYTE_ORDER(arg1);
34042 4 : SWIG_PYTHON_THREAD_END_ALLOW;
34043 : }
34044 4 : if ( bLocalUseExceptions ) {
34045 4 : popErrorHandler();
34046 : }
34047 : #ifndef SED_HACKS
34048 : if ( bLocalUseExceptions ) {
34049 : CPLErr eclass = CPLGetLastErrorType();
34050 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34051 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34052 : }
34053 : }
34054 : #endif
34055 : }
34056 4 : {
34057 : /* %typemap(out) OGRErr */
34058 4 : if ( result != 0 && GetUseExceptions()) {
34059 0 : const char* pszMessage = CPLGetLastErrorMsg();
34060 0 : if( pszMessage[0] != '\0' )
34061 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
34062 : else
34063 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
34064 0 : SWIG_fail;
34065 : }
34066 : }
34067 4 : {
34068 : /* %typemap(ret) OGRErr */
34069 4 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
34070 4 : resultobj = PyInt_FromLong( result );
34071 : }
34072 : }
34073 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34074 : return resultobj;
34075 : fail:
34076 : return NULL;
34077 : }
34078 :
34079 :
34080 3 : SWIGINTERN PyObject *_wrap_RegisterAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34081 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34082 :
34083 3 : if (!SWIG_Python_UnpackTuple(args, "RegisterAll", 0, 0, 0)) SWIG_fail;
34084 3 : {
34085 3 : const int bLocalUseExceptions = GetUseExceptions();
34086 3 : if ( bLocalUseExceptions ) {
34087 3 : pushErrorHandler();
34088 : }
34089 3 : {
34090 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34091 3 : OGRRegisterAll();
34092 3 : SWIG_PYTHON_THREAD_END_ALLOW;
34093 : }
34094 3 : if ( bLocalUseExceptions ) {
34095 3 : popErrorHandler();
34096 : }
34097 : #ifndef SED_HACKS
34098 : if ( bLocalUseExceptions ) {
34099 : CPLErr eclass = CPLGetLastErrorType();
34100 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34101 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34102 : }
34103 : }
34104 : #endif
34105 : }
34106 3 : resultobj = SWIG_Py_Void();
34107 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34108 : return resultobj;
34109 0 : fail:
34110 0 : return NULL;
34111 : }
34112 :
34113 :
34114 71 : SWIGINTERN PyObject *_wrap_GeometryTypeToName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34115 71 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34116 71 : OGRwkbGeometryType arg1 ;
34117 71 : int val1 ;
34118 71 : int ecode1 = 0 ;
34119 71 : PyObject *swig_obj[1] ;
34120 71 : char *result = 0 ;
34121 :
34122 71 : if (!args) SWIG_fail;
34123 71 : swig_obj[0] = args;
34124 71 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34125 71 : if (!SWIG_IsOK(ecode1)) {
34126 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GeometryTypeToName" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34127 : }
34128 71 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34129 71 : {
34130 71 : const int bLocalUseExceptions = GetUseExceptions();
34131 71 : if ( bLocalUseExceptions ) {
34132 46 : pushErrorHandler();
34133 : }
34134 71 : {
34135 71 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34136 71 : result = (char *)OGRGeometryTypeToName(arg1);
34137 71 : SWIG_PYTHON_THREAD_END_ALLOW;
34138 : }
34139 71 : if ( bLocalUseExceptions ) {
34140 46 : popErrorHandler();
34141 : }
34142 : #ifndef SED_HACKS
34143 : if ( bLocalUseExceptions ) {
34144 : CPLErr eclass = CPLGetLastErrorType();
34145 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34146 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34147 : }
34148 : }
34149 : #endif
34150 : }
34151 71 : resultobj = SWIG_FromCharPtr((const char *)result);
34152 71 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34153 : return resultobj;
34154 : fail:
34155 : return NULL;
34156 : }
34157 :
34158 :
34159 1649 : SWIGINTERN PyObject *_wrap_GetFieldTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34160 1649 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34161 1649 : OGRFieldType arg1 ;
34162 1649 : int val1 ;
34163 1649 : int ecode1 = 0 ;
34164 1649 : PyObject *swig_obj[1] ;
34165 1649 : char *result = 0 ;
34166 :
34167 1649 : if (!args) SWIG_fail;
34168 1649 : swig_obj[0] = args;
34169 1649 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34170 1649 : if (!SWIG_IsOK(ecode1)) {
34171 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetFieldTypeName" "', argument " "1"" of type '" "OGRFieldType""'");
34172 : }
34173 1649 : arg1 = static_cast< OGRFieldType >(val1);
34174 1649 : {
34175 1649 : const int bLocalUseExceptions = GetUseExceptions();
34176 1649 : if ( bLocalUseExceptions ) {
34177 1477 : pushErrorHandler();
34178 : }
34179 1649 : {
34180 1649 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34181 1649 : result = (char *)OGR_GetFieldTypeName(arg1);
34182 1649 : SWIG_PYTHON_THREAD_END_ALLOW;
34183 : }
34184 1649 : if ( bLocalUseExceptions ) {
34185 1477 : popErrorHandler();
34186 : }
34187 : #ifndef SED_HACKS
34188 : if ( bLocalUseExceptions ) {
34189 : CPLErr eclass = CPLGetLastErrorType();
34190 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34191 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34192 : }
34193 : }
34194 : #endif
34195 : }
34196 1649 : resultobj = SWIG_FromCharPtr((const char *)result);
34197 1649 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34198 : return resultobj;
34199 : fail:
34200 : return NULL;
34201 : }
34202 :
34203 :
34204 1480 : SWIGINTERN PyObject *_wrap_GetFieldSubTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34205 1480 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34206 1480 : OGRFieldSubType arg1 ;
34207 1480 : int val1 ;
34208 1480 : int ecode1 = 0 ;
34209 1480 : PyObject *swig_obj[1] ;
34210 1480 : char *result = 0 ;
34211 :
34212 1480 : if (!args) SWIG_fail;
34213 1480 : swig_obj[0] = args;
34214 1480 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34215 1480 : if (!SWIG_IsOK(ecode1)) {
34216 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetFieldSubTypeName" "', argument " "1"" of type '" "OGRFieldSubType""'");
34217 : }
34218 1480 : arg1 = static_cast< OGRFieldSubType >(val1);
34219 1480 : {
34220 1480 : const int bLocalUseExceptions = GetUseExceptions();
34221 1480 : if ( bLocalUseExceptions ) {
34222 1480 : pushErrorHandler();
34223 : }
34224 1480 : {
34225 1480 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34226 1480 : result = (char *)OGR_GetFieldSubTypeName(arg1);
34227 1480 : SWIG_PYTHON_THREAD_END_ALLOW;
34228 : }
34229 1480 : if ( bLocalUseExceptions ) {
34230 1480 : popErrorHandler();
34231 : }
34232 : #ifndef SED_HACKS
34233 : if ( bLocalUseExceptions ) {
34234 : CPLErr eclass = CPLGetLastErrorType();
34235 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34236 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34237 : }
34238 : }
34239 : #endif
34240 : }
34241 1480 : resultobj = SWIG_FromCharPtr((const char *)result);
34242 1480 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34243 : return resultobj;
34244 : fail:
34245 : return NULL;
34246 : }
34247 :
34248 :
34249 2072 : SWIGINTERN PyObject *_wrap_GT_Flatten(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34250 2072 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34251 2072 : OGRwkbGeometryType arg1 ;
34252 2072 : int val1 ;
34253 2072 : int ecode1 = 0 ;
34254 2072 : PyObject *swig_obj[1] ;
34255 2072 : OGRwkbGeometryType result;
34256 :
34257 2072 : if (!args) SWIG_fail;
34258 2072 : swig_obj[0] = args;
34259 2072 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34260 2072 : if (!SWIG_IsOK(ecode1)) {
34261 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_Flatten" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34262 : }
34263 2072 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34264 2072 : {
34265 2072 : const int bLocalUseExceptions = GetUseExceptions();
34266 2072 : if ( bLocalUseExceptions ) {
34267 119 : pushErrorHandler();
34268 : }
34269 2072 : {
34270 2072 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34271 2072 : result = (OGRwkbGeometryType)OGR_GT_Flatten(arg1);
34272 2072 : SWIG_PYTHON_THREAD_END_ALLOW;
34273 : }
34274 2072 : if ( bLocalUseExceptions ) {
34275 119 : popErrorHandler();
34276 : }
34277 : #ifndef SED_HACKS
34278 : if ( bLocalUseExceptions ) {
34279 : CPLErr eclass = CPLGetLastErrorType();
34280 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34281 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34282 : }
34283 : }
34284 : #endif
34285 : }
34286 2072 : resultobj = SWIG_From_int(static_cast< int >(result));
34287 2072 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34288 : return resultobj;
34289 : fail:
34290 : return NULL;
34291 : }
34292 :
34293 :
34294 36 : SWIGINTERN PyObject *_wrap_GT_SetZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34295 36 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34296 36 : OGRwkbGeometryType arg1 ;
34297 36 : int val1 ;
34298 36 : int ecode1 = 0 ;
34299 36 : PyObject *swig_obj[1] ;
34300 36 : OGRwkbGeometryType result;
34301 :
34302 36 : if (!args) SWIG_fail;
34303 36 : swig_obj[0] = args;
34304 36 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34305 36 : if (!SWIG_IsOK(ecode1)) {
34306 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_SetZ" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34307 : }
34308 36 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34309 36 : {
34310 36 : const int bLocalUseExceptions = GetUseExceptions();
34311 36 : if ( bLocalUseExceptions ) {
34312 0 : pushErrorHandler();
34313 : }
34314 36 : {
34315 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34316 36 : result = (OGRwkbGeometryType)OGR_GT_SetZ(arg1);
34317 36 : SWIG_PYTHON_THREAD_END_ALLOW;
34318 : }
34319 36 : if ( bLocalUseExceptions ) {
34320 0 : popErrorHandler();
34321 : }
34322 : #ifndef SED_HACKS
34323 : if ( bLocalUseExceptions ) {
34324 : CPLErr eclass = CPLGetLastErrorType();
34325 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34326 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34327 : }
34328 : }
34329 : #endif
34330 : }
34331 36 : resultobj = SWIG_From_int(static_cast< int >(result));
34332 36 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34333 : return resultobj;
34334 : fail:
34335 : return NULL;
34336 : }
34337 :
34338 :
34339 36 : SWIGINTERN PyObject *_wrap_GT_SetM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34340 36 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34341 36 : OGRwkbGeometryType arg1 ;
34342 36 : int val1 ;
34343 36 : int ecode1 = 0 ;
34344 36 : PyObject *swig_obj[1] ;
34345 36 : OGRwkbGeometryType result;
34346 :
34347 36 : if (!args) SWIG_fail;
34348 36 : swig_obj[0] = args;
34349 36 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34350 36 : if (!SWIG_IsOK(ecode1)) {
34351 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_SetM" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34352 : }
34353 36 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34354 36 : {
34355 36 : const int bLocalUseExceptions = GetUseExceptions();
34356 36 : if ( bLocalUseExceptions ) {
34357 0 : pushErrorHandler();
34358 : }
34359 36 : {
34360 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34361 36 : result = (OGRwkbGeometryType)OGR_GT_SetM(arg1);
34362 36 : SWIG_PYTHON_THREAD_END_ALLOW;
34363 : }
34364 36 : if ( bLocalUseExceptions ) {
34365 0 : popErrorHandler();
34366 : }
34367 : #ifndef SED_HACKS
34368 : if ( bLocalUseExceptions ) {
34369 : CPLErr eclass = CPLGetLastErrorType();
34370 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34371 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34372 : }
34373 : }
34374 : #endif
34375 : }
34376 36 : resultobj = SWIG_From_int(static_cast< int >(result));
34377 36 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34378 : return resultobj;
34379 : fail:
34380 : return NULL;
34381 : }
34382 :
34383 :
34384 18 : SWIGINTERN PyObject *_wrap_GT_SetModifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34385 18 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34386 18 : OGRwkbGeometryType arg1 ;
34387 18 : int arg2 ;
34388 18 : int arg3 = (int) FALSE ;
34389 18 : int val1 ;
34390 18 : int ecode1 = 0 ;
34391 18 : int val2 ;
34392 18 : int ecode2 = 0 ;
34393 18 : int val3 ;
34394 18 : int ecode3 = 0 ;
34395 18 : PyObject *swig_obj[3] ;
34396 18 : OGRwkbGeometryType result;
34397 :
34398 18 : if (!SWIG_Python_UnpackTuple(args, "GT_SetModifier", 2, 3, swig_obj)) SWIG_fail;
34399 18 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34400 18 : if (!SWIG_IsOK(ecode1)) {
34401 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_SetModifier" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34402 : }
34403 18 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34404 18 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34405 18 : if (!SWIG_IsOK(ecode2)) {
34406 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GT_SetModifier" "', argument " "2"" of type '" "int""'");
34407 : }
34408 18 : arg2 = static_cast< int >(val2);
34409 18 : if (swig_obj[2]) {
34410 18 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
34411 18 : if (!SWIG_IsOK(ecode3)) {
34412 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GT_SetModifier" "', argument " "3"" of type '" "int""'");
34413 : }
34414 : arg3 = static_cast< int >(val3);
34415 : }
34416 18 : {
34417 18 : const int bLocalUseExceptions = GetUseExceptions();
34418 18 : if ( bLocalUseExceptions ) {
34419 0 : pushErrorHandler();
34420 : }
34421 18 : {
34422 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34423 18 : result = (OGRwkbGeometryType)GT_SetModifier(arg1,arg2,arg3);
34424 18 : SWIG_PYTHON_THREAD_END_ALLOW;
34425 : }
34426 18 : if ( bLocalUseExceptions ) {
34427 0 : popErrorHandler();
34428 : }
34429 : #ifndef SED_HACKS
34430 : if ( bLocalUseExceptions ) {
34431 : CPLErr eclass = CPLGetLastErrorType();
34432 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34433 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34434 : }
34435 : }
34436 : #endif
34437 : }
34438 18 : resultobj = SWIG_From_int(static_cast< int >(result));
34439 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34440 : return resultobj;
34441 : fail:
34442 : return NULL;
34443 : }
34444 :
34445 :
34446 18 : SWIGINTERN PyObject *_wrap_GT_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34447 18 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34448 18 : OGRwkbGeometryType arg1 ;
34449 18 : int val1 ;
34450 18 : int ecode1 = 0 ;
34451 18 : PyObject *swig_obj[1] ;
34452 18 : int result;
34453 :
34454 18 : if (!args) SWIG_fail;
34455 18 : swig_obj[0] = args;
34456 18 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34457 18 : if (!SWIG_IsOK(ecode1)) {
34458 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_HasZ" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34459 : }
34460 18 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34461 18 : {
34462 18 : const int bLocalUseExceptions = GetUseExceptions();
34463 18 : if ( bLocalUseExceptions ) {
34464 0 : pushErrorHandler();
34465 : }
34466 18 : {
34467 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34468 18 : result = (int)OGR_GT_HasZ(arg1);
34469 18 : SWIG_PYTHON_THREAD_END_ALLOW;
34470 : }
34471 18 : if ( bLocalUseExceptions ) {
34472 0 : popErrorHandler();
34473 : }
34474 : #ifndef SED_HACKS
34475 : if ( bLocalUseExceptions ) {
34476 : CPLErr eclass = CPLGetLastErrorType();
34477 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34478 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34479 : }
34480 : }
34481 : #endif
34482 : }
34483 18 : resultobj = SWIG_From_int(static_cast< int >(result));
34484 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34485 : return resultobj;
34486 : fail:
34487 : return NULL;
34488 : }
34489 :
34490 :
34491 18 : SWIGINTERN PyObject *_wrap_GT_HasM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34492 18 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34493 18 : OGRwkbGeometryType arg1 ;
34494 18 : int val1 ;
34495 18 : int ecode1 = 0 ;
34496 18 : PyObject *swig_obj[1] ;
34497 18 : int result;
34498 :
34499 18 : if (!args) SWIG_fail;
34500 18 : swig_obj[0] = args;
34501 18 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34502 18 : if (!SWIG_IsOK(ecode1)) {
34503 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_HasM" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34504 : }
34505 18 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34506 18 : {
34507 18 : const int bLocalUseExceptions = GetUseExceptions();
34508 18 : if ( bLocalUseExceptions ) {
34509 0 : pushErrorHandler();
34510 : }
34511 18 : {
34512 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34513 18 : result = (int)OGR_GT_HasM(arg1);
34514 18 : SWIG_PYTHON_THREAD_END_ALLOW;
34515 : }
34516 18 : if ( bLocalUseExceptions ) {
34517 0 : popErrorHandler();
34518 : }
34519 : #ifndef SED_HACKS
34520 : if ( bLocalUseExceptions ) {
34521 : CPLErr eclass = CPLGetLastErrorType();
34522 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34523 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34524 : }
34525 : }
34526 : #endif
34527 : }
34528 18 : resultobj = SWIG_From_int(static_cast< int >(result));
34529 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34530 : return resultobj;
34531 : fail:
34532 : return NULL;
34533 : }
34534 :
34535 :
34536 14 : SWIGINTERN PyObject *_wrap_GT_IsSubClassOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34537 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34538 14 : OGRwkbGeometryType arg1 ;
34539 14 : OGRwkbGeometryType arg2 ;
34540 14 : int val1 ;
34541 14 : int ecode1 = 0 ;
34542 14 : int val2 ;
34543 14 : int ecode2 = 0 ;
34544 14 : PyObject *swig_obj[2] ;
34545 14 : int result;
34546 :
34547 14 : if (!SWIG_Python_UnpackTuple(args, "GT_IsSubClassOf", 2, 2, swig_obj)) SWIG_fail;
34548 14 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34549 14 : if (!SWIG_IsOK(ecode1)) {
34550 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_IsSubClassOf" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34551 : }
34552 14 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34553 14 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34554 14 : if (!SWIG_IsOK(ecode2)) {
34555 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GT_IsSubClassOf" "', argument " "2"" of type '" "OGRwkbGeometryType""'");
34556 : }
34557 14 : arg2 = static_cast< OGRwkbGeometryType >(val2);
34558 14 : {
34559 14 : const int bLocalUseExceptions = GetUseExceptions();
34560 14 : if ( bLocalUseExceptions ) {
34561 0 : pushErrorHandler();
34562 : }
34563 14 : {
34564 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34565 14 : result = (int)OGR_GT_IsSubClassOf(arg1,arg2);
34566 14 : SWIG_PYTHON_THREAD_END_ALLOW;
34567 : }
34568 14 : if ( bLocalUseExceptions ) {
34569 0 : popErrorHandler();
34570 : }
34571 : #ifndef SED_HACKS
34572 : if ( bLocalUseExceptions ) {
34573 : CPLErr eclass = CPLGetLastErrorType();
34574 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34575 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34576 : }
34577 : }
34578 : #endif
34579 : }
34580 14 : resultobj = SWIG_From_int(static_cast< int >(result));
34581 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34582 : return resultobj;
34583 : fail:
34584 : return NULL;
34585 : }
34586 :
34587 :
34588 15 : SWIGINTERN PyObject *_wrap_GT_IsCurve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34589 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34590 15 : OGRwkbGeometryType arg1 ;
34591 15 : int val1 ;
34592 15 : int ecode1 = 0 ;
34593 15 : PyObject *swig_obj[1] ;
34594 15 : int result;
34595 :
34596 15 : if (!args) SWIG_fail;
34597 15 : swig_obj[0] = args;
34598 15 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34599 15 : if (!SWIG_IsOK(ecode1)) {
34600 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_IsCurve" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34601 : }
34602 15 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34603 15 : {
34604 15 : const int bLocalUseExceptions = GetUseExceptions();
34605 15 : if ( bLocalUseExceptions ) {
34606 0 : pushErrorHandler();
34607 : }
34608 15 : {
34609 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34610 15 : result = (int)OGR_GT_IsCurve(arg1);
34611 15 : SWIG_PYTHON_THREAD_END_ALLOW;
34612 : }
34613 15 : if ( bLocalUseExceptions ) {
34614 0 : popErrorHandler();
34615 : }
34616 : #ifndef SED_HACKS
34617 : if ( bLocalUseExceptions ) {
34618 : CPLErr eclass = CPLGetLastErrorType();
34619 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34620 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34621 : }
34622 : }
34623 : #endif
34624 : }
34625 15 : resultobj = SWIG_From_int(static_cast< int >(result));
34626 15 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34627 : return resultobj;
34628 : fail:
34629 : return NULL;
34630 : }
34631 :
34632 :
34633 13 : SWIGINTERN PyObject *_wrap_GT_IsSurface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34634 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34635 13 : OGRwkbGeometryType arg1 ;
34636 13 : int val1 ;
34637 13 : int ecode1 = 0 ;
34638 13 : PyObject *swig_obj[1] ;
34639 13 : int result;
34640 :
34641 13 : if (!args) SWIG_fail;
34642 13 : swig_obj[0] = args;
34643 13 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34644 13 : if (!SWIG_IsOK(ecode1)) {
34645 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_IsSurface" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34646 : }
34647 13 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34648 13 : {
34649 13 : const int bLocalUseExceptions = GetUseExceptions();
34650 13 : if ( bLocalUseExceptions ) {
34651 0 : pushErrorHandler();
34652 : }
34653 13 : {
34654 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34655 13 : result = (int)OGR_GT_IsSurface(arg1);
34656 13 : SWIG_PYTHON_THREAD_END_ALLOW;
34657 : }
34658 13 : if ( bLocalUseExceptions ) {
34659 0 : popErrorHandler();
34660 : }
34661 : #ifndef SED_HACKS
34662 : if ( bLocalUseExceptions ) {
34663 : CPLErr eclass = CPLGetLastErrorType();
34664 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34665 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34666 : }
34667 : }
34668 : #endif
34669 : }
34670 13 : resultobj = SWIG_From_int(static_cast< int >(result));
34671 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34672 : return resultobj;
34673 : fail:
34674 : return NULL;
34675 : }
34676 :
34677 :
34678 15 : SWIGINTERN PyObject *_wrap_GT_IsNonLinear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34679 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34680 15 : OGRwkbGeometryType arg1 ;
34681 15 : int val1 ;
34682 15 : int ecode1 = 0 ;
34683 15 : PyObject *swig_obj[1] ;
34684 15 : int result;
34685 :
34686 15 : if (!args) SWIG_fail;
34687 15 : swig_obj[0] = args;
34688 15 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34689 15 : if (!SWIG_IsOK(ecode1)) {
34690 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_IsNonLinear" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34691 : }
34692 15 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34693 15 : {
34694 15 : const int bLocalUseExceptions = GetUseExceptions();
34695 15 : if ( bLocalUseExceptions ) {
34696 0 : pushErrorHandler();
34697 : }
34698 15 : {
34699 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34700 15 : result = (int)OGR_GT_IsNonLinear(arg1);
34701 15 : SWIG_PYTHON_THREAD_END_ALLOW;
34702 : }
34703 15 : if ( bLocalUseExceptions ) {
34704 0 : popErrorHandler();
34705 : }
34706 : #ifndef SED_HACKS
34707 : if ( bLocalUseExceptions ) {
34708 : CPLErr eclass = CPLGetLastErrorType();
34709 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34710 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34711 : }
34712 : }
34713 : #endif
34714 : }
34715 15 : resultobj = SWIG_From_int(static_cast< int >(result));
34716 15 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34717 : return resultobj;
34718 : fail:
34719 : return NULL;
34720 : }
34721 :
34722 :
34723 9 : SWIGINTERN PyObject *_wrap_GT_GetCollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34724 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34725 9 : OGRwkbGeometryType arg1 ;
34726 9 : int val1 ;
34727 9 : int ecode1 = 0 ;
34728 9 : PyObject *swig_obj[1] ;
34729 9 : OGRwkbGeometryType result;
34730 :
34731 9 : if (!args) SWIG_fail;
34732 9 : swig_obj[0] = args;
34733 9 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34734 9 : if (!SWIG_IsOK(ecode1)) {
34735 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_GetCollection" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34736 : }
34737 9 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34738 9 : {
34739 9 : const int bLocalUseExceptions = GetUseExceptions();
34740 9 : if ( bLocalUseExceptions ) {
34741 0 : pushErrorHandler();
34742 : }
34743 9 : {
34744 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34745 9 : result = (OGRwkbGeometryType)OGR_GT_GetCollection(arg1);
34746 9 : SWIG_PYTHON_THREAD_END_ALLOW;
34747 : }
34748 9 : if ( bLocalUseExceptions ) {
34749 0 : popErrorHandler();
34750 : }
34751 : #ifndef SED_HACKS
34752 : if ( bLocalUseExceptions ) {
34753 : CPLErr eclass = CPLGetLastErrorType();
34754 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34755 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34756 : }
34757 : }
34758 : #endif
34759 : }
34760 9 : resultobj = SWIG_From_int(static_cast< int >(result));
34761 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34762 : return resultobj;
34763 : fail:
34764 : return NULL;
34765 : }
34766 :
34767 :
34768 16 : SWIGINTERN PyObject *_wrap_GT_GetCurve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34769 16 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34770 16 : OGRwkbGeometryType arg1 ;
34771 16 : int val1 ;
34772 16 : int ecode1 = 0 ;
34773 16 : PyObject *swig_obj[1] ;
34774 16 : OGRwkbGeometryType result;
34775 :
34776 16 : if (!args) SWIG_fail;
34777 16 : swig_obj[0] = args;
34778 16 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34779 16 : if (!SWIG_IsOK(ecode1)) {
34780 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_GetCurve" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34781 : }
34782 16 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34783 16 : {
34784 16 : const int bLocalUseExceptions = GetUseExceptions();
34785 16 : if ( bLocalUseExceptions ) {
34786 0 : pushErrorHandler();
34787 : }
34788 16 : {
34789 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34790 16 : result = (OGRwkbGeometryType)OGR_GT_GetCurve(arg1);
34791 16 : SWIG_PYTHON_THREAD_END_ALLOW;
34792 : }
34793 16 : if ( bLocalUseExceptions ) {
34794 0 : popErrorHandler();
34795 : }
34796 : #ifndef SED_HACKS
34797 : if ( bLocalUseExceptions ) {
34798 : CPLErr eclass = CPLGetLastErrorType();
34799 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34800 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34801 : }
34802 : }
34803 : #endif
34804 : }
34805 16 : resultobj = SWIG_From_int(static_cast< int >(result));
34806 16 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34807 : return resultobj;
34808 : fail:
34809 : return NULL;
34810 : }
34811 :
34812 :
34813 16 : SWIGINTERN PyObject *_wrap_GT_GetLinear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34814 16 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34815 16 : OGRwkbGeometryType arg1 ;
34816 16 : int val1 ;
34817 16 : int ecode1 = 0 ;
34818 16 : PyObject *swig_obj[1] ;
34819 16 : OGRwkbGeometryType result;
34820 :
34821 16 : if (!args) SWIG_fail;
34822 16 : swig_obj[0] = args;
34823 16 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34824 16 : if (!SWIG_IsOK(ecode1)) {
34825 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_GetLinear" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34826 : }
34827 16 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34828 16 : {
34829 16 : const int bLocalUseExceptions = GetUseExceptions();
34830 16 : if ( bLocalUseExceptions ) {
34831 0 : pushErrorHandler();
34832 : }
34833 16 : {
34834 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34835 16 : result = (OGRwkbGeometryType)OGR_GT_GetLinear(arg1);
34836 16 : SWIG_PYTHON_THREAD_END_ALLOW;
34837 : }
34838 16 : if ( bLocalUseExceptions ) {
34839 0 : popErrorHandler();
34840 : }
34841 : #ifndef SED_HACKS
34842 : if ( bLocalUseExceptions ) {
34843 : CPLErr eclass = CPLGetLastErrorType();
34844 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34845 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34846 : }
34847 : }
34848 : #endif
34849 : }
34850 16 : resultobj = SWIG_From_int(static_cast< int >(result));
34851 16 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34852 : return resultobj;
34853 : fail:
34854 : return NULL;
34855 : }
34856 :
34857 :
34858 2 : SWIGINTERN PyObject *_wrap_SetNonLinearGeometriesEnabledFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34859 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34860 2 : int arg1 ;
34861 2 : int val1 ;
34862 2 : int ecode1 = 0 ;
34863 2 : PyObject *swig_obj[1] ;
34864 :
34865 2 : if (!args) SWIG_fail;
34866 2 : swig_obj[0] = args;
34867 2 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34868 2 : if (!SWIG_IsOK(ecode1)) {
34869 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SetNonLinearGeometriesEnabledFlag" "', argument " "1"" of type '" "int""'");
34870 : }
34871 2 : arg1 = static_cast< int >(val1);
34872 2 : {
34873 2 : const int bLocalUseExceptions = GetUseExceptions();
34874 2 : if ( bLocalUseExceptions ) {
34875 0 : pushErrorHandler();
34876 : }
34877 2 : {
34878 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34879 2 : OGRSetNonLinearGeometriesEnabledFlag(arg1);
34880 2 : SWIG_PYTHON_THREAD_END_ALLOW;
34881 : }
34882 2 : if ( bLocalUseExceptions ) {
34883 0 : popErrorHandler();
34884 : }
34885 : #ifndef SED_HACKS
34886 : if ( bLocalUseExceptions ) {
34887 : CPLErr eclass = CPLGetLastErrorType();
34888 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34889 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34890 : }
34891 : }
34892 : #endif
34893 : }
34894 2 : resultobj = SWIG_Py_Void();
34895 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34896 : return resultobj;
34897 : fail:
34898 : return NULL;
34899 : }
34900 :
34901 :
34902 1 : SWIGINTERN PyObject *_wrap_GetNonLinearGeometriesEnabledFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34903 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34904 1 : int result;
34905 :
34906 1 : if (!SWIG_Python_UnpackTuple(args, "GetNonLinearGeometriesEnabledFlag", 0, 0, 0)) SWIG_fail;
34907 1 : {
34908 1 : const int bLocalUseExceptions = GetUseExceptions();
34909 1 : if ( bLocalUseExceptions ) {
34910 0 : pushErrorHandler();
34911 : }
34912 1 : {
34913 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34914 1 : result = (int)OGRGetNonLinearGeometriesEnabledFlag();
34915 1 : SWIG_PYTHON_THREAD_END_ALLOW;
34916 : }
34917 1 : if ( bLocalUseExceptions ) {
34918 0 : popErrorHandler();
34919 : }
34920 : #ifndef SED_HACKS
34921 : if ( bLocalUseExceptions ) {
34922 : CPLErr eclass = CPLGetLastErrorType();
34923 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34924 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34925 : }
34926 : }
34927 : #endif
34928 : }
34929 1 : resultobj = SWIG_From_int(static_cast< int >(result));
34930 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34931 : return resultobj;
34932 0 : fail:
34933 0 : return NULL;
34934 : }
34935 :
34936 :
34937 1 : SWIGINTERN PyObject *_wrap_GetOpenDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34938 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34939 1 : int arg1 ;
34940 1 : int val1 ;
34941 1 : int ecode1 = 0 ;
34942 1 : PyObject *swig_obj[1] ;
34943 1 : OGRDataSourceShadow *result = 0 ;
34944 :
34945 1 : if (!args) SWIG_fail;
34946 1 : swig_obj[0] = args;
34947 1 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34948 1 : if (!SWIG_IsOK(ecode1)) {
34949 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetOpenDS" "', argument " "1"" of type '" "int""'");
34950 : }
34951 1 : arg1 = static_cast< int >(val1);
34952 1 : {
34953 1 : const int bLocalUseExceptions = GetUseExceptions();
34954 1 : if ( bLocalUseExceptions ) {
34955 0 : pushErrorHandler();
34956 : }
34957 1 : {
34958 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34959 1 : result = (OGRDataSourceShadow *)GetOpenDS(arg1);
34960 1 : SWIG_PYTHON_THREAD_END_ALLOW;
34961 : }
34962 1 : if ( bLocalUseExceptions ) {
34963 0 : popErrorHandler();
34964 : }
34965 : #ifndef SED_HACKS
34966 : if ( bLocalUseExceptions ) {
34967 : CPLErr eclass = CPLGetLastErrorType();
34968 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34969 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34970 : }
34971 : }
34972 : #endif
34973 : }
34974 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
34975 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34976 : return resultobj;
34977 : fail:
34978 : return NULL;
34979 : }
34980 :
34981 :
34982 7036 : SWIGINTERN PyObject *_wrap_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34983 7036 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34984 7036 : char *arg1 = (char *) 0 ;
34985 7036 : int arg2 = (int) 0 ;
34986 7036 : int bToFree1 = 0 ;
34987 7036 : int val2 ;
34988 7036 : int ecode2 = 0 ;
34989 7036 : PyObject * obj0 = 0 ;
34990 7036 : PyObject * obj1 = 0 ;
34991 7036 : char * kwnames[] = {
34992 : (char *)"utf8_path", (char *)"update", NULL
34993 : };
34994 7036 : OGRDataSourceShadow *result = 0 ;
34995 :
34996 7036 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Open", kwnames, &obj0, &obj1)) SWIG_fail;
34997 7036 : {
34998 : /* %typemap(in) (const char *utf8_path) */
34999 7036 : if (PyUnicode_Check(obj0) || PyBytes_Check(obj0))
35000 : {
35001 3856 : arg1 = GDALPythonObjectToCStr( obj0, &bToFree1 );
35002 : }
35003 : else
35004 : {
35005 3180 : arg1 = GDALPythonPathToCStr(obj0, &bToFree1);
35006 :
35007 : }
35008 7036 : if (arg1 == NULL)
35009 : {
35010 1 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
35011 1 : SWIG_fail;
35012 : }
35013 : }
35014 7035 : if (obj1) {
35015 1663 : ecode2 = SWIG_AsVal_int(obj1, &val2);
35016 1663 : if (!SWIG_IsOK(ecode2)) {
35017 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Open" "', argument " "2"" of type '" "int""'");
35018 : }
35019 : arg2 = static_cast< int >(val2);
35020 : }
35021 7035 : {
35022 7035 : const int bLocalUseExceptions = GetUseExceptions();
35023 7035 : if ( bLocalUseExceptions ) {
35024 2639 : pushErrorHandler();
35025 : }
35026 7035 : {
35027 7035 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35028 7035 : result = (OGRDataSourceShadow *)Open((char const *)arg1,arg2);
35029 7035 : SWIG_PYTHON_THREAD_END_ALLOW;
35030 : }
35031 7035 : if ( bLocalUseExceptions ) {
35032 2639 : popErrorHandler();
35033 : }
35034 : #ifndef SED_HACKS
35035 : if( result == NULL && bLocalUseExceptions ) {
35036 : CPLErr eclass = CPLGetLastErrorType();
35037 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35038 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35039 : }
35040 : }
35041 : #endif
35042 7035 : if( result != NULL && bLocalUseExceptions ) {
35043 : #ifdef SED_HACKS
35044 2566 : bLocalUseExceptionsCode = FALSE;
35045 : #endif
35046 : }
35047 : }
35048 7035 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
35049 7035 : {
35050 : /* %typemap(freearg) (const char *utf8_path) */
35051 7035 : GDALPythonFreeCStr(arg1, bToFree1);
35052 : }
35053 7181 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35054 : return resultobj;
35055 1 : fail:
35056 1 : {
35057 : /* %typemap(freearg) (const char *utf8_path) */
35058 7036 : GDALPythonFreeCStr(arg1, bToFree1);
35059 : }
35060 : return NULL;
35061 : }
35062 :
35063 :
35064 23 : SWIGINTERN PyObject *_wrap_OpenShared(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35065 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35066 23 : char *arg1 = (char *) 0 ;
35067 23 : int arg2 = (int) 0 ;
35068 23 : int bToFree1 = 0 ;
35069 23 : int val2 ;
35070 23 : int ecode2 = 0 ;
35071 23 : PyObject * obj0 = 0 ;
35072 23 : PyObject * obj1 = 0 ;
35073 23 : char * kwnames[] = {
35074 : (char *)"utf8_path", (char *)"update", NULL
35075 : };
35076 23 : OGRDataSourceShadow *result = 0 ;
35077 :
35078 23 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:OpenShared", kwnames, &obj0, &obj1)) SWIG_fail;
35079 23 : {
35080 : /* %typemap(in) (const char *utf8_path) */
35081 23 : if (PyUnicode_Check(obj0) || PyBytes_Check(obj0))
35082 : {
35083 23 : arg1 = GDALPythonObjectToCStr( obj0, &bToFree1 );
35084 : }
35085 : else
35086 : {
35087 0 : arg1 = GDALPythonPathToCStr(obj0, &bToFree1);
35088 :
35089 : }
35090 23 : if (arg1 == NULL)
35091 : {
35092 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
35093 0 : SWIG_fail;
35094 : }
35095 : }
35096 23 : if (obj1) {
35097 14 : ecode2 = SWIG_AsVal_int(obj1, &val2);
35098 14 : if (!SWIG_IsOK(ecode2)) {
35099 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OpenShared" "', argument " "2"" of type '" "int""'");
35100 : }
35101 : arg2 = static_cast< int >(val2);
35102 : }
35103 23 : {
35104 23 : const int bLocalUseExceptions = GetUseExceptions();
35105 23 : if ( bLocalUseExceptions ) {
35106 14 : pushErrorHandler();
35107 : }
35108 23 : {
35109 23 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35110 23 : result = (OGRDataSourceShadow *)OpenShared((char const *)arg1,arg2);
35111 23 : SWIG_PYTHON_THREAD_END_ALLOW;
35112 : }
35113 23 : if ( bLocalUseExceptions ) {
35114 14 : popErrorHandler();
35115 : }
35116 : #ifndef SED_HACKS
35117 : if( result == NULL && bLocalUseExceptions ) {
35118 : CPLErr eclass = CPLGetLastErrorType();
35119 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35120 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35121 : }
35122 : }
35123 : #endif
35124 23 : if( result != NULL && bLocalUseExceptions ) {
35125 : #ifdef SED_HACKS
35126 14 : bLocalUseExceptionsCode = FALSE;
35127 : #endif
35128 : }
35129 : }
35130 23 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
35131 23 : {
35132 : /* %typemap(freearg) (const char *utf8_path) */
35133 23 : GDALPythonFreeCStr(arg1, bToFree1);
35134 : }
35135 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35136 : return resultobj;
35137 0 : fail:
35138 0 : {
35139 : /* %typemap(freearg) (const char *utf8_path) */
35140 23 : GDALPythonFreeCStr(arg1, bToFree1);
35141 : }
35142 : return NULL;
35143 : }
35144 :
35145 :
35146 2702 : SWIGINTERN PyObject *_wrap_GetDriverByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35147 2702 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35148 2702 : char *arg1 = (char *) 0 ;
35149 2702 : int res1 ;
35150 2702 : char *buf1 = 0 ;
35151 2702 : int alloc1 = 0 ;
35152 2702 : PyObject *swig_obj[1] ;
35153 2702 : OGRDriverShadow *result = 0 ;
35154 :
35155 2702 : if (!args) SWIG_fail;
35156 2702 : swig_obj[0] = args;
35157 2702 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
35158 2702 : if (!SWIG_IsOK(res1)) {
35159 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDriverByName" "', argument " "1"" of type '" "char const *""'");
35160 : }
35161 2702 : arg1 = reinterpret_cast< char * >(buf1);
35162 2702 : {
35163 2702 : const int bLocalUseExceptions = GetUseExceptions();
35164 2702 : if ( bLocalUseExceptions ) {
35165 1348 : pushErrorHandler();
35166 : }
35167 2702 : result = (OGRDriverShadow *)GetDriverByName((char const *)arg1);
35168 2702 : if ( bLocalUseExceptions ) {
35169 1348 : popErrorHandler();
35170 : }
35171 : #ifndef SED_HACKS
35172 : if ( bLocalUseExceptions ) {
35173 : CPLErr eclass = CPLGetLastErrorType();
35174 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35175 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35176 : }
35177 : }
35178 : #endif
35179 : }
35180 2702 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
35181 2702 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
35182 2702 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35183 : return resultobj;
35184 0 : fail:
35185 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
35186 : return NULL;
35187 : }
35188 :
35189 :
35190 0 : SWIGINTERN PyObject *_wrap_GetDriver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35191 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35192 0 : int arg1 ;
35193 0 : int val1 ;
35194 0 : int ecode1 = 0 ;
35195 0 : PyObject *swig_obj[1] ;
35196 0 : OGRDriverShadow *result = 0 ;
35197 :
35198 0 : if (!args) SWIG_fail;
35199 0 : swig_obj[0] = args;
35200 0 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
35201 0 : if (!SWIG_IsOK(ecode1)) {
35202 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetDriver" "', argument " "1"" of type '" "int""'");
35203 : }
35204 0 : arg1 = static_cast< int >(val1);
35205 0 : {
35206 0 : const int bLocalUseExceptions = GetUseExceptions();
35207 0 : if ( bLocalUseExceptions ) {
35208 0 : pushErrorHandler();
35209 : }
35210 0 : result = (OGRDriverShadow *)GetDriver(arg1);
35211 0 : if ( bLocalUseExceptions ) {
35212 0 : popErrorHandler();
35213 : }
35214 : #ifndef SED_HACKS
35215 : if ( bLocalUseExceptions ) {
35216 : CPLErr eclass = CPLGetLastErrorType();
35217 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35218 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35219 : }
35220 : }
35221 : #endif
35222 : }
35223 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
35224 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35225 : return resultobj;
35226 : fail:
35227 : return NULL;
35228 : }
35229 :
35230 :
35231 59 : SWIGINTERN PyObject *_wrap_GeneralCmdLineProcessor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35232 59 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35233 59 : char **arg1 = (char **) 0 ;
35234 59 : int arg2 = (int) 0 ;
35235 59 : int val2 ;
35236 59 : int ecode2 = 0 ;
35237 59 : PyObject *swig_obj[2] ;
35238 59 : char **result = 0 ;
35239 :
35240 59 : if (!SWIG_Python_UnpackTuple(args, "GeneralCmdLineProcessor", 1, 2, swig_obj)) SWIG_fail;
35241 59 : {
35242 : /* %typemap(in) char **dict */
35243 59 : arg1 = NULL;
35244 59 : if ( PySequence_Check( swig_obj[0] ) ) {
35245 59 : int bErr = FALSE;
35246 59 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
35247 59 : if ( bErr )
35248 : {
35249 0 : SWIG_fail;
35250 : }
35251 : }
35252 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
35253 0 : int bErr = FALSE;
35254 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
35255 0 : if ( bErr )
35256 : {
35257 0 : SWIG_fail;
35258 : }
35259 : }
35260 : else {
35261 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
35262 0 : SWIG_fail;
35263 : }
35264 : }
35265 59 : if (swig_obj[1]) {
35266 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35267 0 : if (!SWIG_IsOK(ecode2)) {
35268 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeneralCmdLineProcessor" "', argument " "2"" of type '" "int""'");
35269 : }
35270 : arg2 = static_cast< int >(val2);
35271 : }
35272 59 : {
35273 59 : const int bLocalUseExceptions = GetUseExceptions();
35274 59 : if ( bLocalUseExceptions ) {
35275 10 : pushErrorHandler();
35276 : }
35277 59 : result = (char **)GeneralCmdLineProcessor(arg1,arg2);
35278 59 : if ( bLocalUseExceptions ) {
35279 10 : popErrorHandler();
35280 : }
35281 : #ifndef SED_HACKS
35282 : if ( bLocalUseExceptions ) {
35283 : CPLErr eclass = CPLGetLastErrorType();
35284 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35285 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35286 : }
35287 : }
35288 : #endif
35289 : }
35290 59 : {
35291 : /* %typemap(out) char **CSL -> ( string ) */
35292 59 : bool bErr = false;
35293 59 : resultobj = CSLToList(result, &bErr);
35294 59 : CSLDestroy(result);
35295 59 : if( bErr ) {
35296 0 : SWIG_fail;
35297 : }
35298 : }
35299 59 : {
35300 : /* %typemap(freearg) char **dict */
35301 59 : CSLDestroy( arg1 );
35302 : }
35303 59 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35304 : return resultobj;
35305 0 : fail:
35306 0 : {
35307 : /* %typemap(freearg) char **dict */
35308 0 : CSLDestroy( arg1 );
35309 : }
35310 : return NULL;
35311 : }
35312 :
35313 :
35314 11 : SWIGINTERN PyObject *_wrap_TermProgress_nocb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35315 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35316 11 : double arg1 ;
35317 11 : char *arg2 = (char *) NULL ;
35318 11 : void *arg3 = (void *) NULL ;
35319 11 : double val1 ;
35320 11 : int ecode1 = 0 ;
35321 11 : int res2 ;
35322 11 : char *buf2 = 0 ;
35323 11 : int alloc2 = 0 ;
35324 11 : int res3 ;
35325 11 : PyObject * obj0 = 0 ;
35326 11 : PyObject * obj1 = 0 ;
35327 11 : PyObject * obj2 = 0 ;
35328 11 : char * kwnames[] = {
35329 : (char *)"dfProgress", (char *)"pszMessage", (char *)"pData", NULL
35330 : };
35331 11 : int result;
35332 :
35333 11 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:TermProgress_nocb", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
35334 11 : ecode1 = SWIG_AsVal_double(obj0, &val1);
35335 11 : if (!SWIG_IsOK(ecode1)) {
35336 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TermProgress_nocb" "', argument " "1"" of type '" "double""'");
35337 : }
35338 11 : arg1 = static_cast< double >(val1);
35339 11 : if (obj1) {
35340 11 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35341 11 : if (!SWIG_IsOK(res2)) {
35342 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TermProgress_nocb" "', argument " "2"" of type '" "char const *""'");
35343 : }
35344 11 : arg2 = reinterpret_cast< char * >(buf2);
35345 : }
35346 11 : if (obj2) {
35347 11 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
35348 11 : if (!SWIG_IsOK(res3)) {
35349 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TermProgress_nocb" "', argument " "3"" of type '" "void *""'");
35350 : }
35351 : }
35352 11 : {
35353 11 : const int bLocalUseExceptions = GetUseExceptions();
35354 11 : if ( bLocalUseExceptions ) {
35355 5 : pushErrorHandler();
35356 : }
35357 11 : result = (int)GDALTermProgress_nocb(arg1,(char const *)arg2,arg3);
35358 11 : if ( bLocalUseExceptions ) {
35359 5 : popErrorHandler();
35360 : }
35361 : #ifndef SED_HACKS
35362 : if ( bLocalUseExceptions ) {
35363 : CPLErr eclass = CPLGetLastErrorType();
35364 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35365 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35366 : }
35367 : }
35368 : #endif
35369 : }
35370 11 : resultobj = SWIG_From_int(static_cast< int >(result));
35371 11 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
35372 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35373 : return resultobj;
35374 0 : fail:
35375 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
35376 : return NULL;
35377 : }
35378 :
35379 :
35380 : static PyMethodDef SwigMethods[] = {
35381 : { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
35382 : { "GetUseExceptions", _wrap_GetUseExceptions, METH_NOARGS, "GetUseExceptions() -> int"},
35383 : { "_GetExceptionsLocal", _wrap__GetExceptionsLocal, METH_NOARGS, "_GetExceptionsLocal() -> int"},
35384 : { "_SetExceptionsLocal", _wrap__SetExceptionsLocal, METH_O, "_SetExceptionsLocal(int bVal)"},
35385 : { "_UseExceptions", _wrap__UseExceptions, METH_NOARGS, "_UseExceptions()"},
35386 : { "_DontUseExceptions", _wrap__DontUseExceptions, METH_NOARGS, "_DontUseExceptions()"},
35387 : { "_UserHasSpecifiedIfUsingExceptions", _wrap__UserHasSpecifiedIfUsingExceptions, METH_NOARGS, "_UserHasSpecifiedIfUsingExceptions() -> int"},
35388 : { "MajorObject_GetDescription", _wrap_MajorObject_GetDescription, METH_O, "MajorObject_GetDescription(MajorObject self) -> char const *"},
35389 : { "MajorObject_SetDescription", _wrap_MajorObject_SetDescription, METH_VARARGS, "MajorObject_SetDescription(MajorObject self, char const * pszNewDesc)"},
35390 : { "MajorObject_GetMetadataDomainList", _wrap_MajorObject_GetMetadataDomainList, METH_O, "MajorObject_GetMetadataDomainList(MajorObject self) -> char **"},
35391 : { "MajorObject_GetMetadata_Dict", _wrap_MajorObject_GetMetadata_Dict, METH_VARARGS, "MajorObject_GetMetadata_Dict(MajorObject self, char const * pszDomain=\"\") -> char **"},
35392 : { "MajorObject_GetMetadata_List", _wrap_MajorObject_GetMetadata_List, METH_VARARGS, "MajorObject_GetMetadata_List(MajorObject self, char const * pszDomain=\"\") -> char **"},
35393 : { "MajorObject_SetMetadata", _wrap_MajorObject_SetMetadata, METH_VARARGS, "\n"
35394 : "MajorObject_SetMetadata(MajorObject self, char ** papszMetadata, char const * pszDomain=\"\") -> CPLErr\n"
35395 : "MajorObject_SetMetadata(MajorObject self, char * pszMetadataString, char const * pszDomain=\"\") -> CPLErr\n"
35396 : ""},
35397 : { "MajorObject_GetMetadataItem", _wrap_MajorObject_GetMetadataItem, METH_VARARGS, "MajorObject_GetMetadataItem(MajorObject self, char const * pszName, char const * pszDomain=\"\") -> char const *"},
35398 : { "MajorObject_SetMetadataItem", _wrap_MajorObject_SetMetadataItem, METH_VARARGS, "MajorObject_SetMetadataItem(MajorObject self, char const * pszName, char const * pszValue, char const * pszDomain=\"\") -> CPLErr"},
35399 : { "MajorObject_swigregister", MajorObject_swigregister, METH_O, NULL},
35400 : { "GetGEOSVersionMajor", _wrap_GetGEOSVersionMajor, METH_NOARGS, "GetGEOSVersionMajor() -> int"},
35401 : { "GetGEOSVersionMinor", _wrap_GetGEOSVersionMinor, METH_NOARGS, "GetGEOSVersionMinor() -> int"},
35402 : { "GetGEOSVersionMicro", _wrap_GetGEOSVersionMicro, METH_NOARGS, "GetGEOSVersionMicro() -> int"},
35403 : { "new_StyleTable", _wrap_new_StyleTable, METH_NOARGS, "new_StyleTable() -> StyleTable"},
35404 : { "delete_StyleTable", _wrap_delete_StyleTable, METH_O, "delete_StyleTable(StyleTable self)"},
35405 : { "StyleTable_AddStyle", _wrap_StyleTable_AddStyle, METH_VARARGS, "StyleTable_AddStyle(StyleTable self, char const * pszName, char const * pszStyleString) -> int"},
35406 : { "StyleTable_LoadStyleTable", _wrap_StyleTable_LoadStyleTable, METH_VARARGS, "StyleTable_LoadStyleTable(StyleTable self, char const * utf8_path) -> int"},
35407 : { "StyleTable_SaveStyleTable", _wrap_StyleTable_SaveStyleTable, METH_VARARGS, "StyleTable_SaveStyleTable(StyleTable self, char const * utf8_path) -> int"},
35408 : { "StyleTable_Find", _wrap_StyleTable_Find, METH_VARARGS, "StyleTable_Find(StyleTable self, char const * pszName) -> char const *"},
35409 : { "StyleTable_ResetStyleStringReading", _wrap_StyleTable_ResetStyleStringReading, METH_O, "StyleTable_ResetStyleStringReading(StyleTable self)"},
35410 : { "StyleTable_GetNextStyle", _wrap_StyleTable_GetNextStyle, METH_O, "StyleTable_GetNextStyle(StyleTable self) -> char const *"},
35411 : { "StyleTable_GetLastStyleName", _wrap_StyleTable_GetLastStyleName, METH_O, "StyleTable_GetLastStyleName(StyleTable self) -> char const *"},
35412 : { "StyleTable_swigregister", StyleTable_swigregister, METH_O, NULL},
35413 : { "StyleTable_swiginit", StyleTable_swiginit, METH_VARARGS, NULL},
35414 : { "new_ArrowArray", _wrap_new_ArrowArray, METH_NOARGS, "new_ArrowArray() -> ArrowArray"},
35415 : { "delete_ArrowArray", _wrap_delete_ArrowArray, METH_O, "delete_ArrowArray(ArrowArray self)"},
35416 : { "ArrowArray__getPtr", _wrap_ArrowArray__getPtr, METH_O, "ArrowArray__getPtr(ArrowArray self) -> VoidPtrAsLong"},
35417 : { "ArrowArray_GetChildrenCount", _wrap_ArrowArray_GetChildrenCount, METH_O, "ArrowArray_GetChildrenCount(ArrowArray self) -> GIntBig"},
35418 : { "ArrowArray_GetLength", _wrap_ArrowArray_GetLength, METH_O, "ArrowArray_GetLength(ArrowArray self) -> GIntBig"},
35419 : { "ArrowArray_swigregister", ArrowArray_swigregister, METH_O, NULL},
35420 : { "ArrowArray_swiginit", ArrowArray_swiginit, METH_VARARGS, NULL},
35421 : { "new_ArrowSchema", _wrap_new_ArrowSchema, METH_NOARGS, "new_ArrowSchema() -> ArrowSchema"},
35422 : { "delete_ArrowSchema", _wrap_delete_ArrowSchema, METH_O, "delete_ArrowSchema(ArrowSchema self)"},
35423 : { "ArrowSchema__getPtr", _wrap_ArrowSchema__getPtr, METH_O, "ArrowSchema__getPtr(ArrowSchema self) -> VoidPtrAsLong"},
35424 : { "ArrowSchema_GetName", _wrap_ArrowSchema_GetName, METH_O, "ArrowSchema_GetName(ArrowSchema self) -> char const *"},
35425 : { "ArrowSchema_GetChildrenCount", _wrap_ArrowSchema_GetChildrenCount, METH_O, "ArrowSchema_GetChildrenCount(ArrowSchema self) -> GIntBig"},
35426 : { "ArrowSchema_GetChild", _wrap_ArrowSchema_GetChild, METH_VARARGS, "ArrowSchema_GetChild(ArrowSchema self, int iChild) -> ArrowSchema"},
35427 : { "ArrowSchema_swigregister", ArrowSchema_swigregister, METH_O, NULL},
35428 : { "ArrowSchema_swiginit", ArrowSchema_swiginit, METH_VARARGS, NULL},
35429 : { "delete_ArrowArrayStream", _wrap_delete_ArrowArrayStream, METH_O, "delete_ArrowArrayStream(ArrowArrayStream self)"},
35430 : { "ArrowArrayStream_GetSchema", _wrap_ArrowArrayStream_GetSchema, METH_O, "ArrowArrayStream_GetSchema(ArrowArrayStream self) -> ArrowSchema"},
35431 : { "ArrowArrayStream_GetNextRecordBatch", _wrap_ArrowArrayStream_GetNextRecordBatch, METH_VARARGS, "ArrowArrayStream_GetNextRecordBatch(ArrowArrayStream self, char ** options=None) -> ArrowArray"},
35432 : { "ArrowArrayStream_swigregister", ArrowArrayStream_swigregister, METH_O, NULL},
35433 : { "Layer_GetDataset", _wrap_Layer_GetDataset, METH_O, "\n"
35434 : "Layer_GetDataset(Layer self) -> GDALDatasetShadow *\n"
35435 : "\n"
35436 : "Return the dataset associated with this layer.\n"
35437 : "\n"
35438 : "For more details: :cpp:func:`OGR_L_GetDataset`\n"
35439 : "\n"
35440 : "Returns\n"
35441 : "-------\n"
35442 : "Dataset:\n"
35443 : " Dataset or None\n"
35444 : "\n"
35445 : ""},
35446 : { "Layer_Rename", _wrap_Layer_Rename, METH_VARARGS, "Layer_Rename(Layer self, char const * new_name) -> OGRErr"},
35447 : { "Layer_GetRefCount", _wrap_Layer_GetRefCount, METH_O, "\n"
35448 : "Layer_GetRefCount(Layer self) -> int\n"
35449 : "\n"
35450 : "For more details: :cpp:func:`OGR_L_GetRefCount`\n"
35451 : "\n"
35452 : ""},
35453 : { "Layer_SetSpatialFilter", _wrap_Layer_SetSpatialFilter, METH_VARARGS, "\n"
35454 : "Layer_SetSpatialFilter(Layer self, Geometry filter)\n"
35455 : "Layer_SetSpatialFilter(Layer self, int iGeomField, Geometry filter)\n"
35456 : "\n"
35457 : "Set a new spatial filter.\n"
35458 : "\n"
35459 : "For more details:\n"
35460 : "\n"
35461 : "- :cpp:func:`OGR_L_SetSpatialFilter`\n"
35462 : "- :cpp:func:`OGR_L_SetSpatialFilterEx`\n"
35463 : "\n"
35464 : "Parameters\n"
35465 : "-----------\n"
35466 : "iGeomField: int, optional\n"
35467 : " index of the geometry field on which the spatial filter operates.\n"
35468 : "filter: Geometry\n"
35469 : " The geometry to use as a filtering region. None may\n"
35470 : " be passed indicating that the current spatial filter should be\n"
35471 : " cleared, but no new one instituted.\n"
35472 : "\n"
35473 : ""},
35474 : { "Layer_SetSpatialFilterRect", _wrap_Layer_SetSpatialFilterRect, METH_VARARGS, "\n"
35475 : "Layer_SetSpatialFilterRect(Layer self, double minx, double miny, double maxx, double maxy)\n"
35476 : "Layer_SetSpatialFilterRect(Layer self, int iGeomField, double minx, double miny, double maxx, double maxy)\n"
35477 : "\n"
35478 : "Set a new rectangular spatial filter.\n"
35479 : "\n"
35480 : "For more details:\n"
35481 : "\n"
35482 : "- :cpp:func:`OGR_L_SetSpatialFilterRect`\n"
35483 : "- :cpp:func:`OGR_L_SetSpatialFilterRectEx`\n"
35484 : "\n"
35485 : "Parameters\n"
35486 : "-----------\n"
35487 : "iGeomField: int, optional\n"
35488 : " index of the geometry field on which the spatial filter operates.\n"
35489 : "minx: float\n"
35490 : " the minimum X coordinate for the rectangular region.\n"
35491 : "miny: float\n"
35492 : " the minimum Y coordinate for the rectangular region.\n"
35493 : "maxx: float\n"
35494 : " the maximum X coordinate for the rectangular region.\n"
35495 : "maxy: float\n"
35496 : " the maximum Y coordinate for the rectangular region.\n"
35497 : "\n"
35498 : ""},
35499 : { "Layer_GetSpatialFilter", _wrap_Layer_GetSpatialFilter, METH_O, "\n"
35500 : "Layer_GetSpatialFilter(Layer self) -> Geometry\n"
35501 : "\n"
35502 : "This function returns the current spatial filter for this layer.\n"
35503 : "\n"
35504 : "For more details: :cpp:func:`OGR_L_GetSpatialFilter`\n"
35505 : "\n"
35506 : "Returns\n"
35507 : "--------\n"
35508 : "Geometry:\n"
35509 : " The spatial filter geometry.\n"
35510 : "\n"
35511 : ""},
35512 : { "Layer_SetAttributeFilter", _wrap_Layer_SetAttributeFilter, METH_VARARGS, "\n"
35513 : "Layer_SetAttributeFilter(Layer self, char * filter_string) -> OGRErr\n"
35514 : "\n"
35515 : "Set a new attribute query.\n"
35516 : "\n"
35517 : "For more details: :cpp:func:`OGR_L_SetAttributeFilter`\n"
35518 : "\n"
35519 : "Parameters\n"
35520 : "-----------\n"
35521 : "filter_string: str\n"
35522 : " query in restricted SQL WHERE format, or None to clear the\n"
35523 : " current query.\n"
35524 : "\n"
35525 : "Returns\n"
35526 : "--------\n"
35527 : "int:\n"
35528 : " :py:const:`osgeo.ogr.OGRERR_NONE` if successfully installed,\n"
35529 : " or an error code if the query expression is in error,\n"
35530 : " or some other failure occurs.\n"
35531 : "\n"
35532 : ""},
35533 : { "Layer_ResetReading", _wrap_Layer_ResetReading, METH_O, "\n"
35534 : "Layer_ResetReading(Layer self)\n"
35535 : "\n"
35536 : "Reset feature reading to start on the first feature.\n"
35537 : "\n"
35538 : "For more details: :cpp:func:`OGR_L_ResetReading`\n"
35539 : "\n"
35540 : ""},
35541 : { "Layer_GetName", _wrap_Layer_GetName, METH_O, "\n"
35542 : "Layer_GetName(Layer self) -> char const *\n"
35543 : "\n"
35544 : "Return the layer name.\n"
35545 : "\n"
35546 : "For more details: :cpp:func:`OGR_L_GetName`\n"
35547 : "\n"
35548 : "Returns\n"
35549 : "--------\n"
35550 : "str:\n"
35551 : " The layer name\n"
35552 : "\n"
35553 : ""},
35554 : { "Layer_GetGeomType", _wrap_Layer_GetGeomType, METH_O, "\n"
35555 : "Layer_GetGeomType(Layer self) -> OGRwkbGeometryType\n"
35556 : "\n"
35557 : "Return the layer geometry type.\n"
35558 : "\n"
35559 : "For more details: :cpp:func:`OGR_L_GetGeomType`\n"
35560 : "\n"
35561 : "Returns\n"
35562 : "--------\n"
35563 : "int:\n"
35564 : " The geometry type code. The types can be found with\n"
35565 : " 'osgeo.ogr.wkb' prefix. For example :py:const:`osgeo.ogr.wkbPolygon`.\n"
35566 : "\n"
35567 : ""},
35568 : { "Layer_GetGeometryColumn", _wrap_Layer_GetGeometryColumn, METH_O, "\n"
35569 : "Layer_GetGeometryColumn(Layer self) -> char const *\n"
35570 : "\n"
35571 : "This method returns the name of the underlying database column being\n"
35572 : "used as the geometry column, or '' if not supported.\n"
35573 : "\n"
35574 : "For more details: :cpp:func:`OGR_L_GetGeometryColumn`\n"
35575 : "\n"
35576 : "Returns\n"
35577 : "--------\n"
35578 : "str:\n"
35579 : " geometry column name.\n"
35580 : "\n"
35581 : ""},
35582 : { "Layer_GetFIDColumn", _wrap_Layer_GetFIDColumn, METH_O, "\n"
35583 : "Layer_GetFIDColumn(Layer self) -> char const *\n"
35584 : "\n"
35585 : "This method returns the name of the underlying database column being\n"
35586 : "used as the FID column, or '' if not supported.\n"
35587 : "\n"
35588 : "For more details: :cpp:func:`OGR_L_GetFIDColumn`\n"
35589 : "\n"
35590 : "Returns\n"
35591 : "--------\n"
35592 : "str:\n"
35593 : " fid column name.\n"
35594 : "\n"
35595 : ""},
35596 : { "Layer_GetFeature", _wrap_Layer_GetFeature, METH_VARARGS, "\n"
35597 : "Layer_GetFeature(Layer self, GIntBig fid) -> Feature\n"
35598 : "\n"
35599 : "Fetch a feature by its identifier.\n"
35600 : "\n"
35601 : "For more details: :cpp:func:`OGR_L_GetFeature`\n"
35602 : "\n"
35603 : "Use :py:func:`TestCapability` with (:py:const:`osgeo.ogr.OLCRandomRead`)\n"
35604 : "to establish if this layer supports efficient random access reading via\n"
35605 : ":py:func:`GetFeature`; However, the call should always work if the feature exists.\n"
35606 : "\n"
35607 : "Sequential reads (with :py:func:`GetNextFeature`) are generally\n"
35608 : "considered interrupted by a :py:func:`GetFeature` call.\n"
35609 : "\n"
35610 : "Parameters\n"
35611 : "-----------\n"
35612 : "fid: int\n"
35613 : " The feature id of the feature to read.\n"
35614 : "\n"
35615 : "Returns\n"
35616 : "--------\n"
35617 : "Feature:\n"
35618 : " A new feature now owned by the caller, or None on failure.\n"
35619 : " The returned feature should be deleted with :py:func:`Destroy`.\n"
35620 : "\n"
35621 : ""},
35622 : { "Layer_GetNextFeature", _wrap_Layer_GetNextFeature, METH_O, "\n"
35623 : "Layer_GetNextFeature(Layer self) -> Feature\n"
35624 : "\n"
35625 : "Fetch the next available feature from this layer.\n"
35626 : "\n"
35627 : "For more details: :cpp:func:`OGR_L_GetNextFeature`\n"
35628 : "\n"
35629 : "Returns\n"
35630 : "--------\n"
35631 : "Feature:\n"
35632 : " A feature or None if no more features are available.\n"
35633 : "\n"
35634 : ""},
35635 : { "Layer_SetNextByIndex", _wrap_Layer_SetNextByIndex, METH_VARARGS, "\n"
35636 : "Layer_SetNextByIndex(Layer self, GIntBig new_index) -> OGRErr\n"
35637 : "\n"
35638 : "Move read cursor to the nIndex'th feature in the current resultset.\n"
35639 : "\n"
35640 : "For more details: :cpp:func:`OGR_L_SetNextByIndex`\n"
35641 : "\n"
35642 : "Parameters\n"
35643 : "-----------\n"
35644 : "new_index: int\n"
35645 : " The index indicating how many steps into the result set to seek.\n"
35646 : "\n"
35647 : "Returns\n"
35648 : "--------\n"
35649 : "int:\n"
35650 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success or an error code.\n"
35651 : "\n"
35652 : ""},
35653 : { "Layer_SetFeature", _wrap_Layer_SetFeature, METH_VARARGS, "\n"
35654 : "Layer_SetFeature(Layer self, Feature feature) -> OGRErr\n"
35655 : "\n"
35656 : "Rewrite an existing feature.\n"
35657 : "\n"
35658 : "For more details: :cpp:func:`OGR_L_SetFeature`\n"
35659 : "\n"
35660 : "To set a feature, but create it if it doesn't exist see :py:meth:`.Layer.UpsertFeature`.\n"
35661 : "\n"
35662 : "Parameters\n"
35663 : "-----------\n"
35664 : "feature: Feature\n"
35665 : " The feature to write.\n"
35666 : "\n"
35667 : "Returns\n"
35668 : "--------\n"
35669 : "int:\n"
35670 : " :py:const:`osgeo.ogr.OGRERR_NONE` if the operation works,\n"
35671 : " otherwise an appropriate error code\n"
35672 : " (e.g :py:const:`osgeo.ogr.OGRERR_NON_EXISTING_FEATURE` if the\n"
35673 : " feature does not exist).\n"
35674 : "\n"
35675 : ""},
35676 : { "Layer_CreateFeature", _wrap_Layer_CreateFeature, METH_VARARGS, "\n"
35677 : "Layer_CreateFeature(Layer self, Feature feature) -> OGRErr\n"
35678 : "\n"
35679 : "Create and write a new feature within a layer.\n"
35680 : "\n"
35681 : "For more details: :cpp:func:`OGR_L_CreateFeature`\n"
35682 : "\n"
35683 : "To create a feature, but set it if it exists see :py:meth:`.Layer.UpsertFeature`.\n"
35684 : "\n"
35685 : "Parameters\n"
35686 : "-----------\n"
35687 : "feature: Feature\n"
35688 : " The feature to write to disk.\n"
35689 : "\n"
35690 : "Returns\n"
35691 : "--------\n"
35692 : "int:\n"
35693 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35694 : "\n"
35695 : ""},
35696 : { "Layer_UpsertFeature", _wrap_Layer_UpsertFeature, METH_VARARGS, "\n"
35697 : "Layer_UpsertFeature(Layer self, Feature feature) -> OGRErr\n"
35698 : "\n"
35699 : "Rewrite an existing feature or create a new feature within a layer.\n"
35700 : "\n"
35701 : "For more details: :cpp:func:`OGR_L_UpsertFeature`\n"
35702 : "\n"
35703 : "Parameters\n"
35704 : "-----------\n"
35705 : "feature: Feature\n"
35706 : " The feature to write to disk.\n"
35707 : "\n"
35708 : "Returns\n"
35709 : "--------\n"
35710 : "int:\n"
35711 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35712 : "\n"
35713 : ""},
35714 : { "Layer_UpdateFeature", _wrap_Layer_UpdateFeature, METH_VARARGS, "Layer_UpdateFeature(Layer self, Feature feature, int nUpdatedFieldsCount, int nUpdatedGeomFieldsCount, bool bUpdateStyleString) -> OGRErr"},
35715 : { "Layer_DeleteFeature", _wrap_Layer_DeleteFeature, METH_VARARGS, "\n"
35716 : "Layer_DeleteFeature(Layer self, GIntBig fid) -> OGRErr\n"
35717 : "\n"
35718 : "Delete feature from layer.\n"
35719 : "\n"
35720 : "For more details: :cpp:func:`OGR_L_DeleteFeature`\n"
35721 : "\n"
35722 : "Parameters\n"
35723 : "-----------\n"
35724 : "fid: int\n"
35725 : " The feature id to be deleted from the layer\n"
35726 : "\n"
35727 : "Returns\n"
35728 : "--------\n"
35729 : "int:\n"
35730 : " :py:const:`osgeo.ogr.OGRERR_NONE` if the operation works,\n"
35731 : " otherwise an appropriate error code\n"
35732 : " (e.g :py:const:`osgeo.ogr.OGRERR_NON_EXISTING_FEATURE`)\n"
35733 : " if the feature does not exist.\n"
35734 : "\n"
35735 : ""},
35736 : { "Layer_SyncToDisk", _wrap_Layer_SyncToDisk, METH_O, "\n"
35737 : "Layer_SyncToDisk(Layer self) -> OGRErr\n"
35738 : "\n"
35739 : "Flush pending changes to disk.\n"
35740 : "\n"
35741 : "For more details: :cpp:func:`OGR_L_SyncToDisk`\n"
35742 : "\n"
35743 : "Returns\n"
35744 : "--------\n"
35745 : "int:\n"
35746 : " :py:const:`osgeo.ogr.OGRERR_NONE` if no error occurs\n"
35747 : " (even if nothing is done) or an error code.\n"
35748 : "\n"
35749 : ""},
35750 : { "Layer_GetLayerDefn", _wrap_Layer_GetLayerDefn, METH_O, "\n"
35751 : "Layer_GetLayerDefn(Layer self) -> FeatureDefn\n"
35752 : "\n"
35753 : "Fetch the schema information for this layer.\n"
35754 : "\n"
35755 : "For more details: :cpp:func:`OGR_L_GetLayerDefn`\n"
35756 : "\n"
35757 : "Returns\n"
35758 : "--------\n"
35759 : "FeatureDefn:\n"
35760 : " The feature definition.\n"
35761 : "\n"
35762 : ""},
35763 : { "Layer_GetFeatureCount", (PyCFunction)(void(*)(void))_wrap_Layer_GetFeatureCount, METH_VARARGS|METH_KEYWORDS, "\n"
35764 : "Layer_GetFeatureCount(Layer self, int force=1) -> GIntBig\n"
35765 : "\n"
35766 : "Fetch the feature count in this layer.\n"
35767 : "\n"
35768 : "For more details: :cpp:func:`OGR_L_GetFeatureCount`\n"
35769 : "\n"
35770 : "Parameters\n"
35771 : "-----------\n"
35772 : "force: int\n"
35773 : " Flag indicating whether the count should be computed even if\n"
35774 : " it is expensive.\n"
35775 : "\n"
35776 : "Returns\n"
35777 : "--------\n"
35778 : "int:\n"
35779 : " Feature count, -1 if count not known.\n"
35780 : "\n"
35781 : ""},
35782 : { "Layer_GetExtent", (PyCFunction)(void(*)(void))_wrap_Layer_GetExtent, METH_VARARGS|METH_KEYWORDS, "\n"
35783 : "Layer_GetExtent(Layer self, int force=1, int can_return_null=0, int geom_field=0)\n"
35784 : "\n"
35785 : "Fetch the extent of this layer.\n"
35786 : "\n"
35787 : "For more details:\n"
35788 : "\n"
35789 : "- :cpp:func:`OGR_L_GetExtent`\n"
35790 : "- :cpp:func:`OGR_L_GetExtentEx`\n"
35791 : "\n"
35792 : ".. warning:: Check the return order of the bounds.\n"
35793 : "\n"
35794 : "Parameters\n"
35795 : "-----------\n"
35796 : "force: int, default=False\n"
35797 : " Flag indicating whether the extent should be computed even if\n"
35798 : " it is expensive.\n"
35799 : "can_return_null: int, default=False\n"
35800 : " Whether None can be returned in the response.\n"
35801 : "geom_field: int, default=0\n"
35802 : " The index of the geometry field on which to compute the extent.\n"
35803 : " Can be iterated over using :py:func:`range` and :py:func:`GetGeomFieldCount`.\n"
35804 : "\n"
35805 : "Returns\n"
35806 : "--------\n"
35807 : "minx: float\n"
35808 : "maxx: float\n"
35809 : "miny: float\n"
35810 : "maxy: float\n"
35811 : "\n"
35812 : ""},
35813 : { "Layer_GetExtent3D", (PyCFunction)(void(*)(void))_wrap_Layer_GetExtent3D, METH_VARARGS|METH_KEYWORDS, "Layer_GetExtent3D(Layer self, int force=1, int can_return_null=0, int geom_field=0)"},
35814 : { "Layer_TestCapability", _wrap_Layer_TestCapability, METH_VARARGS, "\n"
35815 : "Layer_TestCapability(Layer self, char const * cap) -> bool\n"
35816 : "\n"
35817 : "Test if this layer supported the named capability.\n"
35818 : "\n"
35819 : "For more details: :cpp:func:`OGR_L_TestCapability`\n"
35820 : "\n"
35821 : "Parameters\n"
35822 : "-----------\n"
35823 : "cap: str\n"
35824 : " The name of the capability to test. These can\n"
35825 : " be found in the `osgeo.ogr` namespace. For example,\n"
35826 : " :py:const:`osgeo.ogr.OLCRandomRead`.\n"
35827 : "\n"
35828 : "Returns\n"
35829 : "--------\n"
35830 : "int:\n"
35831 : " True if the layer has the requested capability, or False otherwise.\n"
35832 : " Will return False for any unrecognized capabilities.\n"
35833 : "\n"
35834 : ""},
35835 : { "Layer_CreateField", (PyCFunction)(void(*)(void))_wrap_Layer_CreateField, METH_VARARGS|METH_KEYWORDS, "\n"
35836 : "Layer_CreateField(Layer self, FieldDefn field_def, int approx_ok=1) -> OGRErr\n"
35837 : "\n"
35838 : "Create a new field on a layer.\n"
35839 : "\n"
35840 : "For more details: :cpp:func:`OGR_L_CreateField`\n"
35841 : "\n"
35842 : "Parameters\n"
35843 : "-----------\n"
35844 : "field_def: FieldDefn\n"
35845 : " The field definition to write to disk.\n"
35846 : "approx_ok: bool, default=True\n"
35847 : " If True, the field may be created in a slightly different\n"
35848 : " form depending on the limitations of the format driver.\n"
35849 : "\n"
35850 : "Returns\n"
35851 : "--------\n"
35852 : "int:\n"
35853 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35854 : "\n"
35855 : ""},
35856 : { "Layer_DeleteField", _wrap_Layer_DeleteField, METH_VARARGS, "\n"
35857 : "Layer_DeleteField(Layer self, int iField) -> OGRErr\n"
35858 : "\n"
35859 : "Delete an existing field on a layer.\n"
35860 : "\n"
35861 : "For more details: :cpp:func:`OGR_L_DeleteField`\n"
35862 : "\n"
35863 : "Parameters\n"
35864 : "-----------\n"
35865 : "iField: int\n"
35866 : " index of the field to delete.\n"
35867 : "\n"
35868 : "Returns\n"
35869 : "--------\n"
35870 : "int:\n"
35871 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35872 : "\n"
35873 : ""},
35874 : { "Layer_ReorderField", _wrap_Layer_ReorderField, METH_VARARGS, "\n"
35875 : "Layer_ReorderField(Layer self, int iOldFieldPos, int iNewFieldPos) -> OGRErr\n"
35876 : "\n"
35877 : "Reorder an existing field on a layer.\n"
35878 : "\n"
35879 : "For more details: :cpp:func:`OGR_L_ReorderField`\n"
35880 : "\n"
35881 : "Parameters\n"
35882 : "-----------\n"
35883 : "iOldFieldPos: int\n"
35884 : " previous position of the field to move. Must be in the\n"
35885 : " range [0,GetFieldCount()-1].\n"
35886 : "iNewFieldPos: int\n"
35887 : " new position of the field to move. Must be in the range\n"
35888 : " [0,GetFieldCount()-1].\n"
35889 : "\n"
35890 : "Returns\n"
35891 : "--------\n"
35892 : "int:\n"
35893 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35894 : "\n"
35895 : ""},
35896 : { "Layer_ReorderFields", _wrap_Layer_ReorderFields, METH_VARARGS, "\n"
35897 : "Layer_ReorderFields(Layer self, int nList) -> OGRErr\n"
35898 : "\n"
35899 : "Reorder all the fields of a layer.\n"
35900 : "\n"
35901 : "For more details: :cpp:func:`OGR_L_ReorderFields`\n"
35902 : "\n"
35903 : "Parameters\n"
35904 : "-----------\n"
35905 : "nList: list[int]\n"
35906 : " A list of GetLayerDefn().GetFieldCount()\n"
35907 : " elements which is a permutation of\n"
35908 : " [0, GetLayerDefn().GetFieldCount()-1].\n"
35909 : "\n"
35910 : "Returns\n"
35911 : "--------\n"
35912 : "int:\n"
35913 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35914 : "\n"
35915 : ""},
35916 : { "Layer_AlterFieldDefn", _wrap_Layer_AlterFieldDefn, METH_VARARGS, "\n"
35917 : "Layer_AlterFieldDefn(Layer self, int iField, FieldDefn field_def, int nFlags) -> OGRErr\n"
35918 : "\n"
35919 : "Alter the definition of an existing field on a layer.\n"
35920 : "\n"
35921 : "For more details: :cpp:func:`OGR_L_AlterFieldDefn`\n"
35922 : "\n"
35923 : "Parameters\n"
35924 : "-----------\n"
35925 : "iField: int\n"
35926 : " index of the field whose definition must be altered.\n"
35927 : "field_def: FieldDefn\n"
35928 : " new field definition\n"
35929 : "nFlags: int\n"
35930 : " Combination of\n"
35931 : " :py:const:`osgeo.ogr.ALTER_NAME_FLAG`,\n"
35932 : " :py:const:`osgeo.ogr.ALTER_TYPE_FLAG`,\n"
35933 : " :py:const:`osgeo.ogr.ALTER_WIDTH_PRECISION_FLAG`,\n"
35934 : " :py:const:`osgeo.ogr.ALTER_NULLABLE_FLAG` and\n"
35935 : " :py:const:`osgeo.ogr.ALTER_DEFAULT_FLAG`\n"
35936 : " to indicate which of the name and/or type and/or width and precision\n"
35937 : " fields and/or nullability from the new field definition must be taken\n"
35938 : " into account.\n"
35939 : "\n"
35940 : "Returns\n"
35941 : "--------\n"
35942 : "int:\n"
35943 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35944 : "\n"
35945 : ""},
35946 : { "Layer_AlterGeomFieldDefn", _wrap_Layer_AlterGeomFieldDefn, METH_VARARGS, "Layer_AlterGeomFieldDefn(Layer self, int iGeomField, GeomFieldDefn field_def, int nFlags) -> OGRErr"},
35947 : { "Layer_CreateGeomField", (PyCFunction)(void(*)(void))_wrap_Layer_CreateGeomField, METH_VARARGS|METH_KEYWORDS, "\n"
35948 : "Layer_CreateGeomField(Layer self, GeomFieldDefn field_def, int approx_ok=1) -> OGRErr\n"
35949 : "\n"
35950 : "Create a new geometry field on a layer.\n"
35951 : "\n"
35952 : "For more details: :cpp:func:`OGR_L_CreateGeomField`\n"
35953 : "\n"
35954 : "Parameters\n"
35955 : "-----------\n"
35956 : "field_def: GeomFieldDefn\n"
35957 : " The geometry field definition to write to disk.\n"
35958 : "approx_ok: bool, default=True\n"
35959 : " If True, the field may be created in a slightly different\n"
35960 : " form depending on the limitations of the format driver.\n"
35961 : "\n"
35962 : "Returns\n"
35963 : "--------\n"
35964 : "int:\n"
35965 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35966 : "\n"
35967 : ""},
35968 : { "Layer_StartTransaction", _wrap_Layer_StartTransaction, METH_O, "\n"
35969 : "Layer_StartTransaction(Layer self) -> OGRErr\n"
35970 : "\n"
35971 : "For datasources which support transactions, this creates a transaction.\n"
35972 : "\n"
35973 : "For more details: :cpp:func:`OGR_L_StartTransaction`\n"
35974 : "\n"
35975 : "Returns\n"
35976 : "--------\n"
35977 : "int:\n"
35978 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35979 : "\n"
35980 : ""},
35981 : { "Layer_CommitTransaction", _wrap_Layer_CommitTransaction, METH_O, "\n"
35982 : "Layer_CommitTransaction(Layer self) -> OGRErr\n"
35983 : "\n"
35984 : "For datasources which support transactions, this commits a transaction.\n"
35985 : "\n"
35986 : "For more details: :cpp:func:`OGR_L_CommitTransaction`\n"
35987 : "\n"
35988 : "Returns\n"
35989 : "--------\n"
35990 : "int:\n"
35991 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35992 : "\n"
35993 : ""},
35994 : { "Layer_RollbackTransaction", _wrap_Layer_RollbackTransaction, METH_O, "\n"
35995 : "Layer_RollbackTransaction(Layer self) -> OGRErr\n"
35996 : "\n"
35997 : "Roll back a datasource to its state before the start of the current transaction.\n"
35998 : "\n"
35999 : "For more details: :cpp:func:`OGR_L_RollbackTransaction`\n"
36000 : "\n"
36001 : "Returns\n"
36002 : "--------\n"
36003 : "int:\n"
36004 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
36005 : "\n"
36006 : ""},
36007 : { "Layer_FindFieldIndex", _wrap_Layer_FindFieldIndex, METH_VARARGS, "\n"
36008 : "Layer_FindFieldIndex(Layer self, char const * pszFieldName, int bExactMatch) -> int\n"
36009 : "\n"
36010 : "Find the index of field in a layer.\n"
36011 : "\n"
36012 : "For more details: :cpp:func:`OGR_L_FindFieldIndex`\n"
36013 : "\n"
36014 : "Returns\n"
36015 : "--------\n"
36016 : "int:\n"
36017 : " field index, or -1 if the field doesn't exist\n"
36018 : "\n"
36019 : ""},
36020 : { "Layer_GetSpatialRef", _wrap_Layer_GetSpatialRef, METH_O, "\n"
36021 : "Layer_GetSpatialRef(Layer self) -> SpatialReference\n"
36022 : "\n"
36023 : "Fetch the spatial reference system for this layer.\n"
36024 : "\n"
36025 : "For more details: :cpp:func:`OGR_L_GetSpatialRef`\n"
36026 : "\n"
36027 : "Returns\n"
36028 : "--------\n"
36029 : "SpatialReference:\n"
36030 : " spatial reference, or None if there isn't one.\n"
36031 : "\n"
36032 : ""},
36033 : { "Layer_GetFeaturesRead", _wrap_Layer_GetFeaturesRead, METH_O, "\n"
36034 : "Layer_GetFeaturesRead(Layer self) -> GIntBig\n"
36035 : "\n"
36036 : "For more details: :cpp:func:`OGR_L_GetFeaturesRead`\n"
36037 : "\n"
36038 : ""},
36039 : { "Layer_SetIgnoredFields", _wrap_Layer_SetIgnoredFields, METH_VARARGS, "\n"
36040 : "Layer_SetIgnoredFields(Layer self, char const ** options) -> OGRErr\n"
36041 : "\n"
36042 : "Set which fields can be omitted when retrieving features from the\n"
36043 : "layer.\n"
36044 : "\n"
36045 : "For more details: :cpp:func:`OGR_L_SetIgnoredFields`\n"
36046 : "\n"
36047 : "Parameters\n"
36048 : "-----------\n"
36049 : "options: list[str]\n"
36050 : " A list of field names.\n"
36051 : " If an empty list is passed, the ignored list is cleared.\n"
36052 : "\n"
36053 : "Returns\n"
36054 : "-------\n"
36055 : "int:\n"
36056 : " :py:const:`osgeo.ogr.OGRERR_NONE` if all field names have been resolved\n"
36057 : " (even if the driver does not support this method)\n"
36058 : "\n"
36059 : ""},
36060 : { "Layer_Intersection", (PyCFunction)(void(*)(void))_wrap_Layer_Intersection, METH_VARARGS|METH_KEYWORDS, "\n"
36061 : "Layer_Intersection(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr\n"
36062 : "\n"
36063 : "Intersection of two layers.\n"
36064 : "\n"
36065 : "For more details: :cpp:func:`OGR_L_Intersection`\n"
36066 : "\n"
36067 : "Parameters\n"
36068 : "-----------\n"
36069 : "method_layer: Layer\n"
36070 : " the method layer. Should not be None.\n"
36071 : "result_layer: Layer\n"
36072 : " the layer where the features resulting from the\n"
36073 : " operation are inserted. Should not be None.\n"
36074 : "options: list[str], optional\n"
36075 : " List of options (empty list is allowed). For example [\"PROMOTE_TO_MULTI=YES\"].\n"
36076 : "callback: Callable, optional\n"
36077 : " a GDALProgressFunc() compatible callback function for\n"
36078 : " reporting progress or None.\n"
36079 : "callback_data:\n"
36080 : " Argument to be passed to 'callback'. May be None.\n"
36081 : "\n"
36082 : "Returns\n"
36083 : "-------\n"
36084 : "int:\n"
36085 : " An error code if there was an error or the execution was interrupted,\n"
36086 : " :py:const:`osgeo.ogr.OGRERR_NONE` otherwise.\n"
36087 : "\n"
36088 : ""},
36089 : { "Layer_Union", (PyCFunction)(void(*)(void))_wrap_Layer_Union, METH_VARARGS|METH_KEYWORDS, "\n"
36090 : "Layer_Union(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr\n"
36091 : "\n"
36092 : "Union of two layers.\n"
36093 : "\n"
36094 : "For more details: :cpp:func:`OGR_L_Union`\n"
36095 : "\n"
36096 : "The first geometry field is always used.\n"
36097 : "\n"
36098 : "Parameters\n"
36099 : "-----------\n"
36100 : "method_layer: Layer\n"
36101 : " the method layer. Should not be None.\n"
36102 : "result_layer: Layer\n"
36103 : " the layer where the features resulting from the\n"
36104 : " operation are inserted. Should not be None.\n"
36105 : "options: list[str], optional\n"
36106 : " List of options (empty list is allowed). For example [\"PROMOTE_TO_MULTI=YES\"].\n"
36107 : "callback: Callable, optional\n"
36108 : " a GDALProgressFunc() compatible callback function for\n"
36109 : " reporting progress or None.\n"
36110 : "callback_data:\n"
36111 : " Argument to be passed to 'callback'. May be None.\n"
36112 : "\n"
36113 : "Returns\n"
36114 : "-------\n"
36115 : "int:\n"
36116 : " An error code if there was an error or the execution was interrupted,\n"
36117 : " :py:const:`osgeo.ogr.OGRERR_NONE` otherwise.\n"
36118 : "\n"
36119 : ""},
36120 : { "Layer_SymDifference", (PyCFunction)(void(*)(void))_wrap_Layer_SymDifference, METH_VARARGS|METH_KEYWORDS, "\n"
36121 : "Layer_SymDifference(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr\n"
36122 : "\n"
36123 : "Symmetrical difference of two layers.\n"
36124 : "\n"
36125 : "For more details: :cpp:func:`OGR_L_SymDifference`\n"
36126 : "\n"
36127 : "Parameters\n"
36128 : "-----------\n"
36129 : "method_layer: Layer\n"
36130 : " the method layer. Should not be None.\n"
36131 : "result_layer: Layer\n"
36132 : " the layer where the features resulting from the\n"
36133 : " operation are inserted. Should not be None.\n"
36134 : "options: list[str], optional\n"
36135 : " List of options (empty list is allowed). For example [\"PROMOTE_TO_MULTI=YES\"].\n"
36136 : "callback: Callable, optional\n"
36137 : " a GDALProgressFunc() compatible callback function for\n"
36138 : " reporting progress or None.\n"
36139 : "callback_data:\n"
36140 : " Argument to be passed to 'callback'. May be None.\n"
36141 : "\n"
36142 : "Returns\n"
36143 : "-------\n"
36144 : "int:\n"
36145 : " An error code if there was an error or the execution was interrupted,\n"
36146 : " :py:const:`osgeo.ogr.OGRERR_NONE` otherwise.\n"
36147 : "\n"
36148 : ""},
36149 : { "Layer_Identity", (PyCFunction)(void(*)(void))_wrap_Layer_Identity, METH_VARARGS|METH_KEYWORDS, "\n"
36150 : "Layer_Identity(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr\n"
36151 : "\n"
36152 : "Identify the features of this layer with the ones from the identity layer.\n"
36153 : "\n"
36154 : "For more details: :cpp:func:`OGR_L_Identity`\n"
36155 : "\n"
36156 : "Parameters\n"
36157 : "-----------\n"
36158 : "method_layer: Layer\n"
36159 : " the method layer. Should not be None.\n"
36160 : "result_layer: Layer\n"
36161 : " the layer where the features resulting from the\n"
36162 : " operation are inserted. Should not be None.\n"
36163 : "options: list[str], optional\n"
36164 : " List of options (empty list is allowed). For example [\"PROMOTE_TO_MULTI=YES\"].\n"
36165 : "callback: Callable, optional\n"
36166 : " a GDALProgressFunc() compatible callback function for\n"
36167 : " reporting progress or None.\n"
36168 : "callback_data:\n"
36169 : " Argument to be passed to 'callback'. May be None.\n"
36170 : "\n"
36171 : "Returns\n"
36172 : "-------\n"
36173 : "int:\n"
36174 : " An error code if there was an error or the execution was interrupted,\n"
36175 : " :py:const:`osgeo.ogr.OGRERR_NONE` otherwise.\n"
36176 : "\n"
36177 : ""},
36178 : { "Layer_Update", (PyCFunction)(void(*)(void))_wrap_Layer_Update, METH_VARARGS|METH_KEYWORDS, "\n"
36179 : "Layer_Update(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr\n"
36180 : "\n"
36181 : "Update this layer with features from the update layer.\n"
36182 : "\n"
36183 : "For more details: :cpp:func:`OGR_L_Update`\n"
36184 : "\n"
36185 : "Parameters\n"
36186 : "-----------\n"
36187 : "method_layer: Layer\n"
36188 : " the method layer. Should not be None.\n"
36189 : "result_layer: Layer\n"
36190 : " the layer where the features resulting from the\n"
36191 : " operation are inserted. Should not be None.\n"
36192 : "options: list[str], optional\n"
36193 : " List of options (empty list is allowed). For example [\"PROMOTE_TO_MULTI=YES\"].\n"
36194 : "callback: Callable, optional\n"
36195 : " a GDALProgressFunc() compatible callback function for\n"
36196 : " reporting progress or None.\n"
36197 : "callback_data:\n"
36198 : " Argument to be passed to 'callback'. May be None.\n"
36199 : "\n"
36200 : "Returns\n"
36201 : "-------\n"
36202 : "int:\n"
36203 : " An error code if there was an error or the execution was interrupted,\n"
36204 : " :py:const:`osgeo.ogr.OGRERR_NONE` otherwise.\n"
36205 : "\n"
36206 : ""},
36207 : { "Layer_Clip", (PyCFunction)(void(*)(void))_wrap_Layer_Clip, METH_VARARGS|METH_KEYWORDS, "\n"
36208 : "Layer_Clip(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr\n"
36209 : "\n"
36210 : "Clip off areas that are not covered by the method layer.\n"
36211 : "\n"
36212 : "For more details: :cpp:func:`OGR_L_Clip`\n"
36213 : "\n"
36214 : "Parameters\n"
36215 : "-----------\n"
36216 : "method_layer: Layer\n"
36217 : " the method layer. Should not be None.\n"
36218 : "result_layer: Layer\n"
36219 : " the layer where the features resulting from the\n"
36220 : " operation are inserted. Should not be None.\n"
36221 : "options: list[str], optional\n"
36222 : " List of options (empty list is allowed). For example [\"PROMOTE_TO_MULTI=YES\"].\n"
36223 : "callback: Callable, optional\n"
36224 : " a GDALProgressFunc() compatible callback function for\n"
36225 : " reporting progress or None.\n"
36226 : "callback_data:\n"
36227 : " Argument to be passed to 'callback'. May be None.\n"
36228 : "\n"
36229 : "Returns\n"
36230 : "-------\n"
36231 : "int:\n"
36232 : " An error code if there was an error or the execution was interrupted,\n"
36233 : " :py:const:`osgeo.ogr.OGRERR_NONE` otherwise.\n"
36234 : "\n"
36235 : ""},
36236 : { "Layer_Erase", (PyCFunction)(void(*)(void))_wrap_Layer_Erase, METH_VARARGS|METH_KEYWORDS, "\n"
36237 : "Layer_Erase(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr\n"
36238 : "\n"
36239 : "Remove areas that are covered by the method layer.\n"
36240 : "\n"
36241 : "For more details: :cpp:func:`OGR_L_Erase`\n"
36242 : "\n"
36243 : "Parameters\n"
36244 : "-----------\n"
36245 : "method_layer: Layer\n"
36246 : " the method layer. Should not be None.\n"
36247 : "result_layer: Layer\n"
36248 : " the layer where the features resulting from the\n"
36249 : " operation are inserted. Should not be None.\n"
36250 : "options: list[str], optional\n"
36251 : " List of options (empty list is allowed). For example [\"PROMOTE_TO_MULTI=YES\"].\n"
36252 : "callback: Callable, optional\n"
36253 : " a GDALProgressFunc() compatible callback function for\n"
36254 : " reporting progress or None.\n"
36255 : "callback_data:\n"
36256 : " Argument to be passed to 'callback'. May be None.\n"
36257 : "\n"
36258 : "Returns\n"
36259 : "-------\n"
36260 : "int:\n"
36261 : " An error code if there was an error or the execution was interrupted,\n"
36262 : " :py:const:`osgeo.ogr.OGRERR_NONE` otherwise.\n"
36263 : "\n"
36264 : ""},
36265 : { "Layer_GetStyleTable", _wrap_Layer_GetStyleTable, METH_O, "\n"
36266 : "Layer_GetStyleTable(Layer self) -> StyleTable\n"
36267 : "\n"
36268 : "Get style table.\n"
36269 : "\n"
36270 : "For more details: :cpp:func:`OGR_L_GetStyleTable`\n"
36271 : "\n"
36272 : ""},
36273 : { "Layer_SetStyleTable", _wrap_Layer_SetStyleTable, METH_VARARGS, "\n"
36274 : "Layer_SetStyleTable(Layer self, StyleTable table)\n"
36275 : "\n"
36276 : "Set style table.\n"
36277 : "\n"
36278 : "For more details: :cpp:func:`OGR_L_SetStyleTable`\n"
36279 : "\n"
36280 : ""},
36281 : { "Layer_ExportArrowArrayStreamPyCapsule", _wrap_Layer_ExportArrowArrayStreamPyCapsule, METH_VARARGS, "Layer_ExportArrowArrayStreamPyCapsule(Layer self, char ** options=None) -> PyObject *"},
36282 : { "Layer_GetArrowStream", _wrap_Layer_GetArrowStream, METH_VARARGS, "Layer_GetArrowStream(Layer self, char ** options=None) -> ArrowArrayStream"},
36283 : { "Layer_IsArrowSchemaSupported", _wrap_Layer_IsArrowSchemaSupported, METH_VARARGS, "Layer_IsArrowSchemaSupported(Layer self, ArrowSchema schema, char ** options=None)"},
36284 : { "Layer_CreateFieldFromArrowSchema", _wrap_Layer_CreateFieldFromArrowSchema, METH_VARARGS, "Layer_CreateFieldFromArrowSchema(Layer self, ArrowSchema schema, char ** options=None) -> OGRErr"},
36285 : { "Layer_WriteArrowBatch", _wrap_Layer_WriteArrowBatch, METH_VARARGS, "Layer_WriteArrowBatch(Layer self, ArrowSchema schema, ArrowArray array, char ** options=None) -> OGRErr"},
36286 : { "Layer_WriteArrowStreamCapsule", _wrap_Layer_WriteArrowStreamCapsule, METH_VARARGS, "Layer_WriteArrowStreamCapsule(Layer self, PyObject * capsule, int createFieldsFromSchema, char ** options=None) -> OGRErr"},
36287 : { "Layer_WriteArrowSchemaAndArrowArrayCapsule", _wrap_Layer_WriteArrowSchemaAndArrowArrayCapsule, METH_VARARGS, "Layer_WriteArrowSchemaAndArrowArrayCapsule(Layer self, PyObject * schemaCapsule, PyObject * arrayCapsule, int createFieldsFromSchema, char ** options=None) -> OGRErr"},
36288 : { "Layer_GetGeometryTypes", (PyCFunction)(void(*)(void))_wrap_Layer_GetGeometryTypes, METH_VARARGS|METH_KEYWORDS, "\n"
36289 : "Layer_GetGeometryTypes(Layer self, int geom_field=0, int flags=0, GDALProgressFunc callback=0, void * callback_data=None)\n"
36290 : "\n"
36291 : "Get actual geometry types found in features.\n"
36292 : "\n"
36293 : "For more details: :cpp:func:`OGR_L_GetGeometryTypes`\n"
36294 : "\n"
36295 : "Parameters\n"
36296 : "-----------\n"
36297 : "geom_field: int, optional\n"
36298 : " index of the geometry field\n"
36299 : "flags: int, optional\n"
36300 : " 0, or a combination of :py:const:`osgeo.ogr.GGT_COUNT_NOT_NEEDED`,\n"
36301 : " :py:const:`osgeo.ogr.GGT_STOP_IF_MIXED` and\n"
36302 : " :py:const:`osgeo.ogr.GGT_GEOMCOLLECTIONZ_TINZ`\n"
36303 : "callback: Callable, optional\n"
36304 : " a GDALProgressFunc() compatible callback function for\n"
36305 : " cancellation or None.\n"
36306 : "callback_data:\n"
36307 : " Argument to be passed to 'callback'. May be None.\n"
36308 : "\n"
36309 : "Returns\n"
36310 : "-------\n"
36311 : "dict:\n"
36312 : " A dictionary whose keys are :py:const:`osgeo.ogr.wkbXXXX` constants and\n"
36313 : " values the corresponding number of geometries of that type in the layer.\n"
36314 : "\n"
36315 : ""},
36316 : { "Layer_GetSupportedSRSList", (PyCFunction)(void(*)(void))_wrap_Layer_GetSupportedSRSList, METH_VARARGS|METH_KEYWORDS, "Layer_GetSupportedSRSList(Layer self, int geom_field=0)"},
36317 : { "Layer_SetActiveSRS", _wrap_Layer_SetActiveSRS, METH_VARARGS, "Layer_SetActiveSRS(Layer self, int geom_field, SpatialReference srs) -> OGRErr"},
36318 : { "Layer_swigregister", Layer_swigregister, METH_O, NULL},
36319 : { "delete_Feature", _wrap_delete_Feature, METH_O, "delete_Feature(Feature self)"},
36320 : { "new_Feature", (PyCFunction)(void(*)(void))_wrap_new_Feature, METH_VARARGS|METH_KEYWORDS, "\n"
36321 : "new_Feature(FeatureDefn feature_def) -> Feature\n"
36322 : "\n"
36323 : "\n"
36324 : "Parameters\n"
36325 : "-----------\n"
36326 : "feature_def:\n"
36327 : " :py:class:`FeatureDefn` to which the feature will adhere.\n"
36328 : "\n"
36329 : ""},
36330 : { "Feature_GetDefnRef", _wrap_Feature_GetDefnRef, METH_O, "\n"
36331 : "Feature_GetDefnRef(Feature self) -> FeatureDefn\n"
36332 : "\n"
36333 : "\n"
36334 : "Fetch the :py:class:`FeatureDefn` associated with this Feature.\n"
36335 : "\n"
36336 : "See :cpp:func:`OGRFeature::GetDefnRef()`.\n"
36337 : "\n"
36338 : "Returns\n"
36339 : "--------\n"
36340 : "FeatureDefn\n"
36341 : "\n"
36342 : ""},
36343 : { "Feature_SetGeometry", _wrap_Feature_SetGeometry, METH_VARARGS, "\n"
36344 : "Feature_SetGeometry(Feature self, Geometry geom) -> OGRErr\n"
36345 : "\n"
36346 : "\n"
36347 : "Set feature geometry.\n"
36348 : "\n"
36349 : "This function updates the features geometry, and operates exactly as\n"
36350 : ":py:meth:`SetGeometryDirectly`, except that this function does not assume\n"
36351 : "ownership of the passed geometry, but instead makes a copy of it.\n"
36352 : "\n"
36353 : "See :cpp:func:`OGRFeature::SetGeometry`.\n"
36354 : "\n"
36355 : "This method has only an effect on the in-memory feature object. If\n"
36356 : "this object comes from a layer and the modifications must be\n"
36357 : "serialized back to the datasource, :py:meth:`Layer.SetFeature` must be used\n"
36358 : "afterwards. Or if this is a new feature, :py:meth:`Layer.CreateFeature` must be\n"
36359 : "used afterwards.\n"
36360 : "\n"
36361 : "Parameters\n"
36362 : "-----------\n"
36363 : "geom : Geometry\n"
36364 : " new geometry to apply to feature.\n"
36365 : "\n"
36366 : "Returns\n"
36367 : "--------\n"
36368 : "int:\n"
36369 : " :py:const:`OGRERR_NONE` if successful, or\n"
36370 : " :py:const:`OGR_UNSUPPORTED_GEOMETRY_TYPE` if the geometry type is illegal for\n"
36371 : " the :py:class:`FeatureDefn` (checking not yet implemented).\n"
36372 : "\n"
36373 : ""},
36374 : { "Feature_SetGeometryDirectly", _wrap_Feature_SetGeometryDirectly, METH_VARARGS, "Feature_SetGeometryDirectly(Feature self, Geometry geom) -> OGRErr"},
36375 : { "Feature_GetGeometryRef", _wrap_Feature_GetGeometryRef, METH_O, "\n"
36376 : "Feature_GetGeometryRef(Feature self) -> Geometry\n"
36377 : "\n"
36378 : "Return the feature geometry\n"
36379 : "\n"
36380 : "The lifetime of the returned geometry is bound to the one of its belonging\n"
36381 : "feature.\n"
36382 : "\n"
36383 : "See :cpp:func:`OGRFeature::GetGeometryRef`\n"
36384 : "\n"
36385 : "The :py:func:`Feature.geometry` method is also available as an alias of :py:func:`Feature.GetGeometryRef`.\n"
36386 : "\n"
36387 : "Returns\n"
36388 : "--------\n"
36389 : "Geometry:\n"
36390 : " the geometry, or None.\n"
36391 : "\n"
36392 : ""},
36393 : { "Feature_SetGeomField", _wrap_Feature_SetGeomField, METH_VARARGS, "\n"
36394 : "Feature_SetGeomField(Feature self, int iField, Geometry geom) -> OGRErr\n"
36395 : "Feature_SetGeomField(Feature self, char const * field_name, Geometry geom) -> OGRErr\n"
36396 : "\n"
36397 : "\n"
36398 : "Set feature geometry of a specified geometry field.\n"
36399 : "\n"
36400 : "This function updates the features geometry, and operates exactly as\n"
36401 : ":py:meth:`SetGeomFieldDirectly`, except that this function does not assume\n"
36402 : "ownership of the passed geometry, but instead makes a copy of it.\n"
36403 : "\n"
36404 : "See :cpp:func:`OGRFeature::SetGeomField`.\n"
36405 : "\n"
36406 : "Parameters\n"
36407 : "-----------\n"
36408 : "fld_index : int / str\n"
36409 : " Geometry field name or 0-based numeric index. For repeated\n"
36410 : " access, use of the numeric index avoids a lookup\n"
36411 : " step.\n"
36412 : "geom : Geometry\n"
36413 : " handle to the new geometry to apply to feature.\n"
36414 : "\n"
36415 : "Returns\n"
36416 : "--------\n"
36417 : "int:\n"
36418 : " :py:const:`OGRERR_NONE` if successful, or\n"
36419 : " :py:const:`OGR_UNSUPPORTED_GEOMETRY_TYPE` if the geometry type is illegal for\n"
36420 : " the :py:class:`FeatureDefn` (checking not yet implemented).\n"
36421 : "\n"
36422 : ""},
36423 : { "Feature_SetGeomFieldDirectly", _wrap_Feature_SetGeomFieldDirectly, METH_VARARGS, "\n"
36424 : "Feature_SetGeomFieldDirectly(Feature self, int iField, Geometry geom) -> OGRErr\n"
36425 : "Feature_SetGeomFieldDirectly(Feature self, char const * field_name, Geometry geom) -> OGRErr\n"
36426 : ""},
36427 : { "Feature_GetGeomFieldRef", _wrap_Feature_GetGeomFieldRef, METH_VARARGS, "\n"
36428 : "Feature_GetGeomFieldRef(Feature self, int iField) -> Geometry\n"
36429 : "Feature_GetGeomFieldRef(Feature self, char const * field_name) -> Geometry\n"
36430 : "\n"
36431 : "\n"
36432 : "Fetch a feature :py:class:`Geometry`.\n"
36433 : "\n"
36434 : "See :cpp:func:`OGRFeature::GetGeomFieldRef`.\n"
36435 : "\n"
36436 : "Parameters\n"
36437 : "-----------\n"
36438 : "fld_index : int / str\n"
36439 : " Field name or 0-based numeric index. For repeated\n"
36440 : " access, use of the numeric index avoids a lookup\n"
36441 : " step.\n"
36442 : "\n"
36443 : "Returns\n"
36444 : "-------\n"
36445 : "Geometry\n"
36446 : "\n"
36447 : "\n"
36448 : ""},
36449 : { "Feature_Clone", _wrap_Feature_Clone, METH_O, "\n"
36450 : "Feature_Clone(Feature self) -> Feature\n"
36451 : "\n"
36452 : "Duplicate a Feature.\n"
36453 : "See :cpp:func:`OGRFeature::Clone`.\n"
36454 : "\n"
36455 : "Returns\n"
36456 : "--------\n"
36457 : "Feature\n"
36458 : "\n"
36459 : ""},
36460 : { "Feature_Equal", _wrap_Feature_Equal, METH_VARARGS, "\n"
36461 : "Feature_Equal(Feature self, Feature feature) -> bool\n"
36462 : "\n"
36463 : "\n"
36464 : "Test if two features are the same.\n"
36465 : "\n"
36466 : "Two features are considered equal if they reference the\n"
36467 : "same :py:class:`FeatureDefn`, have the same field values, and the same geometry\n"
36468 : "(as tested by :py:func:`Geometry.Equal`) as well as the same feature id.\n"
36469 : "\n"
36470 : "See :cpp:func:`OGRFeature::Equal`.\n"
36471 : "\n"
36472 : "Parameters\n"
36473 : "-----------\n"
36474 : "feature : Feature\n"
36475 : " feature to test this one against\n"
36476 : "\n"
36477 : "Returns\n"
36478 : "--------\n"
36479 : "bool\n"
36480 : "\n"
36481 : ""},
36482 : { "Feature_GetFieldCount", _wrap_Feature_GetFieldCount, METH_O, "\n"
36483 : "Feature_GetFieldCount(Feature self) -> int\n"
36484 : "\n"
36485 : "\n"
36486 : "Fetch number of fields on this feature This will always be the same as\n"
36487 : "the field count for the :py:class:`FeatureDefn`.\n"
36488 : "\n"
36489 : "See :cpp:func:`OGRFeature::GetFieldCount`.\n"
36490 : "\n"
36491 : "Returns\n"
36492 : "--------\n"
36493 : "int:\n"
36494 : " count of fields.\n"
36495 : "\n"
36496 : ""},
36497 : { "Feature_GetFieldDefnRef", _wrap_Feature_GetFieldDefnRef, METH_VARARGS, "\n"
36498 : "Feature_GetFieldDefnRef(Feature self, int id) -> FieldDefn\n"
36499 : "Feature_GetFieldDefnRef(Feature self, char const * field_name) -> FieldDefn\n"
36500 : "\n"
36501 : "\n"
36502 : "Fetch definition for this field.\n"
36503 : "\n"
36504 : "See :cpp:func:`OGRFeature::GetFieldDefnRef`.\n"
36505 : "\n"
36506 : "Parameters\n"
36507 : "-----------\n"
36508 : "fld_index : int / str\n"
36509 : " Field name or 0-based numeric index. For repeated\n"
36510 : " access, use of the numeric index avoids a lookup\n"
36511 : " step.\n"
36512 : "\n"
36513 : "Returns\n"
36514 : "--------\n"
36515 : "FieldDefn\n"
36516 : " a reference to the field definition. This reference should\n"
36517 : " not be modified.\n"
36518 : "\n"
36519 : ""},
36520 : { "Feature_GetGeomFieldCount", _wrap_Feature_GetGeomFieldCount, METH_O, "\n"
36521 : "Feature_GetGeomFieldCount(Feature self) -> int\n"
36522 : "\n"
36523 : "\n"
36524 : "Fetch number of geometry fields on this feature This will always be\n"
36525 : "the same as the geometry field count for the :py:class:`FeatureDefn`.\n"
36526 : "\n"
36527 : "See :cpp:func:`OGRFeature::GetGeomFieldCount`.\n"
36528 : "\n"
36529 : "Returns\n"
36530 : "--------\n"
36531 : "int:\n"
36532 : " count of geometry fields.\n"
36533 : "\n"
36534 : ""},
36535 : { "Feature_GetGeomFieldDefnRef", _wrap_Feature_GetGeomFieldDefnRef, METH_VARARGS, "\n"
36536 : "Feature_GetGeomFieldDefnRef(Feature self, int id) -> GeomFieldDefn\n"
36537 : "Feature_GetGeomFieldDefnRef(Feature self, char const * field_name) -> GeomFieldDefn\n"
36538 : "\n"
36539 : "\n"
36540 : "Fetch definition for this geometry field.\n"
36541 : "\n"
36542 : "See :cpp:func:`OGRFeature::GetGeomFieldDefnRef`.\n"
36543 : "\n"
36544 : "Parameters\n"
36545 : "-----------\n"
36546 : "fld_index : int / str\n"
36547 : " Field name or 0-based numeric index. For repeated\n"
36548 : " access, use of the numeric index avoids a lookup\n"
36549 : " step.\n"
36550 : "\n"
36551 : "Returns\n"
36552 : "--------\n"
36553 : "GeomFieldDefn:\n"
36554 : " a reference to the field definition.\n"
36555 : " Should not be deleted or modified.\n"
36556 : "\n"
36557 : ""},
36558 : { "Feature_GetFieldAsString", _wrap_Feature_GetFieldAsString, METH_VARARGS, "\n"
36559 : "Feature_GetFieldAsString(Feature self, int id) -> char const\n"
36560 : "Feature_GetFieldAsString(Feature self, char const * field_name) -> char const *\n"
36561 : "\n"
36562 : "\n"
36563 : ":py:const:`OFTReal` and :py:const:`OFTInteger` fields will be translated to string using\n"
36564 : "sprintf(), but not necessarily using the established formatting rules.\n"
36565 : "Other field types, or errors will result in a return value of zero.\n"
36566 : "\n"
36567 : "See :cpp:func:`OGRFeature::GetFieldAsString`.\n"
36568 : "\n"
36569 : "Parameters\n"
36570 : "-----------\n"
36571 : "fld_index : int / str\n"
36572 : " Field name or 0-based numeric index. For repeated\n"
36573 : " access, use of the numeric index avoids a lookup\n"
36574 : " step.\n"
36575 : "\n"
36576 : "Returns\n"
36577 : "--------\n"
36578 : "str:\n"
36579 : " the field value.\n"
36580 : "\n"
36581 : ""},
36582 : { "Feature_GetFieldAsISO8601DateTime", _wrap_Feature_GetFieldAsISO8601DateTime, METH_VARARGS, "\n"
36583 : "Feature_GetFieldAsISO8601DateTime(Feature self, int id, char ** options=None) -> char const\n"
36584 : "Feature_GetFieldAsISO8601DateTime(Feature self, char const * field_name, char ** options=None) -> char const *\n"
36585 : "\n"
36586 : "\n"
36587 : "Fetch :py:const:`OFTDateTime` field value as a ISO8601 representation.\n"
36588 : "\n"
36589 : "Return a string like 'YYYY-MM-DDTHH:MM:SS(.sss)?(Z|([+|-]HH:MM))?'\n"
36590 : "Milliseconds are omitted if equal to zero.\n"
36591 : "Other field types, or errors will result in a return of an empty string.\n"
36592 : "\n"
36593 : "See :cpp:func:`OGRFeature::GetFieldAsISO8601DateTime`.\n"
36594 : "\n"
36595 : ".. versionadded:: 3.7\n"
36596 : "\n"
36597 : "Parameters\n"
36598 : "-----------\n"
36599 : "fld_index : int / str\n"
36600 : " Field name or 0-based numeric index. For repeated\n"
36601 : " access, use of the numeric index avoids a lookup\n"
36602 : " step.\n"
36603 : "options : dict / str\n"
36604 : " Not currently used.\n"
36605 : "\n"
36606 : ""},
36607 : { "Feature_GetFieldAsInteger", _wrap_Feature_GetFieldAsInteger, METH_VARARGS, "\n"
36608 : "Feature_GetFieldAsInteger(Feature self, int id) -> int\n"
36609 : "Feature_GetFieldAsInteger(Feature self, char const * field_name) -> int\n"
36610 : "\n"
36611 : "\n"
36612 : "Fetch field value as a 32-bit integer.\n"
36613 : "\n"
36614 : ":py:const:`OFTString` features will be translated using atoi().\n"
36615 : ":py:const:`OFTReal` fields will be cast to integer. Other field types, or\n"
36616 : "errors will result in a return value of zero.\n"
36617 : "\n"
36618 : "See :cpp:func:`GetFieldAsInteger`.\n"
36619 : "\n"
36620 : "Parameters\n"
36621 : "-----------\n"
36622 : "fld_index : int / str\n"
36623 : " Field name or 0-based numeric index. For repeated\n"
36624 : " access, use of the numeric index avoids a lookup\n"
36625 : " step.\n"
36626 : "\n"
36627 : "Returns\n"
36628 : "--------\n"
36629 : "int:\n"
36630 : " the field value.\n"
36631 : "\n"
36632 : "Examples\n"
36633 : "--------\n"
36634 : ">>> defn = ogr.FeatureDefn()\n"
36635 : ">>> defn.AddFieldDefn(ogr.FieldDefn('my_int', ogr.OFTInteger64))\n"
36636 : ">>> feature = ogr.Feature(defn)\n"
36637 : ">>> feature['my_int'] = 2**32 + 1\n"
36638 : ">>> feature.GetFieldAsInteger('my_int')\n"
36639 : "Warning 1: Integer overflow occurred when trying to return 64bit integer. Use GetFieldAsInteger64() instead\n"
36640 : "2147483647\n"
36641 : ">>> feature.GetFieldAsInteger64('my_int')\n"
36642 : "4294967297\n"
36643 : ">>> feature.GetField('my_int')\n"
36644 : "4294967297\n"
36645 : "\n"
36646 : ""},
36647 : { "Feature_GetFieldAsInteger64", _wrap_Feature_GetFieldAsInteger64, METH_VARARGS, "\n"
36648 : "Feature_GetFieldAsInteger64(Feature self, int id) -> GIntBig\n"
36649 : "Feature_GetFieldAsInteger64(Feature self, char const * field_name) -> GIntBig\n"
36650 : "\n"
36651 : "\n"
36652 : "Fetch field value as integer 64 bit.\n"
36653 : "\n"
36654 : ":py:const:`OFTInteger` are promoted to 64 bit. :py:const:`OFTString` features\n"
36655 : "will be translated using :cpp:func:`CPLAtoGIntBig`. :py:const:`OFTReal` fields\n"
36656 : "will be cast to integer. Other field types, or errors will result in a return\n"
36657 : "value of zero.\n"
36658 : "\n"
36659 : "See :cpp:func:`OGRFeature::GetFieldAsInteger64`.\n"
36660 : "\n"
36661 : "Parameters\n"
36662 : "-----------\n"
36663 : "fld_index : int / str\n"
36664 : " Field name or 0-based numeric index. For repeated\n"
36665 : " access, use of the numeric index avoids a lookup\n"
36666 : " step.\n"
36667 : "\n"
36668 : "Returns\n"
36669 : "--------\n"
36670 : "int:\n"
36671 : " the field value.\n"
36672 : "\n"
36673 : ""},
36674 : { "Feature_GetFieldAsDouble", _wrap_Feature_GetFieldAsDouble, METH_VARARGS, "\n"
36675 : "Feature_GetFieldAsDouble(Feature self, int id) -> double\n"
36676 : "Feature_GetFieldAsDouble(Feature self, char const * field_name) -> double\n"
36677 : "\n"
36678 : "Fetch field value as a double.\n"
36679 : "\n"
36680 : ":py:const:`OFTString` features will be translated using :cpp:func:`CPLAtof`. :py:const:`OFTInteger`\n"
36681 : "fields will be cast to double. Other field types, or errors will\n"
36682 : "result in a return value of zero.\n"
36683 : "\n"
36684 : "See :cpp:func:`OGRFeature::GetFieldAsDouble`.\n"
36685 : "\n"
36686 : "Parameters\n"
36687 : "-----------\n"
36688 : "fld_index : int / str\n"
36689 : " Field name or 0-based numeric index. For repeated\n"
36690 : " access, use of the numeric index avoids a lookup\n"
36691 : " step.\n"
36692 : "\n"
36693 : "Returns\n"
36694 : "--------\n"
36695 : "float:\n"
36696 : " the field value.\n"
36697 : "\n"
36698 : ""},
36699 : { "Feature_GetFieldAsDateTime", _wrap_Feature_GetFieldAsDateTime, METH_VARARGS, "\n"
36700 : "Feature_GetFieldAsDateTime(Feature self, int id)\n"
36701 : "Feature_GetFieldAsDateTime(Feature self, char const * field_name)\n"
36702 : "\n"
36703 : "\n"
36704 : "Fetch field value as date and time.\n"
36705 : "\n"
36706 : "Currently this method only works for :py:const:`OFTDate`, :py:const:`OFTTime`\n"
36707 : "and :py:const:`OFTDateTime` fields.\n"
36708 : "\n"
36709 : "See :cpp:func:`OGRFeature::GetFieldAsDateTime`.\n"
36710 : "\n"
36711 : "Parameters\n"
36712 : "-----------\n"
36713 : "fld_index : int / str\n"
36714 : " Field name or 0-based numeric index. For repeated\n"
36715 : " access, use of the numeric index avoids a lookup\n"
36716 : " step.\n"
36717 : "\n"
36718 : "Returns\n"
36719 : "--------\n"
36720 : "list\n"
36721 : " list containing [ year, month, day, hour, minute, second, timezone flag ]\n"
36722 : "\n"
36723 : "Examples\n"
36724 : "--------\n"
36725 : ">>> from datetime import datetime\n"
36726 : ">>> from zoneinfo import ZoneInfo\n"
36727 : ">>> defn = ogr.FeatureDefn()\n"
36728 : ">>> defn.AddFieldDefn(ogr.FieldDefn('unknown', ogr.OFTDateTime))\n"
36729 : ">>> defn.AddFieldDefn(ogr.FieldDefn('local', ogr.OFTDateTime))\n"
36730 : ">>> defn.AddFieldDefn(ogr.FieldDefn('utc', ogr.OFTDateTime))\n"
36731 : ">>> feature = ogr.Feature(defn)\n"
36732 : ">>> feature['unknown'] = datetime.now()\n"
36733 : ">>> feature['local'] = datetime.now(ZoneInfo('Canada/Eastern'))\n"
36734 : ">>> feature['utc'] = datetime.now(ZoneInfo('UTC'))\n"
36735 : ">>> feature.GetFieldAsDateTime('unknown')\n"
36736 : "[2024, 3, 15, 20, 34, 52.594173431396484, 0]\n"
36737 : ">>> feature.GetFieldAsDateTime('local')\n"
36738 : "[2024, 3, 15, 20, 34, 52.59502410888672, 84]\n"
36739 : ">>> feature.GetFieldAsDateTime('utc')\n"
36740 : "[2024, 3, 16, 0, 34, 52.59580993652344, 100]\n"
36741 : "\n"
36742 : "See Also\n"
36743 : "--------\n"
36744 : ":py:func:`Feature.GetFieldAsISO8601DateTime`\n"
36745 : "\n"
36746 : ""},
36747 : { "Feature_GetFieldAsIntegerList", _wrap_Feature_GetFieldAsIntegerList, METH_VARARGS, "\n"
36748 : "Feature_GetFieldAsIntegerList(Feature self, int id)\n"
36749 : "Feature_GetFieldAsIntegerList(Feature self, char const * field_name)\n"
36750 : "\n"
36751 : "\n"
36752 : "Fetch field value as a list of integers.\n"
36753 : "\n"
36754 : "Currently this function only works for :py:const:`OFTIntegerList` fields.\n"
36755 : "\n"
36756 : "This function is the same as the C++ method\n"
36757 : ":cpp:func:`OGRFeature::GetFieldAsIntegerList`.\n"
36758 : "\n"
36759 : "Parameters\n"
36760 : "-----------\n"
36761 : "fld_index : int / str\n"
36762 : " Field name or 0-based numeric index. For repeated\n"
36763 : " access, use of the numeric index avoids a lookup\n"
36764 : " step.\n"
36765 : "\n"
36766 : "Returns\n"
36767 : "--------\n"
36768 : "list:\n"
36769 : " the field value.\n"
36770 : "\n"
36771 : ""},
36772 : { "Feature_GetFieldAsInteger64List", _wrap_Feature_GetFieldAsInteger64List, METH_VARARGS, "\n"
36773 : "Feature_GetFieldAsInteger64List(Feature self, int id)\n"
36774 : "\n"
36775 : "Fetch field value as a list of 64 bit integers.\n"
36776 : "\n"
36777 : "Currently this function only works for :py:const:`OFTInteger64List` fields.\n"
36778 : "\n"
36779 : "See :cpp:func:`OGRFeature::GetFieldAsInteger64List`.\n"
36780 : "\n"
36781 : "Parameters\n"
36782 : "-----------\n"
36783 : "fld_index : int / str\n"
36784 : " Field name or 0-based numeric index. For repeated\n"
36785 : " access, use of the numeric index avoids a lookup\n"
36786 : " step.\n"
36787 : "\n"
36788 : "Returns\n"
36789 : "--------\n"
36790 : "list:\n"
36791 : " the field value.\n"
36792 : "\n"
36793 : ""},
36794 : { "Feature_GetFieldAsDoubleList", _wrap_Feature_GetFieldAsDoubleList, METH_VARARGS, "\n"
36795 : "Feature_GetFieldAsDoubleList(Feature self, int id)\n"
36796 : "Feature_GetFieldAsDoubleList(Feature self, char const * field_name)\n"
36797 : "\n"
36798 : "\n"
36799 : "Fetch field value as a list of doubles.\n"
36800 : "\n"
36801 : "Currently this function only works for :py:const:`OFTRealList` fields.\n"
36802 : "\n"
36803 : "See :cpp:func:`OGRFeature::GetFieldAsDoubleList`.\n"
36804 : "\n"
36805 : "Parameters\n"
36806 : "-----------\n"
36807 : "fld_index : int / str\n"
36808 : " Field name or 0-based numeric index. For repeated\n"
36809 : " access, use of the numeric index avoids a lookup\n"
36810 : " step.\n"
36811 : "\n"
36812 : "Returns\n"
36813 : "-------\n"
36814 : "list\n"
36815 : "\n"
36816 : "Examples\n"
36817 : "--------\n"
36818 : ">>> defn = ogr.FeatureDefn()\n"
36819 : ">>> defn.AddFieldDefn(ogr.FieldDefn('list', ogr.OFTRealList))\n"
36820 : ">>> feature = ogr.Feature(defn)\n"
36821 : ">>> feature['list'] = [1.1, 2.2, 3.3]\n"
36822 : ">>> feature.GetFieldAsDoubleList('list')\n"
36823 : "[1.1, 2.2, 3.3]\n"
36824 : "\n"
36825 : ""},
36826 : { "Feature_GetFieldAsStringList", _wrap_Feature_GetFieldAsStringList, METH_VARARGS, "\n"
36827 : "Feature_GetFieldAsStringList(Feature self, int id) -> char **\n"
36828 : "\n"
36829 : "\n"
36830 : "Fetch field value as a list of strings.\n"
36831 : "\n"
36832 : "Currently this method only works for :py:const:`OFTStringList` fields.\n"
36833 : "\n"
36834 : "See :cpp:func:`OGRFeature::GetFieldAsStringList`.\n"
36835 : "\n"
36836 : "Parameters\n"
36837 : "-----------\n"
36838 : "fld_index : int / str\n"
36839 : " Field name or 0-based numeric index. For repeated\n"
36840 : " access, use of the numeric index avoids a lookup\n"
36841 : " step.\n"
36842 : "\n"
36843 : "Returns\n"
36844 : "--------\n"
36845 : "list:\n"
36846 : " the field value.\n"
36847 : "\n"
36848 : ""},
36849 : { "Feature_GetFieldAsBinary", _wrap_Feature_GetFieldAsBinary, METH_VARARGS, "\n"
36850 : "Feature_GetFieldAsBinary(Feature self, int id) -> OGRErr\n"
36851 : "Feature_GetFieldAsBinary(Feature self, char const * field_name) -> OGRErr\n"
36852 : "\n"
36853 : "\n"
36854 : "Fetch field value as binary.\n"
36855 : "\n"
36856 : "This method only works for :py:const:`OFTBinary` and :py:const:`OFTString` fields.\n"
36857 : "\n"
36858 : "See :cpp:func:`OGRFeature::GetFieldAsBinary`.\n"
36859 : "\n"
36860 : "Parameters\n"
36861 : "-----------\n"
36862 : "fld_index : int / str\n"
36863 : " Field name or 0-based numeric index. For repeated\n"
36864 : " access, use of the numeric index avoids a lookup\n"
36865 : " step.\n"
36866 : "\n"
36867 : "Returns\n"
36868 : "--------\n"
36869 : "bytearray\n"
36870 : "\n"
36871 : ""},
36872 : { "Feature_IsFieldSet", _wrap_Feature_IsFieldSet, METH_VARARGS, "\n"
36873 : "Feature_IsFieldSet(Feature self, int id) -> bool\n"
36874 : "Feature_IsFieldSet(Feature self, char const * field_name) -> bool\n"
36875 : "\n"
36876 : "\n"
36877 : "Test if a field has ever been assigned a value or not.\n"
36878 : "\n"
36879 : "See :cpp:func:`OGRFeature::IsFieldSet`.\n"
36880 : "\n"
36881 : "Parameters\n"
36882 : "-----------\n"
36883 : "fld_index : int / str\n"
36884 : " Field name or 0-based numeric index. For repeated\n"
36885 : " access, use of the numeric index avoids a lookup\n"
36886 : " step.\n"
36887 : "\n"
36888 : "Returns\n"
36889 : "--------\n"
36890 : "bool:\n"
36891 : " ``True`` if the field has been set, otherwise ``False``.\n"
36892 : "\n"
36893 : ""},
36894 : { "Feature_IsFieldNull", _wrap_Feature_IsFieldNull, METH_VARARGS, "\n"
36895 : "Feature_IsFieldNull(Feature self, int id) -> bool\n"
36896 : "Feature_IsFieldNull(Feature self, char const * field_name) -> bool\n"
36897 : "\n"
36898 : "\n"
36899 : "Test if a field is null.\n"
36900 : "\n"
36901 : "See :cpp:func:OGRFeature::`IsFieldNull`.\n"
36902 : "\n"
36903 : "Parameters\n"
36904 : "-----------\n"
36905 : "fld_index : int / str\n"
36906 : " Field name or 0-based numeric index. For repeated\n"
36907 : " access, use of the numeric index avoids a lookup\n"
36908 : " step.\n"
36909 : "\n"
36910 : "Returns\n"
36911 : "--------\n"
36912 : "bool:\n"
36913 : " ``True`` if the field is null, otherwise ``False``\n"
36914 : "\n"
36915 : ""},
36916 : { "Feature_IsFieldSetAndNotNull", _wrap_Feature_IsFieldSetAndNotNull, METH_VARARGS, "\n"
36917 : "Feature_IsFieldSetAndNotNull(Feature self, int id) -> bool\n"
36918 : "Feature_IsFieldSetAndNotNull(Feature self, char const * field_name) -> bool\n"
36919 : "\n"
36920 : "\n"
36921 : "Test if a field is set and not null.\n"
36922 : "\n"
36923 : "See :cpp:func:`OGRFeature::IsFieldSetAndNotNull`.\n"
36924 : "\n"
36925 : "Parameters\n"
36926 : "-----------\n"
36927 : "fld_index : int / str\n"
36928 : " Field name or 0-based numeric index. For repeated\n"
36929 : " access, use of the numeric index avoids a lookup\n"
36930 : " step.\n"
36931 : "\n"
36932 : "Returns\n"
36933 : "--------\n"
36934 : "bool:\n"
36935 : " ``True`` if the field is set and not null, otherwise ``False``.\n"
36936 : "\n"
36937 : ""},
36938 : { "Feature_GetFieldIndex", _wrap_Feature_GetFieldIndex, METH_VARARGS, "\n"
36939 : "Feature_GetFieldIndex(Feature self, char const * field_name) -> int\n"
36940 : "\n"
36941 : "\n"
36942 : "Fetch the field index given field name.\n"
36943 : "\n"
36944 : "See :cpp:func:`OGRFeature::GetFieldIndex`.\n"
36945 : "\n"
36946 : "Parameters\n"
36947 : "-----------\n"
36948 : "field_name:\n"
36949 : " the name of the field to search for.\n"
36950 : "\n"
36951 : "Returns\n"
36952 : "--------\n"
36953 : "int:\n"
36954 : " the field index, or -1 if no matching field is found.\n"
36955 : "\n"
36956 : ""},
36957 : { "Feature_GetGeomFieldIndex", _wrap_Feature_GetGeomFieldIndex, METH_VARARGS, "\n"
36958 : "Feature_GetGeomFieldIndex(Feature self, char const * field_name) -> int\n"
36959 : "\n"
36960 : "\n"
36961 : "Fetch the geometry field index given geometry field name.\n"
36962 : "\n"
36963 : "See :cpp:func:`OGRFeature::GetGeomFieldIndex`.\n"
36964 : "\n"
36965 : "Parameters\n"
36966 : "-----------\n"
36967 : "field_name:\n"
36968 : " the name of the geometry field to search for.\n"
36969 : "\n"
36970 : "Returns\n"
36971 : "--------\n"
36972 : "int:\n"
36973 : " the geometry field index, or -1 if no matching geometry field is found.\n"
36974 : "\n"
36975 : ""},
36976 : { "Feature_GetFID", _wrap_Feature_GetFID, METH_O, "\n"
36977 : "Feature_GetFID(Feature self) -> GIntBig\n"
36978 : "\n"
36979 : "\n"
36980 : "Get feature identifier.\n"
36981 : "See :cpp:func:`OGRFeature::GetFID`\n"
36982 : "\n"
36983 : "Returns\n"
36984 : "-------\n"
36985 : "int:\n"
36986 : " feature id or :py:const:`NullFID` if none has been assigned.\n"
36987 : "\n"
36988 : ""},
36989 : { "Feature_SetFID", _wrap_Feature_SetFID, METH_VARARGS, "\n"
36990 : "Feature_SetFID(Feature self, GIntBig fid) -> OGRErr\n"
36991 : "\n"
36992 : "\n"
36993 : "Set the feature identifier.\n"
36994 : "\n"
36995 : "For specific types of features this operation may fail on illegal\n"
36996 : "features ids. Generally it always succeeds. Feature ids should be\n"
36997 : "greater than or equal to zero, with the exception of :py:const:NullFID` (-1)\n"
36998 : "indicating that the feature id is unknown.\n"
36999 : "\n"
37000 : "See :cpp:func:`OGRFeature::SetFID`.\n"
37001 : "\n"
37002 : "Parameters\n"
37003 : "-----------\n"
37004 : "fid:\n"
37005 : " the new feature identifier value to assign.\n"
37006 : "\n"
37007 : "Returns\n"
37008 : "--------\n"
37009 : "int:\n"
37010 : " :py:const:`OGRERR_NONE` on success, or some other value on failure.\n"
37011 : "\n"
37012 : ""},
37013 : { "Feature_DumpReadable", _wrap_Feature_DumpReadable, METH_O, "\n"
37014 : "Feature_DumpReadable(Feature self)\n"
37015 : "\n"
37016 : "\n"
37017 : "Print this feature in a human readable form.\n"
37018 : "\n"
37019 : "This dumps the attributes and geometry. It doesn't include\n"
37020 : "definition information other than field types and names nor does it\n"
37021 : "report the geometry spatial reference system.\n"
37022 : "\n"
37023 : "See :cpp:func:`OGRFeature::DumpReadable`.\n"
37024 : "\n"
37025 : "Examples\n"
37026 : "--------\n"
37027 : ">>> with gdal.OpenEx('data/poly.shp') as ds:\n"
37028 : "... lyr = ds.GetLayer(0)\n"
37029 : "... feature = lyr.GetNextFeature()\n"
37030 : "... feature.DumpReadable()\n"
37031 : "...\n"
37032 : "OGRFeature(poly):0\n"
37033 : " AREA (Real) = 215229.266\n"
37034 : " EAS_ID (Integer64) = 168\n"
37035 : " PRFEDEA (String) = 35043411\n"
37036 : " POLYGON ((479819.84375 4765180.5,479690.1875 4765259.5,479647.0 4765369.5,479730.375 4765400.5,480039.03125 4765539.5,480035.34375 4765558.5,480159.78125 4765610.5,480202.28125 4765482.0,480365.0 4765015.5,480389.6875 4764950.0,480133.96875 4764856.5,480080.28125 4764979.5,480082.96875 4765049.5,480088.8125 4765139.5,480059.90625 4765239.5,480019.71875 4765319.5,479980.21875 4765409.5,479909.875 4765370.0,479859.875 4765270.0,479819.84375 4765180.5))\n"
37037 : "\n"
37038 : ""},
37039 : { "Feature_DumpReadableAsString", _wrap_Feature_DumpReadableAsString, METH_VARARGS, "\n"
37040 : "Feature_DumpReadableAsString(Feature self, char ** options=None) -> retStringAndCPLFree *\n"
37041 : "\n"
37042 : "\n"
37043 : "Return feature information in a human-readable form.\n"
37044 : "Returns the text printed by :py:func:`Feature.DumpReadable`.\n"
37045 : "\n"
37046 : "Returns\n"
37047 : "-------\n"
37048 : "str\n"
37049 : "\n"
37050 : ""},
37051 : { "Feature_UnsetField", _wrap_Feature_UnsetField, METH_VARARGS, "\n"
37052 : "Feature_UnsetField(Feature self, int id)\n"
37053 : "Feature_UnsetField(Feature self, char const * field_name)\n"
37054 : "\n"
37055 : "\n"
37056 : "Clear a field, marking it as unset.\n"
37057 : "\n"
37058 : "See :cpp:func:`OGRFeature::UnsetField`.\n"
37059 : "\n"
37060 : "Parameters\n"
37061 : "-----------\n"
37062 : "fld_index : int / str\n"
37063 : " Field name or 0-based numeric index. For repeated\n"
37064 : " access, use of the numeric index avoids a lookup\n"
37065 : " step.\n"
37066 : "\n"
37067 : ""},
37068 : { "Feature_SetFieldNull", _wrap_Feature_SetFieldNull, METH_VARARGS, "\n"
37069 : "Feature_SetFieldNull(Feature self, int id)\n"
37070 : "Feature_SetFieldNull(Feature self, char const * field_name)\n"
37071 : "\n"
37072 : "\n"
37073 : "Clear a field, marking it as null.\n"
37074 : "\n"
37075 : "See :cpp:func:`OGRFeature::SetFieldNull`.\n"
37076 : "\n"
37077 : "Parameters\n"
37078 : "-----------\n"
37079 : "fld_index : int / str\n"
37080 : " Field name or 0-based numeric index. For repeated\n"
37081 : " access, use of the numeric index avoids a lookup\n"
37082 : " step.\n"
37083 : "\n"
37084 : "\n"
37085 : ""},
37086 : { "Feature_SetFieldInteger64", _wrap_Feature_SetFieldInteger64, METH_VARARGS, "Feature_SetFieldInteger64(Feature self, int id, GIntBig value)"},
37087 : { "Feature_SetField", _wrap_Feature_SetField, METH_VARARGS, "\n"
37088 : "Feature_SetField(Feature self, int id, char const * value)\n"
37089 : "Feature_SetField(Feature self, char const * field_name, char const * value)\n"
37090 : "Feature_SetField(Feature self, int id, double value)\n"
37091 : "Feature_SetField(Feature self, char const * field_name, double value)\n"
37092 : "Feature_SetField(Feature self, int id, int year, int month, int day, int hour, int minute, float second, int tzflag)\n"
37093 : "Feature_SetField(Feature self, char const * field_name, int year, int month, int day, int hour, int minute, float second, int tzflag)\n"
37094 : ""},
37095 : { "Feature_SetFieldIntegerList", _wrap_Feature_SetFieldIntegerList, METH_VARARGS, "\n"
37096 : "Feature_SetFieldIntegerList(Feature self, int id, int nList)\n"
37097 : "void\n"
37098 : "\n"
37099 : "Set field to list of integer values.\n"
37100 : "\n"
37101 : "This function currently on has an effect of :py:const:`OFTIntegerList`,\n"
37102 : ":py:const:`OFTInteger64List`, :py:const:`OFTRealList` fields.\n"
37103 : "\n"
37104 : "See :cpp:func:`OGRFeature::SetField`.\n"
37105 : "\n"
37106 : "This method has only an effect on the in-memory feature object. If\n"
37107 : "this object comes from a layer and the modifications must be\n"
37108 : "serialized back to the datasource, :py:meth:`Layer.SetFeature` must be used\n"
37109 : "afterwards. Or if this is a new feature, :py:meth:`Layer.CreateFeature` must be\n"
37110 : "used afterwards.\n"
37111 : "\n"
37112 : "Parameters\n"
37113 : "-----------\n"
37114 : "id : int\n"
37115 : " the field to set, from 0 to :py:meth:`GetFieldCount`-1.\n"
37116 : "nList : list\n"
37117 : " the values to assign.\n"
37118 : "\n"
37119 : ""},
37120 : { "Feature_SetFieldInteger64List", _wrap_Feature_SetFieldInteger64List, METH_VARARGS, "\n"
37121 : "Feature_SetFieldInteger64List(Feature self, int id, int nList)\n"
37122 : "void\n"
37123 : "\n"
37124 : "Set field to list of 64 bit integer values.\n"
37125 : "\n"
37126 : "This function currently on has an effect of :py:const:`OFTIntegerList`,\n"
37127 : ":py:const:`OFTInteger64List`, :py:const:`OFTRealList` fields.\n"
37128 : "\n"
37129 : "See :cpp:func:`OGRFeature::SetField`.\n"
37130 : "\n"
37131 : "This method has only an effect on the in-memory feature object. If\n"
37132 : "this object comes from a layer and the modifications must be\n"
37133 : "serialized back to the datasource, :py:meth:`Layer.SetFeature` must be used\n"
37134 : "afterwards. Or if this is a new feature, :py:meth:`Layer.CreateFeature` must be\n"
37135 : "used afterwards.\n"
37136 : "\n"
37137 : "Parameters\n"
37138 : "-----------\n"
37139 : "id : int\n"
37140 : " the field to set, from 0 to :py:meth:`GetFieldCount`-1.\n"
37141 : "nList : list\n"
37142 : " the values to assign.\n"
37143 : "\n"
37144 : ""},
37145 : { "Feature_SetFieldDoubleList", _wrap_Feature_SetFieldDoubleList, METH_VARARGS, "\n"
37146 : "Feature_SetFieldDoubleList(Feature self, int id, int nList)\n"
37147 : "\n"
37148 : "\n"
37149 : "Set field to list of double values.\n"
37150 : "\n"
37151 : "This function currently on has an effect of :py:const:`OFTIntegerList`,\n"
37152 : ":py:const:`OFTInteger64List`, :py:const:`OFTRealList` fields.\n"
37153 : "\n"
37154 : "See :cpp:func:`OGRFeature::SetField`.\n"
37155 : "\n"
37156 : "This method has only an effect on the in-memory feature object. If\n"
37157 : "this object comes from a layer and the modifications must be\n"
37158 : "serialized back to the datasource, :py:meth:`Layer.SetFeature` must be used\n"
37159 : "afterwards. Or if this is a new feature, :py:meth:`Layer.CreateFeature` must be\n"
37160 : "used afterwards.\n"
37161 : "\n"
37162 : "Parameters\n"
37163 : "-----------\n"
37164 : "id : int\n"
37165 : " the field to set, from 0 to :py:meth:`GetFieldCount`-1.\n"
37166 : "nList : list\n"
37167 : " the values to assign.\n"
37168 : "\n"
37169 : ""},
37170 : { "Feature_SetFieldStringList", _wrap_Feature_SetFieldStringList, METH_VARARGS, "\n"
37171 : "Feature_SetFieldStringList(Feature self, int id, char ** pList)\n"
37172 : "\n"
37173 : "\n"
37174 : "Set field to list of strings value.\n"
37175 : "\n"
37176 : "This function currently only has an effect of :py:const:`OFTStringList` fields.\n"
37177 : "\n"
37178 : "See :cpp:func:`OGRFeature::SetField`.\n"
37179 : "\n"
37180 : "This method has only an effect on the in-memory feature object. If\n"
37181 : "this object comes from a layer and the modifications must be\n"
37182 : "serialized back to the datasource, :py:meth:`Layer.SetFeature` must be used\n"
37183 : "afterwards. Or if this is a new feature, :py:meth:`Layer.CreateFeature` must be\n"
37184 : "used afterwards.\n"
37185 : "\n"
37186 : "Parameters\n"
37187 : "-----------\n"
37188 : "fld_index : int / str\n"
37189 : " Field name or 0-based numeric index. For repeated\n"
37190 : " access, use of the numeric index avoids a lookup\n"
37191 : " step.\n"
37192 : "value:\n"
37193 : " the value to assign.\n"
37194 : "\n"
37195 : ""},
37196 : { "Feature__SetFieldBinary", _wrap_Feature__SetFieldBinary, METH_VARARGS, "Feature__SetFieldBinary(Feature self, int id, int nLen)"},
37197 : { "Feature_SetFieldBinaryFromHexString", _wrap_Feature_SetFieldBinaryFromHexString, METH_VARARGS, "\n"
37198 : "Feature_SetFieldBinaryFromHexString(Feature self, int id, char const * pszValue)\n"
37199 : "Feature_SetFieldBinaryFromHexString(Feature self, char const * field_name, char const * pszValue)\n"
37200 : ""},
37201 : { "Feature_SetFrom", (PyCFunction)(void(*)(void))_wrap_Feature_SetFrom, METH_VARARGS|METH_KEYWORDS, "\n"
37202 : "Feature_SetFrom(Feature self, Feature other, int forgiving=1) -> OGRErr\n"
37203 : "\n"
37204 : "Set one feature from another.\n"
37205 : "\n"
37206 : "Overwrite the contents of this feature from the geometry and\n"
37207 : "attributes of another. The other feature does not need to have the\n"
37208 : "same :py:class:`FeatureDefn`. Field values are copied by corresponding field\n"
37209 : "names. Field types do not have to exactly match. OGR_F_SetField\\*()\n"
37210 : "function conversion rules will be applied as needed.\n"
37211 : "\n"
37212 : "See :cpp:func:`OGRFeature::SetFrom`.\n"
37213 : "\n"
37214 : "Parameters\n"
37215 : "-----------\n"
37216 : "other : Feature\n"
37217 : " feature from which geometry and field values will be copied.\n"
37218 : "forgiving : bool, default = True\n"
37219 : " ``True`` if the operation should continue despite lacking\n"
37220 : " output fields matching some of the source fields.\n"
37221 : "\n"
37222 : "Returns\n"
37223 : "--------\n"
37224 : "int:\n"
37225 : " :py:const:`OGRERR_NONE` if the operation succeeds, even if some values are not\n"
37226 : " transferred, otherwise an error code.\n"
37227 : "\n"
37228 : ""},
37229 : { "Feature_SetFromWithMap", _wrap_Feature_SetFromWithMap, METH_VARARGS, "\n"
37230 : "Feature_SetFromWithMap(Feature self, Feature other, int forgiving, int nList) -> OGRErr\n"
37231 : "\n"
37232 : "\n"
37233 : "Set one feature from another.\n"
37234 : "\n"
37235 : "Overwrite the contents of this feature from the geometry and\n"
37236 : "attributes of another. The other feature does not need to have the\n"
37237 : "same :py:class:`FeatureDefn`. Field values are copied according to the provided\n"
37238 : "indices map. Field types do not have to exactly match.\n"
37239 : "OGR_F_SetField\\*() function conversion rules will be applied as needed.\n"
37240 : "This is more efficient than :py:meth:SetFrom` in that this doesn't\n"
37241 : "lookup the fields by their names. Particularly useful when the field\n"
37242 : "names don't match.\n"
37243 : "\n"
37244 : "See :cpp:func:`OGRFeature::SetFrom`.\n"
37245 : "\n"
37246 : "Parameters\n"
37247 : "-----------\n"
37248 : "other : Feature\n"
37249 : " handle to the feature from which geometry, and field\n"
37250 : " values will be copied.\n"
37251 : "forgiving : bool\n"
37252 : " ``True`` if the operation should continue despite lacking\n"
37253 : " output fields matching some of the source fields.\n"
37254 : "nList : list\n"
37255 : " Array of the indices of the destination feature's fields\n"
37256 : " stored at the corresponding index of the source feature's fields. A\n"
37257 : " value of -1 should be used to ignore the source's field. The array\n"
37258 : " should not be NULL and be as long as the number of fields in the\n"
37259 : " source feature.\n"
37260 : "\n"
37261 : "Returns\n"
37262 : "--------\n"
37263 : "OGRErr:\n"
37264 : " :py:const:`OGRERR_NONE` if the operation succeeds, even if some values are not\n"
37265 : " transferred, otherwise an error code.\n"
37266 : "\n"
37267 : ""},
37268 : { "Feature_GetStyleString", _wrap_Feature_GetStyleString, METH_O, "\n"
37269 : "Feature_GetStyleString(Feature self) -> char const *\n"
37270 : "\n"
37271 : "\n"
37272 : "Fetch style string for this feature.\n"
37273 : "\n"
37274 : "Set the OGR Feature Style Specification for details on the format of\n"
37275 : "this string, and :source_file:`ogr/ogr_featurestyle.h` for services available to parse\n"
37276 : "it.\n"
37277 : "\n"
37278 : "See :cpp:func:`OGRFeature::GetStyleString`.\n"
37279 : "\n"
37280 : "Returns\n"
37281 : "--------\n"
37282 : "str or None\n"
37283 : "\n"
37284 : ""},
37285 : { "Feature_SetStyleString", _wrap_Feature_SetStyleString, METH_VARARGS, "\n"
37286 : "Feature_SetStyleString(Feature self, char const * the_string)\n"
37287 : "\n"
37288 : "\n"
37289 : "Set feature style string.\n"
37290 : "\n"
37291 : "See :cpp:func:`OGRFeature::SetStyleString`.\n"
37292 : "\n"
37293 : "Parameters\n"
37294 : "-----------\n"
37295 : "the_string : str\n"
37296 : " the style string to apply to this feature\n"
37297 : "\n"
37298 : ""},
37299 : { "Feature_GetFieldType", _wrap_Feature_GetFieldType, METH_VARARGS, "\n"
37300 : "Feature_GetFieldType(Feature self, int id) -> OGRFieldType\n"
37301 : "Feature_GetFieldType(Feature self, char const * field_name) -> OGRFieldType\n"
37302 : "\n"
37303 : "\n"
37304 : "Return the type of the given field.\n"
37305 : "\n"
37306 : "Parameters\n"
37307 : "-----------\n"
37308 : "fld_index : int / str\n"
37309 : " Field name or 0-based numeric index. For repeated\n"
37310 : " access, use of the numeric index avoids a lookup\n"
37311 : " step.\n"
37312 : "\n"
37313 : "Returns\n"
37314 : "--------\n"
37315 : "int\n"
37316 : " field type code (e.g., :py:const:`OFTInteger`)\n"
37317 : "\n"
37318 : ""},
37319 : { "Feature_Validate", _wrap_Feature_Validate, METH_VARARGS, "\n"
37320 : "Feature_Validate(Feature self, int flags=OGR_F_VAL_ALL, int bEmitError=TRUE) -> int\n"
37321 : "\n"
37322 : "\n"
37323 : "Validate that a feature meets constraints of its schema.\n"
37324 : "\n"
37325 : "The scope of test is specified with the ``flags`` parameter.\n"
37326 : "\n"
37327 : "Regarding :py:const:`OGR_F_VAL_WIDTH`, the test is done assuming the string\n"
37328 : "width must be interpreted as the number of UTF-8 characters. Some drivers might\n"
37329 : "interpret the width as the number of bytes instead. So this test is rather\n"
37330 : "conservative (if it fails, then it will fail for all interpretations).\n"
37331 : "\n"
37332 : "See :cpp:func:`OGRFeature::Validate`.\n"
37333 : "\n"
37334 : "Parameters\n"
37335 : "-----------\n"
37336 : "flags : int, default = :py:const:`F_VAL_ALL`\n"
37337 : " One ore more of :py:const:`OGR_F_VAL_NULL`,\n"
37338 : " :py:const:`OGR_F_VAL_GEOM_TYPE`, py:const:`OGR_F_VAL_WIDTH` and\n"
37339 : " :py:const:`OGR_F_VAL_ALLOW_NULL_WHEN_DEFAULT` combined with\n"
37340 : " the with ``|`` operator\n"
37341 : "bEmitError : bool, default = True\n"
37342 : " TRUE if a CPLError() must be emitted when a check fails\n"
37343 : "\n"
37344 : "Returns\n"
37345 : "-------\n"
37346 : "int:\n"
37347 : " TRUE if all enabled validation tests pass.\n"
37348 : "\n"
37349 : ""},
37350 : { "Feature_FillUnsetWithDefault", _wrap_Feature_FillUnsetWithDefault, METH_VARARGS, "\n"
37351 : "Feature_FillUnsetWithDefault(Feature self, int bNotNullableOnly=FALSE, char ** options=None)\n"
37352 : "\n"
37353 : "\n"
37354 : "Fill unset fields with default values that might be defined.\n"
37355 : "\n"
37356 : "See :cpp:func:`OGRFeature::FillUnsetWithDefault`.\n"
37357 : "\n"
37358 : "Parameters\n"
37359 : "-----------\n"
37360 : "bNotNullableOnly : bool\n"
37361 : " if we should fill only unset fields with a not-null\n"
37362 : " constraint.\n"
37363 : "options : dict\n"
37364 : " unused currently.\n"
37365 : "\n"
37366 : ""},
37367 : { "Feature_GetNativeData", _wrap_Feature_GetNativeData, METH_O, "\n"
37368 : "Feature_GetNativeData(Feature self) -> char const *\n"
37369 : "\n"
37370 : "\n"
37371 : "Returns the native data for the feature.\n"
37372 : "\n"
37373 : "The native data is the representation in a \"natural\" form that comes\n"
37374 : "from the driver that created this feature, or that is aimed at an\n"
37375 : "output driver. The native data may be in different format, which is\n"
37376 : "indicated by :py:func:`GetNativeMediaType`.\n"
37377 : "\n"
37378 : "Note that most drivers do not support storing the native data in the\n"
37379 : "feature object, and if they do, generally the ``NATIVE_DATA`` open option\n"
37380 : "must be passed at dataset opening.\n"
37381 : "\n"
37382 : "The \"native data\" does not imply it is something more performant or\n"
37383 : "powerful than what can be obtained with the rest of the API, but it\n"
37384 : "may be useful in round-tripping scenarios where some characteristics\n"
37385 : "of the underlying format are not captured otherwise by the OGR\n"
37386 : "abstraction.\n"
37387 : "\n"
37388 : "See :cpp:func:`OGRFeature::GetNativeData` and :ref:`rfc-60`.\n"
37389 : "\n"
37390 : "Returns\n"
37391 : "-------\n"
37392 : "str:\n"
37393 : " a string with the native data, or ``None``.\n"
37394 : "\n"
37395 : ""},
37396 : { "Feature_GetNativeMediaType", _wrap_Feature_GetNativeMediaType, METH_O, "\n"
37397 : "Feature_GetNativeMediaType(Feature self) -> char const *\n"
37398 : "\n"
37399 : "\n"
37400 : "Returns the native media type for the feature.\n"
37401 : "\n"
37402 : "The native media type is the identifier for the format of the native\n"
37403 : "data. It follows the IANA RFC 2045\n"
37404 : "(see https://en.wikipedia.org/wiki/Media_type), e.g.\n"
37405 : "\"application/vnd.geo+json\" for JSon.\n"
37406 : "\n"
37407 : "See :cpp:func:`OGRFeature::GetNativeMediaType` and :ref:`rfc-60`.\n"
37408 : "\n"
37409 : "Returns\n"
37410 : "--------\n"
37411 : "str:\n"
37412 : " a string with the native media type, or ``None``.\n"
37413 : "\n"
37414 : ""},
37415 : { "Feature_SetNativeData", _wrap_Feature_SetNativeData, METH_VARARGS, "\n"
37416 : "Feature_SetNativeData(Feature self, char const * nativeData)\n"
37417 : "\n"
37418 : "\n"
37419 : "Sets the native data for the feature.\n"
37420 : "\n"
37421 : "The native data is the representation in a \"natural\" form that comes\n"
37422 : "from the driver that created this feature, or that is aimed at an\n"
37423 : "output driver. The native data may be in different format, which is\n"
37424 : "indicated by :py:meth:`GetNativeMediaType`.\n"
37425 : "\n"
37426 : "See :cpp:func:`OGRFeature::SetNativeData` and :ref:`rfc-60`.\n"
37427 : "\n"
37428 : "Parameters\n"
37429 : "-----------\n"
37430 : "nativeData : str\n"
37431 : " a string with the native data, or ``None``\n"
37432 : "\n"
37433 : ""},
37434 : { "Feature_SetNativeMediaType", _wrap_Feature_SetNativeMediaType, METH_VARARGS, "\n"
37435 : "Feature_SetNativeMediaType(Feature self, char const * nativeMediaType)\n"
37436 : "\n"
37437 : "\n"
37438 : "Sets the native media type for the feature.\n"
37439 : "\n"
37440 : "The native media type is the identifier for the format of the native\n"
37441 : "data. It follows the IANA RFC 2045\n"
37442 : "(see https://en.wikipedia.org/wiki/Media_type), e.g.\n"
37443 : "\"application/vnd.geo+json\" for JSon.\n"
37444 : "\n"
37445 : "See :cpp:func:`OGRFeature::SetNativeMediaType` and :ref:`rfc-60`.\n"
37446 : "\n"
37447 : "Parameters\n"
37448 : "-----------\n"
37449 : "nativeMediaType : str\n"
37450 : " a string with the native media type, or ``None``\n"
37451 : "\n"
37452 : ""},
37453 : { "Feature_SetFieldString", _wrap_Feature_SetFieldString, METH_VARARGS, "\n"
37454 : "Feature_SetFieldString(Feature self, int id, char const * value)\n"
37455 : "\n"
37456 : "\n"
37457 : "Set field to string value.\n"
37458 : "\n"
37459 : ":py:const:`OFTInteger` fields will be set based on an atoi() conversion of the\n"
37460 : "string. :py:const:`OFTInteger64` fields will be set based on an :cpp:func:`CPLAtoGIntBig`\n"
37461 : "conversion of the string. :py:const:`OFTReal` fields will be set based on an\n"
37462 : ":cpp:func:`CPLAtof` conversion of the string. Other field types may be\n"
37463 : "unaffected.\n"
37464 : "\n"
37465 : "See :cpp:func:`OGRFeature::SetField`.\n"
37466 : "\n"
37467 : "This method has only an effect on the in-memory feature object. If\n"
37468 : "this object comes from a layer and the modifications must be\n"
37469 : "serialized back to the datasource, :py:meth:`Layer.SetFeature` must be used\n"
37470 : "afterwards. Or if this is a new feature, :py:meth:`Layer.CreateFeature` must be\n"
37471 : "used afterwards.\n"
37472 : "\n"
37473 : "Parameters\n"
37474 : "-----------\n"
37475 : "fld_index : int / str\n"
37476 : " Field name or 0-based numeric index. For repeated\n"
37477 : " access, use of the numeric index avoids a lookup\n"
37478 : " step.\n"
37479 : "value:\n"
37480 : " the value to assign.\n"
37481 : "\n"
37482 : ""},
37483 : { "Feature_swigregister", Feature_swigregister, METH_O, NULL},
37484 : { "Feature_swiginit", Feature_swiginit, METH_VARARGS, NULL},
37485 : { "delete_FeatureDefn", _wrap_delete_FeatureDefn, METH_O, "delete_FeatureDefn(FeatureDefn self)"},
37486 : { "new_FeatureDefn", (PyCFunction)(void(*)(void))_wrap_new_FeatureDefn, METH_VARARGS|METH_KEYWORDS, "\n"
37487 : "new_FeatureDefn(char const * name_null_ok=None) -> FeatureDefn\n"
37488 : "\n"
37489 : "\n"
37490 : "Create a new feature definition object to hold the field definitions.\n"
37491 : "\n"
37492 : "Parameters\n"
37493 : "----------\n"
37494 : "name_null_ok : str, optional\n"
37495 : " Name for the :py:class:`FeatureDefn`.\n"
37496 : "\n"
37497 : ""},
37498 : { "FeatureDefn_GetName", _wrap_FeatureDefn_GetName, METH_O, "\n"
37499 : "FeatureDefn_GetName(FeatureDefn self) -> char const *\n"
37500 : "\n"
37501 : "\n"
37502 : "Get name of the :py:class:`FeatureDefn`.\n"
37503 : "\n"
37504 : "See :cpp:func:`OGRFeatureDefn::GetName`.\n"
37505 : "\n"
37506 : "Returns\n"
37507 : "--------\n"
37508 : "str:\n"
37509 : " the name\n"
37510 : "\n"
37511 : ""},
37512 : { "FeatureDefn_GetFieldCount", _wrap_FeatureDefn_GetFieldCount, METH_O, "\n"
37513 : "FeatureDefn_GetFieldCount(FeatureDefn self) -> int\n"
37514 : "\n"
37515 : "\n"
37516 : "Fetch number of fields on the passed feature definition.\n"
37517 : "\n"
37518 : "See :cpp:func:`OGRFeatureDefn::GetFieldCount`.\n"
37519 : "\n"
37520 : "Returns\n"
37521 : "--------\n"
37522 : "int:\n"
37523 : " count of fields.\n"
37524 : "\n"
37525 : ""},
37526 : { "FeatureDefn_GetFieldDefn", _wrap_FeatureDefn_GetFieldDefn, METH_VARARGS, "\n"
37527 : "FeatureDefn_GetFieldDefn(FeatureDefn self, int i) -> FieldDefn\n"
37528 : "\n"
37529 : "\n"
37530 : "Fetch field definition of the passed feature definition.\n"
37531 : "\n"
37532 : "See :cpp:func:`OGRFeatureDefn::GetFieldDefn`.\n"
37533 : "\n"
37534 : "Parameters\n"
37535 : "-----------\n"
37536 : "i : int / str\n"
37537 : " Field name or 0-based numeric index. For repeated\n"
37538 : " access, use of the numeric index avoids a lookup\n"
37539 : " step.\n"
37540 : "\n"
37541 : "Returns\n"
37542 : "--------\n"
37543 : "FieldDefn:\n"
37544 : " internal field definition object or ``None`` if the field does not\n"
37545 : " exist. This object should not be modified by the application.\n"
37546 : "\n"
37547 : ""},
37548 : { "FeatureDefn_GetFieldIndex", _wrap_FeatureDefn_GetFieldIndex, METH_VARARGS, "\n"
37549 : "FeatureDefn_GetFieldIndex(FeatureDefn self, char const * field_name) -> int\n"
37550 : "\n"
37551 : "\n"
37552 : "Find field by name.\n"
37553 : "\n"
37554 : "The field index of the first field matching the passed field name\n"
37555 : "(case insensitively) is returned.\n"
37556 : "\n"
37557 : "See :cpp:func:`OGRFeatureDefn::GetFieldIndex`.\n"
37558 : "\n"
37559 : "Parameters\n"
37560 : "-----------\n"
37561 : "field_name : str\n"
37562 : " the field name to search for.\n"
37563 : "\n"
37564 : "Returns\n"
37565 : "--------\n"
37566 : "int:\n"
37567 : " the field index, or -1 if no match found.\n"
37568 : "\n"
37569 : ""},
37570 : { "FeatureDefn_AddFieldDefn", _wrap_FeatureDefn_AddFieldDefn, METH_VARARGS, "\n"
37571 : "FeatureDefn_AddFieldDefn(FeatureDefn self, FieldDefn defn)\n"
37572 : "\n"
37573 : "\n"
37574 : "Add a new field definition.\n"
37575 : "\n"
37576 : "To add a new field definition to a layer definition, do not use this\n"
37577 : "function directly, but use :py:meth:`Layer.CreateField` instead.\n"
37578 : "\n"
37579 : "This function should only be called while there are no :py:class:`Feature`\n"
37580 : "objects in existence based on this :py:class:`FeatureDefn`. The\n"
37581 : ":py:class:`FieldDefn` passed in is copied.\n"
37582 : "\n"
37583 : "See :cpp:func:`OGRFeatureDefn::AddFieldDefn`.\n"
37584 : "\n"
37585 : "Parameters\n"
37586 : "-----------\n"
37587 : "defn : FieldDefn\n"
37588 : " the new field definition.\n"
37589 : "\n"
37590 : ""},
37591 : { "FeatureDefn_GetGeomFieldCount", _wrap_FeatureDefn_GetGeomFieldCount, METH_O, "\n"
37592 : "FeatureDefn_GetGeomFieldCount(FeatureDefn self) -> int\n"
37593 : "\n"
37594 : "\n"
37595 : "Fetch number of geometry fields on the passed feature definition.\n"
37596 : "\n"
37597 : "See :cpp:func:`OGRFeatureDefn::GetGeomFieldCount`.\n"
37598 : "\n"
37599 : "Returns\n"
37600 : "--------\n"
37601 : "int:\n"
37602 : " count of geometry fields.\n"
37603 : "\n"
37604 : ""},
37605 : { "FeatureDefn_GetGeomFieldDefn", _wrap_FeatureDefn_GetGeomFieldDefn, METH_VARARGS, "\n"
37606 : "FeatureDefn_GetGeomFieldDefn(FeatureDefn self, int i) -> GeomFieldDefn\n"
37607 : "\n"
37608 : "\n"
37609 : "Fetch geometry field definition of the passed feature definition.\n"
37610 : "\n"
37611 : "See :cpp:func:`OGRFeatureDefn::GetGeomFieldDefn`.\n"
37612 : "\n"
37613 : "Parameters\n"
37614 : "-----------\n"
37615 : "i : int\n"
37616 : " the geometry field to fetch, between 0 and GetGeomFieldCount() - 1.\n"
37617 : "\n"
37618 : "Returns\n"
37619 : "--------\n"
37620 : "GeomFieldDefn:\n"
37621 : " an internal field definition object or ``None`` if invalid\n"
37622 : " index. This object should not be modified by the application.\n"
37623 : "\n"
37624 : ""},
37625 : { "FeatureDefn_GetGeomFieldIndex", _wrap_FeatureDefn_GetGeomFieldIndex, METH_VARARGS, "\n"
37626 : "FeatureDefn_GetGeomFieldIndex(FeatureDefn self, char const * field_name) -> int\n"
37627 : "\n"
37628 : "\n"
37629 : "Find geometry field by name.\n"
37630 : "\n"
37631 : "The geometry field index of the first geometry field matching the\n"
37632 : "passed field name (case insensitively) is returned.\n"
37633 : "\n"
37634 : "See :cpp:func:`OGRFeatureDefn::GetGeomFieldIndex`.\n"
37635 : "\n"
37636 : "Parameters\n"
37637 : "-----------\n"
37638 : "field_name : str\n"
37639 : " the geometry field name to search for.\n"
37640 : "\n"
37641 : "Returns\n"
37642 : "--------\n"
37643 : "int:\n"
37644 : " the geometry field index, or -1 if no match found.\n"
37645 : "\n"
37646 : ""},
37647 : { "FeatureDefn_AddGeomFieldDefn", _wrap_FeatureDefn_AddGeomFieldDefn, METH_VARARGS, "\n"
37648 : "FeatureDefn_AddGeomFieldDefn(FeatureDefn self, GeomFieldDefn defn)\n"
37649 : "\n"
37650 : "\n"
37651 : "Add a new geometry field definition.\n"
37652 : "\n"
37653 : "To add a new field definition to a layer definition, do not use this\n"
37654 : "function directly, but use :py:meth:`Layer.CreateGeomField` instead.\n"
37655 : "\n"
37656 : "This function should only be called while there are no :py:class:`Feature`\n"
37657 : "objects in existence based on this :py:class:`FeatureDefn`. The\n"
37658 : ":py:class:`GeomFieldDefn` passed in is copied.\n"
37659 : "\n"
37660 : "See :cpp:Func:`OGRFeatureDefn::AddGeomFieldDefn`.\n"
37661 : "\n"
37662 : "Parameters\n"
37663 : "-----------\n"
37664 : "defn : GeomFieldDefn\n"
37665 : " new geometry field definition.\n"
37666 : "\n"
37667 : ""},
37668 : { "FeatureDefn_DeleteGeomFieldDefn", _wrap_FeatureDefn_DeleteGeomFieldDefn, METH_VARARGS, "\n"
37669 : "FeatureDefn_DeleteGeomFieldDefn(FeatureDefn self, int idx) -> OGRErr\n"
37670 : "\n"
37671 : "\n"
37672 : "Delete an existing geometry field definition.\n"
37673 : "\n"
37674 : "To delete an existing geometry field definition from a layer\n"
37675 : "definition, do not use this function directly, but use\n"
37676 : ":py:meth:`Layer.DeleteGeomField` instead ( not implemented yet).\n"
37677 : "\n"
37678 : "This function should only be called while there are no :py:class:`Feature`\n"
37679 : "objects in existence based on this :py:class:`FeatureDefn`.\n"
37680 : "\n"
37681 : "See :cpp:func:`OGRFeatureDefn::DeleteGeomFieldDefn`.\n"
37682 : "\n"
37683 : "Parameters\n"
37684 : "-----------\n"
37685 : "idx : int\n"
37686 : " the index of the geometry field definition.\n"
37687 : "\n"
37688 : "Returns\n"
37689 : "--------\n"
37690 : "int:\n"
37691 : " :py:const:`OGRERR_NONE` in case of success.\n"
37692 : "\n"
37693 : ""},
37694 : { "FeatureDefn_GetGeomType", _wrap_FeatureDefn_GetGeomType, METH_O, "\n"
37695 : "FeatureDefn_GetGeomType(FeatureDefn self) -> OGRwkbGeometryType\n"
37696 : "\n"
37697 : "\n"
37698 : "Fetch the geometry base type of the passed feature definition.\n"
37699 : "\n"
37700 : "This is equivalent to ``GetGeomFieldDefn(0).GetType()``.\n"
37701 : "\n"
37702 : "See :cpp:func:`OGRFeatureDefn::GetGeomType`.\n"
37703 : "\n"
37704 : "Returns\n"
37705 : "--------\n"
37706 : "int :\n"
37707 : " the base type for all geometry related to this definition.\n"
37708 : "\n"
37709 : ""},
37710 : { "FeatureDefn_SetGeomType", _wrap_FeatureDefn_SetGeomType, METH_VARARGS, "\n"
37711 : "FeatureDefn_SetGeomType(FeatureDefn self, OGRwkbGeometryType geom_type)\n"
37712 : "\n"
37713 : "\n"
37714 : "Assign the base geometry type for the passed layer (the same as the\n"
37715 : "feature definition).\n"
37716 : "\n"
37717 : "This is equivalent to ``GetGeomFieldDefn(0).SetType()``.\n"
37718 : "\n"
37719 : "All geometry objects using this type must be of the defined type or a\n"
37720 : "derived type. The default upon creation is :py:const:`wkbUnknown` which allows for\n"
37721 : "any geometry type. The geometry type should generally not be changed\n"
37722 : "after any :py:class:`Feature` objects have been created against this definition.\n"
37723 : "\n"
37724 : "See :cpp:func:`OGRFeatureDefn::SetGeomType`.\n"
37725 : "\n"
37726 : "Parameters\n"
37727 : "-----------\n"
37728 : "geom_type : int\n"
37729 : " the new type to assign.\n"
37730 : "\n"
37731 : ""},
37732 : { "FeatureDefn_GetReferenceCount", _wrap_FeatureDefn_GetReferenceCount, METH_O, "\n"
37733 : "FeatureDefn_GetReferenceCount(FeatureDefn self) -> int\n"
37734 : "\n"
37735 : "\n"
37736 : "Fetch current reference count.\n"
37737 : "\n"
37738 : "See :cpp:func:`OGRFeatureDefn::GetReferenceCount`.\n"
37739 : "\n"
37740 : "Returns\n"
37741 : "--------\n"
37742 : "int:\n"
37743 : " the current reference count.\n"
37744 : "\n"
37745 : ""},
37746 : { "FeatureDefn_IsGeometryIgnored", _wrap_FeatureDefn_IsGeometryIgnored, METH_O, "\n"
37747 : "FeatureDefn_IsGeometryIgnored(FeatureDefn self) -> int\n"
37748 : "\n"
37749 : "\n"
37750 : "Determine whether the geometry can be omitted when fetching features.\n"
37751 : "\n"
37752 : "Equivalent to ``GetGeomFieldDefn(0).IsIgnored()``.\n"
37753 : "\n"
37754 : "See :cpp:func:`OGRFeatureDefn::IsGeometryIgnored`.\n"
37755 : "\n"
37756 : "Returns\n"
37757 : "--------\n"
37758 : "int:\n"
37759 : " ignore state\n"
37760 : "\n"
37761 : ""},
37762 : { "FeatureDefn_SetGeometryIgnored", _wrap_FeatureDefn_SetGeometryIgnored, METH_VARARGS, "\n"
37763 : "FeatureDefn_SetGeometryIgnored(FeatureDefn self, int bIgnored)\n"
37764 : "\n"
37765 : "\n"
37766 : "Set whether the geometry can be omitted when fetching features.\n"
37767 : "\n"
37768 : "This is equivalent to ``GetGeomFieldDefn(0).SetIgnored()``.\n"
37769 : "\n"
37770 : "See :cpp:func:`OGRFeatureDefn::SetGeometryIgnored`.\n"
37771 : "\n"
37772 : "Parameters\n"
37773 : "-----------\n"
37774 : "bignored : bool\n"
37775 : " ignore state\n"
37776 : "\n"
37777 : ""},
37778 : { "FeatureDefn_IsStyleIgnored", _wrap_FeatureDefn_IsStyleIgnored, METH_O, "\n"
37779 : "FeatureDefn_IsStyleIgnored(FeatureDefn self) -> int\n"
37780 : "\n"
37781 : "\n"
37782 : "Determine whether the style can be omitted when fetching features.\n"
37783 : "\n"
37784 : "See :cpp:func:`OGRFeatureDefn::IsStyleIgnored`.\n"
37785 : "\n"
37786 : "Returns\n"
37787 : "--------\n"
37788 : "int:\n"
37789 : " ignore state\n"
37790 : "\n"
37791 : ""},
37792 : { "FeatureDefn_SetStyleIgnored", _wrap_FeatureDefn_SetStyleIgnored, METH_VARARGS, "\n"
37793 : "FeatureDefn_SetStyleIgnored(FeatureDefn self, int bIgnored)\n"
37794 : "\n"
37795 : "\n"
37796 : "Set whether the style can be omitted when fetching features.\n"
37797 : "\n"
37798 : "See :cpp:func:`OGRFeatureDefn::SetStyleIgnored`.\n"
37799 : "\n"
37800 : "Parameters\n"
37801 : "-----------\n"
37802 : "bignored : bool\n"
37803 : " ignore state\n"
37804 : "\n"
37805 : ""},
37806 : { "FeatureDefn_IsSame", _wrap_FeatureDefn_IsSame, METH_VARARGS, "\n"
37807 : "FeatureDefn_IsSame(FeatureDefn self, FeatureDefn other_defn) -> int\n"
37808 : "\n"
37809 : "\n"
37810 : "Test if the feature definition is identical to the other one.\n"
37811 : "\n"
37812 : "Parameters\n"
37813 : "-----------\n"
37814 : "other_defn : FeatureDefn\n"
37815 : " other feature definition to compare to.\n"
37816 : "\n"
37817 : "Returns\n"
37818 : "--------\n"
37819 : "int:\n"
37820 : " 1 if the feature definition is identical to the other one.\n"
37821 : "\n"
37822 : ""},
37823 : { "FeatureDefn_swigregister", FeatureDefn_swigregister, METH_O, NULL},
37824 : { "FeatureDefn_swiginit", FeatureDefn_swiginit, METH_VARARGS, NULL},
37825 : { "delete_FieldDefn", _wrap_delete_FieldDefn, METH_O, "delete_FieldDefn(FieldDefn self)"},
37826 : { "new_FieldDefn", (PyCFunction)(void(*)(void))_wrap_new_FieldDefn, METH_VARARGS|METH_KEYWORDS, "\n"
37827 : "new_FieldDefn(char const * name_null_ok=\"unnamed\", OGRFieldType field_type=OFTString) -> FieldDefn\n"
37828 : "\n"
37829 : "Python proxy of an :cpp:class:`OGRFieldDefn`.\n"
37830 : "\n"
37831 : ""},
37832 : { "FieldDefn_GetName", _wrap_FieldDefn_GetName, METH_O, "FieldDefn_GetName(FieldDefn self) -> char const *"},
37833 : { "FieldDefn_GetNameRef", _wrap_FieldDefn_GetNameRef, METH_O, "\n"
37834 : "FieldDefn_GetNameRef(FieldDefn self) -> char const *\n"
37835 : "\n"
37836 : "\n"
37837 : "Fetch name of this field.\n"
37838 : "\n"
37839 : "See :cpp:func:`OGRFieldDefn::GetNameRef`.\n"
37840 : "\n"
37841 : "Returns\n"
37842 : "--------\n"
37843 : "str:\n"
37844 : " the name of the field definition.\n"
37845 : "\n"
37846 : ""},
37847 : { "FieldDefn_SetName", _wrap_FieldDefn_SetName, METH_VARARGS, "\n"
37848 : "FieldDefn_SetName(FieldDefn self, char const * name)\n"
37849 : "\n"
37850 : "\n"
37851 : "Reset the name of this field.\n"
37852 : "\n"
37853 : "See :cpp:func:`OGRFieldDefn::SetName`.\n"
37854 : "\n"
37855 : "Parameters\n"
37856 : "-----------\n"
37857 : "name : str\n"
37858 : " the new name to apply\n"
37859 : "\n"
37860 : ""},
37861 : { "FieldDefn_GetAlternativeName", _wrap_FieldDefn_GetAlternativeName, METH_O, "FieldDefn_GetAlternativeName(FieldDefn self) -> char const *"},
37862 : { "FieldDefn_GetAlternativeNameRef", _wrap_FieldDefn_GetAlternativeNameRef, METH_O, "\n"
37863 : "FieldDefn_GetAlternativeNameRef(FieldDefn self) -> char const *\n"
37864 : "\n"
37865 : "\n"
37866 : "Fetch the alternative name (or \"alias\") for this field.\n"
37867 : "\n"
37868 : "The alternative name is an optional attribute for a field which can\n"
37869 : "provide a more user-friendly, descriptive name of a field which is not\n"
37870 : "subject to the usual naming constraints defined by the data provider.\n"
37871 : "\n"
37872 : "This is a metadata style attribute only: the alternative name cannot\n"
37873 : "be used in place of the actual field name during SQL queries or other\n"
37874 : "field name dependent API calls.\n"
37875 : "\n"
37876 : "See :cpp:func:`OGRFieldDefn::GetAlternativeNameRef`.\n"
37877 : "\n"
37878 : ".. versionadded:: 3.2\n"
37879 : "\n"
37880 : "Returns\n"
37881 : "--------\n"
37882 : "str:\n"
37883 : " the alternative name of the field definition.\n"
37884 : "\n"
37885 : ""},
37886 : { "FieldDefn_SetAlternativeName", _wrap_FieldDefn_SetAlternativeName, METH_VARARGS, "\n"
37887 : "FieldDefn_SetAlternativeName(FieldDefn self, char const * alternativeName)\n"
37888 : "\n"
37889 : "\n"
37890 : "Reset the alternative name (or \"alias\") for this field.\n"
37891 : "\n"
37892 : "The alternative name is an optional attribute for a field which can\n"
37893 : "provide a more user-friendly, descriptive name of a field which is not\n"
37894 : "subject to the usual naming constraints defined by the data provider.\n"
37895 : "\n"
37896 : "This is a metadata style attribute only: the alternative name cannot\n"
37897 : "be used in place of the actual field name during SQL queries or other\n"
37898 : "field name dependent API calls.\n"
37899 : "\n"
37900 : "See :cpp:func:`OGRFieldDefn::SetAlternativeName`.\n"
37901 : "\n"
37902 : ".. versionadded:: 3.2\n"
37903 : "\n"
37904 : "Parameters\n"
37905 : "-----------\n"
37906 : "alternativeName : str\n"
37907 : " the new alternative name to apply.\n"
37908 : "\n"
37909 : ""},
37910 : { "FieldDefn_GetType", _wrap_FieldDefn_GetType, METH_O, "\n"
37911 : "FieldDefn_GetType(FieldDefn self) -> OGRFieldType\n"
37912 : "\n"
37913 : "\n"
37914 : "Fetch type of this field.\n"
37915 : "\n"
37916 : "See :cpp:func:`OGRFieldDefn::GetType`.\n"
37917 : "\n"
37918 : "Returns\n"
37919 : "--------\n"
37920 : "int\n"
37921 : " field type code, e.g. :py:const:`OFTInteger`\n"
37922 : "\n"
37923 : ""},
37924 : { "FieldDefn_SetType", _wrap_FieldDefn_SetType, METH_VARARGS, "\n"
37925 : "FieldDefn_SetType(FieldDefn self, OGRFieldType type)\n"
37926 : "\n"
37927 : "\n"
37928 : "Set the type of this field.\n"
37929 : "\n"
37930 : "This should never be done to a :py:class:`FieldDefn` that is already part of\n"
37931 : "an :py:class:`FeatureDefn`.\n"
37932 : "\n"
37933 : "See :cpp:func:`OGRFieldDefn::SetType`.\n"
37934 : "\n"
37935 : "Parameters\n"
37936 : "-----------\n"
37937 : "type : int\n"
37938 : " the new field type.\n"
37939 : "\n"
37940 : "Examples\n"
37941 : "--------\n"
37942 : ">>> f = ogr.FieldDefn()\n"
37943 : ">>> f.SetType(ogr.OFTReal)\n"
37944 : "\n"
37945 : ""},
37946 : { "FieldDefn_GetSubType", _wrap_FieldDefn_GetSubType, METH_O, "\n"
37947 : "FieldDefn_GetSubType(FieldDefn self) -> OGRFieldSubType\n"
37948 : "\n"
37949 : "\n"
37950 : "Fetch subtype of this field.\n"
37951 : "\n"
37952 : "See :cpp:func:`OGRFieldDefn::GetSubType`.\n"
37953 : "\n"
37954 : "Returns\n"
37955 : "--------\n"
37956 : "int\n"
37957 : " field subtype code, default = :py:const:`OFSTNone`\n"
37958 : "\n"
37959 : ""},
37960 : { "FieldDefn_SetSubType", _wrap_FieldDefn_SetSubType, METH_VARARGS, "\n"
37961 : "FieldDefn_SetSubType(FieldDefn self, OGRFieldSubType type)\n"
37962 : "\n"
37963 : "\n"
37964 : "Set the subtype of this field.\n"
37965 : "\n"
37966 : "This should never be done to a :py:class:`FieldDefn` that is already part of\n"
37967 : "an :py:class:FeatureDefn`.\n"
37968 : "\n"
37969 : "See :cpp:func:`OGRFieldDefn::SetSubType`.\n"
37970 : "\n"
37971 : "Parameters\n"
37972 : "-----------\n"
37973 : "type :\n"
37974 : " the new field subtype.\n"
37975 : "\n"
37976 : "Examples\n"
37977 : "--------\n"
37978 : ">>> f = ogr.FieldDefn()\n"
37979 : ">>> f.SetType(ogr.OFTReal)\n"
37980 : ">>> f.SetSubType(ogr.OFSTJSON)\n"
37981 : "Warning 1: Type and subtype of field definition are not compatible. Resetting to OFSTNone\n"
37982 : ">>> f.SetSubType(ogr.OFSTFloat32)\n"
37983 : "\n"
37984 : ""},
37985 : { "FieldDefn_GetJustify", _wrap_FieldDefn_GetJustify, METH_O, "\n"
37986 : "FieldDefn_GetJustify(FieldDefn self) -> OGRJustification\n"
37987 : "\n"
37988 : "\n"
37989 : "Get the justification for this field.\n"
37990 : "\n"
37991 : "See :cpp:func:`OGRFieldDefn::GetJustify`.\n"
37992 : "\n"
37993 : "Note: no driver is know to use the concept of field justification.\n"
37994 : "\n"
37995 : "Returns\n"
37996 : "--------\n"
37997 : "OGRJustification:\n"
37998 : " the justification.\n"
37999 : "\n"
38000 : ""},
38001 : { "FieldDefn_SetJustify", _wrap_FieldDefn_SetJustify, METH_VARARGS, "\n"
38002 : "FieldDefn_SetJustify(FieldDefn self, OGRJustification justify)\n"
38003 : "\n"
38004 : "\n"
38005 : "Set the justification for this field.\n"
38006 : "\n"
38007 : "Note: no driver is know to use the concept of field justification.\n"
38008 : "\n"
38009 : "See :cpp:func:`OGRFieldDefn::SetJustify`.\n"
38010 : "\n"
38011 : "Parameters\n"
38012 : "-----------\n"
38013 : "justify : int\n"
38014 : " the new justification\n"
38015 : "\n"
38016 : "Examples\n"
38017 : "--------\n"
38018 : ">>> f = ogr.FieldDefn('desc', ogr.OFTString)\n"
38019 : ">>> f.SetJustify(ogr.OJRight)\n"
38020 : "\n"
38021 : ""},
38022 : { "FieldDefn_GetWidth", _wrap_FieldDefn_GetWidth, METH_O, "\n"
38023 : "FieldDefn_GetWidth(FieldDefn self) -> int\n"
38024 : "\n"
38025 : "\n"
38026 : "Get the formatting width for this field.\n"
38027 : "\n"
38028 : "See :cpp:func:`OGRFieldDefn::GetWidth`.\n"
38029 : "\n"
38030 : "Returns\n"
38031 : "--------\n"
38032 : "int:\n"
38033 : " the width, zero means no specified width.\n"
38034 : "\n"
38035 : ""},
38036 : { "FieldDefn_SetWidth", _wrap_FieldDefn_SetWidth, METH_VARARGS, "\n"
38037 : "FieldDefn_SetWidth(FieldDefn self, int width)\n"
38038 : "\n"
38039 : "\n"
38040 : "Set the formatting width for this field in characters.\n"
38041 : "\n"
38042 : "See :cpp:func:`OGRFieldDefn::SetWidth`.\n"
38043 : "\n"
38044 : "Parameters\n"
38045 : "-----------\n"
38046 : "width : int\n"
38047 : " the new width\n"
38048 : "\n"
38049 : ""},
38050 : { "FieldDefn_GetPrecision", _wrap_FieldDefn_GetPrecision, METH_O, "\n"
38051 : "FieldDefn_GetPrecision(FieldDefn self) -> int\n"
38052 : "\n"
38053 : "\n"
38054 : "Get the formatting precision for this field.\n"
38055 : "\n"
38056 : "This should normally be zero for fields of types other than :py:const:`OFTReal`.\n"
38057 : "\n"
38058 : "See :cpp:func:`OGRFieldDefn::GetPrecision`.\n"
38059 : "\n"
38060 : "Returns\n"
38061 : "--------\n"
38062 : "int:\n"
38063 : " the precision.\n"
38064 : "\n"
38065 : ""},
38066 : { "FieldDefn_SetPrecision", _wrap_FieldDefn_SetPrecision, METH_VARARGS, "\n"
38067 : "FieldDefn_SetPrecision(FieldDefn self, int precision)\n"
38068 : "\n"
38069 : "\n"
38070 : "Set the formatting precision for this field in characters.\n"
38071 : "\n"
38072 : "This should normally be zero for fields of types other than :py:const:`OFTReal`.\n"
38073 : "\n"
38074 : "See :cpp:func:`OGRFieldDefn::SetPrecision`.\n"
38075 : "\n"
38076 : "Parameters\n"
38077 : "-----------\n"
38078 : "precision : int\n"
38079 : " the new precision.\n"
38080 : "\n"
38081 : ""},
38082 : { "FieldDefn_GetTZFlag", _wrap_FieldDefn_GetTZFlag, METH_O, "FieldDefn_GetTZFlag(FieldDefn self) -> int"},
38083 : { "FieldDefn_SetTZFlag", _wrap_FieldDefn_SetTZFlag, METH_VARARGS, "FieldDefn_SetTZFlag(FieldDefn self, int tzflag)"},
38084 : { "FieldDefn_GetTypeName", _wrap_FieldDefn_GetTypeName, METH_O, "FieldDefn_GetTypeName(FieldDefn self) -> char const *"},
38085 : { "FieldDefn_GetFieldTypeName", _wrap_FieldDefn_GetFieldTypeName, METH_VARARGS, "FieldDefn_GetFieldTypeName(FieldDefn self, OGRFieldType type) -> char const *"},
38086 : { "FieldDefn_IsIgnored", _wrap_FieldDefn_IsIgnored, METH_O, "\n"
38087 : "FieldDefn_IsIgnored(FieldDefn self) -> int\n"
38088 : "\n"
38089 : "\n"
38090 : "Return whether this field should be omitted when fetching features.\n"
38091 : "\n"
38092 : "See :cpp:func:`OGRFieldDefn::IsIgnored`.\n"
38093 : "\n"
38094 : "Returns\n"
38095 : "--------\n"
38096 : "int:\n"
38097 : " ignore state\n"
38098 : "\n"
38099 : ""},
38100 : { "FieldDefn_SetIgnored", _wrap_FieldDefn_SetIgnored, METH_VARARGS, "\n"
38101 : "FieldDefn_SetIgnored(FieldDefn self, int bIgnored)\n"
38102 : "\n"
38103 : "\n"
38104 : "Set whether this field should be omitted when fetching features.\n"
38105 : "\n"
38106 : "See :cpp:func:`OGRFieldDefn::SetIgnored`.\n"
38107 : "\n"
38108 : "Parameters\n"
38109 : "-----------\n"
38110 : "bignored : bool\n"
38111 : " ignore state\n"
38112 : "\n"
38113 : ""},
38114 : { "FieldDefn_IsNullable", _wrap_FieldDefn_IsNullable, METH_O, "\n"
38115 : "FieldDefn_IsNullable(FieldDefn self) -> int\n"
38116 : "\n"
38117 : "\n"
38118 : "Return whether this field can receive null values.\n"
38119 : "\n"
38120 : "By default, fields are nullable.\n"
38121 : "\n"
38122 : "Even if this method returns FALSE (i.e not-nullable field), it doesn't\n"
38123 : "mean that :py:meth:`Feature.IsFieldSet` will necessary return TRUE, as\n"
38124 : "fields can be temporary unset and null/not-null validation is usually\n"
38125 : "done when :py:meth:`Layer.CreateFeature`/:py:meth:`Layer.SetFeature` is called.\n"
38126 : "\n"
38127 : "See :cpp:func:`OGRFieldDefn::IsNullable`.\n"
38128 : "\n"
38129 : "Returns\n"
38130 : "--------\n"
38131 : "int:\n"
38132 : " TRUE if the field is authorized to be null.\n"
38133 : "\n"
38134 : ""},
38135 : { "FieldDefn_SetNullable", _wrap_FieldDefn_SetNullable, METH_VARARGS, "\n"
38136 : "FieldDefn_SetNullable(FieldDefn self, int bNullable)\n"
38137 : "\n"
38138 : "\n"
38139 : "Set whether this field can receive null values.\n"
38140 : "\n"
38141 : "By default, fields are nullable, so this method is generally called\n"
38142 : "with ``False`` to set a not-null constraint.\n"
38143 : "\n"
38144 : "Drivers that support writing not-null constraint will advertise the\n"
38145 : "``GDAL_DCAP_NOTNULL_FIELDS`` driver metadata item.\n"
38146 : "\n"
38147 : "See :cpp:func:`OGRFieldDefn::SetNullable`.\n"
38148 : "\n"
38149 : "Parameters\n"
38150 : "-----------\n"
38151 : "bNullable : bool\n"
38152 : " ``False`` if the field must have a not-null constraint.\n"
38153 : "\n"
38154 : ""},
38155 : { "FieldDefn_IsUnique", _wrap_FieldDefn_IsUnique, METH_O, "\n"
38156 : "FieldDefn_IsUnique(FieldDefn self) -> int\n"
38157 : "\n"
38158 : "\n"
38159 : "Return whether this field has a unique constraint.\n"
38160 : "\n"
38161 : "By default, fields have no unique constraint.\n"
38162 : "\n"
38163 : "See :cpp:func:`OGRFieldDefn::IsUnique`.\n"
38164 : "\n"
38165 : ".. versionadded:: 3.2\n"
38166 : "\n"
38167 : "Returns\n"
38168 : "--------\n"
38169 : "int:\n"
38170 : " TRUE if the field has a unique constraint.\n"
38171 : "\n"
38172 : ""},
38173 : { "FieldDefn_SetUnique", _wrap_FieldDefn_SetUnique, METH_VARARGS, "\n"
38174 : "FieldDefn_SetUnique(FieldDefn self, int bUnique)\n"
38175 : "\n"
38176 : "\n"
38177 : "Set whether this field has a unique constraint.\n"
38178 : "\n"
38179 : "By default, fields have no unique constraint, so this method is\n"
38180 : "generally called with TRUE to set a unique constraint.\n"
38181 : "\n"
38182 : "Drivers that support writing unique constraint will advertise the\n"
38183 : "``GDAL_DCAP_UNIQUE_FIELDS`` driver metadata item.\n"
38184 : "\n"
38185 : "Note that once a :py:class:`FieldDefn` has been added to a layer definition with\n"
38186 : ":py:meth:`Layer.AddFieldDefn`, its setter methods should not be called on the\n"
38187 : "object returned with ``GetLayerDefn().GetFieldDefn()``. Instead,\n"
38188 : ":py:meth:`Layer::AlterFieldDefn` should be called on a new instance of\n"
38189 : ":py:class:`FieldDefn`, for drivers that support :py:meth:`Layer.AlterFieldDefn`.\n"
38190 : "\n"
38191 : "See :cpp:func:`OGRFieldDefn::SetUnique`.\n"
38192 : "\n"
38193 : ".. versionadded:: 3.2\n"
38194 : "\n"
38195 : "Parameters\n"
38196 : "-----------\n"
38197 : "bUnique : bool\n"
38198 : " ``True`` if the field must have a unique constraint\n"
38199 : "\n"
38200 : ""},
38201 : { "FieldDefn_IsGenerated", _wrap_FieldDefn_IsGenerated, METH_O, "FieldDefn_IsGenerated(FieldDefn self) -> int"},
38202 : { "FieldDefn_SetGenerated", _wrap_FieldDefn_SetGenerated, METH_VARARGS, "FieldDefn_SetGenerated(FieldDefn self, int bGenerated)"},
38203 : { "FieldDefn_GetDefault", _wrap_FieldDefn_GetDefault, METH_O, "\n"
38204 : "FieldDefn_GetDefault(FieldDefn self) -> char const *\n"
38205 : "\n"
38206 : "\n"
38207 : "Get default field value.\n"
38208 : "\n"
38209 : "See :cpp:func:`OGRFieldDefn::GetDefault`.\n"
38210 : "\n"
38211 : "Returns\n"
38212 : "--------\n"
38213 : "str:\n"
38214 : " default field value or ``None``.\n"
38215 : "\n"
38216 : ""},
38217 : { "FieldDefn_SetDefault", _wrap_FieldDefn_SetDefault, METH_VARARGS, "\n"
38218 : "FieldDefn_SetDefault(FieldDefn self, char const * pszValue)\n"
38219 : "\n"
38220 : "\n"
38221 : "Set default field value.\n"
38222 : "\n"
38223 : "The default field value is taken into account by drivers (generally\n"
38224 : "those with a SQL interface) that support it at field creation time.\n"
38225 : "OGR will generally not automatically set the default field value to\n"
38226 : "null fields by itself when calling OGRFeature::CreateFeature() /\n"
38227 : "OGRFeature::SetFeature(), but will let the low-level layers to do the\n"
38228 : "job. So retrieving the feature from the layer is recommended.\n"
38229 : "\n"
38230 : "The accepted values are NULL, a numeric value, a literal value\n"
38231 : "enclosed between single quote characters (and inner single quote\n"
38232 : "characters escaped by repetition of the single quote character),\n"
38233 : "CURRENT_TIMESTAMP, CURRENT_TIME, CURRENT_DATE or a driver specific\n"
38234 : "expression (that might be ignored by other drivers). For a datetime\n"
38235 : "literal value, format should be 'YYYY/MM/DD HH:MM:SS[.sss]'\n"
38236 : "(considered as UTC time).\n"
38237 : "\n"
38238 : "Drivers that support writing DEFAULT clauses will advertise the\n"
38239 : "GDAL_DCAP_DEFAULT_FIELDS driver metadata item.\n"
38240 : "\n"
38241 : "See :cpp:func:`OGRFieldDefn::SetDefault`.\n"
38242 : "\n"
38243 : "Parameters\n"
38244 : "-----------\n"
38245 : "pszValue : str\n"
38246 : " new default field value or NULL pointer.\n"
38247 : "\n"
38248 : ""},
38249 : { "FieldDefn_IsDefaultDriverSpecific", _wrap_FieldDefn_IsDefaultDriverSpecific, METH_O, "\n"
38250 : "FieldDefn_IsDefaultDriverSpecific(FieldDefn self) -> int\n"
38251 : "\n"
38252 : "\n"
38253 : "Returns whether the default value is driver specific.\n"
38254 : "\n"
38255 : "Driver specific default values are those that are not NULL, a numeric\n"
38256 : "value, a literal value enclosed between single quote characters,\n"
38257 : "CURRENT_TIMESTAMP, CURRENT_TIME, CURRENT_DATE or datetime literal\n"
38258 : "value.\n"
38259 : "\n"
38260 : "See :cpp:func:`OGRFieldDefn::IsDefaultDriverSpecific`.\n"
38261 : "\n"
38262 : "Returns\n"
38263 : "--------\n"
38264 : "int:\n"
38265 : " TRUE if the default value is driver specific.\n"
38266 : "\n"
38267 : ""},
38268 : { "FieldDefn_GetDomainName", _wrap_FieldDefn_GetDomainName, METH_O, "\n"
38269 : "FieldDefn_GetDomainName(FieldDefn self) -> char const *\n"
38270 : "\n"
38271 : "\n"
38272 : "Return the name of the field domain for this field.\n"
38273 : "\n"
38274 : "By default an empty string is returned.\n"
38275 : "\n"
38276 : "Field domains ( :py:class:`FieldDomain` class) are attached at the :py:class:`Dataset` level and should be retrieved with :py:meth:`Dataset.GetFieldDomain`.\n"
38277 : "\n"
38278 : "See :cpp:func:`OGRFieldDefn::GetDomainName`.\n"
38279 : "\n"
38280 : ".. versionadded:: 3.3\n"
38281 : "\n"
38282 : "Returns\n"
38283 : "--------\n"
38284 : "str:\n"
38285 : " the field domain name, or an empty string if there is none.\n"
38286 : "\n"
38287 : ""},
38288 : { "FieldDefn_SetDomainName", _wrap_FieldDefn_SetDomainName, METH_VARARGS, "\n"
38289 : "FieldDefn_SetDomainName(FieldDefn self, char const * name)\n"
38290 : "\n"
38291 : "\n"
38292 : "Set the name of the field domain for this field.\n"
38293 : "\n"
38294 : "Field domains ( :py:class:`FieldDomain`) are attached at the :py:class:`Dataset` level.\n"
38295 : "\n"
38296 : "See :cpp:func:`OGRFieldDefn::SetDomainName`.\n"
38297 : "\n"
38298 : ".. versionadded:: 3.3\n"
38299 : "\n"
38300 : "Parameters\n"
38301 : "-----------\n"
38302 : "name : str\n"
38303 : " Field domain name.\n"
38304 : "\n"
38305 : ""},
38306 : { "FieldDefn_GetComment", _wrap_FieldDefn_GetComment, METH_O, "FieldDefn_GetComment(FieldDefn self) -> char const *"},
38307 : { "FieldDefn_SetComment", _wrap_FieldDefn_SetComment, METH_VARARGS, "FieldDefn_SetComment(FieldDefn self, char const * comment)"},
38308 : { "FieldDefn_swigregister", FieldDefn_swigregister, METH_O, NULL},
38309 : { "FieldDefn_swiginit", FieldDefn_swiginit, METH_VARARGS, NULL},
38310 : { "delete_GeomFieldDefn", _wrap_delete_GeomFieldDefn, METH_O, "delete_GeomFieldDefn(GeomFieldDefn self)"},
38311 : { "new_GeomFieldDefn", (PyCFunction)(void(*)(void))_wrap_new_GeomFieldDefn, METH_VARARGS|METH_KEYWORDS, "new_GeomFieldDefn(char const * name_null_ok=\"\", OGRwkbGeometryType field_type=wkbUnknown) -> GeomFieldDefn"},
38312 : { "GeomFieldDefn_GetName", _wrap_GeomFieldDefn_GetName, METH_O, "GeomFieldDefn_GetName(GeomFieldDefn self) -> char const *"},
38313 : { "GeomFieldDefn_GetNameRef", _wrap_GeomFieldDefn_GetNameRef, METH_O, "GeomFieldDefn_GetNameRef(GeomFieldDefn self) -> char const *"},
38314 : { "GeomFieldDefn_SetName", _wrap_GeomFieldDefn_SetName, METH_VARARGS, "GeomFieldDefn_SetName(GeomFieldDefn self, char const * name)"},
38315 : { "GeomFieldDefn_GetType", _wrap_GeomFieldDefn_GetType, METH_O, "GeomFieldDefn_GetType(GeomFieldDefn self) -> OGRwkbGeometryType"},
38316 : { "GeomFieldDefn_SetType", _wrap_GeomFieldDefn_SetType, METH_VARARGS, "GeomFieldDefn_SetType(GeomFieldDefn self, OGRwkbGeometryType type)"},
38317 : { "GeomFieldDefn_GetSpatialRef", _wrap_GeomFieldDefn_GetSpatialRef, METH_O, "GeomFieldDefn_GetSpatialRef(GeomFieldDefn self) -> SpatialReference"},
38318 : { "GeomFieldDefn_SetSpatialRef", _wrap_GeomFieldDefn_SetSpatialRef, METH_VARARGS, "GeomFieldDefn_SetSpatialRef(GeomFieldDefn self, SpatialReference srs)"},
38319 : { "GeomFieldDefn_IsIgnored", _wrap_GeomFieldDefn_IsIgnored, METH_O, "GeomFieldDefn_IsIgnored(GeomFieldDefn self) -> int"},
38320 : { "GeomFieldDefn_SetIgnored", _wrap_GeomFieldDefn_SetIgnored, METH_VARARGS, "GeomFieldDefn_SetIgnored(GeomFieldDefn self, int bIgnored)"},
38321 : { "GeomFieldDefn_IsNullable", _wrap_GeomFieldDefn_IsNullable, METH_O, "GeomFieldDefn_IsNullable(GeomFieldDefn self) -> int"},
38322 : { "GeomFieldDefn_SetNullable", _wrap_GeomFieldDefn_SetNullable, METH_VARARGS, "GeomFieldDefn_SetNullable(GeomFieldDefn self, int bNullable)"},
38323 : { "GeomFieldDefn_GetCoordinatePrecision", _wrap_GeomFieldDefn_GetCoordinatePrecision, METH_O, "GeomFieldDefn_GetCoordinatePrecision(GeomFieldDefn self) -> GeomCoordinatePrecision"},
38324 : { "GeomFieldDefn_SetCoordinatePrecision", _wrap_GeomFieldDefn_SetCoordinatePrecision, METH_VARARGS, "GeomFieldDefn_SetCoordinatePrecision(GeomFieldDefn self, GeomCoordinatePrecision coordPrec)"},
38325 : { "GeomFieldDefn_swigregister", GeomFieldDefn_swigregister, METH_O, NULL},
38326 : { "GeomFieldDefn_swiginit", GeomFieldDefn_swiginit, METH_VARARGS, NULL},
38327 : { "CreateGeometryFromWkb", (PyCFunction)(void(*)(void))_wrap_CreateGeometryFromWkb, METH_VARARGS|METH_KEYWORDS, "CreateGeometryFromWkb(size_t len, SpatialReference reference=None) -> Geometry"},
38328 : { "CreateGeometryFromWkt", (PyCFunction)(void(*)(void))_wrap_CreateGeometryFromWkt, METH_VARARGS|METH_KEYWORDS, "CreateGeometryFromWkt(char ** val, SpatialReference reference=None) -> Geometry"},
38329 : { "CreateGeometryFromGML", _wrap_CreateGeometryFromGML, METH_O, "CreateGeometryFromGML(char const * input_string) -> Geometry"},
38330 : { "CreateGeometryFromJson", _wrap_CreateGeometryFromJson, METH_O, "CreateGeometryFromJson(char const * input_string) -> Geometry"},
38331 : { "CreateGeometryFromEsriJson", _wrap_CreateGeometryFromEsriJson, METH_O, "CreateGeometryFromEsriJson(char const * input_string) -> Geometry"},
38332 : { "BuildPolygonFromEdges", (PyCFunction)(void(*)(void))_wrap_BuildPolygonFromEdges, METH_VARARGS|METH_KEYWORDS, "BuildPolygonFromEdges(Geometry hLineCollection, int bBestEffort=0, int bAutoClose=0, double dfTolerance=0) -> Geometry"},
38333 : { "ApproximateArcAngles", (PyCFunction)(void(*)(void))_wrap_ApproximateArcAngles, METH_VARARGS|METH_KEYWORDS, "ApproximateArcAngles(double dfCenterX, double dfCenterY, double dfZ, double dfPrimaryRadius, double dfSecondaryAxis, double dfRotation, double dfStartAngle, double dfEndAngle, double dfMaxAngleStepSizeDegrees) -> Geometry"},
38334 : { "ForceToPolygon", _wrap_ForceToPolygon, METH_O, "ForceToPolygon(Geometry geom_in) -> Geometry"},
38335 : { "ForceToLineString", _wrap_ForceToLineString, METH_O, "ForceToLineString(Geometry geom_in) -> Geometry"},
38336 : { "ForceToMultiPolygon", _wrap_ForceToMultiPolygon, METH_O, "ForceToMultiPolygon(Geometry geom_in) -> Geometry"},
38337 : { "ForceToMultiPoint", _wrap_ForceToMultiPoint, METH_O, "ForceToMultiPoint(Geometry geom_in) -> Geometry"},
38338 : { "ForceToMultiLineString", _wrap_ForceToMultiLineString, METH_O, "ForceToMultiLineString(Geometry geom_in) -> Geometry"},
38339 : { "ForceTo", _wrap_ForceTo, METH_VARARGS, "ForceTo(Geometry geom_in, OGRwkbGeometryType eTargetType, char ** options=None) -> Geometry"},
38340 : { "delete_Geometry", _wrap_delete_Geometry, METH_O, "delete_Geometry(Geometry self)"},
38341 : { "new_Geometry", (PyCFunction)(void(*)(void))_wrap_new_Geometry, METH_VARARGS|METH_KEYWORDS, "new_Geometry(OGRwkbGeometryType type=wkbUnknown, char * wkt=None, int wkb=0, char * gml=None) -> Geometry"},
38342 : { "Geometry_ExportToWkt", _wrap_Geometry_ExportToWkt, METH_O, "\n"
38343 : "Geometry_ExportToWkt(Geometry self) -> OGRErr\n"
38344 : "\n"
38345 : "Convert a geometry into well known text format.\n"
38346 : "\n"
38347 : "For more details: :cpp:func:`OGR_G_ExportToWkt`\n"
38348 : "\n"
38349 : "Returns\n"
38350 : "--------\n"
38351 : "str\n"
38352 : "\n"
38353 : ""},
38354 : { "Geometry_ExportToIsoWkt", _wrap_Geometry_ExportToIsoWkt, METH_O, "\n"
38355 : "Geometry_ExportToIsoWkt(Geometry self) -> OGRErr\n"
38356 : "\n"
38357 : "Convert a geometry into SFSQL 1.2 / ISO SQL/MM Part 3 well known text\n"
38358 : "format.\n"
38359 : "\n"
38360 : "For more details: :cpp:func:`OGR_G_ExportToIsoWkt`\n"
38361 : "\n"
38362 : ".. versionadded:: 2.0\n"
38363 : "\n"
38364 : "Returns\n"
38365 : "--------\n"
38366 : "str\n"
38367 : "\n"
38368 : ""},
38369 : { "Geometry_ExportToWkb", (PyCFunction)(void(*)(void))_wrap_Geometry_ExportToWkb, METH_VARARGS|METH_KEYWORDS, "\n"
38370 : "Geometry_ExportToWkb(Geometry self, OGRwkbByteOrder byte_order=wkbNDR) -> OGRErr\n"
38371 : "\n"
38372 : "Convert a geometry well known binary format.\n"
38373 : "\n"
38374 : "For more details: :cpp:func:`OGR_G_ExportToWkb`\n"
38375 : "\n"
38376 : "Parameters\n"
38377 : "-----------\n"
38378 : "byte_order: osgeo.ogr.wkbXDR | osgeo.ogr.wkbNDR, default=osgeo.ogr.wkbNDR\n"
38379 : " One of wkbXDR or wkbNDR indicating MSB or LSB byte order respectively.\n"
38380 : "\n"
38381 : "Returns\n"
38382 : "--------\n"
38383 : "bytes\n"
38384 : "\n"
38385 : ""},
38386 : { "Geometry_ExportToIsoWkb", (PyCFunction)(void(*)(void))_wrap_Geometry_ExportToIsoWkb, METH_VARARGS|METH_KEYWORDS, "\n"
38387 : "Geometry_ExportToIsoWkb(Geometry self, OGRwkbByteOrder byte_order=wkbNDR) -> OGRErr\n"
38388 : "\n"
38389 : "Convert a geometry into SFSQL 1.2 / ISO SQL/MM Part 3 well known\n"
38390 : "binary format.\n"
38391 : "\n"
38392 : "For more details: :cpp:func:`OGR_G_ExportToIsoWkb`\n"
38393 : "\n"
38394 : ".. versionadded:: 2.0\n"
38395 : "\n"
38396 : "Parameters\n"
38397 : "-----------\n"
38398 : "byte_order: osgeo.ogr.wkbXDR | osgeo.ogr.wkbNDR, default=osgeo.ogr.wkbNDR\n"
38399 : " One of wkbXDR or wkbNDR indicating MSB or LSB byte order respectively.\n"
38400 : "\n"
38401 : "Returns\n"
38402 : "--------\n"
38403 : "bytes\n"
38404 : "\n"
38405 : ""},
38406 : { "Geometry_ExportToGML", (PyCFunction)(void(*)(void))_wrap_Geometry_ExportToGML, METH_VARARGS|METH_KEYWORDS, "Geometry_ExportToGML(Geometry self, char ** options=None) -> retStringAndCPLFree *"},
38407 : { "Geometry_ExportToKML", _wrap_Geometry_ExportToKML, METH_VARARGS, "Geometry_ExportToKML(Geometry self, char const * altitude_mode=None) -> retStringAndCPLFree *"},
38408 : { "Geometry_ExportToJson", (PyCFunction)(void(*)(void))_wrap_Geometry_ExportToJson, METH_VARARGS|METH_KEYWORDS, "Geometry_ExportToJson(Geometry self, char ** options=None) -> retStringAndCPLFree *"},
38409 : { "Geometry_AddPoint", (PyCFunction)(void(*)(void))_wrap_Geometry_AddPoint, METH_VARARGS|METH_KEYWORDS, "\n"
38410 : "Geometry_AddPoint(Geometry self, double x, double y, double z=0)\n"
38411 : "\n"
38412 : "Add a point to a geometry (line string or point).\n"
38413 : "\n"
38414 : "The vertex count of the line string is increased by one, and assigned from\n"
38415 : "the passed location value.\n"
38416 : "\n"
38417 : "The geometry is promoted to include a Z component, if it does not already\n"
38418 : "have one, even if the Z parameter is not explicitly specified. To avoid that\n"
38419 : "use AddPoint_2D.\n"
38420 : "\n"
38421 : "This is the same as :cpp:func:`OGR_G_AddPoint`\n"
38422 : "\n"
38423 : "Parameters\n"
38424 : "-----------\n"
38425 : "X: float\n"
38426 : " x coordinate of point to add.\n"
38427 : "Y: float\n"
38428 : " y coordinate of point to add.\n"
38429 : "Z: float\n"
38430 : " z coordinate of point to add. Defaults to 0\n"
38431 : "\n"
38432 : "Examples\n"
38433 : "-------\n"
38434 : ">>> ogr.GeometryTypeToName(pt.GetGeometryType())\n"
38435 : "'Point'\n"
38436 : ">>> pt.AddPoint(3, 7)\n"
38437 : ">>> ogr.GeometryTypeToName(pt.GetGeometryType())\n"
38438 : "'3D Point'\n"
38439 : "\n"
38440 : ""},
38441 : { "Geometry_AddPointM", (PyCFunction)(void(*)(void))_wrap_Geometry_AddPointM, METH_VARARGS|METH_KEYWORDS, "Geometry_AddPointM(Geometry self, double x, double y, double m)"},
38442 : { "Geometry_AddPointZM", (PyCFunction)(void(*)(void))_wrap_Geometry_AddPointZM, METH_VARARGS|METH_KEYWORDS, "Geometry_AddPointZM(Geometry self, double x, double y, double z, double m)"},
38443 : { "Geometry_AddPoint_2D", _wrap_Geometry_AddPoint_2D, METH_VARARGS, "\n"
38444 : "Geometry_AddPoint_2D(Geometry self, double x, double y)\n"
38445 : "\n"
38446 : "Add a point to a geometry (line string or point).\n"
38447 : "\n"
38448 : "The vertex count of the line string is increased by one, and assigned from\n"
38449 : "the passed location value.\n"
38450 : "\n"
38451 : "If the geometry includes a Z or M component, the value for those components\n"
38452 : "for the added point will be 0.\n"
38453 : "\n"
38454 : "This is the same as :cpp:func:`OGR_G_AddPoint_2D`\n"
38455 : "\n"
38456 : "Parameters\n"
38457 : "-----------\n"
38458 : "X: float\n"
38459 : " x coordinate of point to add.\n"
38460 : "Y: float\n"
38461 : " y coordinate of point to add.\n"
38462 : "\n"
38463 : "Examples\n"
38464 : "--------\n"
38465 : ">>> pt = ogr.Geometry(ogr.wkbPoint)\n"
38466 : ">>> ogr.GeometryTypeToName(pt.GetGeometryType())\n"
38467 : "'Point'\n"
38468 : ">>> pt.AddPoint_2D(3, 7)\n"
38469 : ">>> ogr.GeometryTypeToName(pt.GetGeometryType())\n"
38470 : "'Point'\n"
38471 : "\n"
38472 : ""},
38473 : { "Geometry_AddGeometryDirectly", _wrap_Geometry_AddGeometryDirectly, METH_VARARGS, "Geometry_AddGeometryDirectly(Geometry self, Geometry other_disown) -> OGRErr"},
38474 : { "Geometry_AddGeometry", _wrap_Geometry_AddGeometry, METH_VARARGS, "Geometry_AddGeometry(Geometry self, Geometry other) -> OGRErr"},
38475 : { "Geometry_RemoveGeometry", _wrap_Geometry_RemoveGeometry, METH_VARARGS, "Geometry_RemoveGeometry(Geometry self, int iSubGeom) -> OGRErr"},
38476 : { "Geometry_Clone", _wrap_Geometry_Clone, METH_O, "\n"
38477 : "Geometry_Clone(Geometry self) -> Geometry\n"
38478 : "\n"
38479 : "Make a copy of this object.\n"
38480 : "\n"
38481 : "For more details: :cpp:func:`OGR_G_Clone`\n"
38482 : "\n"
38483 : "Returns\n"
38484 : "--------\n"
38485 : "Geometry:\n"
38486 : " The copy of the geometry with the same spatial reference system\n"
38487 : " as the original.\n"
38488 : "\n"
38489 : ""},
38490 : { "Geometry_GetGeometryType", _wrap_Geometry_GetGeometryType, METH_O, "\n"
38491 : "Geometry_GetGeometryType(Geometry self) -> OGRwkbGeometryType\n"
38492 : "\n"
38493 : "Fetch geometry type.\n"
38494 : "\n"
38495 : "For more details: :cpp:func:`OGR_G_GetGeometryType`\n"
38496 : "\n"
38497 : "Returns\n"
38498 : "--------\n"
38499 : "int:\n"
38500 : " The geometry type code. The types can be found with\n"
38501 : " 'osgeo.ogr.wkb' prefix. For example :py:const:`osgeo.ogr.wkbPolygon`.\n"
38502 : "\n"
38503 : ""},
38504 : { "Geometry_GetGeometryName", _wrap_Geometry_GetGeometryName, METH_O, "\n"
38505 : "Geometry_GetGeometryName(Geometry self) -> char const *\n"
38506 : "\n"
38507 : "Fetch WKT name for geometry type.\n"
38508 : "\n"
38509 : "For more details: :cpp:func:`OGR_G_GetGeometryName`\n"
38510 : "\n"
38511 : "geometry to get name from.\n"
38512 : "\n"
38513 : "Returns\n"
38514 : "--------\n"
38515 : "str\n"
38516 : "\n"
38517 : ""},
38518 : { "Geometry_Length", _wrap_Geometry_Length, METH_O, "\n"
38519 : "Geometry_Length(Geometry self) -> double\n"
38520 : "\n"
38521 : "Compute geometry length.\n"
38522 : "\n"
38523 : "The returned length is a 2D Cartesian (planar) area in units of the\n"
38524 : "spatial reference system in use, so potentially 'degrees' for a\n"
38525 : "geometry expressed in a geographic SRS.\n"
38526 : "\n"
38527 : "For more details: :cpp:func:`OGR_G_Length`\n"
38528 : "\n"
38529 : "Returns\n"
38530 : "--------\n"
38531 : "float:\n"
38532 : " the length of the geometry in units of the spatial reference\n"
38533 : " system in use, or 0.0 for unsupported geometry types.\n"
38534 : "\n"
38535 : "\n"
38536 : ""},
38537 : { "Geometry_Area", _wrap_Geometry_Area, METH_O, "\n"
38538 : "Geometry_Area(Geometry self) -> double\n"
38539 : "\n"
38540 : "Compute geometry area.\n"
38541 : "\n"
38542 : "The returned area is a 2D Cartesian (planar) area in square units of the\n"
38543 : "spatial reference system in use, so potentially 'square degrees' for a\n"
38544 : "geometry expressed in a geographic SRS.\n"
38545 : "\n"
38546 : "For more details: :cpp:func:`OGR_G_Area`\n"
38547 : "\n"
38548 : "Returns\n"
38549 : "--------\n"
38550 : "float:\n"
38551 : " the area of the geometry in square units of the spatial reference\n"
38552 : " system in use, or 0.0 for unsupported geometry types.\n"
38553 : "\n"
38554 : "\n"
38555 : ""},
38556 : { "Geometry_GeodesicLength", _wrap_Geometry_GeodesicLength, METH_O, "\n"
38557 : "Geometry_GeodesicLength(Geometry self) -> double\n"
38558 : "\n"
38559 : "Compute geometry length, considered as a curve on the underlying\n"
38560 : "ellipsoid of the SRS attached to the geometry.\n"
38561 : "\n"
38562 : "For more details: :cpp:func:`OGR_G_GeodesicLength`\n"
38563 : "\n"
38564 : "Returns\n"
38565 : "--------\n"
38566 : "float:\n"
38567 : " the area in meters, or a negative value for unsupported geometry types.\n"
38568 : "\n"
38569 : "\n"
38570 : ""},
38571 : { "Geometry_GeodesicArea", _wrap_Geometry_GeodesicArea, METH_O, "\n"
38572 : "Geometry_GeodesicArea(Geometry self) -> double\n"
38573 : "\n"
38574 : "Compute geometry area, considered as a surface on the underlying\n"
38575 : "ellipsoid of the SRS attached to the geometry.\n"
38576 : "\n"
38577 : "For more details: :cpp:func:`OGR_G_GeodesicArea`\n"
38578 : "\n"
38579 : "Returns\n"
38580 : "--------\n"
38581 : "float:\n"
38582 : " the area in square meters, or a negative value for unsupported geometry types.\n"
38583 : "\n"
38584 : "\n"
38585 : ""},
38586 : { "Geometry_IsClockwise", _wrap_Geometry_IsClockwise, METH_O, "Geometry_IsClockwise(Geometry self) -> bool"},
38587 : { "Geometry_GetArea", _wrap_Geometry_GetArea, METH_O, "Geometry_GetArea(Geometry self) -> double"},
38588 : { "Geometry_GetPointCount", _wrap_Geometry_GetPointCount, METH_O, "Geometry_GetPointCount(Geometry self) -> int"},
38589 : { "Geometry_GetPoints", (PyCFunction)(void(*)(void))_wrap_Geometry_GetPoints, METH_VARARGS|METH_KEYWORDS, "Geometry_GetPoints(Geometry self, int nCoordDimension=0)"},
38590 : { "Geometry_GetX", (PyCFunction)(void(*)(void))_wrap_Geometry_GetX, METH_VARARGS|METH_KEYWORDS, "Geometry_GetX(Geometry self, int point=0) -> double"},
38591 : { "Geometry_GetY", (PyCFunction)(void(*)(void))_wrap_Geometry_GetY, METH_VARARGS|METH_KEYWORDS, "Geometry_GetY(Geometry self, int point=0) -> double"},
38592 : { "Geometry_GetZ", (PyCFunction)(void(*)(void))_wrap_Geometry_GetZ, METH_VARARGS|METH_KEYWORDS, "Geometry_GetZ(Geometry self, int point=0) -> double"},
38593 : { "Geometry_GetM", (PyCFunction)(void(*)(void))_wrap_Geometry_GetM, METH_VARARGS|METH_KEYWORDS, "Geometry_GetM(Geometry self, int point=0) -> double"},
38594 : { "Geometry_GetPoint", _wrap_Geometry_GetPoint, METH_VARARGS, "Geometry_GetPoint(Geometry self, int iPoint=0)"},
38595 : { "Geometry_GetPointZM", _wrap_Geometry_GetPointZM, METH_VARARGS, "Geometry_GetPointZM(Geometry self, int iPoint=0)"},
38596 : { "Geometry_GetPoint_2D", _wrap_Geometry_GetPoint_2D, METH_VARARGS, "Geometry_GetPoint_2D(Geometry self, int iPoint=0)"},
38597 : { "Geometry_GetGeometryCount", _wrap_Geometry_GetGeometryCount, METH_O, "Geometry_GetGeometryCount(Geometry self) -> int"},
38598 : { "Geometry_SetPoint", (PyCFunction)(void(*)(void))_wrap_Geometry_SetPoint, METH_VARARGS|METH_KEYWORDS, "Geometry_SetPoint(Geometry self, int point, double x, double y, double z=0)"},
38599 : { "Geometry_SetPointM", (PyCFunction)(void(*)(void))_wrap_Geometry_SetPointM, METH_VARARGS|METH_KEYWORDS, "Geometry_SetPointM(Geometry self, int point, double x, double y, double m)"},
38600 : { "Geometry_SetPointZM", (PyCFunction)(void(*)(void))_wrap_Geometry_SetPointZM, METH_VARARGS|METH_KEYWORDS, "Geometry_SetPointZM(Geometry self, int point, double x, double y, double z, double m)"},
38601 : { "Geometry_SetPoint_2D", (PyCFunction)(void(*)(void))_wrap_Geometry_SetPoint_2D, METH_VARARGS|METH_KEYWORDS, "Geometry_SetPoint_2D(Geometry self, int point, double x, double y)"},
38602 : { "Geometry_SwapXY", _wrap_Geometry_SwapXY, METH_O, "\n"
38603 : "Geometry_SwapXY(Geometry self)\n"
38604 : "\n"
38605 : "Swap x and y coordinates.\n"
38606 : "\n"
38607 : "For more details: :cpp:func:`OGR_G_SwapXY`\n"
38608 : "\n"
38609 : ".. versionadded:: 2.3.0\n"
38610 : "\n"
38611 : "\n"
38612 : ""},
38613 : { "Geometry_GetGeometryRef", _wrap_Geometry_GetGeometryRef, METH_VARARGS, "Geometry_GetGeometryRef(Geometry self, int geom) -> Geometry"},
38614 : { "Geometry_Simplify", _wrap_Geometry_Simplify, METH_VARARGS, "\n"
38615 : "Geometry_Simplify(Geometry self, double tolerance) -> Geometry\n"
38616 : "\n"
38617 : "Compute a simplified geometry.\n"
38618 : "\n"
38619 : "For more details: :cpp:func:`OGR_G_Simplify`\n"
38620 : "\n"
38621 : "Parameters\n"
38622 : "-----------\n"
38623 : "tolerance: float\n"
38624 : " The distance tolerance for the simplification.\n"
38625 : "\n"
38626 : "Returns\n"
38627 : "--------\n"
38628 : "Geometry:\n"
38629 : " The simplified geometry or None if an error occurs.\n"
38630 : "\n"
38631 : ""},
38632 : { "Geometry_SimplifyPreserveTopology", _wrap_Geometry_SimplifyPreserveTopology, METH_VARARGS, "\n"
38633 : "Geometry_SimplifyPreserveTopology(Geometry self, double tolerance) -> Geometry\n"
38634 : "\n"
38635 : "Simplify the geometry while preserving topology.\n"
38636 : "\n"
38637 : "For more details: :cpp:func:`OGR_G_SimplifyPreserveTopology`\n"
38638 : "\n"
38639 : "Parameters\n"
38640 : "-----------\n"
38641 : "tolerance: float\n"
38642 : " The distance tolerance for the simplification.\n"
38643 : "\n"
38644 : "Returns\n"
38645 : "--------\n"
38646 : "Geometry:\n"
38647 : " The simplified geometry or None if an error occurs.\n"
38648 : "\n"
38649 : ""},
38650 : { "Geometry_DelaunayTriangulation", (PyCFunction)(void(*)(void))_wrap_Geometry_DelaunayTriangulation, METH_VARARGS|METH_KEYWORDS, "\n"
38651 : "Geometry_DelaunayTriangulation(Geometry self, double dfTolerance=0.0, int bOnlyEdges=FALSE) -> Geometry\n"
38652 : "\n"
38653 : "Return a Delaunay triangulation of the vertices of the geometry.\n"
38654 : "\n"
38655 : "For more details: :cpp:func:`OGR_G_DelaunayTriangulation`\n"
38656 : "\n"
38657 : ".. versionadded:: 2.1\n"
38658 : "\n"
38659 : "Parameters\n"
38660 : "-----------\n"
38661 : "dfTolerance: float\n"
38662 : " optional snapping tolerance to use for improved robustness\n"
38663 : "bOnlyEdges: bool\n"
38664 : " If True, will return a MULTILINESTRING, otherwise it will\n"
38665 : " return a GEOMETRYCOLLECTION containing triangular POLYGONs.\n"
38666 : "\n"
38667 : "Returns\n"
38668 : "--------\n"
38669 : "Geometry:\n"
38670 : " The geometry resulting from the Delaunay triangulation or None if an\n"
38671 : " error occurs.\n"
38672 : "\n"
38673 : ""},
38674 : { "Geometry_Polygonize", _wrap_Geometry_Polygonize, METH_O, "\n"
38675 : "Geometry_Polygonize(Geometry self) -> Geometry\n"
38676 : "\n"
38677 : "Polygonizes a set of sparse edges.\n"
38678 : "\n"
38679 : "For more details: :cpp:func:`OGR_G_Polygonize`\n"
38680 : "\n"
38681 : "Returns\n"
38682 : "--------\n"
38683 : "Geometry:\n"
38684 : " A new geometry or None on failure.\n"
38685 : "\n"
38686 : ""},
38687 : { "Geometry_BuildArea", _wrap_Geometry_BuildArea, METH_O, "\n"
38688 : "Geometry_BuildArea(Geometry self) -> Geometry\n"
38689 : "\n"
38690 : "Polygonize a linework assuming inner polygons are holes.\n"
38691 : "\n"
38692 : "For more details: :cpp:func:`OGR_G_BuildArea`\n"
38693 : "\n"
38694 : "Returns\n"
38695 : "--------\n"
38696 : "Geometry:\n"
38697 : " A new geometry or None on failure.\n"
38698 : "\n"
38699 : ""},
38700 : { "Geometry_Boundary", _wrap_Geometry_Boundary, METH_O, "\n"
38701 : "Geometry_Boundary(Geometry self) -> Geometry\n"
38702 : "\n"
38703 : "Compute boundary.\n"
38704 : "\n"
38705 : "For more details: :cpp:func:`OGR_G_Boundary`\n"
38706 : "\n"
38707 : "Returns\n"
38708 : "--------\n"
38709 : "Geometry:\n"
38710 : " A new geometry or None on failure.\n"
38711 : "\n"
38712 : ""},
38713 : { "Geometry_GetBoundary", _wrap_Geometry_GetBoundary, METH_O, "\n"
38714 : "Geometry_GetBoundary(Geometry self) -> Geometry\n"
38715 : "\n"
38716 : "Compute boundary (deprecated)\n"
38717 : "\n"
38718 : "For more details: :cpp:func:`OGR_G_GetBoundary`\n"
38719 : "\n"
38720 : "..warning:: Deprecated\n"
38721 : "\n"
38722 : "See: :cpp:func:`OGR_G_Boundary`\n"
38723 : "\n"
38724 : ""},
38725 : { "Geometry_ConvexHull", _wrap_Geometry_ConvexHull, METH_O, "\n"
38726 : "Geometry_ConvexHull(Geometry self) -> Geometry\n"
38727 : "\n"
38728 : "Compute convex hull.\n"
38729 : "\n"
38730 : "For more details: :cpp:func:`OGR_G_ConvexHull`\n"
38731 : "\n"
38732 : "Returns\n"
38733 : "--------\n"
38734 : "Geometry:\n"
38735 : " a handle to A newly allocated geometry now owned by the caller, or\n"
38736 : " None on failure.\n"
38737 : "\n"
38738 : ""},
38739 : { "Geometry_ConcaveHull", _wrap_Geometry_ConcaveHull, METH_VARARGS, "Geometry_ConcaveHull(Geometry self, double ratio, bool allowHoles) -> Geometry"},
38740 : { "Geometry_MakeValid", _wrap_Geometry_MakeValid, METH_VARARGS, "\n"
38741 : "Geometry_MakeValid(Geometry self, char ** options=None) -> Geometry\n"
38742 : "\n"
38743 : "Attempts to make an invalid geometry valid without losing vertices.\n"
38744 : "\n"
38745 : "For more details: :cpp:func:`OGR_G_MakeValidEx`\n"
38746 : "\n"
38747 : ".. versionadded:: 3.0\n"
38748 : ".. versionadded:: 3.4 options\n"
38749 : "\n"
38750 : "Parameters\n"
38751 : "-----------\n"
38752 : "options: list[str], optional\n"
38753 : " papszOptions to be passed in. For example: [\"METHOD=STRUCTURE\"].\n"
38754 : "\n"
38755 : "Returns\n"
38756 : "--------\n"
38757 : "Geometry:\n"
38758 : " A newly allocated geometry now owned by the caller, or None on\n"
38759 : " failure.\n"
38760 : "\n"
38761 : ""},
38762 : { "Geometry_SetPrecision", _wrap_Geometry_SetPrecision, METH_VARARGS, "Geometry_SetPrecision(Geometry self, double gridSize, int flags=0) -> Geometry"},
38763 : { "Geometry_Normalize", _wrap_Geometry_Normalize, METH_O, "\n"
38764 : "Geometry_Normalize(Geometry self) -> Geometry\n"
38765 : "\n"
38766 : "Attempts to bring geometry into normalized/canonical form.\n"
38767 : "\n"
38768 : "For more details: :cpp:func:`OGR_G_Normalize`\n"
38769 : "\n"
38770 : ".. versionadded:: 3.3\n"
38771 : "\n"
38772 : "Returns\n"
38773 : "--------\n"
38774 : "Geometry:\n"
38775 : " A newly allocated geometry now owned by the caller, or None on\n"
38776 : " failure.\n"
38777 : "\n"
38778 : ""},
38779 : { "Geometry_RemoveLowerDimensionSubGeoms", _wrap_Geometry_RemoveLowerDimensionSubGeoms, METH_O, "Geometry_RemoveLowerDimensionSubGeoms(Geometry self) -> Geometry"},
38780 : { "Geometry_Buffer", _wrap_Geometry_Buffer, METH_VARARGS, "\n"
38781 : "Geometry_Buffer(Geometry self, double distance, int quadsecs=30) -> Geometry\n"
38782 : "Geometry_Buffer(Geometry self, double distance, char ** options) -> Geometry\n"
38783 : "\n"
38784 : "Compute buffer of geometry.\n"
38785 : "\n"
38786 : "For more details: :cpp:func:`OGR_G_Buffer`\n"
38787 : "\n"
38788 : "Parameters\n"
38789 : "-----------\n"
38790 : "distance: float\n"
38791 : " The buffer distance to be applied. Should be expressed into\n"
38792 : " the same unit as the coordinates of the geometry.\n"
38793 : "quadsecs: int, default=30\n"
38794 : " The number of segments used to approximate a 90 degree\n"
38795 : " (quadrant) of curvature.\n"
38796 : "options: list/dict\n"
38797 : " An optional list of options to control the buffer output.\n"
38798 : " See :cpp:func:`OGR_G_BufferEx`.\n"
38799 : "\n"
38800 : "Returns\n"
38801 : "--------\n"
38802 : "Geometry:\n"
38803 : " The newly created geometry or None if an error occurs.\n"
38804 : "\n"
38805 : ""},
38806 : { "Geometry_Intersection", _wrap_Geometry_Intersection, METH_VARARGS, "\n"
38807 : "Geometry_Intersection(Geometry self, Geometry other) -> Geometry\n"
38808 : "\n"
38809 : "Compute intersection.\n"
38810 : "\n"
38811 : "For more details: :cpp:func:`OGR_G_Intersection`\n"
38812 : "\n"
38813 : "Parameters\n"
38814 : "-----------\n"
38815 : "other: Geometry\n"
38816 : " The other geometry.\n"
38817 : "\n"
38818 : "Returns\n"
38819 : "--------\n"
38820 : "Geometry:\n"
38821 : " A new geometry representing the intersection or None if there is no\n"
38822 : " intersection or an error occurs.\n"
38823 : "\n"
38824 : ""},
38825 : { "Geometry_Union", _wrap_Geometry_Union, METH_VARARGS, "\n"
38826 : "Geometry_Union(Geometry self, Geometry other) -> Geometry\n"
38827 : "\n"
38828 : "Compute union.\n"
38829 : "\n"
38830 : "For more details: :cpp:func:`OGR_G_Union`\n"
38831 : "\n"
38832 : "Parameters\n"
38833 : "-----------\n"
38834 : "other: Geometry\n"
38835 : " The other geometry.\n"
38836 : "\n"
38837 : "Returns\n"
38838 : "--------\n"
38839 : "Geometry:\n"
38840 : " A new geometry representing the union or None if an error occurs.\n"
38841 : "\n"
38842 : ""},
38843 : { "Geometry_UnionCascaded", _wrap_Geometry_UnionCascaded, METH_O, "\n"
38844 : "Geometry_UnionCascaded(Geometry self) -> Geometry\n"
38845 : "\n"
38846 : "Compute union using cascading.\n"
38847 : "\n"
38848 : "For more deails: :cpp:func:`OGR_G_UnionCascaded`\n"
38849 : "\n"
38850 : "Returns\n"
38851 : "--------\n"
38852 : "Geometry:\n"
38853 : " A new geometry representing the union or None if an error occurs.\n"
38854 : "\n"
38855 : ""},
38856 : { "Geometry_UnaryUnion", _wrap_Geometry_UnaryUnion, METH_O, "Geometry_UnaryUnion(Geometry self) -> Geometry"},
38857 : { "Geometry_Difference", _wrap_Geometry_Difference, METH_VARARGS, "\n"
38858 : "Geometry_Difference(Geometry self, Geometry other) -> Geometry\n"
38859 : "\n"
38860 : "Compute difference.\n"
38861 : "\n"
38862 : "For more details: :cpp:func:`OGR_G_Difference`\n"
38863 : "\n"
38864 : "Parameters\n"
38865 : "-----------\n"
38866 : "other: Geometry\n"
38867 : " The other geometry.\n"
38868 : "\n"
38869 : "Returns\n"
38870 : "--------\n"
38871 : "Geometry:\n"
38872 : " A new geometry representing the difference or None if the difference\n"
38873 : " is empty or an error occurs.\n"
38874 : "\n"
38875 : ""},
38876 : { "Geometry_SymDifference", _wrap_Geometry_SymDifference, METH_VARARGS, "\n"
38877 : "Geometry_SymDifference(Geometry self, Geometry other) -> Geometry\n"
38878 : "\n"
38879 : "Compute symmetric difference.\n"
38880 : "\n"
38881 : "For more details: :cpp:func:`OGR_G_SymDifference`\n"
38882 : "\n"
38883 : "Parameters\n"
38884 : "-----------\n"
38885 : "other:\n"
38886 : " the other geometry.\n"
38887 : "\n"
38888 : "Returns\n"
38889 : "--------\n"
38890 : "Geometry:\n"
38891 : " A new geometry representing the symmetric difference or None if the\n"
38892 : " difference is empty or an error occurs.\n"
38893 : "\n"
38894 : ""},
38895 : { "Geometry_SymmetricDifference", _wrap_Geometry_SymmetricDifference, METH_VARARGS, "\n"
38896 : "Geometry_SymmetricDifference(Geometry self, Geometry other) -> Geometry\n"
38897 : "\n"
38898 : "Compute symmetric difference (deprecated)\n"
38899 : "\n"
38900 : "For more details: :cpp:func:`OGR_G_SymmetricDifference`\n"
38901 : "\n"
38902 : ".. warning:: Deprecated\n"
38903 : "\n"
38904 : "\n"
38905 : ""},
38906 : { "Geometry_Distance", _wrap_Geometry_Distance, METH_VARARGS, "\n"
38907 : "Geometry_Distance(Geometry self, Geometry other) -> double\n"
38908 : "\n"
38909 : "Compute distance between two geometries.\n"
38910 : "\n"
38911 : "For more details: :cpp:func:`OGR_G_Distance`\n"
38912 : "\n"
38913 : "Parameters\n"
38914 : "-----------\n"
38915 : "other: Geometry\n"
38916 : " The other geometry to compare against.\n"
38917 : "\n"
38918 : "Returns\n"
38919 : "--------\n"
38920 : "float:\n"
38921 : " The distance between the geometries or -1 if an error occurs.\n"
38922 : "\n"
38923 : ""},
38924 : { "Geometry_Distance3D", _wrap_Geometry_Distance3D, METH_VARARGS, "\n"
38925 : "Geometry_Distance3D(Geometry self, Geometry other) -> double\n"
38926 : "\n"
38927 : "Returns the 3D distance between two geometries.\n"
38928 : "\n"
38929 : "For more details: :cpp:func:`OGR_G_Distance3D`\n"
38930 : "\n"
38931 : ".. versionadded:: 2.2\n"
38932 : "\n"
38933 : "Parameters\n"
38934 : "-----------\n"
38935 : "other: Geometry\n"
38936 : " The other geometry to compare against.\n"
38937 : "\n"
38938 : "Returns\n"
38939 : "--------\n"
38940 : "float:\n"
38941 : " The distance between the geometries or -1 if an error occurs.\n"
38942 : "\n"
38943 : ""},
38944 : { "Geometry_Empty", _wrap_Geometry_Empty, METH_O, "\n"
38945 : "Geometry_Empty(Geometry self)\n"
38946 : "\n"
38947 : "Clear geometry information.\n"
38948 : "\n"
38949 : "For more details: :cpp:func:`OGR_G_Empty`\n"
38950 : "\n"
38951 : ""},
38952 : { "Geometry_IsEmpty", _wrap_Geometry_IsEmpty, METH_O, "\n"
38953 : "Geometry_IsEmpty(Geometry self) -> bool\n"
38954 : "\n"
38955 : "Test if the geometry is empty.\n"
38956 : "\n"
38957 : "For more details: :cpp:func:`OGR_G_IsEmpty`\n"
38958 : "\n"
38959 : "Returns\n"
38960 : "--------\n"
38961 : "int:\n"
38962 : " True if the geometry has no points, otherwise False.\n"
38963 : "\n"
38964 : ""},
38965 : { "Geometry_IsValid", _wrap_Geometry_IsValid, METH_O, "\n"
38966 : "Geometry_IsValid(Geometry self) -> bool\n"
38967 : "\n"
38968 : "Test if the geometry is valid.\n"
38969 : "\n"
38970 : "For more details: :cpp:func:`OGR_G_IsValid`\n"
38971 : "\n"
38972 : "Returns\n"
38973 : "--------\n"
38974 : "int:\n"
38975 : " True if the geometry has no points, otherwise False.\n"
38976 : "\n"
38977 : ""},
38978 : { "Geometry_IsSimple", _wrap_Geometry_IsSimple, METH_O, "\n"
38979 : "Geometry_IsSimple(Geometry self) -> bool\n"
38980 : "\n"
38981 : "Returns True if the geometry is simple.\n"
38982 : "\n"
38983 : "For more details: :cpp:func:`OGR_G_IsSimple`\n"
38984 : "\n"
38985 : "Returns\n"
38986 : "--------\n"
38987 : "int:\n"
38988 : " True if object is simple, otherwise False.\n"
38989 : "\n"
38990 : ""},
38991 : { "Geometry_IsRing", _wrap_Geometry_IsRing, METH_O, "\n"
38992 : "Geometry_IsRing(Geometry self) -> bool\n"
38993 : "\n"
38994 : "Test if the geometry is a ring.\n"
38995 : "\n"
38996 : "For more details: :cpp:func:`OGR_G_IsRing`\n"
38997 : "\n"
38998 : "Returns\n"
38999 : "--------\n"
39000 : "int:\n"
39001 : " True if the geometry has no points, otherwise False.\n"
39002 : "\n"
39003 : ""},
39004 : { "Geometry_Intersects", _wrap_Geometry_Intersects, METH_VARARGS, "\n"
39005 : "Geometry_Intersects(Geometry self, Geometry other) -> bool\n"
39006 : "\n"
39007 : "Determines whether two geometries intersect.\n"
39008 : "\n"
39009 : "For more details: :cpp:func:`OGR_G_Intersects`\n"
39010 : "\n"
39011 : "Parameters\n"
39012 : "-----------\n"
39013 : "other: Geometry\n"
39014 : " The other geometry to test against.\n"
39015 : "\n"
39016 : "Returns\n"
39017 : "--------\n"
39018 : "int:\n"
39019 : " True if the geometries intersect, otherwise False.\n"
39020 : "\n"
39021 : ""},
39022 : { "Geometry_Intersect", _wrap_Geometry_Intersect, METH_VARARGS, "Geometry_Intersect(Geometry self, Geometry other) -> bool"},
39023 : { "Geometry_Equals", _wrap_Geometry_Equals, METH_VARARGS, "\n"
39024 : "Geometry_Equals(Geometry self, Geometry other) -> bool\n"
39025 : "\n"
39026 : "Returns True if two geometries are equivalent.\n"
39027 : "\n"
39028 : "For more details: :cpp:func:`OGR_G_Equals`\n"
39029 : "\n"
39030 : "Parameters\n"
39031 : "-----------\n"
39032 : "other: Geometry\n"
39033 : " The other geometry to test against.\n"
39034 : "\n"
39035 : "Returns\n"
39036 : "--------\n"
39037 : "int:\n"
39038 : " True if equivalent or False otherwise.\n"
39039 : "\n"
39040 : ""},
39041 : { "Geometry_Equal", _wrap_Geometry_Equal, METH_VARARGS, "Geometry_Equal(Geometry self, Geometry other) -> bool"},
39042 : { "Geometry_Disjoint", _wrap_Geometry_Disjoint, METH_VARARGS, "\n"
39043 : "Geometry_Disjoint(Geometry self, Geometry other) -> bool\n"
39044 : "\n"
39045 : "Test for disjointness.\n"
39046 : "\n"
39047 : "For more details: :cpp:func:`OGR_G_Disjoint`\n"
39048 : "\n"
39049 : "Parameters\n"
39050 : "-----------\n"
39051 : "other: Geometry\n"
39052 : " The other geometry to compare.\n"
39053 : "\n"
39054 : "Returns\n"
39055 : "--------\n"
39056 : "int:\n"
39057 : " True if they are disjoint, otherwise False.\n"
39058 : "\n"
39059 : ""},
39060 : { "Geometry_Touches", _wrap_Geometry_Touches, METH_VARARGS, "\n"
39061 : "Geometry_Touches(Geometry self, Geometry other) -> bool\n"
39062 : "\n"
39063 : "Test for touching.\n"
39064 : "\n"
39065 : "For more details: :cpp:func:`OGR_G_Touches`\n"
39066 : "\n"
39067 : "Parameters\n"
39068 : "-----------\n"
39069 : "other:\n"
39070 : " the other geometry to compare.\n"
39071 : "\n"
39072 : "Returns\n"
39073 : "--------\n"
39074 : "int:\n"
39075 : " True if they are touching, otherwise False.\n"
39076 : "\n"
39077 : ""},
39078 : { "Geometry_Crosses", _wrap_Geometry_Crosses, METH_VARARGS, "\n"
39079 : "Geometry_Crosses(Geometry self, Geometry other) -> bool\n"
39080 : "\n"
39081 : "Test for crossing.\n"
39082 : "\n"
39083 : "For more details: :cpp:func:`OGR_G_Crosses`\n"
39084 : "\n"
39085 : "Parameters\n"
39086 : "-----------\n"
39087 : "other: Geometry\n"
39088 : " the other geometry to compare.\n"
39089 : "\n"
39090 : "Returns\n"
39091 : "--------\n"
39092 : "int:\n"
39093 : " True if they are crossing, otherwise False.\n"
39094 : "\n"
39095 : ""},
39096 : { "Geometry_Within", _wrap_Geometry_Within, METH_VARARGS, "\n"
39097 : "Geometry_Within(Geometry self, Geometry other) -> bool\n"
39098 : "\n"
39099 : "Test for containment.\n"
39100 : "\n"
39101 : "For more details: :cpp:func:`OGR_G_Within`\n"
39102 : "\n"
39103 : "Parameters\n"
39104 : "-----------\n"
39105 : "other: Geometry\n"
39106 : " the other geometry to compare.\n"
39107 : "\n"
39108 : "Returns\n"
39109 : "--------\n"
39110 : "int:\n"
39111 : " True if this is within other, otherwise False.\n"
39112 : "\n"
39113 : ""},
39114 : { "Geometry_Contains", _wrap_Geometry_Contains, METH_VARARGS, "\n"
39115 : "Geometry_Contains(Geometry self, Geometry other) -> bool\n"
39116 : "\n"
39117 : "Test for containment.\n"
39118 : "\n"
39119 : "For more details: :cpp:func:`OGR_G_Contains`\n"
39120 : "\n"
39121 : "Parameters\n"
39122 : "-----------\n"
39123 : "other: Geometry\n"
39124 : " the other geometry to compare.\n"
39125 : "\n"
39126 : "Returns\n"
39127 : "--------\n"
39128 : "int:\n"
39129 : " True if this contains the other geometry, otherwise False.\n"
39130 : "\n"
39131 : ""},
39132 : { "Geometry_Overlaps", _wrap_Geometry_Overlaps, METH_VARARGS, "\n"
39133 : "Geometry_Overlaps(Geometry self, Geometry other) -> bool\n"
39134 : "\n"
39135 : "Test for overlap.\n"
39136 : "\n"
39137 : "For more details: :cpp:func:`OGR_G_Overlaps`\n"
39138 : "\n"
39139 : "Parameters\n"
39140 : "-----------\n"
39141 : "other: Geometry\n"
39142 : " the other geometry to compare.\n"
39143 : "\n"
39144 : "Returns\n"
39145 : "--------\n"
39146 : "int:\n"
39147 : " True if they are overlapping, otherwise False.\n"
39148 : "\n"
39149 : ""},
39150 : { "Geometry_TransformTo", _wrap_Geometry_TransformTo, METH_VARARGS, "\n"
39151 : "Geometry_TransformTo(Geometry self, SpatialReference reference) -> OGRErr\n"
39152 : "\n"
39153 : "Transform geometry to new spatial reference system.\n"
39154 : "\n"
39155 : "For more details: :cpp:func:`OGR_G_TransformTo`\n"
39156 : "\n"
39157 : "Parameters\n"
39158 : "-----------\n"
39159 : "reference: SpatialReference\n"
39160 : " The spatial reference system to apply.\n"
39161 : "\n"
39162 : "Returns\n"
39163 : "--------\n"
39164 : "int:\n"
39165 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success, or an error code.\n"
39166 : "\n"
39167 : ""},
39168 : { "Geometry_GetSpatialReference", _wrap_Geometry_GetSpatialReference, METH_O, "\n"
39169 : "Geometry_GetSpatialReference(Geometry self) -> SpatialReference\n"
39170 : "\n"
39171 : "For more details: :cpp:func:`OGR_G_GetSpatialReference`\n"
39172 : "\n"
39173 : "Returns spatial reference system for geometry.\n"
39174 : "\n"
39175 : "Returns\n"
39176 : "--------\n"
39177 : "SpatialReference\n"
39178 : "\n"
39179 : ""},
39180 : { "Geometry_AssignSpatialReference", _wrap_Geometry_AssignSpatialReference, METH_VARARGS, "\n"
39181 : "Geometry_AssignSpatialReference(Geometry self, SpatialReference reference)\n"
39182 : "\n"
39183 : "Assign spatial reference to this object.\n"
39184 : "\n"
39185 : "For more details: :cpp:func:`OGR_G_AssignSpatialReference`\n"
39186 : "\n"
39187 : "Parameters\n"
39188 : "-----------\n"
39189 : "reference: SpatialReference\n"
39190 : " The new spatial reference system to apply.\n"
39191 : "\n"
39192 : ""},
39193 : { "Geometry_CloseRings", _wrap_Geometry_CloseRings, METH_O, "\n"
39194 : "Geometry_CloseRings(Geometry self)\n"
39195 : "\n"
39196 : "Force rings to be closed.\n"
39197 : "\n"
39198 : "For more details: :cpp:func:`OGR_G_CloseRings`\n"
39199 : "\n"
39200 : ""},
39201 : { "Geometry_FlattenTo2D", _wrap_Geometry_FlattenTo2D, METH_O, "\n"
39202 : "Geometry_FlattenTo2D(Geometry self)\n"
39203 : "\n"
39204 : "Convert geometry to strictly 2D.\n"
39205 : "\n"
39206 : "For more details: :cpp:func:`OGR_G_FlattenTo2D`\n"
39207 : "\n"
39208 : ""},
39209 : { "Geometry_Segmentize", _wrap_Geometry_Segmentize, METH_VARARGS, "\n"
39210 : "Geometry_Segmentize(Geometry self, double dfMaxLength)\n"
39211 : "\n"
39212 : "Modify the geometry such it has no segment longer then the given\n"
39213 : "distance.\n"
39214 : "\n"
39215 : "For more details: :cpp:func:`OGR_G_Segmentize`\n"
39216 : "\n"
39217 : "Parameters\n"
39218 : "-----------\n"
39219 : "dfMaxLength: float\n"
39220 : " the maximum distance between 2 points after segmentization\n"
39221 : "\n"
39222 : ""},
39223 : { "Geometry_GetEnvelope", _wrap_Geometry_GetEnvelope, METH_O, "\n"
39224 : "Geometry_GetEnvelope(Geometry self)\n"
39225 : "\n"
39226 : "Computes and returns the bounding envelope for this geometry in the\n"
39227 : "passed psEnvelope structure.\n"
39228 : "\n"
39229 : "For more details: :cpp:func:`OGR_G_GetEnvelope`\n"
39230 : "\n"
39231 : ".. warning:: Check the return order of the bounds.\n"
39232 : "\n"
39233 : "Returns\n"
39234 : "--------\n"
39235 : "minx: float\n"
39236 : "maxx: float\n"
39237 : "miny: float\n"
39238 : "maxy: float\n"
39239 : "\n"
39240 : ""},
39241 : { "Geometry_GetEnvelope3D", _wrap_Geometry_GetEnvelope3D, METH_O, "\n"
39242 : "Geometry_GetEnvelope3D(Geometry self)\n"
39243 : "\n"
39244 : "Computes and returns the bounding envelope (3D) for this geometry in\n"
39245 : "the passed psEnvelope structure.\n"
39246 : "\n"
39247 : "For more details: :cpp:func:`OGR_G_GetEnvelope3D`\n"
39248 : "\n"
39249 : ".. warning:: Check the return order of the bounds.\n"
39250 : "\n"
39251 : "Returns\n"
39252 : "--------\n"
39253 : "minx: float\n"
39254 : "maxx: float\n"
39255 : "miny: float\n"
39256 : "maxy: float\n"
39257 : "minz: float\n"
39258 : "maxz: float\n"
39259 : "\n"
39260 : ""},
39261 : { "Geometry_Centroid", _wrap_Geometry_Centroid, METH_O, "\n"
39262 : "Geometry_Centroid(Geometry self) -> Geometry\n"
39263 : "\n"
39264 : "Compute the geometry centroid.\n"
39265 : "\n"
39266 : "For more details: :cpp:func:`OGR_G_Centroid`\n"
39267 : "\n"
39268 : "Returns\n"
39269 : "--------\n"
39270 : "Geometry\n"
39271 : "\n"
39272 : ""},
39273 : { "Geometry_PointOnSurface", _wrap_Geometry_PointOnSurface, METH_O, "\n"
39274 : "Geometry_PointOnSurface(Geometry self) -> Geometry\n"
39275 : "\n"
39276 : "Returns a point guaranteed to lie on the surface.\n"
39277 : "\n"
39278 : "For more details: :cpp:func:`OGR_G_PointOnSurface`\n"
39279 : "\n"
39280 : "Returns\n"
39281 : "--------\n"
39282 : "Geometry:\n"
39283 : " A point guaranteed to lie on the surface or None if an error occurred.\n"
39284 : "\n"
39285 : ""},
39286 : { "Geometry_WkbSize", _wrap_Geometry_WkbSize, METH_O, "\n"
39287 : "Geometry_WkbSize(Geometry self) -> size_t\n"
39288 : "\n"
39289 : "Returns size of related binary representation.\n"
39290 : "\n"
39291 : "For more details: :cpp:func:`OGR_G_WkbSize`\n"
39292 : "\n"
39293 : "Returns\n"
39294 : "--------\n"
39295 : "int\n"
39296 : "\n"
39297 : ""},
39298 : { "Geometry_GetCoordinateDimension", _wrap_Geometry_GetCoordinateDimension, METH_O, "\n"
39299 : "Geometry_GetCoordinateDimension(Geometry self) -> int\n"
39300 : "\n"
39301 : "Get the dimension of the coordinates in this geometry.\n"
39302 : "\n"
39303 : "For more details: :cpp:func:`OGR_G_GetCoordinateDimension`\n"
39304 : "\n"
39305 : ".. warning:: Deprecated. Use :py:func:`CoordinateDimension`,\n"
39306 : " :py:func:`Is3D`, or :py:func:`IsMeasured`.\n"
39307 : "\n"
39308 : "Returns\n"
39309 : "--------\n"
39310 : "int:\n"
39311 : " This will return 2 or 3.\n"
39312 : "\n"
39313 : ""},
39314 : { "Geometry_CoordinateDimension", _wrap_Geometry_CoordinateDimension, METH_O, "\n"
39315 : "Geometry_CoordinateDimension(Geometry self) -> int\n"
39316 : "\n"
39317 : "Get the dimension of the coordinates in this geometry.\n"
39318 : "\n"
39319 : "For more details: :cpp:func:`OGR_G_CoordinateDimension`\n"
39320 : "\n"
39321 : ".. versionadded:: 2.1\n"
39322 : "\n"
39323 : "Returns\n"
39324 : "--------\n"
39325 : "int:\n"
39326 : " This will return 2 for XY, 3 for XYZ and XYM, and 4 for XYZM data.\n"
39327 : "\n"
39328 : ""},
39329 : { "Geometry_Is3D", _wrap_Geometry_Is3D, METH_O, "\n"
39330 : "Geometry_Is3D(Geometry self) -> int\n"
39331 : "\n"
39332 : "See whether this geometry has Z coordinates.\n"
39333 : "\n"
39334 : "For more details: :cpp:func:`OGR_G_Is3D`\n"
39335 : "\n"
39336 : ".. versionadded:: 2.1\n"
39337 : "\n"
39338 : "Returns\n"
39339 : "--------\n"
39340 : "int:\n"
39341 : " True if the geometry has Z coordinates.\n"
39342 : "\n"
39343 : ""},
39344 : { "Geometry_IsMeasured", _wrap_Geometry_IsMeasured, METH_O, "\n"
39345 : "Geometry_IsMeasured(Geometry self) -> int\n"
39346 : "\n"
39347 : "See whether this geometry is measured.\n"
39348 : "\n"
39349 : "For more details: :cpp:func:`OGR_G_IsMeasured`\n"
39350 : "\n"
39351 : ".. versionadded:: 2.1\n"
39352 : "\n"
39353 : "Returns\n"
39354 : "--------\n"
39355 : "int:\n"
39356 : " True if the geometry has M coordinates.\n"
39357 : "\n"
39358 : ""},
39359 : { "Geometry_SetCoordinateDimension", _wrap_Geometry_SetCoordinateDimension, METH_VARARGS, "\n"
39360 : "Geometry_SetCoordinateDimension(Geometry self, int dimension)\n"
39361 : "\n"
39362 : "Set the coordinate dimension.\n"
39363 : "\n"
39364 : "For more details: :cpp:func:`OGR_G_SetCoordinateDimension`\n"
39365 : "\n"
39366 : ".. warning:: Deprecated. Use :py:func:`Set3D` or :py:func:`SetMeasured`.\n"
39367 : "\n"
39368 : "Parameters\n"
39369 : "-----------\n"
39370 : "dimension: int\n"
39371 : " New coordinate dimension value, either 2 or 3.\n"
39372 : "\n"
39373 : ""},
39374 : { "Geometry_Set3D", _wrap_Geometry_Set3D, METH_VARARGS, "\n"
39375 : "Geometry_Set3D(Geometry self, int b3D)\n"
39376 : "\n"
39377 : "Add or remove the Z coordinate dimension.\n"
39378 : "\n"
39379 : "For more details: :cpp:func:`OGR_G_Set3D`\n"
39380 : "\n"
39381 : ".. versionadded:: 2.1\n"
39382 : "\n"
39383 : "Parameters\n"
39384 : "-----------\n"
39385 : "bIs3D: bool\n"
39386 : " Should the geometry have a Z dimension, either True or False.\n"
39387 : "\n"
39388 : ""},
39389 : { "Geometry_SetMeasured", _wrap_Geometry_SetMeasured, METH_VARARGS, "\n"
39390 : "Geometry_SetMeasured(Geometry self, int bMeasured)\n"
39391 : "\n"
39392 : "Add or remove the M coordinate dimension.\n"
39393 : "\n"
39394 : "For more details: :cpp:func:`OGR_G_SetMeasured`\n"
39395 : "\n"
39396 : ".. versionadded:: 2.1\n"
39397 : "\n"
39398 : "Parameters\n"
39399 : "-----------\n"
39400 : "bIsMeasured: bool\n"
39401 : " Should the geometry have a M dimension, either True or False.\n"
39402 : "\n"
39403 : ""},
39404 : { "Geometry_GetDimension", _wrap_Geometry_GetDimension, METH_O, "\n"
39405 : "Geometry_GetDimension(Geometry self) -> int\n"
39406 : "\n"
39407 : "Get the dimension of this geometry.\n"
39408 : "\n"
39409 : "For more details: :cpp:func:`OGR_G_GetDimension`\n"
39410 : "\n"
39411 : "Returns\n"
39412 : "--------\n"
39413 : "int:\n"
39414 : " 0 for points, 1 for lines, and 2 for surfaces.\n"
39415 : "\n"
39416 : ""},
39417 : { "Geometry_HasCurveGeometry", _wrap_Geometry_HasCurveGeometry, METH_VARARGS, "Geometry_HasCurveGeometry(Geometry self, int bLookForCircular=FALSE) -> int"},
39418 : { "Geometry_GetLinearGeometry", (PyCFunction)(void(*)(void))_wrap_Geometry_GetLinearGeometry, METH_VARARGS|METH_KEYWORDS, "Geometry_GetLinearGeometry(Geometry self, double dfMaxAngleStepSizeDegrees=0.0, char ** options=None) -> Geometry"},
39419 : { "Geometry_GetCurveGeometry", (PyCFunction)(void(*)(void))_wrap_Geometry_GetCurveGeometry, METH_VARARGS|METH_KEYWORDS, "Geometry_GetCurveGeometry(Geometry self, char ** options=None) -> Geometry"},
39420 : { "Geometry_Value", _wrap_Geometry_Value, METH_VARARGS, "Geometry_Value(Geometry self, double dfDistance) -> Geometry"},
39421 : { "Geometry_Transform", _wrap_Geometry_Transform, METH_VARARGS, "\n"
39422 : "Geometry_Transform(Geometry self, CoordinateTransformation trans) -> OGRErr\n"
39423 : "Geometry_Transform(Geometry self, GeomTransformer transformer) -> Geometry\n"
39424 : "\n"
39425 : "Apply arbitrary coordinate transformation to geometry.\n"
39426 : "\n"
39427 : "For more details: :cpp:func:`OGR_G_Transform`\n"
39428 : "\n"
39429 : "Parameters\n"
39430 : "-----------\n"
39431 : "trans: CoordinateTransform\n"
39432 : " The transformation to apply.\n"
39433 : "\n"
39434 : "Returns\n"
39435 : "--------\n"
39436 : "Geometry:\n"
39437 : " The transformed geometry.\n"
39438 : "\n"
39439 : ""},
39440 : { "Geometry_CreatePreparedGeometry", _wrap_Geometry_CreatePreparedGeometry, METH_O, "Geometry_CreatePreparedGeometry(Geometry self) -> PreparedGeometry"},
39441 : { "Geometry_swigregister", Geometry_swigregister, METH_O, NULL},
39442 : { "Geometry_swiginit", Geometry_swiginit, METH_VARARGS, NULL},
39443 : { "delete_PreparedGeometry", _wrap_delete_PreparedGeometry, METH_O, "delete_PreparedGeometry(PreparedGeometry self)"},
39444 : { "PreparedGeometry_Intersects", _wrap_PreparedGeometry_Intersects, METH_VARARGS, "PreparedGeometry_Intersects(PreparedGeometry self, Geometry otherGeom) -> bool"},
39445 : { "PreparedGeometry_Contains", _wrap_PreparedGeometry_Contains, METH_VARARGS, "PreparedGeometry_Contains(PreparedGeometry self, Geometry otherGeom) -> bool"},
39446 : { "PreparedGeometry_swigregister", PreparedGeometry_swigregister, METH_O, NULL},
39447 : { "new_GeomTransformer", _wrap_new_GeomTransformer, METH_VARARGS, "new_GeomTransformer(CoordinateTransformation ct, char ** options=None) -> GeomTransformer"},
39448 : { "delete_GeomTransformer", _wrap_delete_GeomTransformer, METH_O, "delete_GeomTransformer(GeomTransformer self)"},
39449 : { "GeomTransformer_Transform", _wrap_GeomTransformer_Transform, METH_VARARGS, "GeomTransformer_Transform(GeomTransformer self, Geometry src_geom) -> Geometry"},
39450 : { "GeomTransformer_swigregister", GeomTransformer_swigregister, METH_O, NULL},
39451 : { "GeomTransformer_swiginit", GeomTransformer_swiginit, METH_VARARGS, NULL},
39452 : { "delete_FieldDomain", _wrap_delete_FieldDomain, METH_O, "delete_FieldDomain(FieldDomain self)"},
39453 : { "FieldDomain_GetName", _wrap_FieldDomain_GetName, METH_O, "\n"
39454 : "FieldDomain_GetName(FieldDomain self) -> char const *\n"
39455 : "\n"
39456 : "\n"
39457 : "Get the name of the field domain.\n"
39458 : "\n"
39459 : "See :cpp:func:`OGRFieldDomain::GetName`.\n"
39460 : "\n"
39461 : ".. versionadded:: 3.3\n"
39462 : "\n"
39463 : "Returns\n"
39464 : "--------\n"
39465 : "str\n"
39466 : " the field domain name.\n"
39467 : "\n"
39468 : ""},
39469 : { "FieldDomain_GetDescription", _wrap_FieldDomain_GetDescription, METH_O, "\n"
39470 : "FieldDomain_GetDescription(FieldDomain self) -> char const *\n"
39471 : "\n"
39472 : "\n"
39473 : "Get the description of the field domain.\n"
39474 : "\n"
39475 : "See :cpp:func:`OGRFieldDomain::GetDescription`.\n"
39476 : "\n"
39477 : ".. versionadded:: 3.3\n"
39478 : "\n"
39479 : "Returns\n"
39480 : "--------\n"
39481 : "str\n"
39482 : " the field domain description (might be empty string).\n"
39483 : "\n"
39484 : ""},
39485 : { "FieldDomain_GetFieldType", _wrap_FieldDomain_GetFieldType, METH_O, "\n"
39486 : "FieldDomain_GetFieldType(FieldDomain self) -> OGRFieldType\n"
39487 : "\n"
39488 : "\n"
39489 : "Get the field type of the field domain.\n"
39490 : "\n"
39491 : "See :cpp:func:`OGRFieldDomain::GetFieldType`.\n"
39492 : "\n"
39493 : ".. versionadded:: 3.3\n"
39494 : "\n"
39495 : "Returns\n"
39496 : "--------\n"
39497 : "int\n"
39498 : " the field type of the field domain.\n"
39499 : "\n"
39500 : ""},
39501 : { "FieldDomain_GetFieldSubType", _wrap_FieldDomain_GetFieldSubType, METH_O, "\n"
39502 : "FieldDomain_GetFieldSubType(FieldDomain self) -> OGRFieldSubType\n"
39503 : "\n"
39504 : "\n"
39505 : "Get the field subtype of the field domain.\n"
39506 : "\n"
39507 : "See :cpp:func:`OGRFieldDomain::GetFieldSubType`.\n"
39508 : "\n"
39509 : ".. versionadded:: 3.3\n"
39510 : "\n"
39511 : "Returns\n"
39512 : "--------\n"
39513 : "int\n"
39514 : " the field subtype of the field domain.\n"
39515 : "\n"
39516 : ""},
39517 : { "FieldDomain_GetDomainType", _wrap_FieldDomain_GetDomainType, METH_O, "\n"
39518 : "FieldDomain_GetDomainType(FieldDomain self) -> OGRFieldDomainType\n"
39519 : "\n"
39520 : "\n"
39521 : "Get the type of the field domain.\n"
39522 : "\n"
39523 : "See :cpp:func:`OGRFieldDomain::GetDomainType`.\n"
39524 : "\n"
39525 : ".. versionadded:: 3.3\n"
39526 : "\n"
39527 : "Returns\n"
39528 : "--------\n"
39529 : "int\n"
39530 : " the type of the field domain.\n"
39531 : "\n"
39532 : "Examples\n"
39533 : "--------\n"
39534 : ">>> d = ogr.CreateCodedFieldDomain('my_code', None, ogr.OFTInteger, ogr.OFSTNone, { 1 : 'owned', 2 : 'leased' })\n"
39535 : ">>> d.GetDomainType() == ogr.OFDT_CODED\n"
39536 : "True\n"
39537 : "\n"
39538 : "\n"
39539 : ""},
39540 : { "FieldDomain_GetSplitPolicy", _wrap_FieldDomain_GetSplitPolicy, METH_O, "\n"
39541 : "FieldDomain_GetSplitPolicy(FieldDomain self) -> OGRFieldDomainSplitPolicy\n"
39542 : "\n"
39543 : "\n"
39544 : "Get the split policy of the field domain.\n"
39545 : "\n"
39546 : "See :cpp:func:`OGRFieldDomain::GetSplitPolicy`.\n"
39547 : "\n"
39548 : ".. versionadded:: 3.3\n"
39549 : "\n"
39550 : "Returns\n"
39551 : "--------\n"
39552 : "int\n"
39553 : " the split policy of the field domain (default = :py:const:`OFDSP_DEFAULT_VALUE`)\n"
39554 : "\n"
39555 : ""},
39556 : { "FieldDomain_SetSplitPolicy", _wrap_FieldDomain_SetSplitPolicy, METH_VARARGS, "\n"
39557 : "FieldDomain_SetSplitPolicy(FieldDomain self, OGRFieldDomainSplitPolicy policy)\n"
39558 : "\n"
39559 : "\n"
39560 : "Set the split policy of the field domain.\n"
39561 : "\n"
39562 : "See :cpp:func:`OGRFieldDomain::SetSplitPolicy`.\n"
39563 : "\n"
39564 : ".. versionadded:: 3.3\n"
39565 : "\n"
39566 : "policy : int\n"
39567 : " the split policy code of the field domain.\n"
39568 : "\n"
39569 : ""},
39570 : { "FieldDomain_GetMergePolicy", _wrap_FieldDomain_GetMergePolicy, METH_O, "\n"
39571 : "FieldDomain_GetMergePolicy(FieldDomain self) -> OGRFieldDomainMergePolicy\n"
39572 : "\n"
39573 : "\n"
39574 : "Get the merge policy of the field domain.\n"
39575 : "\n"
39576 : "See :cpp:func:`OGRFieldDomain::GetMergePolicy`.\n"
39577 : "\n"
39578 : ".. versionadded:: 3.3\n"
39579 : "\n"
39580 : "Returns\n"
39581 : "--------\n"
39582 : "int\n"
39583 : " the merge policy of the field domain (default = :py:const:`OFDMP_DEFAULT_VALUE`)\n"
39584 : "\n"
39585 : ""},
39586 : { "FieldDomain_SetMergePolicy", _wrap_FieldDomain_SetMergePolicy, METH_VARARGS, "\n"
39587 : "FieldDomain_SetMergePolicy(FieldDomain self, OGRFieldDomainMergePolicy policy)\n"
39588 : "\n"
39589 : "\n"
39590 : "Set the merge policy of the field domain.\n"
39591 : "\n"
39592 : "See :cpp:func:`OGRFieldDomain::SetMergePolicy`.\n"
39593 : "\n"
39594 : ".. versionadded:: 3.3\n"
39595 : "\n"
39596 : "Parameters\n"
39597 : "-----------\n"
39598 : "policy : int\n"
39599 : " the merge policy code of the field domain.\n"
39600 : "\n"
39601 : ""},
39602 : { "FieldDomain_GetEnumeration", _wrap_FieldDomain_GetEnumeration, METH_O, "\n"
39603 : "FieldDomain_GetEnumeration(FieldDomain self) -> OGRCodedValue const *\n"
39604 : "\n"
39605 : "\n"
39606 : "Get the enumeration as a mapping of codes to values.\n"
39607 : "\n"
39608 : "See :cpp:func:`OGRCodedFieldDomain::GetEnumeration`.\n"
39609 : "\n"
39610 : ".. versionadded:: 3.3\n"
39611 : "\n"
39612 : "Returns\n"
39613 : "--------\n"
39614 : "dict\n"
39615 : "\n"
39616 : "Examples\n"
39617 : "--------\n"
39618 : ">>> d = ogr.CreateCodedFieldDomain('my_domain', None, ogr.OFTInteger, ogr.OFSTNone, { 1 : 'owned', 2 : 'leased' })\n"
39619 : ">>> d.GetEnumeration()\n"
39620 : "{'1': 'owned', '2': 'leased'}\n"
39621 : "\n"
39622 : "\n"
39623 : ""},
39624 : { "FieldDomain_GetMinAsDouble", _wrap_FieldDomain_GetMinAsDouble, METH_O, "\n"
39625 : "FieldDomain_GetMinAsDouble(FieldDomain self) -> double\n"
39626 : "\n"
39627 : "\n"
39628 : "Get the minimum value of a range domain.\n"
39629 : "\n"
39630 : "See :cpp:func:`OGRRangeFieldDomain::GetMin()`\n"
39631 : "\n"
39632 : ".. versionadded:: 3.3\n"
39633 : "\n"
39634 : "Returns\n"
39635 : "--------\n"
39636 : "float\n"
39637 : " the minimum value of the range\n"
39638 : "\n"
39639 : ""},
39640 : { "FieldDomain_GetMinAsString", _wrap_FieldDomain_GetMinAsString, METH_O, "\n"
39641 : "FieldDomain_GetMinAsString(FieldDomain self) -> char const *\n"
39642 : "\n"
39643 : "\n"
39644 : "Get the minimum value of a range domain.\n"
39645 : "\n"
39646 : "See :cpp:func:`OGRRangeFieldDomain::GetMin()`\n"
39647 : "\n"
39648 : ".. versionadded:: 3.3\n"
39649 : "\n"
39650 : "Returns\n"
39651 : "--------\n"
39652 : "str\n"
39653 : " the minimum value of the range\n"
39654 : "\n"
39655 : ""},
39656 : { "FieldDomain_IsMinInclusive", _wrap_FieldDomain_IsMinInclusive, METH_O, "FieldDomain_IsMinInclusive(FieldDomain self) -> bool"},
39657 : { "FieldDomain_GetMaxAsDouble", _wrap_FieldDomain_GetMaxAsDouble, METH_O, "\n"
39658 : "FieldDomain_GetMaxAsDouble(FieldDomain self) -> double\n"
39659 : "\n"
39660 : "\n"
39661 : "Get the maximum value of a range domain.\n"
39662 : "\n"
39663 : "See :cpp:func:`OGRRangeFieldDomain::GetMax()`\n"
39664 : "\n"
39665 : ".. versionadded:: 3.3\n"
39666 : "\n"
39667 : "Returns\n"
39668 : "--------\n"
39669 : "float\n"
39670 : " the maximum value of the range\n"
39671 : "\n"
39672 : ""},
39673 : { "FieldDomain_GetMaxAsString", _wrap_FieldDomain_GetMaxAsString, METH_O, "\n"
39674 : "FieldDomain_GetMaxAsString(FieldDomain self) -> char const *\n"
39675 : "\n"
39676 : "\n"
39677 : "Get the maximum value of a range domain.\n"
39678 : "\n"
39679 : "See :cpp:func:`OGRRangeFieldDomain::GetMax()`\n"
39680 : "\n"
39681 : ".. versionadded:: 3.3\n"
39682 : "\n"
39683 : "Returns\n"
39684 : "--------\n"
39685 : "str\n"
39686 : " the maximum value of the range\n"
39687 : "\n"
39688 : ""},
39689 : { "FieldDomain_IsMaxInclusive", _wrap_FieldDomain_IsMaxInclusive, METH_O, "FieldDomain_IsMaxInclusive(FieldDomain self) -> bool"},
39690 : { "FieldDomain_GetGlob", _wrap_FieldDomain_GetGlob, METH_O, "\n"
39691 : "FieldDomain_GetGlob(FieldDomain self) -> char const *\n"
39692 : "\n"
39693 : "\n"
39694 : "Get the glob expression.\n"
39695 : "\n"
39696 : "See :cpp:func:`OGRGlobFieldDomain::GetGlob`.\n"
39697 : "\n"
39698 : ".. versionadded:: 3.3\n"
39699 : "\n"
39700 : "Returns\n"
39701 : "--------\n"
39702 : "str\n"
39703 : " the glob expression, or ``None`` in case of error\n"
39704 : "\n"
39705 : ""},
39706 : { "FieldDomain_swigregister", FieldDomain_swigregister, METH_O, NULL},
39707 : { "CreateCodedFieldDomain", _wrap_CreateCodedFieldDomain, METH_VARARGS, "\n"
39708 : "CreateCodedFieldDomain(char const * name, char const * description, OGRFieldType type, OGRFieldSubType subtype, OGRCodedValue const * enumeration) -> FieldDomain\n"
39709 : "\n"
39710 : "\n"
39711 : "Creates a new coded field domain.\n"
39712 : "\n"
39713 : "See :cpp:func:`OGRCodedFieldDomain::OGRCodedFieldDomain`.\n"
39714 : "\n"
39715 : ".. versionadded:: 3.3\n"
39716 : "\n"
39717 : "Parameters\n"
39718 : "-----------\n"
39719 : "name : str\n"
39720 : " Domain name. Should not be ``None``.\n"
39721 : "description : str, optional\n"
39722 : " Domain description (can be ``None``)\n"
39723 : "type : int\n"
39724 : " Field type.\n"
39725 : "subtype : int\n"
39726 : " Field subtype.\n"
39727 : "enumeration : dict\n"
39728 : " Enumeration as a dictionary of (code : value) pairs. Should not be ``None``.\n"
39729 : "\n"
39730 : "Returns\n"
39731 : "--------\n"
39732 : "FieldDomain\n"
39733 : "\n"
39734 : ""},
39735 : { "CreateRangeFieldDomain", _wrap_CreateRangeFieldDomain, METH_VARARGS, "\n"
39736 : "CreateRangeFieldDomain(char const * name, char const * description, OGRFieldType type, OGRFieldSubType subtype, double min, bool minIsInclusive, double max, double maxIsInclusive) -> FieldDomain\n"
39737 : "\n"
39738 : "Creates a new range field domain.\n"
39739 : "\n"
39740 : "See :cpp:func:`OGRRangeFieldDomain::OGRRangeFieldDomain`.\n"
39741 : "\n"
39742 : ".. versionadded:: 3.3\n"
39743 : "\n"
39744 : "Parameters\n"
39745 : "-----------\n"
39746 : "name : str\n"
39747 : " Domain name. Should not be ``None``.\n"
39748 : "description : str, optional\n"
39749 : " Domain description (can be ``None``)\n"
39750 : "type : int\n"
39751 : " Field type. Generally numeric. Potentially :py:const:`OFTDateTime`.\n"
39752 : "subtype : int\n"
39753 : " Field subtype.\n"
39754 : "min : float, optional\n"
39755 : " Minimum value (can be ``None``).\n"
39756 : "minIsInclusive : bool\n"
39757 : " Whether the minimum value is included in the range.\n"
39758 : "max : float, optional\n"
39759 : " Maximum value (can be ``None``).\n"
39760 : "maxIsInclusive : bool\n"
39761 : " Whether the maximum value is included in the range.\n"
39762 : "\n"
39763 : "Returns\n"
39764 : "--------\n"
39765 : "FieldDomain\n"
39766 : "\n"
39767 : ""},
39768 : { "CreateRangeFieldDomainDateTime", _wrap_CreateRangeFieldDomainDateTime, METH_VARARGS, "CreateRangeFieldDomainDateTime(char const * name, char const * description, char const * min, bool minIsInclusive, char const * max, double maxIsInclusive) -> FieldDomain"},
39769 : { "CreateGlobFieldDomain", _wrap_CreateGlobFieldDomain, METH_VARARGS, "\n"
39770 : "CreateGlobFieldDomain(char const * name, char const * description, OGRFieldType type, OGRFieldSubType subtype, char const * glob) -> FieldDomain\n"
39771 : "\n"
39772 : "\n"
39773 : "Creates a new glob field domain.\n"
39774 : "\n"
39775 : "See :cpp:func:`OGRGlobFieldDomain::OGRGlobFieldDomain`\n"
39776 : "\n"
39777 : ".. versionadded:: 3.3\n"
39778 : "\n"
39779 : "Parameters\n"
39780 : "-----------\n"
39781 : "name : str\n"
39782 : " Domain name. Should not be ``None``.\n"
39783 : "description : str, optional\n"
39784 : " Domain description (can be ``None``)\n"
39785 : "type : int\n"
39786 : " Field type.\n"
39787 : "subtype : int\n"
39788 : " Field subtype.\n"
39789 : "glob : str\n"
39790 : " Glob expression. Should not be ``None``.\n"
39791 : "\n"
39792 : "Returns\n"
39793 : "--------\n"
39794 : "FieldDomain\n"
39795 : "\n"
39796 : ""},
39797 : { "delete_GeomCoordinatePrecision", _wrap_delete_GeomCoordinatePrecision, METH_O, "delete_GeomCoordinatePrecision(GeomCoordinatePrecision self)"},
39798 : { "GeomCoordinatePrecision_Set", _wrap_GeomCoordinatePrecision_Set, METH_VARARGS, "GeomCoordinatePrecision_Set(GeomCoordinatePrecision self, double xyResolution, double zResolution, double mResolution)"},
39799 : { "GeomCoordinatePrecision_SetFromMeter", _wrap_GeomCoordinatePrecision_SetFromMeter, METH_VARARGS, "GeomCoordinatePrecision_SetFromMeter(GeomCoordinatePrecision self, SpatialReference srs, double xyMeterResolution, double zMeterResolution, double mResolution)"},
39800 : { "GeomCoordinatePrecision_GetXYResolution", _wrap_GeomCoordinatePrecision_GetXYResolution, METH_O, "GeomCoordinatePrecision_GetXYResolution(GeomCoordinatePrecision self) -> double"},
39801 : { "GeomCoordinatePrecision_GetZResolution", _wrap_GeomCoordinatePrecision_GetZResolution, METH_O, "GeomCoordinatePrecision_GetZResolution(GeomCoordinatePrecision self) -> double"},
39802 : { "GeomCoordinatePrecision_GetMResolution", _wrap_GeomCoordinatePrecision_GetMResolution, METH_O, "GeomCoordinatePrecision_GetMResolution(GeomCoordinatePrecision self) -> double"},
39803 : { "GeomCoordinatePrecision_GetFormats", _wrap_GeomCoordinatePrecision_GetFormats, METH_O, "GeomCoordinatePrecision_GetFormats(GeomCoordinatePrecision self) -> char **"},
39804 : { "GeomCoordinatePrecision_GetFormatSpecificOptions", _wrap_GeomCoordinatePrecision_GetFormatSpecificOptions, METH_VARARGS, "GeomCoordinatePrecision_GetFormatSpecificOptions(GeomCoordinatePrecision self, char const * formatName) -> char **"},
39805 : { "GeomCoordinatePrecision_SetFormatSpecificOptions", _wrap_GeomCoordinatePrecision_SetFormatSpecificOptions, METH_VARARGS, "GeomCoordinatePrecision_SetFormatSpecificOptions(GeomCoordinatePrecision self, char const * formatName, char ** formatSpecificOptions)"},
39806 : { "GeomCoordinatePrecision_swigregister", GeomCoordinatePrecision_swigregister, METH_O, NULL},
39807 : { "CreateGeomCoordinatePrecision", _wrap_CreateGeomCoordinatePrecision, METH_NOARGS, "CreateGeomCoordinatePrecision() -> GeomCoordinatePrecision"},
39808 : { "GetDriverCount", _wrap_GetDriverCount, METH_NOARGS, "GetDriverCount() -> int"},
39809 : { "GetOpenDSCount", _wrap_GetOpenDSCount, METH_NOARGS, "GetOpenDSCount() -> int"},
39810 : { "SetGenerate_DB2_V72_BYTE_ORDER", _wrap_SetGenerate_DB2_V72_BYTE_ORDER, METH_O, "SetGenerate_DB2_V72_BYTE_ORDER(int bGenerate_DB2_V72_BYTE_ORDER) -> OGRErr"},
39811 : { "RegisterAll", _wrap_RegisterAll, METH_NOARGS, "RegisterAll()"},
39812 : { "GeometryTypeToName", _wrap_GeometryTypeToName, METH_O, "GeometryTypeToName(OGRwkbGeometryType eType) -> char const *"},
39813 : { "GetFieldTypeName", _wrap_GetFieldTypeName, METH_O, "\n"
39814 : "GetFieldTypeName(OGRFieldType type) -> char const *\n"
39815 : "\n"
39816 : "Fetch human readable name for a field type.\n"
39817 : "\n"
39818 : "See :cpp:func:`OGRFieldDefn::GetFieldTypeName`.\n"
39819 : "\n"
39820 : "Parameters\n"
39821 : "-----------\n"
39822 : "type : int\n"
39823 : " the field type code to get name for\n"
39824 : "\n"
39825 : "Returns\n"
39826 : "--------\n"
39827 : "str\n"
39828 : " the name\n"
39829 : "\n"
39830 : "Examples\n"
39831 : "--------\n"
39832 : ">>> ogr.GetFieldTypeName(0)\n"
39833 : "'Integer'\n"
39834 : "\n"
39835 : ">>> ogr.GetFieldTypeName(ogr.OFTReal)\n"
39836 : "'Real'\n"
39837 : "\n"
39838 : ""},
39839 : { "GetFieldSubTypeName", _wrap_GetFieldSubTypeName, METH_O, "\n"
39840 : "GetFieldSubTypeName(OGRFieldSubType type) -> char const *\n"
39841 : "\n"
39842 : "\n"
39843 : "Fetch human readable name for a field subtype.\n"
39844 : "\n"
39845 : "See :cpp:func:`OGRFieldDefn::GetFieldSubTypeName`.\n"
39846 : "\n"
39847 : "Parameters\n"
39848 : "-----------\n"
39849 : "type : int\n"
39850 : " the field subtype to get name for.\n"
39851 : "\n"
39852 : "Returns\n"
39853 : "--------\n"
39854 : "str\n"
39855 : " the name.\n"
39856 : "\n"
39857 : "Examples\n"
39858 : "--------\n"
39859 : ">>> ogr.GetFieldSubTypeName(1)\n"
39860 : "'Boolean'\n"
39861 : "\n"
39862 : ">>> ogr.GetFieldSubTypeName(ogr.OFSTInt16)\n"
39863 : "'Int16'\n"
39864 : "\n"
39865 : "\n"
39866 : ""},
39867 : { "GT_Flatten", _wrap_GT_Flatten, METH_O, "GT_Flatten(OGRwkbGeometryType eType) -> OGRwkbGeometryType"},
39868 : { "GT_SetZ", _wrap_GT_SetZ, METH_O, "GT_SetZ(OGRwkbGeometryType eType) -> OGRwkbGeometryType"},
39869 : { "GT_SetM", _wrap_GT_SetM, METH_O, "GT_SetM(OGRwkbGeometryType eType) -> OGRwkbGeometryType"},
39870 : { "GT_SetModifier", _wrap_GT_SetModifier, METH_VARARGS, "GT_SetModifier(OGRwkbGeometryType eType, int bSetZ, int bSetM=FALSE) -> OGRwkbGeometryType"},
39871 : { "GT_HasZ", _wrap_GT_HasZ, METH_O, "GT_HasZ(OGRwkbGeometryType eType) -> int"},
39872 : { "GT_HasM", _wrap_GT_HasM, METH_O, "GT_HasM(OGRwkbGeometryType eType) -> int"},
39873 : { "GT_IsSubClassOf", _wrap_GT_IsSubClassOf, METH_VARARGS, "GT_IsSubClassOf(OGRwkbGeometryType eType, OGRwkbGeometryType eSuperType) -> int"},
39874 : { "GT_IsCurve", _wrap_GT_IsCurve, METH_O, "GT_IsCurve(OGRwkbGeometryType arg1) -> int"},
39875 : { "GT_IsSurface", _wrap_GT_IsSurface, METH_O, "GT_IsSurface(OGRwkbGeometryType arg1) -> int"},
39876 : { "GT_IsNonLinear", _wrap_GT_IsNonLinear, METH_O, "GT_IsNonLinear(OGRwkbGeometryType arg1) -> int"},
39877 : { "GT_GetCollection", _wrap_GT_GetCollection, METH_O, "GT_GetCollection(OGRwkbGeometryType eType) -> OGRwkbGeometryType"},
39878 : { "GT_GetCurve", _wrap_GT_GetCurve, METH_O, "GT_GetCurve(OGRwkbGeometryType eType) -> OGRwkbGeometryType"},
39879 : { "GT_GetLinear", _wrap_GT_GetLinear, METH_O, "GT_GetLinear(OGRwkbGeometryType eType) -> OGRwkbGeometryType"},
39880 : { "SetNonLinearGeometriesEnabledFlag", _wrap_SetNonLinearGeometriesEnabledFlag, METH_O, "SetNonLinearGeometriesEnabledFlag(int bFlag)"},
39881 : { "GetNonLinearGeometriesEnabledFlag", _wrap_GetNonLinearGeometriesEnabledFlag, METH_NOARGS, "GetNonLinearGeometriesEnabledFlag() -> int"},
39882 : { "GetOpenDS", _wrap_GetOpenDS, METH_O, "GetOpenDS(int ds_number) -> OGRDataSourceShadow *"},
39883 : { "Open", (PyCFunction)(void(*)(void))_wrap_Open, METH_VARARGS|METH_KEYWORDS, "\n"
39884 : "Open(char const * utf8_path, int update=0) -> OGRDataSourceShadow *\n"
39885 : "\n"
39886 : "\n"
39887 : "Open a vector file as a :py:class:`gdal.Dataset`.\n"
39888 : "Equivalent to calling :py:func:`gdal.OpenEx` with the\n"
39889 : ":py:const:`gdal.OF_VECTOR` flag.\n"
39890 : "\n"
39891 : "Parameters\n"
39892 : "----------\n"
39893 : "utf8_path : str\n"
39894 : " name of the file to open\n"
39895 : "\n"
39896 : "Returns\n"
39897 : "-------\n"
39898 : "gdal.Dataset, or ``None`` on failure\n"
39899 : "\n"
39900 : "Examples\n"
39901 : "--------\n"
39902 : ">>> from osgeo import ogr\n"
39903 : ">>> ogr.GetDriverByName('ESRI Shapefile').GetDescription()\n"
39904 : "'ESRI Shapefile'\n"
39905 : ">>> ogr.GetDriverByName('GTiff')\n"
39906 : ">>>\n"
39907 : "\n"
39908 : ""},
39909 : { "OpenShared", (PyCFunction)(void(*)(void))_wrap_OpenShared, METH_VARARGS|METH_KEYWORDS, "\n"
39910 : "OpenShared(char const * utf8_path, int update=0) -> OGRDataSourceShadow *\n"
39911 : "\n"
39912 : "\n"
39913 : "Open a vector file as a :py:class:`gdal.Dataset`. If the file has already been\n"
39914 : "opened in the current thread, return a reference to the already-opened\n"
39915 : ":py:class:`gdal.Dataset`. Equivalent to calling :py:func:`gdal.OpenEx` with the\n"
39916 : ":py:const:`gdal.OF_VECTOR` and :py:const:`gdal.OF_SHARED` flags.\n"
39917 : "\n"
39918 : "Parameters\n"
39919 : "----------\n"
39920 : "utf8_path : str\n"
39921 : " name of the file to open\n"
39922 : "\n"
39923 : "Returns\n"
39924 : "-------\n"
39925 : "gdal.Dataset, or ``None`` on failure\n"
39926 : "\n"
39927 : "\n"
39928 : ""},
39929 : { "GetDriverByName", _wrap_GetDriverByName, METH_O, "\n"
39930 : "GetDriverByName(char const * name) -> OGRDriverShadow *\n"
39931 : "\n"
39932 : "\n"
39933 : "Get a vector driver. Like :py:func:`gdal.GetDriverByName`, but\n"
39934 : "only returns drivers that handle vector data.\n"
39935 : "\n"
39936 : "Parameters\n"
39937 : "----------\n"
39938 : "name : str\n"
39939 : " name of the driver to fetch\n"
39940 : "\n"
39941 : "Returns\n"
39942 : "-------\n"
39943 : "gdal.Driver\n"
39944 : "\n"
39945 : "Examples\n"
39946 : "--------\n"
39947 : ">>> ogr.GetDriverByName('ESRI Shapefile').GetDescription()\n"
39948 : "'ESRI Shapefile'\n"
39949 : "\n"
39950 : ">>> ogr.GetDriverByName('GTiff')\n"
39951 : ">>>\n"
39952 : "\n"
39953 : ""},
39954 : { "GetDriver", _wrap_GetDriver, METH_O, "GetDriver(int driver_number) -> OGRDriverShadow *"},
39955 : { "GeneralCmdLineProcessor", _wrap_GeneralCmdLineProcessor, METH_VARARGS, "GeneralCmdLineProcessor(char ** papszArgv, int nOptions=0) -> char **"},
39956 : { "TermProgress_nocb", (PyCFunction)(void(*)(void))_wrap_TermProgress_nocb, METH_VARARGS|METH_KEYWORDS, "TermProgress_nocb(double dfProgress, char const * pszMessage=None, void * pData=None) -> int"},
39957 : { NULL, NULL, 0, NULL }
39958 : };
39959 :
39960 : static PyMethodDef SwigMethods_proxydocs[] = {
39961 : { NULL, NULL, 0, NULL }
39962 : };
39963 :
39964 :
39965 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
39966 :
39967 0 : static void *_p_OGRLayerShadowTo_p_GDALMajorObjectShadow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
39968 0 : return (void *)((GDALMajorObjectShadow *) ((OGRLayerShadow *) x));
39969 : }
39970 : static swig_type_info _swigt__p_ArrowArray = {"_p_ArrowArray", "ArrowArray *", 0, 0, (void*)0, 0};
39971 : static swig_type_info _swigt__p_ArrowArrayStream = {"_p_ArrowArrayStream", "ArrowArrayStream *", 0, 0, (void*)0, 0};
39972 : static swig_type_info _swigt__p_ArrowSchema = {"_p_ArrowSchema", "ArrowSchema *", 0, 0, (void*)0, 0};
39973 : static swig_type_info _swigt__p_GDALDatasetShadow = {"_p_GDALDatasetShadow", "GDALDatasetShadow *|OGRDataSourceShadow *", 0, 0, (void*)0, 0};
39974 : static swig_type_info _swigt__p_GDALDriverShadow = {"_p_GDALDriverShadow", "GDALDriverShadow *|OGRDriverShadow *", 0, 0, (void*)0, 0};
39975 : static swig_type_info _swigt__p_GDALMajorObjectShadow = {"_p_GDALMajorObjectShadow", "GDALMajorObjectShadow *", 0, 0, (void*)0, 0};
39976 : static swig_type_info _swigt__p_GDALProgressFunc = {"_p_GDALProgressFunc", "GDALProgressFunc *", 0, 0, (void*)0, 0};
39977 : static swig_type_info _swigt__p_GIntBig = {"_p_GIntBig", "GIntBig *", 0, 0, (void*)0, 0};
39978 : static swig_type_info _swigt__p_OGRCodedValue = {"_p_OGRCodedValue", "OGRCodedValue *", 0, 0, (void*)0, 0};
39979 : static swig_type_info _swigt__p_OGRFeatureDefnShadow = {"_p_OGRFeatureDefnShadow", "OGRFeatureDefnShadow *", 0, 0, (void*)0, 0};
39980 : static swig_type_info _swigt__p_OGRFeatureShadow = {"_p_OGRFeatureShadow", "OGRFeatureShadow *", 0, 0, (void*)0, 0};
39981 : static swig_type_info _swigt__p_OGRFieldDefnShadow = {"_p_OGRFieldDefnShadow", "OGRFieldDefnShadow *", 0, 0, (void*)0, 0};
39982 : static swig_type_info _swigt__p_OGRFieldDomainShadow = {"_p_OGRFieldDomainShadow", "OGRFieldDomainShadow *", 0, 0, (void*)0, 0};
39983 : static swig_type_info _swigt__p_OGRGeomCoordinatePrecisionShadow = {"_p_OGRGeomCoordinatePrecisionShadow", "OGRGeomCoordinatePrecisionShadow *", 0, 0, (void*)0, 0};
39984 : static swig_type_info _swigt__p_OGRGeomFieldDefnShadow = {"_p_OGRGeomFieldDefnShadow", "OGRGeomFieldDefnShadow *", 0, 0, (void*)0, 0};
39985 : static swig_type_info _swigt__p_OGRGeomTransformerShadow = {"_p_OGRGeomTransformerShadow", "OGRGeomTransformerShadow *", 0, 0, (void*)0, 0};
39986 : static swig_type_info _swigt__p_OGRGeometryShadow = {"_p_OGRGeometryShadow", "OGRGeometryShadow *", 0, 0, (void*)0, 0};
39987 : static swig_type_info _swigt__p_OGRLayerShadow = {"_p_OGRLayerShadow", "OGRLayerShadow *", 0, 0, (void*)0, 0};
39988 : static swig_type_info _swigt__p_OGRPreparedGeometryShadow = {"_p_OGRPreparedGeometryShadow", "OGRPreparedGeometryShadow *", 0, 0, (void*)0, 0};
39989 : static swig_type_info _swigt__p_OGRStyleTableShadow = {"_p_OGRStyleTableShadow", "OGRStyleTableShadow *", 0, 0, (void*)0, 0};
39990 : static swig_type_info _swigt__p_OSRCoordinateTransformationShadow = {"_p_OSRCoordinateTransformationShadow", "OSRCoordinateTransformationShadow *", 0, 0, (void*)0, 0};
39991 : static swig_type_info _swigt__p_OSRSpatialReferenceShadow = {"_p_OSRSpatialReferenceShadow", "OSRSpatialReferenceShadow *", 0, 0, (void*)0, 0};
39992 : static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
39993 : static swig_type_info _swigt__p_char = {"_p_char", "char *|retStringAndCPLFree *", 0, 0, (void*)0, 0};
39994 : static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
39995 : static swig_type_info _swigt__p_f_double_p_q_const__char_p_void__int = {"_p_f_double_p_q_const__char_p_void__int", "int (*)(double,char const *,void *)", 0, 0, (void*)0, 0};
39996 : static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0};
39997 : static swig_type_info _swigt__p_int = {"_p_int", "OGRFieldSubType *|OSRAxisMappingStrategy *|OGRFieldDomainType *|OGRFieldType *|CPLErr *|int *|OGRwkbGeometryType *|OGRJustification *|OGRAxisOrientation *|OGRFieldDomainSplitPolicy *|OGRFieldDomainMergePolicy *|OGRwkbByteOrder *|OGRErr *", 0, 0, (void*)0, 0};
39998 : static swig_type_info _swigt__p_p_GIntBig = {"_p_p_GIntBig", "GIntBig **", 0, 0, (void*)0, 0};
39999 : static swig_type_info _swigt__p_p_OGRGeometryTypeCounter = {"_p_p_OGRGeometryTypeCounter", "OGRGeometryTypeCounter **", 0, 0, (void*)0, 0};
40000 : static swig_type_info _swigt__p_p_OGRSpatialReferenceH = {"_p_p_OGRSpatialReferenceH", "OGRSpatialReferenceH **", 0, 0, (void*)0, 0};
40001 : static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
40002 : static swig_type_info _swigt__p_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0};
40003 : static swig_type_info _swigt__p_p_int = {"_p_p_int", "int **", 0, 0, (void*)0, 0};
40004 : static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
40005 :
40006 : static swig_type_info *swig_type_initial[] = {
40007 : &_swigt__p_ArrowArray,
40008 : &_swigt__p_ArrowArrayStream,
40009 : &_swigt__p_ArrowSchema,
40010 : &_swigt__p_GDALDatasetShadow,
40011 : &_swigt__p_GDALDriverShadow,
40012 : &_swigt__p_GDALMajorObjectShadow,
40013 : &_swigt__p_GDALProgressFunc,
40014 : &_swigt__p_GIntBig,
40015 : &_swigt__p_OGRCodedValue,
40016 : &_swigt__p_OGRFeatureDefnShadow,
40017 : &_swigt__p_OGRFeatureShadow,
40018 : &_swigt__p_OGRFieldDefnShadow,
40019 : &_swigt__p_OGRFieldDomainShadow,
40020 : &_swigt__p_OGRGeomCoordinatePrecisionShadow,
40021 : &_swigt__p_OGRGeomFieldDefnShadow,
40022 : &_swigt__p_OGRGeomTransformerShadow,
40023 : &_swigt__p_OGRGeometryShadow,
40024 : &_swigt__p_OGRLayerShadow,
40025 : &_swigt__p_OGRPreparedGeometryShadow,
40026 : &_swigt__p_OGRStyleTableShadow,
40027 : &_swigt__p_OSRCoordinateTransformationShadow,
40028 : &_swigt__p_OSRSpatialReferenceShadow,
40029 : &_swigt__p_bool,
40030 : &_swigt__p_char,
40031 : &_swigt__p_double,
40032 : &_swigt__p_f_double_p_q_const__char_p_void__int,
40033 : &_swigt__p_float,
40034 : &_swigt__p_int,
40035 : &_swigt__p_p_GIntBig,
40036 : &_swigt__p_p_OGRGeometryTypeCounter,
40037 : &_swigt__p_p_OGRSpatialReferenceH,
40038 : &_swigt__p_p_char,
40039 : &_swigt__p_p_double,
40040 : &_swigt__p_p_int,
40041 : &_swigt__p_size_t,
40042 : };
40043 :
40044 : static swig_cast_info _swigc__p_ArrowArray[] = { {&_swigt__p_ArrowArray, 0, 0, 0},{0, 0, 0, 0}};
40045 : static swig_cast_info _swigc__p_ArrowArrayStream[] = { {&_swigt__p_ArrowArrayStream, 0, 0, 0},{0, 0, 0, 0}};
40046 : static swig_cast_info _swigc__p_ArrowSchema[] = { {&_swigt__p_ArrowSchema, 0, 0, 0},{0, 0, 0, 0}};
40047 : static swig_cast_info _swigc__p_GDALDatasetShadow[] = { {&_swigt__p_GDALDatasetShadow, 0, 0, 0},{0, 0, 0, 0}};
40048 : static swig_cast_info _swigc__p_GDALDriverShadow[] = { {&_swigt__p_GDALDriverShadow, 0, 0, 0},{0, 0, 0, 0}};
40049 : static swig_cast_info _swigc__p_GDALMajorObjectShadow[] = { {&_swigt__p_GDALMajorObjectShadow, 0, 0, 0}, {&_swigt__p_OGRLayerShadow, _p_OGRLayerShadowTo_p_GDALMajorObjectShadow, 0, 0},{0, 0, 0, 0}};
40050 : static swig_cast_info _swigc__p_GDALProgressFunc[] = { {&_swigt__p_GDALProgressFunc, 0, 0, 0},{0, 0, 0, 0}};
40051 : static swig_cast_info _swigc__p_GIntBig[] = { {&_swigt__p_GIntBig, 0, 0, 0},{0, 0, 0, 0}};
40052 : static swig_cast_info _swigc__p_OGRCodedValue[] = { {&_swigt__p_OGRCodedValue, 0, 0, 0},{0, 0, 0, 0}};
40053 : static swig_cast_info _swigc__p_OGRFeatureDefnShadow[] = { {&_swigt__p_OGRFeatureDefnShadow, 0, 0, 0},{0, 0, 0, 0}};
40054 : static swig_cast_info _swigc__p_OGRFeatureShadow[] = { {&_swigt__p_OGRFeatureShadow, 0, 0, 0},{0, 0, 0, 0}};
40055 : static swig_cast_info _swigc__p_OGRFieldDefnShadow[] = { {&_swigt__p_OGRFieldDefnShadow, 0, 0, 0},{0, 0, 0, 0}};
40056 : static swig_cast_info _swigc__p_OGRFieldDomainShadow[] = { {&_swigt__p_OGRFieldDomainShadow, 0, 0, 0},{0, 0, 0, 0}};
40057 : static swig_cast_info _swigc__p_OGRGeomCoordinatePrecisionShadow[] = { {&_swigt__p_OGRGeomCoordinatePrecisionShadow, 0, 0, 0},{0, 0, 0, 0}};
40058 : static swig_cast_info _swigc__p_OGRGeomFieldDefnShadow[] = { {&_swigt__p_OGRGeomFieldDefnShadow, 0, 0, 0},{0, 0, 0, 0}};
40059 : static swig_cast_info _swigc__p_OGRGeomTransformerShadow[] = { {&_swigt__p_OGRGeomTransformerShadow, 0, 0, 0},{0, 0, 0, 0}};
40060 : static swig_cast_info _swigc__p_OGRGeometryShadow[] = { {&_swigt__p_OGRGeometryShadow, 0, 0, 0},{0, 0, 0, 0}};
40061 : static swig_cast_info _swigc__p_OGRLayerShadow[] = { {&_swigt__p_OGRLayerShadow, 0, 0, 0},{0, 0, 0, 0}};
40062 : static swig_cast_info _swigc__p_OGRPreparedGeometryShadow[] = { {&_swigt__p_OGRPreparedGeometryShadow, 0, 0, 0},{0, 0, 0, 0}};
40063 : static swig_cast_info _swigc__p_OGRStyleTableShadow[] = { {&_swigt__p_OGRStyleTableShadow, 0, 0, 0},{0, 0, 0, 0}};
40064 : static swig_cast_info _swigc__p_OSRCoordinateTransformationShadow[] = { {&_swigt__p_OSRCoordinateTransformationShadow, 0, 0, 0},{0, 0, 0, 0}};
40065 : static swig_cast_info _swigc__p_OSRSpatialReferenceShadow[] = { {&_swigt__p_OSRSpatialReferenceShadow, 0, 0, 0},{0, 0, 0, 0}};
40066 : static swig_cast_info _swigc__p_bool[] = { {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
40067 : static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
40068 : static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
40069 : static swig_cast_info _swigc__p_f_double_p_q_const__char_p_void__int[] = { {&_swigt__p_f_double_p_q_const__char_p_void__int, 0, 0, 0},{0, 0, 0, 0}};
40070 : static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
40071 : static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
40072 : static swig_cast_info _swigc__p_p_GIntBig[] = { {&_swigt__p_p_GIntBig, 0, 0, 0},{0, 0, 0, 0}};
40073 : static swig_cast_info _swigc__p_p_OGRGeometryTypeCounter[] = { {&_swigt__p_p_OGRGeometryTypeCounter, 0, 0, 0},{0, 0, 0, 0}};
40074 : static swig_cast_info _swigc__p_p_OGRSpatialReferenceH[] = { {&_swigt__p_p_OGRSpatialReferenceH, 0, 0, 0},{0, 0, 0, 0}};
40075 : static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
40076 : static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
40077 : static swig_cast_info _swigc__p_p_int[] = { {&_swigt__p_p_int, 0, 0, 0},{0, 0, 0, 0}};
40078 : static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
40079 :
40080 : static swig_cast_info *swig_cast_initial[] = {
40081 : _swigc__p_ArrowArray,
40082 : _swigc__p_ArrowArrayStream,
40083 : _swigc__p_ArrowSchema,
40084 : _swigc__p_GDALDatasetShadow,
40085 : _swigc__p_GDALDriverShadow,
40086 : _swigc__p_GDALMajorObjectShadow,
40087 : _swigc__p_GDALProgressFunc,
40088 : _swigc__p_GIntBig,
40089 : _swigc__p_OGRCodedValue,
40090 : _swigc__p_OGRFeatureDefnShadow,
40091 : _swigc__p_OGRFeatureShadow,
40092 : _swigc__p_OGRFieldDefnShadow,
40093 : _swigc__p_OGRFieldDomainShadow,
40094 : _swigc__p_OGRGeomCoordinatePrecisionShadow,
40095 : _swigc__p_OGRGeomFieldDefnShadow,
40096 : _swigc__p_OGRGeomTransformerShadow,
40097 : _swigc__p_OGRGeometryShadow,
40098 : _swigc__p_OGRLayerShadow,
40099 : _swigc__p_OGRPreparedGeometryShadow,
40100 : _swigc__p_OGRStyleTableShadow,
40101 : _swigc__p_OSRCoordinateTransformationShadow,
40102 : _swigc__p_OSRSpatialReferenceShadow,
40103 : _swigc__p_bool,
40104 : _swigc__p_char,
40105 : _swigc__p_double,
40106 : _swigc__p_f_double_p_q_const__char_p_void__int,
40107 : _swigc__p_float,
40108 : _swigc__p_int,
40109 : _swigc__p_p_GIntBig,
40110 : _swigc__p_p_OGRGeometryTypeCounter,
40111 : _swigc__p_p_OGRSpatialReferenceH,
40112 : _swigc__p_p_char,
40113 : _swigc__p_p_double,
40114 : _swigc__p_p_int,
40115 : _swigc__p_size_t,
40116 : };
40117 :
40118 :
40119 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
40120 :
40121 : static swig_const_info swig_const_table[] = {
40122 : { SWIG_PY_POINTER, "TermProgress", 0, 0, (void *)((int (*)(double,char const *,void *))(GDALTermProgress)), &SWIGTYPE_p_f_double_p_q_const__char_p_void__int },
40123 : {0, 0, 0, 0.0, 0, 0}};
40124 :
40125 : #ifdef __cplusplus
40126 : }
40127 : #endif
40128 : /* -----------------------------------------------------------------------------
40129 : * Type initialization:
40130 : * This problem is tough by the requirement that no dynamic
40131 : * memory is used. Also, since swig_type_info structures store pointers to
40132 : * swig_cast_info structures and swig_cast_info structures store pointers back
40133 : * to swig_type_info structures, we need some lookup code at initialization.
40134 : * The idea is that swig generates all the structures that are needed.
40135 : * The runtime then collects these partially filled structures.
40136 : * The SWIG_InitializeModule function takes these initial arrays out of
40137 : * swig_module, and does all the lookup, filling in the swig_module.types
40138 : * array with the correct data and linking the correct swig_cast_info
40139 : * structures together.
40140 : *
40141 : * The generated swig_type_info structures are assigned statically to an initial
40142 : * array. We just loop through that array, and handle each type individually.
40143 : * First we lookup if this type has been already loaded, and if so, use the
40144 : * loaded structure instead of the generated one. Then we have to fill in the
40145 : * cast linked list. The cast data is initially stored in something like a
40146 : * two-dimensional array. Each row corresponds to a type (there are the same
40147 : * number of rows as there are in the swig_type_initial array). Each entry in
40148 : * a column is one of the swig_cast_info structures for that type.
40149 : * The cast_initial array is actually an array of arrays, because each row has
40150 : * a variable number of columns. So to actually build the cast linked list,
40151 : * we find the array of casts associated with the type, and loop through it
40152 : * adding the casts to the list. The one last trick we need to do is making
40153 : * sure the type pointer in the swig_cast_info struct is correct.
40154 : *
40155 : * First off, we lookup the cast->type name to see if it is already loaded.
40156 : * There are three cases to handle:
40157 : * 1) If the cast->type has already been loaded AND the type we are adding
40158 : * casting info to has not been loaded (it is in this module), THEN we
40159 : * replace the cast->type pointer with the type pointer that has already
40160 : * been loaded.
40161 : * 2) If BOTH types (the one we are adding casting info to, and the
40162 : * cast->type) are loaded, THEN the cast info has already been loaded by
40163 : * the previous module so we just ignore it.
40164 : * 3) Finally, if cast->type has not already been loaded, then we add that
40165 : * swig_cast_info to the linked list (because the cast->type) pointer will
40166 : * be correct.
40167 : * ----------------------------------------------------------------------------- */
40168 :
40169 : #ifdef __cplusplus
40170 : extern "C" {
40171 : #if 0
40172 : } /* c-mode */
40173 : #endif
40174 : #endif
40175 :
40176 : #if 0
40177 : #define SWIGRUNTIME_DEBUG
40178 : #endif
40179 :
40180 :
40181 : SWIGRUNTIME void
40182 : SWIG_InitializeModule(void *clientdata) {
40183 : size_t i;
40184 : swig_module_info *module_head, *iter;
40185 : int init;
40186 :
40187 : /* check to see if the circular list has been setup, if not, set it up */
40188 : if (swig_module.next==0) {
40189 : /* Initialize the swig_module */
40190 : swig_module.type_initial = swig_type_initial;
40191 : swig_module.cast_initial = swig_cast_initial;
40192 : swig_module.next = &swig_module;
40193 : init = 1;
40194 : } else {
40195 : init = 0;
40196 : }
40197 :
40198 : /* Try and load any already created modules */
40199 : module_head = SWIG_GetModule(clientdata);
40200 : if (!module_head) {
40201 : /* This is the first module loaded for this interpreter */
40202 : /* so set the swig module into the interpreter */
40203 : SWIG_SetModule(clientdata, &swig_module);
40204 : } else {
40205 : /* the interpreter has loaded a SWIG module, but has it loaded this one? */
40206 : iter=module_head;
40207 : do {
40208 : if (iter==&swig_module) {
40209 : /* Our module is already in the list, so there's nothing more to do. */
40210 : return;
40211 : }
40212 : iter=iter->next;
40213 : } while (iter!= module_head);
40214 :
40215 : /* otherwise we must add our module into the list */
40216 : swig_module.next = module_head->next;
40217 : module_head->next = &swig_module;
40218 : }
40219 :
40220 : /* When multiple interpreters are used, a module could have already been initialized in
40221 : a different interpreter, but not yet have a pointer in this interpreter.
40222 : In this case, we do not want to continue adding types... everything should be
40223 : set up already */
40224 : if (init == 0) return;
40225 :
40226 : /* Now work on filling in swig_module.types */
40227 : #ifdef SWIGRUNTIME_DEBUG
40228 : printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
40229 : #endif
40230 : for (i = 0; i < swig_module.size; ++i) {
40231 : swig_type_info *type = 0;
40232 : swig_type_info *ret;
40233 : swig_cast_info *cast;
40234 :
40235 : #ifdef SWIGRUNTIME_DEBUG
40236 : printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
40237 : #endif
40238 :
40239 : /* if there is another module already loaded */
40240 : if (swig_module.next != &swig_module) {
40241 : type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
40242 : }
40243 : if (type) {
40244 : /* Overwrite clientdata field */
40245 : #ifdef SWIGRUNTIME_DEBUG
40246 : printf("SWIG_InitializeModule: found type %s\n", type->name);
40247 : #endif
40248 : if (swig_module.type_initial[i]->clientdata) {
40249 : type->clientdata = swig_module.type_initial[i]->clientdata;
40250 : #ifdef SWIGRUNTIME_DEBUG
40251 : printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
40252 : #endif
40253 : }
40254 : } else {
40255 : type = swig_module.type_initial[i];
40256 : }
40257 :
40258 : /* Insert casting types */
40259 : cast = swig_module.cast_initial[i];
40260 : while (cast->type) {
40261 : /* Don't need to add information already in the list */
40262 : ret = 0;
40263 : #ifdef SWIGRUNTIME_DEBUG
40264 : printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
40265 : #endif
40266 : if (swig_module.next != &swig_module) {
40267 : ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
40268 : #ifdef SWIGRUNTIME_DEBUG
40269 : if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
40270 : #endif
40271 : }
40272 : if (ret) {
40273 : if (type == swig_module.type_initial[i]) {
40274 : #ifdef SWIGRUNTIME_DEBUG
40275 : printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
40276 : #endif
40277 : cast->type = ret;
40278 : ret = 0;
40279 : } else {
40280 : /* Check for casting already in the list */
40281 : swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
40282 : #ifdef SWIGRUNTIME_DEBUG
40283 : if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
40284 : #endif
40285 : if (!ocast) ret = 0;
40286 : }
40287 : }
40288 :
40289 : if (!ret) {
40290 : #ifdef SWIGRUNTIME_DEBUG
40291 : printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
40292 : #endif
40293 : if (type->cast) {
40294 : type->cast->prev = cast;
40295 : cast->next = type->cast;
40296 : }
40297 : type->cast = cast;
40298 : }
40299 : cast++;
40300 : }
40301 : /* Set entry in modules->types array equal to the type */
40302 : swig_module.types[i] = type;
40303 : }
40304 : swig_module.types[i] = 0;
40305 :
40306 : #ifdef SWIGRUNTIME_DEBUG
40307 : printf("**** SWIG_InitializeModule: Cast List ******\n");
40308 : for (i = 0; i < swig_module.size; ++i) {
40309 : int j = 0;
40310 : swig_cast_info *cast = swig_module.cast_initial[i];
40311 : printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
40312 : while (cast->type) {
40313 : printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
40314 : cast++;
40315 : ++j;
40316 : }
40317 : printf("---- Total casts: %d\n",j);
40318 : }
40319 : printf("**** SWIG_InitializeModule: Cast List ******\n");
40320 : #endif
40321 : }
40322 :
40323 : /* This function will propagate the clientdata field of type to
40324 : * any new swig_type_info structures that have been added into the list
40325 : * of equivalent types. It is like calling
40326 : * SWIG_TypeClientData(type, clientdata) a second time.
40327 : */
40328 : SWIGRUNTIME void
40329 : SWIG_PropagateClientData(void) {
40330 : size_t i;
40331 : swig_cast_info *equiv;
40332 : static int init_run = 0;
40333 :
40334 : if (init_run) return;
40335 : init_run = 1;
40336 :
40337 : for (i = 0; i < swig_module.size; i++) {
40338 : if (swig_module.types[i]->clientdata) {
40339 : equiv = swig_module.types[i]->cast;
40340 : while (equiv) {
40341 : if (!equiv->converter) {
40342 : if (equiv->type && !equiv->type->clientdata)
40343 : SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
40344 : }
40345 : equiv = equiv->next;
40346 : }
40347 : }
40348 : }
40349 : }
40350 :
40351 : #ifdef __cplusplus
40352 : #if 0
40353 : {
40354 : /* c-mode */
40355 : #endif
40356 : }
40357 : #endif
40358 :
40359 :
40360 :
40361 : #ifdef __cplusplus
40362 : extern "C" {
40363 : #endif
40364 :
40365 : /* Python-specific SWIG API */
40366 : #define SWIG_newvarlink() SWIG_Python_newvarlink()
40367 : #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
40368 : #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
40369 :
40370 : /* -----------------------------------------------------------------------------
40371 : * global variable support code.
40372 : * ----------------------------------------------------------------------------- */
40373 :
40374 : typedef struct swig_globalvar {
40375 : char *name; /* Name of global variable */
40376 : PyObject *(*get_attr)(void); /* Return the current value */
40377 : int (*set_attr)(PyObject *); /* Set the value */
40378 : struct swig_globalvar *next;
40379 : } swig_globalvar;
40380 :
40381 : typedef struct swig_varlinkobject {
40382 : PyObject_HEAD
40383 : swig_globalvar *vars;
40384 : } swig_varlinkobject;
40385 :
40386 : SWIGINTERN PyObject *
40387 : swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
40388 : #if PY_VERSION_HEX >= 0x03000000
40389 : return PyUnicode_InternFromString("<Swig global variables>");
40390 : #else
40391 : return PyString_FromString("<Swig global variables>");
40392 : #endif
40393 : }
40394 :
40395 : SWIGINTERN PyObject *
40396 : swig_varlink_str(swig_varlinkobject *v) {
40397 : #if PY_VERSION_HEX >= 0x03000000
40398 : PyObject *str = PyUnicode_InternFromString("(");
40399 : PyObject *tail;
40400 : PyObject *joined;
40401 : swig_globalvar *var;
40402 : for (var = v->vars; var; var=var->next) {
40403 : tail = PyUnicode_FromString(var->name);
40404 : joined = PyUnicode_Concat(str, tail);
40405 : Py_DecRef(str);
40406 : Py_DecRef(tail);
40407 : str = joined;
40408 : if (var->next) {
40409 : tail = PyUnicode_InternFromString(", ");
40410 : joined = PyUnicode_Concat(str, tail);
40411 : Py_DecRef(str);
40412 : Py_DecRef(tail);
40413 : str = joined;
40414 : }
40415 : }
40416 : tail = PyUnicode_InternFromString(")");
40417 : joined = PyUnicode_Concat(str, tail);
40418 : Py_DecRef(str);
40419 : Py_DecRef(tail);
40420 : str = joined;
40421 : #else
40422 : PyObject *str = PyString_FromString("(");
40423 : swig_globalvar *var;
40424 : for (var = v->vars; var; var=var->next) {
40425 : PyString_ConcatAndDel(&str,PyString_FromString(var->name));
40426 : if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
40427 : }
40428 : PyString_ConcatAndDel(&str,PyString_FromString(")"));
40429 : #endif
40430 : return str;
40431 : }
40432 :
40433 : SWIGINTERN void
40434 : swig_varlink_dealloc(swig_varlinkobject *v) {
40435 : swig_globalvar *var = v->vars;
40436 : while (var) {
40437 : swig_globalvar *n = var->next;
40438 : free(var->name);
40439 : free(var);
40440 : var = n;
40441 : }
40442 : }
40443 :
40444 : SWIGINTERN PyObject *
40445 : swig_varlink_getattr(swig_varlinkobject *v, char *n) {
40446 : PyObject *res = NULL;
40447 : swig_globalvar *var = v->vars;
40448 : while (var) {
40449 : if (strcmp(var->name,n) == 0) {
40450 : res = (*var->get_attr)();
40451 : break;
40452 : }
40453 : var = var->next;
40454 : }
40455 : if (res == NULL && !PyErr_Occurred()) {
40456 : PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
40457 : }
40458 : return res;
40459 : }
40460 :
40461 : SWIGINTERN int
40462 : swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
40463 : int res = 1;
40464 : swig_globalvar *var = v->vars;
40465 : while (var) {
40466 : if (strcmp(var->name,n) == 0) {
40467 : res = (*var->set_attr)(p);
40468 : break;
40469 : }
40470 : var = var->next;
40471 : }
40472 : if (res == 1 && !PyErr_Occurred()) {
40473 : PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
40474 : }
40475 : return res;
40476 : }
40477 :
40478 : SWIGINTERN PyTypeObject*
40479 : swig_varlink_type(void) {
40480 : static char varlink__doc__[] = "Swig var link object";
40481 : static PyTypeObject varlink_type;
40482 : static int type_init = 0;
40483 : if (!type_init) {
40484 : const PyTypeObject tmp = {
40485 : #if PY_VERSION_HEX >= 0x03000000
40486 : PyVarObject_HEAD_INIT(NULL, 0)
40487 : #else
40488 : PyObject_HEAD_INIT(NULL)
40489 : 0, /* ob_size */
40490 : #endif
40491 : "swigvarlink", /* tp_name */
40492 : sizeof(swig_varlinkobject), /* tp_basicsize */
40493 : 0, /* tp_itemsize */
40494 : (destructor) swig_varlink_dealloc, /* tp_dealloc */
40495 : 0, /* tp_print */
40496 : (getattrfunc) swig_varlink_getattr, /* tp_getattr */
40497 : (setattrfunc) swig_varlink_setattr, /* tp_setattr */
40498 : 0, /* tp_compare */
40499 : (reprfunc) swig_varlink_repr, /* tp_repr */
40500 : 0, /* tp_as_number */
40501 : 0, /* tp_as_sequence */
40502 : 0, /* tp_as_mapping */
40503 : 0, /* tp_hash */
40504 : 0, /* tp_call */
40505 : (reprfunc) swig_varlink_str, /* tp_str */
40506 : 0, /* tp_getattro */
40507 : 0, /* tp_setattro */
40508 : 0, /* tp_as_buffer */
40509 : 0, /* tp_flags */
40510 : varlink__doc__, /* tp_doc */
40511 : 0, /* tp_traverse */
40512 : 0, /* tp_clear */
40513 : 0, /* tp_richcompare */
40514 : 0, /* tp_weaklistoffset */
40515 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
40516 : 0, /* tp_del */
40517 : 0, /* tp_version_tag */
40518 : #if PY_VERSION_HEX >= 0x03040000
40519 : 0, /* tp_finalize */
40520 : #endif
40521 : #ifdef COUNT_ALLOCS
40522 : 0, /* tp_allocs */
40523 : 0, /* tp_frees */
40524 : 0, /* tp_maxalloc */
40525 : 0, /* tp_prev */
40526 : 0 /* tp_next */
40527 : #endif
40528 : };
40529 : varlink_type = tmp;
40530 : type_init = 1;
40531 : if (PyType_Ready(&varlink_type) < 0)
40532 : return NULL;
40533 : }
40534 : return &varlink_type;
40535 : }
40536 :
40537 : /* Create a variable linking object for use later */
40538 : SWIGINTERN PyObject *
40539 : SWIG_Python_newvarlink(void) {
40540 : swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
40541 : if (result) {
40542 : result->vars = 0;
40543 : }
40544 : return ((PyObject*) result);
40545 : }
40546 :
40547 : SWIGINTERN void
40548 : SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
40549 : swig_varlinkobject *v = (swig_varlinkobject *) p;
40550 : swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
40551 : if (gv) {
40552 : size_t size = strlen(name)+1;
40553 : gv->name = (char *)malloc(size);
40554 : if (gv->name) {
40555 : memcpy(gv->name, name, size);
40556 : gv->get_attr = get_attr;
40557 : gv->set_attr = set_attr;
40558 : gv->next = v->vars;
40559 : }
40560 : }
40561 : v->vars = gv;
40562 : }
40563 :
40564 : SWIGINTERN PyObject *
40565 : SWIG_globals(void) {
40566 : static PyObject *globals = 0;
40567 : if (!globals) {
40568 : globals = SWIG_newvarlink();
40569 : }
40570 : return globals;
40571 : }
40572 :
40573 : /* -----------------------------------------------------------------------------
40574 : * constants/methods manipulation
40575 : * ----------------------------------------------------------------------------- */
40576 :
40577 : /* Install Constants */
40578 : SWIGINTERN void
40579 273 : SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
40580 273 : PyObject *obj = 0;
40581 273 : size_t i;
40582 546 : for (i = 0; constants[i].type; ++i) {
40583 273 : switch(constants[i].type) {
40584 273 : case SWIG_PY_POINTER:
40585 273 : obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
40586 273 : break;
40587 0 : case SWIG_PY_BINARY:
40588 0 : obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
40589 : break;
40590 : default:
40591 : obj = 0;
40592 : break;
40593 : }
40594 273 : if (obj) {
40595 273 : PyDict_SetItemString(d, constants[i].name, obj);
40596 273 : Py_DECREF(obj);
40597 : }
40598 : }
40599 273 : }
40600 :
40601 : /* -----------------------------------------------------------------------------*/
40602 : /* Fix SwigMethods to carry the callback ptrs when needed */
40603 : /* -----------------------------------------------------------------------------*/
40604 :
40605 : SWIGINTERN void
40606 273 : SWIG_Python_FixMethods(PyMethodDef *methods,
40607 : swig_const_info *const_table,
40608 : swig_type_info **types,
40609 : swig_type_info **types_initial) {
40610 273 : size_t i;
40611 119574 : for (i = 0; methods[i].ml_name; ++i) {
40612 119301 : const char *c = methods[i].ml_doc;
40613 119301 : if (!c) continue;
40614 112476 : c = strstr(c, "swig_ptr: ");
40615 112476 : if (c) {
40616 0 : int j;
40617 0 : swig_const_info *ci = 0;
40618 0 : const char *name = c + 10;
40619 0 : for (j = 0; const_table[j].type; ++j) {
40620 0 : if (strncmp(const_table[j].name, name,
40621 : strlen(const_table[j].name)) == 0) {
40622 : ci = &(const_table[j]);
40623 : break;
40624 : }
40625 : }
40626 0 : if (ci) {
40627 119301 : void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
40628 0 : if (ptr) {
40629 0 : size_t shift = (ci->ptype) - types;
40630 0 : swig_type_info *ty = types_initial[shift];
40631 0 : size_t ldoc = (c - methods[i].ml_doc);
40632 0 : size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
40633 0 : char *ndoc = (char*)malloc(ldoc + lptr + 10);
40634 0 : if (ndoc) {
40635 0 : char *buff = ndoc;
40636 0 : memcpy(buff, methods[i].ml_doc, ldoc);
40637 0 : buff += ldoc;
40638 0 : memcpy(buff, "swig_ptr: ", 10);
40639 0 : buff += 10;
40640 0 : SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
40641 0 : methods[i].ml_doc = ndoc;
40642 : }
40643 : }
40644 : }
40645 : }
40646 : }
40647 273 : }
40648 :
40649 : /* -----------------------------------------------------------------------------
40650 : * Method creation and docstring support functions
40651 : * ----------------------------------------------------------------------------- */
40652 :
40653 : /* -----------------------------------------------------------------------------
40654 : * Function to find the method definition with the correct docstring for the
40655 : * proxy module as opposed to the low-level API
40656 : * ----------------------------------------------------------------------------- */
40657 :
40658 0 : SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
40659 : /* Find the function in the modified method table */
40660 0 : size_t offset = 0;
40661 0 : int found = 0;
40662 0 : while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
40663 0 : if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
40664 : found = 1;
40665 : break;
40666 : }
40667 0 : offset++;
40668 : }
40669 : /* Use the copy with the modified docstring if available */
40670 0 : return found ? &SwigMethods_proxydocs[offset] : NULL;
40671 : }
40672 :
40673 : /* -----------------------------------------------------------------------------
40674 : * Wrapper of PyInstanceMethod_New() used in Python 3
40675 : * It is exported to the generated module, used for -fastproxy
40676 : * ----------------------------------------------------------------------------- */
40677 :
40678 0 : SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
40679 0 : if (PyCFunction_Check(func)) {
40680 0 : PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
40681 0 : PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
40682 0 : if (ml)
40683 0 : func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
40684 : }
40685 : #if PY_VERSION_HEX >= 0x03000000
40686 0 : return PyInstanceMethod_New(func);
40687 : #else
40688 : return PyMethod_New(func, NULL, NULL);
40689 : #endif
40690 : }
40691 :
40692 : /* -----------------------------------------------------------------------------
40693 : * Wrapper of PyStaticMethod_New()
40694 : * It is exported to the generated module, used for -fastproxy
40695 : * ----------------------------------------------------------------------------- */
40696 :
40697 : SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
40698 : if (PyCFunction_Check(func)) {
40699 : PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
40700 : PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
40701 : if (ml)
40702 : func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
40703 : }
40704 : return PyStaticMethod_New(func);
40705 : }
40706 :
40707 : #ifdef __cplusplus
40708 : }
40709 : #endif
40710 :
40711 : /* -----------------------------------------------------------------------------*
40712 : * Partial Init method
40713 : * -----------------------------------------------------------------------------*/
40714 :
40715 : #ifdef __cplusplus
40716 : extern "C"
40717 : #endif
40718 :
40719 : SWIGEXPORT
40720 : #if PY_VERSION_HEX >= 0x03000000
40721 : PyObject*
40722 : #else
40723 : void
40724 : #endif
40725 273 : SWIG_init(void) {
40726 273 : PyObject *m, *d, *md, *globals;
40727 :
40728 : #if PY_VERSION_HEX >= 0x03000000
40729 273 : static struct PyModuleDef SWIG_module = {
40730 : PyModuleDef_HEAD_INIT,
40731 : SWIG_name,
40732 : NULL,
40733 : -1,
40734 : SwigMethods,
40735 : NULL,
40736 : NULL,
40737 : NULL,
40738 : NULL
40739 : };
40740 : #endif
40741 :
40742 : #if defined(SWIGPYTHON_BUILTIN)
40743 : static SwigPyClientData SwigPyObject_clientdata = {
40744 : 0, 0, 0, 0, 0, 0, 0
40745 : };
40746 : static PyGetSetDef this_getset_def = {
40747 : (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
40748 : };
40749 : static SwigPyGetSet thisown_getset_closure = {
40750 : SwigPyObject_own,
40751 : SwigPyObject_own
40752 : };
40753 : static PyGetSetDef thisown_getset_def = {
40754 : (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
40755 : };
40756 : PyTypeObject *builtin_pytype;
40757 : int builtin_base_count;
40758 : swig_type_info *builtin_basetype;
40759 : PyObject *tuple;
40760 : PyGetSetDescrObject *static_getset;
40761 : PyTypeObject *metatype;
40762 : PyTypeObject *swigpyobject;
40763 : SwigPyClientData *cd;
40764 : PyObject *public_interface, *public_symbol;
40765 : PyObject *this_descr;
40766 : PyObject *thisown_descr;
40767 : PyObject *self = 0;
40768 : int i;
40769 :
40770 : (void)builtin_pytype;
40771 : (void)builtin_base_count;
40772 : (void)builtin_basetype;
40773 : (void)tuple;
40774 : (void)static_getset;
40775 : (void)self;
40776 :
40777 : /* Metaclass is used to implement static member variables */
40778 : metatype = SwigPyObjectType();
40779 : assert(metatype);
40780 : #endif
40781 :
40782 273 : (void)globals;
40783 :
40784 : /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
40785 273 : SWIG_This();
40786 273 : SWIG_Python_TypeCache();
40787 273 : SwigPyPacked_type();
40788 : #ifndef SWIGPYTHON_BUILTIN
40789 273 : SwigPyObject_type();
40790 : #endif
40791 :
40792 : /* Fix SwigMethods to carry the callback ptrs when needed */
40793 273 : SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
40794 :
40795 : #if PY_VERSION_HEX >= 0x03000000
40796 273 : m = PyModule_Create(&SWIG_module);
40797 : #else
40798 : m = Py_InitModule(SWIG_name, SwigMethods);
40799 : #endif
40800 :
40801 273 : md = d = PyModule_GetDict(m);
40802 273 : (void)md;
40803 :
40804 273 : SWIG_InitializeModule(0);
40805 :
40806 : #ifdef SWIGPYTHON_BUILTIN
40807 : swigpyobject = SwigPyObject_TypeOnce();
40808 :
40809 : SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
40810 : assert(SwigPyObject_stype);
40811 : cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
40812 : if (!cd) {
40813 : SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
40814 : SwigPyObject_clientdata.pytype = swigpyobject;
40815 : } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
40816 : PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
40817 : # if PY_VERSION_HEX >= 0x03000000
40818 : return NULL;
40819 : # else
40820 : return;
40821 : # endif
40822 : }
40823 :
40824 : /* All objects have a 'this' attribute */
40825 : this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
40826 : (void)this_descr;
40827 :
40828 : /* All objects have a 'thisown' attribute */
40829 : thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
40830 : (void)thisown_descr;
40831 :
40832 : public_interface = PyList_New(0);
40833 : public_symbol = 0;
40834 : (void)public_symbol;
40835 :
40836 : PyDict_SetItemString(md, "__all__", public_interface);
40837 : Py_DECREF(public_interface);
40838 : for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
40839 : SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
40840 : for (i = 0; swig_const_table[i].name != 0; ++i)
40841 : SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
40842 : #endif
40843 :
40844 273 : SWIG_InstallConstants(d,swig_const_table);
40845 :
40846 273 : SWIG_Python_SetConstant(d, "wkb25DBit",SWIG_From_int(static_cast< int >(0x80000000)));
40847 273 : SWIG_Python_SetConstant(d, "wkb25Bit",SWIG_From_int(static_cast< int >(0x80000000)));
40848 273 : SWIG_Python_SetConstant(d, "wkbUnknown",SWIG_From_int(static_cast< int >(0)));
40849 273 : SWIG_Python_SetConstant(d, "wkbPoint",SWIG_From_int(static_cast< int >(1)));
40850 273 : SWIG_Python_SetConstant(d, "wkbLineString",SWIG_From_int(static_cast< int >(2)));
40851 273 : SWIG_Python_SetConstant(d, "wkbPolygon",SWIG_From_int(static_cast< int >(3)));
40852 273 : SWIG_Python_SetConstant(d, "wkbMultiPoint",SWIG_From_int(static_cast< int >(4)));
40853 273 : SWIG_Python_SetConstant(d, "wkbMultiLineString",SWIG_From_int(static_cast< int >(5)));
40854 273 : SWIG_Python_SetConstant(d, "wkbMultiPolygon",SWIG_From_int(static_cast< int >(6)));
40855 273 : SWIG_Python_SetConstant(d, "wkbGeometryCollection",SWIG_From_int(static_cast< int >(7)));
40856 273 : SWIG_Python_SetConstant(d, "wkbCircularString",SWIG_From_int(static_cast< int >(8)));
40857 273 : SWIG_Python_SetConstant(d, "wkbCompoundCurve",SWIG_From_int(static_cast< int >(9)));
40858 273 : SWIG_Python_SetConstant(d, "wkbCurvePolygon",SWIG_From_int(static_cast< int >(10)));
40859 273 : SWIG_Python_SetConstant(d, "wkbMultiCurve",SWIG_From_int(static_cast< int >(11)));
40860 273 : SWIG_Python_SetConstant(d, "wkbMultiSurface",SWIG_From_int(static_cast< int >(12)));
40861 273 : SWIG_Python_SetConstant(d, "wkbCurve",SWIG_From_int(static_cast< int >(13)));
40862 273 : SWIG_Python_SetConstant(d, "wkbSurface",SWIG_From_int(static_cast< int >(14)));
40863 273 : SWIG_Python_SetConstant(d, "wkbPolyhedralSurface",SWIG_From_int(static_cast< int >(15)));
40864 273 : SWIG_Python_SetConstant(d, "wkbTIN",SWIG_From_int(static_cast< int >(16)));
40865 273 : SWIG_Python_SetConstant(d, "wkbTriangle",SWIG_From_int(static_cast< int >(17)));
40866 273 : SWIG_Python_SetConstant(d, "wkbNone",SWIG_From_int(static_cast< int >(100)));
40867 273 : SWIG_Python_SetConstant(d, "wkbLinearRing",SWIG_From_int(static_cast< int >(101)));
40868 273 : SWIG_Python_SetConstant(d, "wkbCircularStringZ",SWIG_From_int(static_cast< int >(1008)));
40869 273 : SWIG_Python_SetConstant(d, "wkbCompoundCurveZ",SWIG_From_int(static_cast< int >(1009)));
40870 273 : SWIG_Python_SetConstant(d, "wkbCurvePolygonZ",SWIG_From_int(static_cast< int >(1010)));
40871 273 : SWIG_Python_SetConstant(d, "wkbMultiCurveZ",SWIG_From_int(static_cast< int >(1011)));
40872 273 : SWIG_Python_SetConstant(d, "wkbMultiSurfaceZ",SWIG_From_int(static_cast< int >(1012)));
40873 273 : SWIG_Python_SetConstant(d, "wkbCurveZ",SWIG_From_int(static_cast< int >(1013)));
40874 273 : SWIG_Python_SetConstant(d, "wkbSurfaceZ",SWIG_From_int(static_cast< int >(1014)));
40875 273 : SWIG_Python_SetConstant(d, "wkbPolyhedralSurfaceZ",SWIG_From_int(static_cast< int >(1015)));
40876 273 : SWIG_Python_SetConstant(d, "wkbTINZ",SWIG_From_int(static_cast< int >(1016)));
40877 273 : SWIG_Python_SetConstant(d, "wkbTriangleZ",SWIG_From_int(static_cast< int >(1017)));
40878 273 : SWIG_Python_SetConstant(d, "wkbPointM",SWIG_From_int(static_cast< int >(2001)));
40879 273 : SWIG_Python_SetConstant(d, "wkbLineStringM",SWIG_From_int(static_cast< int >(2002)));
40880 273 : SWIG_Python_SetConstant(d, "wkbPolygonM",SWIG_From_int(static_cast< int >(2003)));
40881 273 : SWIG_Python_SetConstant(d, "wkbMultiPointM",SWIG_From_int(static_cast< int >(2004)));
40882 273 : SWIG_Python_SetConstant(d, "wkbMultiLineStringM",SWIG_From_int(static_cast< int >(2005)));
40883 273 : SWIG_Python_SetConstant(d, "wkbMultiPolygonM",SWIG_From_int(static_cast< int >(2006)));
40884 273 : SWIG_Python_SetConstant(d, "wkbGeometryCollectionM",SWIG_From_int(static_cast< int >(2007)));
40885 273 : SWIG_Python_SetConstant(d, "wkbCircularStringM",SWIG_From_int(static_cast< int >(2008)));
40886 273 : SWIG_Python_SetConstant(d, "wkbCompoundCurveM",SWIG_From_int(static_cast< int >(2009)));
40887 273 : SWIG_Python_SetConstant(d, "wkbCurvePolygonM",SWIG_From_int(static_cast< int >(2010)));
40888 273 : SWIG_Python_SetConstant(d, "wkbMultiCurveM",SWIG_From_int(static_cast< int >(2011)));
40889 273 : SWIG_Python_SetConstant(d, "wkbMultiSurfaceM",SWIG_From_int(static_cast< int >(2012)));
40890 273 : SWIG_Python_SetConstant(d, "wkbCurveM",SWIG_From_int(static_cast< int >(2013)));
40891 273 : SWIG_Python_SetConstant(d, "wkbSurfaceM",SWIG_From_int(static_cast< int >(2014)));
40892 273 : SWIG_Python_SetConstant(d, "wkbPolyhedralSurfaceM",SWIG_From_int(static_cast< int >(2015)));
40893 273 : SWIG_Python_SetConstant(d, "wkbTINM",SWIG_From_int(static_cast< int >(2016)));
40894 273 : SWIG_Python_SetConstant(d, "wkbTriangleM",SWIG_From_int(static_cast< int >(2017)));
40895 273 : SWIG_Python_SetConstant(d, "wkbPointZM",SWIG_From_int(static_cast< int >(3001)));
40896 273 : SWIG_Python_SetConstant(d, "wkbLineStringZM",SWIG_From_int(static_cast< int >(3002)));
40897 273 : SWIG_Python_SetConstant(d, "wkbPolygonZM",SWIG_From_int(static_cast< int >(3003)));
40898 273 : SWIG_Python_SetConstant(d, "wkbMultiPointZM",SWIG_From_int(static_cast< int >(3004)));
40899 273 : SWIG_Python_SetConstant(d, "wkbMultiLineStringZM",SWIG_From_int(static_cast< int >(3005)));
40900 273 : SWIG_Python_SetConstant(d, "wkbMultiPolygonZM",SWIG_From_int(static_cast< int >(3006)));
40901 273 : SWIG_Python_SetConstant(d, "wkbGeometryCollectionZM",SWIG_From_int(static_cast< int >(3007)));
40902 273 : SWIG_Python_SetConstant(d, "wkbCircularStringZM",SWIG_From_int(static_cast< int >(3008)));
40903 273 : SWIG_Python_SetConstant(d, "wkbCompoundCurveZM",SWIG_From_int(static_cast< int >(3009)));
40904 273 : SWIG_Python_SetConstant(d, "wkbCurvePolygonZM",SWIG_From_int(static_cast< int >(3010)));
40905 273 : SWIG_Python_SetConstant(d, "wkbMultiCurveZM",SWIG_From_int(static_cast< int >(3011)));
40906 273 : SWIG_Python_SetConstant(d, "wkbMultiSurfaceZM",SWIG_From_int(static_cast< int >(3012)));
40907 273 : SWIG_Python_SetConstant(d, "wkbCurveZM",SWIG_From_int(static_cast< int >(3013)));
40908 273 : SWIG_Python_SetConstant(d, "wkbSurfaceZM",SWIG_From_int(static_cast< int >(3014)));
40909 273 : SWIG_Python_SetConstant(d, "wkbPolyhedralSurfaceZM",SWIG_From_int(static_cast< int >(3015)));
40910 273 : SWIG_Python_SetConstant(d, "wkbTINZM",SWIG_From_int(static_cast< int >(3016)));
40911 273 : SWIG_Python_SetConstant(d, "wkbTriangleZM",SWIG_From_int(static_cast< int >(3017)));
40912 273 : SWIG_Python_SetConstant(d, "wkbPoint25D",SWIG_From_int(static_cast< int >(0x80000001)));
40913 273 : SWIG_Python_SetConstant(d, "wkbLineString25D",SWIG_From_int(static_cast< int >(0x80000002)));
40914 273 : SWIG_Python_SetConstant(d, "wkbPolygon25D",SWIG_From_int(static_cast< int >(0x80000003)));
40915 273 : SWIG_Python_SetConstant(d, "wkbMultiPoint25D",SWIG_From_int(static_cast< int >(0x80000004)));
40916 273 : SWIG_Python_SetConstant(d, "wkbMultiLineString25D",SWIG_From_int(static_cast< int >(0x80000005)));
40917 273 : SWIG_Python_SetConstant(d, "wkbMultiPolygon25D",SWIG_From_int(static_cast< int >(0x80000006)));
40918 273 : SWIG_Python_SetConstant(d, "wkbGeometryCollection25D",SWIG_From_int(static_cast< int >(0x80000007)));
40919 273 : SWIG_Python_SetConstant(d, "OFTInteger",SWIG_From_int(static_cast< int >(0)));
40920 273 : SWIG_Python_SetConstant(d, "OFTIntegerList",SWIG_From_int(static_cast< int >(1)));
40921 273 : SWIG_Python_SetConstant(d, "OFTReal",SWIG_From_int(static_cast< int >(2)));
40922 273 : SWIG_Python_SetConstant(d, "OFTRealList",SWIG_From_int(static_cast< int >(3)));
40923 273 : SWIG_Python_SetConstant(d, "OFTString",SWIG_From_int(static_cast< int >(4)));
40924 273 : SWIG_Python_SetConstant(d, "OFTStringList",SWIG_From_int(static_cast< int >(5)));
40925 273 : SWIG_Python_SetConstant(d, "OFTWideString",SWIG_From_int(static_cast< int >(6)));
40926 273 : SWIG_Python_SetConstant(d, "OFTWideStringList",SWIG_From_int(static_cast< int >(7)));
40927 273 : SWIG_Python_SetConstant(d, "OFTBinary",SWIG_From_int(static_cast< int >(8)));
40928 273 : SWIG_Python_SetConstant(d, "OFTDate",SWIG_From_int(static_cast< int >(9)));
40929 273 : SWIG_Python_SetConstant(d, "OFTTime",SWIG_From_int(static_cast< int >(10)));
40930 273 : SWIG_Python_SetConstant(d, "OFTDateTime",SWIG_From_int(static_cast< int >(11)));
40931 273 : SWIG_Python_SetConstant(d, "OFTInteger64",SWIG_From_int(static_cast< int >(12)));
40932 273 : SWIG_Python_SetConstant(d, "OFTInteger64List",SWIG_From_int(static_cast< int >(13)));
40933 273 : SWIG_Python_SetConstant(d, "OFSTNone",SWIG_From_int(static_cast< int >(0)));
40934 273 : SWIG_Python_SetConstant(d, "OFSTBoolean",SWIG_From_int(static_cast< int >(1)));
40935 273 : SWIG_Python_SetConstant(d, "OFSTInt16",SWIG_From_int(static_cast< int >(2)));
40936 273 : SWIG_Python_SetConstant(d, "OFSTFloat32",SWIG_From_int(static_cast< int >(3)));
40937 273 : SWIG_Python_SetConstant(d, "OFSTJSON",SWIG_From_int(static_cast< int >(4)));
40938 273 : SWIG_Python_SetConstant(d, "OFSTUUID",SWIG_From_int(static_cast< int >(5)));
40939 273 : SWIG_Python_SetConstant(d, "OJUndefined",SWIG_From_int(static_cast< int >(0)));
40940 273 : SWIG_Python_SetConstant(d, "OJLeft",SWIG_From_int(static_cast< int >(1)));
40941 273 : SWIG_Python_SetConstant(d, "OJRight",SWIG_From_int(static_cast< int >(2)));
40942 273 : SWIG_Python_SetConstant(d, "OFDT_CODED",SWIG_From_int(static_cast< int >(0)));
40943 273 : SWIG_Python_SetConstant(d, "OFDT_RANGE",SWIG_From_int(static_cast< int >(1)));
40944 273 : SWIG_Python_SetConstant(d, "OFDT_GLOB",SWIG_From_int(static_cast< int >(2)));
40945 273 : SWIG_Python_SetConstant(d, "OFDSP_DEFAULT_VALUE",SWIG_From_int(static_cast< int >(0)));
40946 273 : SWIG_Python_SetConstant(d, "OFDSP_DUPLICATE",SWIG_From_int(static_cast< int >(1)));
40947 273 : SWIG_Python_SetConstant(d, "OFDSP_GEOMETRY_RATIO",SWIG_From_int(static_cast< int >(2)));
40948 273 : SWIG_Python_SetConstant(d, "OFDMP_DEFAULT_VALUE",SWIG_From_int(static_cast< int >(0)));
40949 273 : SWIG_Python_SetConstant(d, "OFDMP_SUM",SWIG_From_int(static_cast< int >(1)));
40950 273 : SWIG_Python_SetConstant(d, "OFDMP_GEOMETRY_WEIGHTED",SWIG_From_int(static_cast< int >(2)));
40951 273 : SWIG_Python_SetConstant(d, "wkbXDR",SWIG_From_int(static_cast< int >(0)));
40952 273 : SWIG_Python_SetConstant(d, "wkbNDR",SWIG_From_int(static_cast< int >(1)));
40953 273 : SWIG_Python_SetConstant(d, "NullFID",SWIG_From_int(static_cast< int >(-1)));
40954 273 : SWIG_Python_SetConstant(d, "ALTER_NAME_FLAG",SWIG_From_int(static_cast< int >(1)));
40955 273 : SWIG_Python_SetConstant(d, "ALTER_TYPE_FLAG",SWIG_From_int(static_cast< int >(2)));
40956 273 : SWIG_Python_SetConstant(d, "ALTER_WIDTH_PRECISION_FLAG",SWIG_From_int(static_cast< int >(4)));
40957 273 : SWIG_Python_SetConstant(d, "ALTER_NULLABLE_FLAG",SWIG_From_int(static_cast< int >(8)));
40958 273 : SWIG_Python_SetConstant(d, "ALTER__FLAG",SWIG_From_int(static_cast< int >(8)));
40959 273 : SWIG_Python_SetConstant(d, "ALTER_DEFAULT_FLAG",SWIG_From_int(static_cast< int >(16)));
40960 273 : SWIG_Python_SetConstant(d, "ALTER_UNIQUE_FLAG",SWIG_From_int(static_cast< int >(32)));
40961 273 : SWIG_Python_SetConstant(d, "ALTER_DOMAIN_FLAG",SWIG_From_int(static_cast< int >(64)));
40962 273 : SWIG_Python_SetConstant(d, "ALTER_ALTERNATIVE_NAME_FLAG",SWIG_From_int(static_cast< int >(128)));
40963 273 : SWIG_Python_SetConstant(d, "ALTER_COMMENT_FLAG",SWIG_From_int(static_cast< int >(256)));
40964 273 : SWIG_Python_SetConstant(d, "ALTER_ALL_FLAG",SWIG_From_int(static_cast< int >(1+2+4+8+16+32+64+128+256)));
40965 273 : SWIG_Python_SetConstant(d, "ALTER_GEOM_FIELD_DEFN_NAME_FLAG",SWIG_From_int(static_cast< int >(4096)));
40966 273 : SWIG_Python_SetConstant(d, "ALTER_GEOM_FIELD_DEFN_TYPE_FLAG",SWIG_From_int(static_cast< int >(8192)));
40967 273 : SWIG_Python_SetConstant(d, "ALTER_GEOM_FIELD_DEFN_NULLABLE_FLAG",SWIG_From_int(static_cast< int >(16384)));
40968 273 : SWIG_Python_SetConstant(d, "ALTER_GEOM_FIELD_DEFN_SRS_FLAG",SWIG_From_int(static_cast< int >(32768)));
40969 273 : SWIG_Python_SetConstant(d, "ALTER_GEOM_FIELD_DEFN_SRS_COORD_EPOCH_FLAG",SWIG_From_int(static_cast< int >(65536)));
40970 273 : SWIG_Python_SetConstant(d, "ALTER_GEOM_FIELD_DEFN_ALL_FLAG",SWIG_From_int(static_cast< int >(4096+8192+16384+32768+65536)));
40971 273 : SWIG_Python_SetConstant(d, "F_VAL_NULL",SWIG_From_int(static_cast< int >(0x00000001)));
40972 273 : SWIG_Python_SetConstant(d, "F_VAL_GEOM_TYPE",SWIG_From_int(static_cast< int >(0x00000002)));
40973 273 : SWIG_Python_SetConstant(d, "F_VAL_WIDTH",SWIG_From_int(static_cast< int >(0x00000004)));
40974 273 : SWIG_Python_SetConstant(d, "F_VAL_ALLOW_NULL_WHEN_DEFAULT",SWIG_From_int(static_cast< int >(0x00000008)));
40975 273 : SWIG_Python_SetConstant(d, "F_VAL_ALL",SWIG_From_int(static_cast< int >(0xFFFFFFFF)));
40976 273 : SWIG_Python_SetConstant(d, "TZFLAG_UNKNOWN",SWIG_From_int(static_cast< int >(0)));
40977 273 : SWIG_Python_SetConstant(d, "TZFLAG_LOCALTIME",SWIG_From_int(static_cast< int >(1)));
40978 273 : SWIG_Python_SetConstant(d, "TZFLAG_MIXED_TZ",SWIG_From_int(static_cast< int >(2)));
40979 273 : SWIG_Python_SetConstant(d, "TZFLAG_UTC",SWIG_From_int(static_cast< int >(100)));
40980 273 : SWIG_Python_SetConstant(d, "GGT_COUNT_NOT_NEEDED",SWIG_From_int(static_cast< int >(0x1)));
40981 273 : SWIG_Python_SetConstant(d, "GGT_STOP_IF_MIXED",SWIG_From_int(static_cast< int >(0x2)));
40982 273 : SWIG_Python_SetConstant(d, "GGT_GEOMCOLLECTIONZ_TINZ",SWIG_From_int(static_cast< int >(0x4)));
40983 273 : SWIG_Python_SetConstant(d, "OLCRandomRead",SWIG_FromCharPtr("RandomRead"));
40984 273 : SWIG_Python_SetConstant(d, "OLCSequentialWrite",SWIG_FromCharPtr("SequentialWrite"));
40985 273 : SWIG_Python_SetConstant(d, "OLCRandomWrite",SWIG_FromCharPtr("RandomWrite"));
40986 273 : SWIG_Python_SetConstant(d, "OLCFastSpatialFilter",SWIG_FromCharPtr("FastSpatialFilter"));
40987 273 : SWIG_Python_SetConstant(d, "OLCFastFeatureCount",SWIG_FromCharPtr("FastFeatureCount"));
40988 273 : SWIG_Python_SetConstant(d, "OLCFastGetExtent",SWIG_FromCharPtr("FastGetExtent"));
40989 273 : SWIG_Python_SetConstant(d, "OLCFastGetExtent3D",SWIG_FromCharPtr("FastGetExtent3D"));
40990 273 : SWIG_Python_SetConstant(d, "OLCCreateField",SWIG_FromCharPtr("CreateField"));
40991 273 : SWIG_Python_SetConstant(d, "OLCDeleteField",SWIG_FromCharPtr("DeleteField"));
40992 273 : SWIG_Python_SetConstant(d, "OLCReorderFields",SWIG_FromCharPtr("ReorderFields"));
40993 273 : SWIG_Python_SetConstant(d, "OLCAlterFieldDefn",SWIG_FromCharPtr("AlterFieldDefn"));
40994 273 : SWIG_Python_SetConstant(d, "OLCAlterGeomFieldDefn",SWIG_FromCharPtr("AlterGeomFieldDefn"));
40995 273 : SWIG_Python_SetConstant(d, "OLCTransactions",SWIG_FromCharPtr("Transactions"));
40996 273 : SWIG_Python_SetConstant(d, "OLCDeleteFeature",SWIG_FromCharPtr("DeleteFeature"));
40997 273 : SWIG_Python_SetConstant(d, "OLCUpsertFeature",SWIG_FromCharPtr("UpsertFeature"));
40998 273 : SWIG_Python_SetConstant(d, "OLCUpdateFeature",SWIG_FromCharPtr("UpdateFeature"));
40999 273 : SWIG_Python_SetConstant(d, "OLCFastSetNextByIndex",SWIG_FromCharPtr("FastSetNextByIndex"));
41000 273 : SWIG_Python_SetConstant(d, "OLCStringsAsUTF8",SWIG_FromCharPtr("StringsAsUTF8"));
41001 273 : SWIG_Python_SetConstant(d, "OLCIgnoreFields",SWIG_FromCharPtr("IgnoreFields"));
41002 273 : SWIG_Python_SetConstant(d, "OLCCreateGeomField",SWIG_FromCharPtr("CreateGeomField"));
41003 273 : SWIG_Python_SetConstant(d, "OLCCurveGeometries",SWIG_FromCharPtr("CurveGeometries"));
41004 273 : SWIG_Python_SetConstant(d, "OLCMeasuredGeometries",SWIG_FromCharPtr("MeasuredGeometries"));
41005 273 : SWIG_Python_SetConstant(d, "OLCZGeometries",SWIG_FromCharPtr("ZGeometries"));
41006 273 : SWIG_Python_SetConstant(d, "OLCRename",SWIG_FromCharPtr("Rename"));
41007 273 : SWIG_Python_SetConstant(d, "OLCFastGetArrowStream",SWIG_FromCharPtr("FastGetArrowStream"));
41008 273 : SWIG_Python_SetConstant(d, "OLCFastWriteArrowBatch",SWIG_FromCharPtr("FastWriteArrowBatch"));
41009 273 : SWIG_Python_SetConstant(d, "ODsCCreateLayer",SWIG_FromCharPtr("CreateLayer"));
41010 273 : SWIG_Python_SetConstant(d, "ODsCDeleteLayer",SWIG_FromCharPtr("DeleteLayer"));
41011 273 : SWIG_Python_SetConstant(d, "ODsCCreateGeomFieldAfterCreateLayer",SWIG_FromCharPtr("CreateGeomFieldAfterCreateLayer"));
41012 273 : SWIG_Python_SetConstant(d, "ODsCCurveGeometries",SWIG_FromCharPtr("CurveGeometries"));
41013 273 : SWIG_Python_SetConstant(d, "ODsCTransactions",SWIG_FromCharPtr("Transactions"));
41014 273 : SWIG_Python_SetConstant(d, "ODsCEmulatedTransactions",SWIG_FromCharPtr("EmulatedTransactions"));
41015 273 : SWIG_Python_SetConstant(d, "ODsCMeasuredGeometries",SWIG_FromCharPtr("MeasuredGeometries"));
41016 273 : SWIG_Python_SetConstant(d, "ODsCZGeometries",SWIG_FromCharPtr("ZGeometries"));
41017 273 : SWIG_Python_SetConstant(d, "ODsCRandomLayerRead",SWIG_FromCharPtr("RandomLayerRead"));
41018 273 : SWIG_Python_SetConstant(d, "ODsCRandomLayerWrite",SWIG_FromCharPtr("RandomLayerWrite "));
41019 273 : SWIG_Python_SetConstant(d, "ODsCAddFieldDomain",SWIG_FromCharPtr("AddFieldDomain"));
41020 273 : SWIG_Python_SetConstant(d, "ODsCDeleteFieldDomain",SWIG_FromCharPtr("DeleteFieldDomain"));
41021 273 : SWIG_Python_SetConstant(d, "ODsCUpdateFieldDomain",SWIG_FromCharPtr("UpdateFieldDomain"));
41022 273 : SWIG_Python_SetConstant(d, "ODrCCreateDataSource",SWIG_FromCharPtr("CreateDataSource"));
41023 273 : SWIG_Python_SetConstant(d, "ODrCDeleteDataSource",SWIG_FromCharPtr("DeleteDataSource"));
41024 273 : SWIG_Python_SetConstant(d, "OLMD_FID64",SWIG_FromCharPtr("OLMD_FID64"));
41025 273 : SWIG_Python_SetConstant(d, "GEOS_PREC_NO_TOPO",SWIG_From_int(static_cast< int >(1)));
41026 273 : SWIG_Python_SetConstant(d, "GEOS_PREC_KEEP_COLLAPSED",SWIG_From_int(static_cast< int >(2)));
41027 273 : SWIG_Python_SetConstant(d, "OGRERR_NONE",SWIG_From_int(static_cast< int >(0)));
41028 273 : SWIG_Python_SetConstant(d, "OGRERR_NOT_ENOUGH_DATA",SWIG_From_int(static_cast< int >(1)));
41029 273 : SWIG_Python_SetConstant(d, "OGRERR_NOT_ENOUGH_MEMORY",SWIG_From_int(static_cast< int >(2)));
41030 273 : SWIG_Python_SetConstant(d, "OGRERR_UNSUPPORTED_GEOMETRY_TYPE",SWIG_From_int(static_cast< int >(3)));
41031 273 : SWIG_Python_SetConstant(d, "OGRERR_UNSUPPORTED_OPERATION",SWIG_From_int(static_cast< int >(4)));
41032 273 : SWIG_Python_SetConstant(d, "OGRERR_CORRUPT_DATA",SWIG_From_int(static_cast< int >(5)));
41033 273 : SWIG_Python_SetConstant(d, "OGRERR_FAILURE",SWIG_From_int(static_cast< int >(6)));
41034 273 : SWIG_Python_SetConstant(d, "OGRERR_UNSUPPORTED_SRS",SWIG_From_int(static_cast< int >(7)));
41035 273 : SWIG_Python_SetConstant(d, "OGRERR_INVALID_HANDLE",SWIG_From_int(static_cast< int >(8)));
41036 273 : SWIG_Python_SetConstant(d, "OGRERR_NON_EXISTING_FEATURE",SWIG_From_int(static_cast< int >(9)));
41037 :
41038 :
41039 273 : if ( OGRGetDriverCount() == 0 ) {
41040 0 : OGRRegisterAll();
41041 : }
41042 : // Will be turned on for GDAL 4.0
41043 : // UseExceptions();
41044 :
41045 :
41046 :
41047 :
41048 : /* Initialize threading */
41049 273 : SWIG_PYTHON_INITIALIZE_THREADS;
41050 : #if PY_VERSION_HEX >= 0x03000000
41051 273 : return m;
41052 : #else
41053 : return;
41054 : #endif
41055 : }
41056 :
|
