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 7013 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
449 7013 : if (ty) {
450 7013 : swig_cast_info *iter = ty->cast;
451 9183 : while (iter) {
452 9179 : if (strcmp(iter->type->name, c) == 0) {
453 7009 : if (iter == ty->cast)
454 : return iter;
455 : /* Move iter to the top of the linked list */
456 742 : iter->prev->next = iter->next;
457 742 : if (iter->next)
458 467 : iter->next->prev = iter->prev;
459 742 : iter->next = ty->cast;
460 742 : iter->prev = 0;
461 742 : if (ty->cast) ty->cast->prev = iter;
462 742 : ty->cast = iter;
463 742 : return iter;
464 : }
465 2170 : 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 958 : SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
503 958 : 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 4125 : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
571 4125 : SWIG_TypeClientData(ti, clientdata);
572 4125 : 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 19547 : SWIG_MangledTypeQueryModule(swig_module_info *start,
585 : swig_module_info *end,
586 : const char *name) {
587 19547 : swig_module_info *iter = start;
588 38508 : do {
589 38508 : if (iter->size) {
590 38508 : size_t l = 0;
591 38508 : size_t r = iter->size - 1;
592 131137 : do {
593 : /* since l+r >= 0, we can (>> 1) instead (/ 2) */
594 131137 : size_t i = (l + r) >> 1;
595 131137 : const char *iname = iter->types[i]->name;
596 131137 : if (iname) {
597 131137 : int compare = strcmp(name, iname);
598 131137 : if (compare == 0) {
599 11849 : return iter->types[i];
600 119288 : } else if (compare < 0) {
601 63669 : if (i) {
602 49123 : r = i - 1;
603 : } else {
604 : break;
605 : }
606 55619 : } else if (compare > 0) {
607 55619 : l = i + 1;
608 : }
609 : } else {
610 : break; /* should never happen */
611 : }
612 104742 : } while (l <= r);
613 : }
614 26659 : iter = iter->next;
615 26659 : } 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 22 : 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 22 : swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
634 22 : 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 297 : SWIG_Python_str_FromChar(const char *c)
839 : {
840 : #if PY_VERSION_HEX >= 0x03000000
841 297 : 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 235 : SWIG_Python_ErrorType(int code) {
868 235 : 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 207 : case SWIG_RuntimeError:
877 207 : 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 235 : 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 594 : void end() { if (status) { PyGILState_Release(state); status = false;} }
986 570 : 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 7255830 : void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
994 7255830 : 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 245 : SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1143 245 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1144 245 : PyErr_SetString(errtype, msg);
1145 245 : SWIG_PYTHON_THREAD_END_BLOCK;
1146 245 : }
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 52525 : SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1173 52525 : PyDict_SetItemString(d, name, obj);
1174 52525 : Py_DECREF(obj);
1175 52525 : }
1176 :
1177 : #endif
1178 :
1179 : /* Append a value to the result obj */
1180 :
1181 : SWIGINTERN PyObject*
1182 22211 : SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1183 22211 : if (!result) {
1184 : result = obj;
1185 14408 : } else if (result == Py_None) {
1186 13886 : 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 22211 : return result;
1198 : }
1199 :
1200 : /* Unpack the argument tuple */
1201 :
1202 : SWIGINTERN Py_ssize_t
1203 2042870 : SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1204 : {
1205 2042870 : if (!args) {
1206 32786 : 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 2010080 : if (!PyTuple_Check(args)) {
1215 4125 : if (min <= 1 && max >= 1) {
1216 4125 : Py_ssize_t i;
1217 4125 : objs[0] = args;
1218 4125 : 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 2005960 : Py_ssize_t l = PyTuple_GET_SIZE(args);
1227 2005960 : 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 2005960 : } 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 6267210 : for (i = 0; i < l; ++i) {
1238 4261250 : objs[i] = PyTuple_GET_ITEM(args, i);
1239 : }
1240 2072450 : for (; l < max; ++l) {
1241 66493 : objs[l] = 0;
1242 : }
1243 2005960 : 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 1388700 : SWIG_Py_Void(void)
1282 : {
1283 1388700 : PyObject *none = Py_None;
1284 0 : Py_INCREF(none);
1285 377046 : 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 4125 : SwigPyClientData_New(PyObject* obj)
1320 : {
1321 4125 : if (!obj) {
1322 : return 0;
1323 : } else {
1324 4125 : SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1325 : /* the klass element */
1326 4125 : data->klass = obj;
1327 4125 : Py_INCREF(data->klass);
1328 : /* the newraw method and newargs arguments used to create a new raw instance */
1329 4125 : if (PyClass_Check(obj)) {
1330 4125 : data->newraw = 0;
1331 4125 : data->newargs = obj;
1332 4125 : 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 4125 : data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
1346 4125 : if (PyErr_Occurred()) {
1347 550 : PyErr_Clear();
1348 550 : data->destroy = 0;
1349 : }
1350 4125 : if (data->destroy) {
1351 3575 : int flags;
1352 3575 : Py_INCREF(data->destroy);
1353 3575 : flags = PyCFunction_GET_FLAGS(data->destroy);
1354 3575 : data->delargs = !(flags & (METH_O));
1355 : } else {
1356 550 : data->delargs = 0;
1357 : }
1358 4125 : data->implicitconv = 0;
1359 4125 : data->pytype = 0;
1360 4125 : 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 11956500 : SwigPyObject_type(void) {
1506 11956500 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1507 11956500 : 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 1136190 : SwigPyObject_dealloc(PyObject *v)
1529 : {
1530 1136190 : SwigPyObject *sobj = (SwigPyObject *) v;
1531 1136190 : PyObject *next = sobj->next;
1532 1136190 : if (sobj->own == SWIG_POINTER_OWN) {
1533 701487 : swig_type_info *ty = sobj->ty;
1534 701487 : SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1535 701487 : PyObject *destroy = data ? data->destroy : 0;
1536 701487 : if (destroy) {
1537 : /* destroy is always a VARARGS method */
1538 701487 : 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 701487 : PyObject *type = NULL, *value = NULL, *traceback = NULL;
1548 701487 : PyErr_Fetch(&type, &value, &traceback);
1549 :
1550 701487 : 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 701487 : PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1557 701487 : PyObject *mself = PyCFunction_GET_SELF(destroy);
1558 701487 : res = ((*meth)(mself, v));
1559 : }
1560 701487 : if (!res)
1561 0 : PyErr_WriteUnraisable(destroy);
1562 :
1563 701487 : PyErr_Restore(type, value, traceback);
1564 :
1565 1402970 : 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 1136190 : Py_XDECREF(next);
1575 1136190 : PyObject_DEL(v);
1576 1136190 : }
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 240 : SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1605 : {
1606 240 : SwigPyObject *sobj = (SwigPyObject *)v;
1607 240 : sobj->own = 0;
1608 240 : 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 240 : SwigPyObject_own(PyObject *v, PyObject *args)
1621 : {
1622 240 : PyObject *val = 0;
1623 240 : if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
1624 : return NULL;
1625 : } else {
1626 240 : SwigPyObject *sobj = (SwigPyObject *)v;
1627 240 : PyObject *obj = PyBool_FromLong(sobj->own);
1628 240 : if (val) {
1629 240 : if (PyObject_IsTrue(val)) {
1630 0 : SwigPyObject_acquire(v,args);
1631 : } else {
1632 240 : SwigPyObject_disown(v,args);
1633 : }
1634 : }
1635 240 : 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 275 : SwigPyObject_TypeOnce(void) {
1652 275 : static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1653 :
1654 275 : 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 275 : static PyTypeObject swigpyobject_type;
1699 275 : static int type_init = 0;
1700 275 : if (!type_init) {
1701 275 : 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 275 : swigpyobject_type = tmp;
1770 275 : type_init = 1;
1771 275 : if (PyType_Ready(&swigpyobject_type) < 0)
1772 0 : return NULL;
1773 : }
1774 : return &swigpyobject_type;
1775 : }
1776 :
1777 : SWIGRUNTIME PyObject *
1778 1136360 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1779 : {
1780 1136360 : SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1781 1136360 : if (sobj) {
1782 1136360 : sobj->ptr = ptr;
1783 1136360 : sobj->ty = ty;
1784 1136360 : sobj->own = own;
1785 1136360 : sobj->next = 0;
1786 : }
1787 1136360 : 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 275 : SwigPyPacked_type(void) {
1836 275 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
1837 275 : 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 275 : SwigPyPacked_TypeOnce(void) {
1858 275 : static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1859 275 : static PyTypeObject swigpypacked_type;
1860 275 : static int type_init = 0;
1861 275 : if (!type_init) {
1862 275 : 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 275 : swigpypacked_type = tmp;
1931 275 : type_init = 1;
1932 275 : 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 5035890 : SWIG_This(void)
1978 : {
1979 5035890 : if (Swig_This_global == NULL)
1980 275 : Swig_This_global = SWIG_Python_str_FromChar("this");
1981 5035890 : 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 5370320 : SWIG_Python_GetSwigThis(PyObject *pyobj)
1993 : {
1994 5370340 : PyObject *obj;
1995 :
1996 5370340 : 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 4674450 : 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 4674450 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2039 4674450 : if (obj) {
2040 4313210 : Py_DECREF(obj);
2041 : } else {
2042 361245 : if (PyErr_Occurred()) PyErr_Clear();
2043 361245 : return 0;
2044 : }
2045 : #endif
2046 4313210 : 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 5010160 : SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2074 5010160 : int res;
2075 5010160 : SwigPyObject *sobj;
2076 5010160 : int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2077 :
2078 5010160 : if (!obj)
2079 : return SWIG_ERROR;
2080 5010160 : if (obj == Py_None && !implicit_conv) {
2081 1006 : if (ptr)
2082 1006 : *ptr = 0;
2083 2012 : return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
2084 : }
2085 :
2086 5009150 : res = SWIG_ERROR;
2087 :
2088 5009150 : sobj = SWIG_Python_GetSwigThis(obj);
2089 5009150 : if (own)
2090 0 : *own = 0;
2091 5009150 : while (sobj) {
2092 5009070 : void *vptr = sobj->ptr;
2093 5009070 : if (ty) {
2094 5009070 : swig_type_info *to = sobj->ty;
2095 5009070 : if (to == ty) {
2096 : /* no type cast needed */
2097 5008110 : if (ptr) *ptr = vptr;
2098 : break;
2099 : } else {
2100 962 : swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2101 962 : if (!tc) {
2102 4 : sobj = (SwigPyObject *)sobj->next;
2103 : } else {
2104 958 : if (ptr) {
2105 958 : int newmemory = 0;
2106 958 : *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2107 958 : 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 5009150 : if (sobj) {
2122 5009070 : if (own)
2123 0 : *own = *own | sobj->own;
2124 5009070 : if (flags & SWIG_POINTER_DISOWN) {
2125 729857 : 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 361167 : SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2281 : {
2282 361167 : 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 361167 : dict = PyObject_GetAttrString(inst, "__dict__");
2296 361167 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2297 361167 : Py_DECREF(dict);
2298 361167 : }
2299 :
2300 :
2301 : SWIGINTERN PyObject *
2302 361167 : SWIG_Python_InitShadowInstance(PyObject *args) {
2303 361167 : PyObject *obj[2];
2304 361167 : if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2305 : return NULL;
2306 : } else {
2307 361167 : SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2308 361167 : if (sthis) {
2309 0 : SwigPyObject_append((PyObject*) sthis, obj[1]);
2310 : } else {
2311 361167 : SWIG_Python_SetSwigThis(obj[0], obj[1]);
2312 : }
2313 361167 : return SWIG_Py_Void();
2314 : }
2315 : }
2316 :
2317 : /* Create a new pointer object */
2318 :
2319 : SWIGRUNTIME PyObject *
2320 1147760 : SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2321 1147760 : SwigPyClientData *clientdata;
2322 1147760 : PyObject * robj;
2323 1147760 : int own;
2324 :
2325 1147760 : if (!ptr)
2326 11394 : return SWIG_Py_Void();
2327 :
2328 1136360 : clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2329 1136360 : own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2330 1136360 : 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 1136360 : assert(!(flags & SWIG_BUILTIN_TP_INIT));
2361 :
2362 1136360 : robj = SwigPyObject_New(ptr, type, own);
2363 1136360 : if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2364 774923 : PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2365 774923 : 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 297 : SWIG_Python_TypeCache(void) {
2441 297 : static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2442 297 : return cache;
2443 : }
2444 :
2445 : SWIGRUNTIME swig_type_info *
2446 22 : SWIG_Python_TypeQuery(const char *type)
2447 : {
2448 22 : PyObject *cache = SWIG_Python_TypeCache();
2449 22 : PyObject *key = SWIG_Python_str_FromChar(type);
2450 22 : PyObject *obj = PyDict_GetItem(cache, key);
2451 22 : swig_type_info *descriptor;
2452 22 : if (obj) {
2453 0 : descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2454 : } else {
2455 22 : swig_module_info *swig_module = SWIG_GetModule(0);
2456 22 : descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2457 22 : if (descriptor) {
2458 22 : obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2459 22 : PyDict_SetItem(cache, key, obj);
2460 22 : Py_DECREF(obj);
2461 : }
2462 : }
2463 22 : Py_DECREF(key);
2464 22 : 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 436320 : SWIG_From_int (int value)
2863 : {
2864 436320 : return PyInt_FromLong((long) value);
2865 : }
2866 :
2867 :
2868 : SWIGINTERN swig_type_info*
2869 244 : SWIG_pchar_descriptor(void)
2870 : {
2871 244 : static int init = 0;
2872 244 : static swig_type_info* info = 0;
2873 244 : if (!init) {
2874 22 : info = SWIG_TypeQuery("_p_char");
2875 22 : init = 1;
2876 : }
2877 244 : return info;
2878 : }
2879 :
2880 :
2881 : SWIGINTERNINLINE PyObject *
2882 259431 : SWIG_FromCharPtrAndSize(const char* carray, size_t size)
2883 : {
2884 259431 : if (carray) {
2885 259311 : 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 259311 : 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 120 : return SWIG_Py_Void();
2902 : }
2903 : }
2904 :
2905 :
2906 : SWIGINTERNINLINE PyObject *
2907 259431 : SWIG_FromCharPtr(const char *cptr)
2908 : {
2909 247881 : 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 2907550 : 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 639 : PythonBindingErrorHandler(CPLErr eclass, CPLErrorNum err_no, const char *msg )
2933 : {
2934 639 : PythonBindingErrorHandlerContext* ctxt = static_cast<
2935 639 : 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 639 : 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 639 : else if (eclass != CE_Failure ) {
2955 163 : CPLCallPreviousHandler(eclass, err_no, msg );
2956 : }
2957 : else {
2958 476 : ctxt->nLastCode = err_no;
2959 476 : try
2960 : {
2961 476 : if( ctxt->osFailureMsg.empty() ) {
2962 313 : ctxt->osFailureMsg = msg;
2963 313 : ctxt->osInitialMsg = ctxt->osFailureMsg;
2964 : } else {
2965 163 : if( ctxt->osFailureMsg.size() < 10000 ) {
2966 326 : std::string osTmp(msg);
2967 163 : osTmp += "\nMay be caused by: ";
2968 163 : osTmp += ctxt->osFailureMsg;
2969 163 : ctxt->osFailureMsg = std::move(osTmp);
2970 163 : 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 639 : }
2987 :
2988 :
2989 :
2990 :
2991 : static
2992 7340780 : int GetUseExceptions() {
2993 4617970 : return bUseExceptionsLocal >= 0 ? bUseExceptionsLocal : bUseExceptions;
2994 : }
2995 :
2996 9231 : static int _GetExceptionsLocal()
2997 : {
2998 9231 : return bUseExceptionsLocal;
2999 : }
3000 :
3001 18462 : static void _SetExceptionsLocal(int bVal)
3002 : {
3003 18462 : bUseExceptionsLocal = bVal;
3004 : }
3005 :
3006 : static
3007 26 : void _UseExceptions() {
3008 26 : CPLErrorReset();
3009 26 : bUserHasSpecifiedIfUsingExceptions = TRUE;
3010 26 : 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 18480 : 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 711068 : SWIG_AsVal_double (PyObject *obj, double *val)
3045 : {
3046 711068 : int res = SWIG_TypeError;
3047 711068 : if (PyFloat_Check(obj)) {
3048 386410 : if (val) *val = PyFloat_AsDouble(obj);
3049 386410 : 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 324658 : } else if (PyLong_Check(obj)) {
3056 324658 : double v = PyLong_AsDouble(obj);
3057 324658 : if (!PyErr_Occurred()) {
3058 324658 : if (val) *val = v;
3059 324658 : 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 1828520 : 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 1828520 : if (PyLong_Check(obj)) {
3135 1822400 : long v = PyLong_AsLong(obj);
3136 1822400 : if (!PyErr_Occurred()) {
3137 1822400 : if (val) *val = v;
3138 1822400 : 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 1333760 : SWIG_AsVal_int (PyObject * obj, int *val)
3170 : {
3171 1333760 : long v;
3172 2667520 : int res = SWIG_AsVal_long (obj, &v);
3173 1333760 : if (SWIG_IsOK(res)) {
3174 1327640 : if ((v < INT_MIN || v > INT_MAX)) {
3175 : return SWIG_OverflowError;
3176 : } else {
3177 832888 : 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 4726110 : template<class T> static T ReturnSame(T x)
3194 : {
3195 18476 : if( bReturnSame )
3196 : return x;
3197 : return 0;
3198 : }
3199 :
3200 2907550 : static void pushErrorHandler()
3201 : {
3202 2907550 : CPLErrorReset();
3203 2907550 : PythonBindingErrorHandlerContext* ctxt = new PythonBindingErrorHandlerContext();
3204 2907550 : CPLPushErrorHandlerEx(PythonBindingErrorHandler, ctxt);
3205 2907550 : }
3206 :
3207 2907550 : static void popErrorHandler()
3208 : {
3209 2907550 : PythonBindingErrorHandlerContext* ctxt = static_cast<
3210 2907550 : PythonBindingErrorHandlerContext*>(CPLGetErrorHandlerUserData());
3211 2907550 : CPLPopErrorHandler();
3212 2907550 : if( ctxt->bMemoryError )
3213 : {
3214 0 : CPLErrorSetState(
3215 : CE_Failure, CPLE_OutOfMemory, "Out of memory");
3216 : }
3217 2907550 : else if( !ctxt->osFailureMsg.empty() )
3218 : {
3219 340 : CPLErrorSetState(
3220 313 : CPLGetLastErrorType() == CE_Failure ? CE_Failure: CE_Warning,
3221 : ctxt->nLastCode, ctxt->osFailureMsg.c_str());
3222 : }
3223 2907550 : delete ctxt;
3224 2907550 : }
3225 :
3226 :
3227 :
3228 :
3229 : /* Return a PyObject* from a NULL terminated C String */
3230 : static PyObject* GDALPythonObjectFromCStr(const char *pszStr) CPL_UNUSED;
3231 9460 : static PyObject* GDALPythonObjectFromCStr(const char *pszStr)
3232 : {
3233 9460 : const unsigned char* pszIter = (const unsigned char*) pszStr;
3234 423684 : while(*pszIter != 0)
3235 : {
3236 414224 : 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 414224 : pszIter ++;
3245 : }
3246 9460 : 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 26071 : static char* GDALPythonObjectToCStr(PyObject* pyObject, int* pbToFree)
3253 : {
3254 26071 : *pbToFree = 0;
3255 26071 : if (PyUnicode_Check(pyObject))
3256 : {
3257 26071 : char *pszStr;
3258 26071 : char *pszNewStr;
3259 26071 : Py_ssize_t nLen;
3260 26071 : PyObject* pyUTF8Str = PyUnicode_AsUTF8String(pyObject);
3261 26071 : if( pyUTF8Str == NULL )
3262 : return NULL;
3263 26069 : PyBytes_AsStringAndSize(pyUTF8Str, &pszStr, &nLen);
3264 26069 : pszNewStr = (char *) malloc(nLen+1);
3265 26069 : 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 26069 : memcpy(pszNewStr, pszStr, nLen+1);
3273 26069 : Py_XDECREF(pyUTF8Str);
3274 26069 : *pbToFree = 1;
3275 26069 : 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 3188 : static char * GDALPythonPathToCStr(PyObject* pyObject, int* pbToFree)
3305 : {
3306 3188 : PyObject* os = PyImport_ImportModule("os");
3307 3188 : if (os == NULL)
3308 : {
3309 : return NULL;
3310 : }
3311 :
3312 3188 : PyObject* pathLike = PyObject_GetAttrString(os, "PathLike");
3313 3188 : if (pathLike == NULL)
3314 : {
3315 0 : Py_DECREF(os);
3316 0 : return NULL;
3317 : }
3318 :
3319 3188 : if (!PyObject_IsInstance(pyObject, pathLike))
3320 : {
3321 0 : Py_DECREF(pathLike);
3322 0 : Py_DECREF(os);
3323 0 : return NULL;
3324 : }
3325 :
3326 3188 : PyObject* str = PyObject_Str(pyObject);
3327 3188 : char* ret = NULL;
3328 3188 : if (str != NULL)
3329 : {
3330 3188 : ret = GDALPythonObjectToCStr(str, pbToFree);
3331 3188 : Py_DECREF(str);
3332 : }
3333 :
3334 3188 : Py_DECREF(pathLike);
3335 3188 : Py_DECREF(os);
3336 :
3337 : return ret;
3338 : }
3339 :
3340 :
3341 : static void GDALPythonFreeCStr(void* ptr, int bToFree) CPL_UNUSED;
3342 22261 : static void GDALPythonFreeCStr(void* ptr, int bToFree)
3343 : {
3344 22261 : if (bToFree)
3345 22259 : 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 19 : SWIGINTERN char const *GDALMajorObjectShadow_GetDescription(GDALMajorObjectShadow *self){
3434 19 : return GDALGetDescription( self );
3435 : }
3436 :
3437 : SWIGINTERN int
3438 89443 : 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 89443 : if (PyUnicode_Check(obj))
3445 : #endif
3446 : #else
3447 : if (PyString_Check(obj))
3448 : #endif
3449 : {
3450 89199 : char *cstr; Py_ssize_t len;
3451 89199 : int ret = SWIG_OK;
3452 : #if PY_VERSION_HEX>=0x03000000
3453 : #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3454 89199 : 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 89199 : obj = PyUnicode_AsUTF8String(obj); if (!obj) return SWIG_TypeError;
3462 89199 : if (!obj)
3463 : return SWIG_TypeError;
3464 89199 : if (alloc)
3465 85379 : *alloc = SWIG_NEWOBJ;
3466 : #endif
3467 89199 : PyBytes_AsStringAndSize(obj, &cstr, &len);
3468 : #else
3469 : PyString_AsStringAndSize(obj, &cstr, &len);
3470 : #endif
3471 89199 : if (cptr) {
3472 85379 : if (alloc) {
3473 85379 : if (*alloc == SWIG_NEWOBJ) {
3474 85379 : *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
3475 85379 : *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 89199 : if (psize) *psize = len + 1;
3495 : #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3496 89199 : Py_XDECREF(obj);
3497 : #endif
3498 89199 : 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 244 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3530 244 : if (pchar_descriptor) {
3531 244 : void* vptr = 0;
3532 244 : if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3533 201 : if (cptr) *cptr = (char *) vptr;
3534 201 : if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3535 201 : if (alloc) *alloc = SWIG_OLDOBJ;
3536 201 : 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 422 : static PyObject* CSLToList( char** stringarray, bool *pbErr )
3554 : {
3555 422 : PyObject* res;
3556 422 : if ( stringarray == NULL ) {
3557 45 : res = Py_None;
3558 45 : Py_INCREF( res );
3559 : }
3560 : else {
3561 377 : int len = CSLCount( stringarray );
3562 377 : res = PyList_New( len );
3563 377 : if( !res ) {
3564 0 : *pbErr = true;
3565 0 : return res;
3566 : }
3567 1312 : for ( int i = 0; i < len; ++i ) {
3568 935 : PyObject *o = GDALPythonObjectFromCStr( stringarray[i] );
3569 935 : PyList_SetItem(res, i, o );
3570 : }
3571 : }
3572 422 : *pbErr = false;
3573 422 : 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 419 : static PyObject* GDALPythonObjectFromCStrAndSize(const char *pszStr, size_t nLen)
3582 : {
3583 419 : const unsigned char* pszIter = (const unsigned char*) pszStr;
3584 3852 : for( size_t i = 0; i < nLen; ++i)
3585 : {
3586 3433 : 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 419 : return PyUnicode_FromStringAndSize(pszStr, nLen);
3596 : }
3597 :
3598 :
3599 : static PyObject*
3600 82 : GetCSLStringAsPyDict( char **stringarray, bool bFreeCSL ) {
3601 82 : PyObject* dict = PyDict_New();
3602 82 : if ( stringarray != NULL ) {
3603 485 : for (char** iter = stringarray; *iter; ++iter ) {
3604 419 : const char* pszSep = strchr( *iter, '=' );
3605 419 : if ( pszSep != NULL) {
3606 419 : const char* keyptr = *iter;
3607 419 : const char* valptr = pszSep + 1;
3608 419 : PyObject *nm = GDALPythonObjectFromCStrAndSize( keyptr, (size_t)(pszSep - keyptr) );
3609 419 : PyObject *val = GDALPythonObjectFromCStr( valptr );
3610 419 : PyDict_SetItem(dict, nm, val );
3611 419 : Py_DECREF(nm);
3612 419 : Py_DECREF(val);
3613 : }
3614 : }
3615 : }
3616 82 : if( bFreeCSL )
3617 0 : CSLDestroy(stringarray);
3618 82 : 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 948 : static char **CSLFromPySequence( PyObject *pySeq, int *pbErr )
3629 :
3630 : {
3631 948 : *pbErr = FALSE;
3632 : /* Check if is a list (and reject strings, that are seen as sequence of characters) */
3633 948 : 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 948 : Py_ssize_t size = PySequence_Size(pySeq);
3640 948 : 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 948 : if( size == 0 ) {
3646 : return NULL;
3647 : }
3648 688 : char** papszRet = (char**) VSICalloc((int)size + 1, sizeof(char*));
3649 688 : if( !papszRet ) {
3650 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
3651 0 : *pbErr = TRUE;
3652 0 : return NULL;
3653 : }
3654 2973 : for (int i = 0; i < (int)size; i++) {
3655 2285 : PyObject* pyObj = PySequence_GetItem(pySeq,i);
3656 2285 : if (PyUnicode_Check(pyObj))
3657 : {
3658 2285 : char *pszStr;
3659 2285 : Py_ssize_t nLen;
3660 2285 : PyObject* pyUTF8Str = PyUnicode_AsUTF8String(pyObj);
3661 2285 : 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 2285 : PyBytes_AsStringAndSize(pyUTF8Str, &pszStr, &nLen);
3670 2285 : papszRet[i] = VSIStrdup(pszStr);
3671 4546 : 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 2285 : Py_DECREF(pyObj);
3684 2285 : 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 4456 : int GetGEOSVersionMajor() {
3793 4456 : int num;
3794 4456 : OGRGetGEOSVersion(&num, NULL, NULL);
3795 4456 : return num;
3796 : }
3797 :
3798 215 : int GetGEOSVersionMinor() {
3799 215 : int num;
3800 215 : OGRGetGEOSVersion(NULL, &num, NULL);
3801 215 : return num;
3802 : }
3803 :
3804 215 : int GetGEOSVersionMicro() {
3805 215 : int num;
3806 215 : OGRGetGEOSVersion(NULL, NULL, &num);
3807 215 : 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 564 : SWIGINTERN void delete_ArrowArray(ArrowArray *self){
3841 564 : if( self->release )
3842 507 : self->release(self);
3843 564 : free(self);
3844 : }
3845 521 : SWIGINTERN VoidPtrAsLong ArrowArray__getPtr(ArrowArray *self){
3846 521 : 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 499 : SWIGINTERN void delete_ArrowSchema(ArrowSchema *self){
3858 499 : if( self->release )
3859 418 : self->release(self);
3860 499 : free(self);
3861 : }
3862 676 : SWIGINTERN VoidPtrAsLong ArrowSchema__getPtr(ArrowSchema *self){
3863 676 : return self;
3864 : }
3865 426 : SWIGINTERN char const *ArrowSchema_GetName(ArrowSchema *self){
3866 426 : return self->name;
3867 : }
3868 25 : SWIGINTERN GIntBig ArrowSchema_GetChildrenCount(ArrowSchema *self){
3869 25 : return self->n_children;
3870 : }
3871 831 : SWIGINTERN ArrowSchema const *ArrowSchema_GetChild(ArrowSchema *self,int iChild){
3872 831 : if( iChild < 0 || iChild >= self->n_children )
3873 : {
3874 0 : CPLError(CE_Failure, CPLE_AppDefined, "Wrong index");
3875 0 : return NULL;
3876 : }
3877 831 : return self->children[iChild];
3878 : }
3879 343 : SWIGINTERN void delete_ArrowArrayStream(ArrowArrayStream *self){
3880 343 : if( self->release )
3881 343 : self->release(self);
3882 343 : free(self);
3883 : }
3884 373 : SWIGINTERN ArrowSchema *ArrowArrayStream_GetSchema(ArrowArrayStream *self){
3885 373 : struct ArrowSchema* schema = (struct ArrowSchema* )malloc(sizeof(struct ArrowSchema));
3886 373 : 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 268 : SWIGINTERN GDALDatasetShadow *OGRLayerShadow_GetDataset(OGRLayerShadow *self){
3986 268 : return OGR_L_GetDataset(self);
3987 : }
3988 37 : SWIGINTERN OGRErr OGRLayerShadow_Rename(OGRLayerShadow *self,char const *new_name){
3989 37 : 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 1438 : SWIGINTERN OGRErr OGRLayerShadow_SetAttributeFilter(OGRLayerShadow *self,char *filter_string){
4041 1438 : return OGR_L_SetAttributeFilter((OGRLayerShadow*)self, filter_string);
4042 : }
4043 17629 : SWIGINTERN void OGRLayerShadow_ResetReading(OGRLayerShadow *self){
4044 17629 : OGR_L_ResetReading(self);
4045 17629 : }
4046 1248 : SWIGINTERN char const *OGRLayerShadow_GetName(OGRLayerShadow *self){
4047 1248 : return OGR_L_GetName(self);
4048 : }
4049 1104 : SWIGINTERN OGRwkbGeometryType OGRLayerShadow_GetGeomType(OGRLayerShadow *self){
4050 1104 : return (OGRwkbGeometryType) OGR_L_GetGeomType(self);
4051 : }
4052 580 : SWIGINTERN char const *OGRLayerShadow_GetGeometryColumn(OGRLayerShadow *self){
4053 580 : return OGR_L_GetGeometryColumn(self);
4054 : }
4055 383 : SWIGINTERN char const *OGRLayerShadow_GetFIDColumn(OGRLayerShadow *self){
4056 383 : return OGR_L_GetFIDColumn(self);
4057 : }
4058 2526 : SWIGINTERN OGRFeatureShadow *OGRLayerShadow_GetFeature(OGRLayerShadow *self,GIntBig fid){
4059 2526 : return (OGRFeatureShadow*) OGR_L_GetFeature(self, fid);
4060 : }
4061 78966 : SWIGINTERN OGRFeatureShadow *OGRLayerShadow_GetNextFeature(OGRLayerShadow *self){
4062 78966 : 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 2480 : SWIGINTERN OGRErr OGRLayerShadow_SetFeature(OGRLayerShadow *self,OGRFeatureShadow *feature){
4068 2480 : return OGR_L_SetFeature(self, feature);
4069 : }
4070 283131 : SWIGINTERN OGRErr OGRLayerShadow_CreateFeature(OGRLayerShadow *self,OGRFeatureShadow *feature){
4071 283131 : 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 47 : SWIG_AsVal_bool (PyObject *obj, bool *val)
4120 : {
4121 47 : int r;
4122 47 : if (!PyBool_Check(obj))
4123 : return SWIG_ERROR;
4124 47 : r = PyObject_IsTrue(obj);
4125 47 : if (r == -1)
4126 : return SWIG_ERROR;
4127 47 : 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 3336 : SWIGINTERN OGRErr OGRLayerShadow_DeleteFeature(OGRLayerShadow *self,GIntBig fid){
4140 3336 : return OGR_L_DeleteFeature(self, fid);
4141 : }
4142 251 : SWIGINTERN OGRErr OGRLayerShadow_SyncToDisk(OGRLayerShadow *self){
4143 251 : return OGR_L_SyncToDisk(self);
4144 : }
4145 125351 : SWIGINTERN OGRFeatureDefnShadow *OGRLayerShadow_GetLayerDefn(OGRLayerShadow *self){
4146 250702 : auto defn = (OGRFeatureDefnShadow*) OGR_L_GetLayerDefn(self);
4147 125351 : if (defn)
4148 125351 : OGR_FD_Reference(defn);
4149 125351 : return defn;
4150 : }
4151 36677 : SWIGINTERN GIntBig OGRLayerShadow_GetFeatureCount(OGRLayerShadow *self,int force=1){
4152 36677 : return OGR_L_GetFeatureCount(self, force);
4153 : }
4154 :
4155 : static PyObject *
4156 13790 : CreateTupleFromDoubleArray( const double *first, size_t size ) {
4157 13790 : PyObject *out = PyTuple_New( size );
4158 68865 : for( unsigned int i=0; i<size; i++ ) {
4159 55075 : PyObject *val = PyFloat_FromDouble( *first );
4160 55075 : ++first;
4161 55075 : PyTuple_SetItem( out, i, val );
4162 : }
4163 13790 : return out;
4164 : }
4165 :
4166 369 : 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 738 : OGRErr eErr = OGR_L_GetExtentEx(self, geom_field, (OGREnvelope*)argout, force);
4168 369 : if (can_return_null)
4169 35 : *isvalid = (eErr == 0);
4170 : else
4171 : *isvalid = TRUE;
4172 369 : 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 751 : SWIGINTERN bool OGRLayerShadow_TestCapability(OGRLayerShadow *self,char const *cap){
4183 1502 : return (OGR_L_TestCapability(self, cap) > 0);
4184 : }
4185 :
4186 : SWIGINTERNINLINE PyObject*
4187 37512 : SWIG_From_bool (bool value)
4188 : {
4189 37512 : return PyBool_FromLong(value ? 1 : 0);
4190 : }
4191 :
4192 77671 : SWIGINTERN OGRErr OGRLayerShadow_CreateField(OGRLayerShadow *self,OGRFieldDefnShadow *field_def,int approx_ok=1){
4193 77671 : return OGR_L_CreateField(self, field_def, approx_ok);
4194 : }
4195 69 : SWIGINTERN OGRErr OGRLayerShadow_DeleteField(OGRLayerShadow *self,int iField){
4196 69 : 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 118 : SWIGINTERN OGRErr OGRLayerShadow_AlterFieldDefn(OGRLayerShadow *self,int iField,OGRFieldDefnShadow *field_def,int nFlags){
4212 118 : 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 118 : SWIGINTERN OGRErr OGRLayerShadow_CreateGeomField(OGRLayerShadow *self,OGRGeomFieldDefnShadow *field_def,int approx_ok=1){
4218 118 : 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 913 : SWIGINTERN OSRSpatialReferenceShadow *OGRLayerShadow_GetSpatialRef(OGRLayerShadow *self){
4233 1826 : OGRSpatialReferenceH ref = OGR_L_GetSpatialRef(self);
4234 913 : if( ref )
4235 792 : OSRReference(ref);
4236 913 : 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 345 : SWIGINTERN ArrowArrayStream *OGRLayerShadow_GetArrowStream(OGRLayerShadow *self,char **options=NULL){
4296 345 : struct ArrowArrayStream* stream = (struct ArrowArrayStream* )malloc(sizeof(struct ArrowArrayStream));
4297 345 : 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 524 : SWIGINTERN OGRErr OGRLayerShadow_CreateFieldFromArrowSchema(OGRLayerShadow *self,ArrowSchema const *schema,char **options=NULL){
4309 524 : return OGR_L_CreateFieldFromArrowSchema(self, schema, options) ? 0 : 6;
4310 : }
4311 46 : SWIGINTERN OGRErr OGRLayerShadow_WriteArrowBatch(OGRLayerShadow *self,ArrowSchema const *schema,ArrowArray *array,char **options=NULL){
4312 46 : 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 202158 : SWIGINTERN void delete_OGRFeatureShadow(OGRFeatureShadow *self){
4434 202158 : OGR_F_Destroy(self);
4435 202158 : }
4436 121863 : SWIGINTERN OGRFeatureShadow *new_OGRFeatureShadow(OGRFeatureDefnShadow *feature_def){
4437 121863 : return (OGRFeatureShadow*) OGR_F_Create( feature_def );
4438 : }
4439 47755 : SWIGINTERN OGRFeatureDefnShadow *OGRFeatureShadow_GetDefnRef(OGRFeatureShadow *self){
4440 47755 : return (OGRFeatureDefnShadow*) OGR_F_GetDefnRef(self);
4441 : }
4442 236668 : SWIGINTERN OGRErr OGRFeatureShadow_SetGeometry(OGRFeatureShadow *self,OGRGeometryShadow *geom){
4443 236668 : return OGR_F_SetGeometry(self, geom);
4444 : }
4445 33929 : SWIGINTERN OGRErr OGRFeatureShadow_SetGeometryDirectly(OGRFeatureShadow *self,OGRGeometryShadow *geom){
4446 33929 : return OGR_F_SetGeometryDirectly(self, geom);
4447 : }
4448 38305 : SWIGINTERN OGRGeometryShadow *OGRFeatureShadow_GetGeometryRef(OGRFeatureShadow *self){
4449 38305 : 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 109791 : SWIGINTERN int OGRFeatureShadow_GetFieldCount(OGRFeatureShadow *self){
4497 109791 : 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 0 : SWIGINTERN OGRFieldDefnShadow *OGRFeatureShadow_GetFieldDefnRef__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4503 0 : int i = OGR_F_GetFieldIndex(self, field_name);
4504 0 : if (i == -1)
4505 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4506 : else
4507 0 : 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 792 : SWIGINTERN char const *OGRFeatureShadow_GetFieldAsString__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4528 792 : int i = OGR_F_GetFieldIndex(self, field_name);
4529 792 : 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 792 : 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 186 : SWIGINTERN int OGRFeatureShadow_GetFieldAsInteger__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4554 186 : int i = OGR_F_GetFieldIndex(self, field_name);
4555 186 : if (i == -1)
4556 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4557 : else
4558 186 : 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 22 : SWIGINTERN double OGRFeatureShadow_GetFieldAsDouble__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4579 22 : int i = OGR_F_GetFieldIndex(self, field_name);
4580 22 : if (i == -1)
4581 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4582 : else
4583 22 : 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 214 : SWIGINTERN bool OGRFeatureShadow_IsFieldSet__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4658 214 : int i = OGR_F_GetFieldIndex(self, field_name);
4659 214 : if (i == -1)
4660 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4661 : else
4662 214 : 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 56 : SWIGINTERN bool OGRFeatureShadow_IsFieldNull__SWIG_1(OGRFeatureShadow *self,char const *field_name){
4669 56 : int i = OGR_F_GetFieldIndex(self, field_name);
4670 56 : if (i == -1)
4671 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4672 : else
4673 56 : 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 72 : 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 72 : return OGR_F_GetGeomFieldIndex(self, field_name);
4694 : }
4695 5216 : SWIGINTERN GIntBig OGRFeatureShadow_GetFID(OGRFeatureShadow *self){
4696 5216 : 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 52 : SWIGINTERN retStringAndCPLFree *OGRFeatureShadow_DumpReadableAsString(OGRFeatureShadow *self,char **options=NULL){
4705 52 : 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 86786 : SWIGINTERN void OGRFeatureShadow_SetFieldInteger64(OGRFeatureShadow *self,int id,GIntBig value){
4738 86786 : OGR_F_SetFieldInteger64(self, id, value);
4739 86786 : }
4740 : SWIGINTERN void OGRFeatureShadow_SetField__SWIG_2(OGRFeatureShadow *self,int id,double value){
4741 : OGR_F_SetFieldDouble(self, id, value);
4742 : }
4743 2295 : SWIGINTERN void OGRFeatureShadow_SetField__SWIG_3(OGRFeatureShadow *self,char const *field_name,double value){
4744 2295 : int i = OGR_F_GetFieldIndex(self, field_name);
4745 2295 : if (i == -1)
4746 0 : CPLError(CE_Failure, 1, FIELD_NAME_ERROR_TMPL, field_name);
4747 : else
4748 2295 : OGR_F_SetFieldDouble(self, i, value);
4749 2295 : }
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 1195 : GetBufferAsCharPtrIntSize( PyObject* input, int *nLen, char **pBuf, int *alloc, bool *viewIsValid, Py_buffer *view ) {
4921 1195 : {
4922 1195 : if (PyObject_GetBuffer(input, view, PyBUF_SIMPLE) == 0)
4923 : {
4924 1195 : 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 1195 : *viewIsValid = true;
4930 1195 : *nLen = (int) view->len;
4931 1195 : *pBuf = (char*) view->buf;
4932 1195 : 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 1195 : SWIGINTERN void OGRFeatureShadow__SetFieldBinary(OGRFeatureShadow *self,int id,int nLen,char *pBuf){
4972 1195 : OGR_F_SetFieldBinary(self, id, nLen, pBuf);
4973 1195 : }
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 1740 : SWIGINTERN OGRErr OGRFeatureShadow_SetFrom(OGRFeatureShadow *self,OGRFeatureShadow *other,int forgiving=1){
4993 1740 : 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 542 : SWIGINTERN char const *OGRFeatureShadow_GetStyleString(OGRFeatureShadow *self){
5005 542 : 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 101263 : SWIGINTERN OGRFieldType OGRFeatureShadow_GetFieldType__SWIG_0(OGRFeatureShadow *self,int id){
5011 101263 : OGRFieldDefnH fd = OGR_F_GetFieldDefnRef( self, id );
5012 101263 : if (fd)
5013 101263 : 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 12919 : SWIGINTERN void OGRFeatureShadow_SetFieldString(OGRFeatureShadow *self,int id,char const *value){
5044 12919 : 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 125461 : SWIGINTERN void delete_OGRFeatureDefnShadow(OGRFeatureDefnShadow *self){
5130 : /*OGR_FD_Destroy(self);*/
5131 125461 : OGR_FD_Release( OGRFeatureDefnH(self) );
5132 125461 : }
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 107 : SWIGINTERN char const *OGRFeatureDefnShadow_GetName(OGRFeatureDefnShadow *self){
5139 107 : return OGR_FD_GetName(self);
5140 : }
5141 48297 : SWIGINTERN int OGRFeatureDefnShadow_GetFieldCount(OGRFeatureDefnShadow *self){
5142 48297 : return OGR_FD_GetFieldCount(self);
5143 : }
5144 221588 : SWIGINTERN OGRFieldDefnShadow *OGRFeatureDefnShadow_GetFieldDefn(OGRFeatureDefnShadow *self,int i){
5145 221588 : return (OGRFieldDefnShadow*) OGR_FD_GetFieldDefn(self, i);
5146 : }
5147 1752 : 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 1752 : 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 293 : SWIGINTERN int OGRFeatureDefnShadow_GetGeomFieldCount(OGRFeatureDefnShadow *self){
5155 293 : return OGR_FD_GetGeomFieldCount(self);
5156 : }
5157 578 : SWIGINTERN OGRGeomFieldDefnShadow *OGRFeatureDefnShadow_GetGeomFieldDefn(OGRFeatureDefnShadow *self,int i){
5158 578 : 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 77925 : static int ValidateOGRFieldType(OGRFieldType field_type)
5197 : {
5198 77925 : 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 555 : static int ValidateOGRFieldSubType(OGRFieldSubType field_subtype)
5221 : {
5222 555 : 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 77912 : SWIGINTERN void delete_OGRFieldDefnShadow(OGRFieldDefnShadow *self){
5238 77912 : OGR_Fld_Destroy(self);
5239 77912 : }
5240 77925 : SWIGINTERN OGRFieldDefnShadow *new_OGRFieldDefnShadow(char const *name_null_ok="unnamed",OGRFieldType field_type=OFTString){
5241 77925 : if (ValidateOGRFieldType(field_type))
5242 77925 : return (OGRFieldDefnShadow*) OGR_Fld_Create(name_null_ok, field_type);
5243 : else
5244 0 : return NULL;
5245 : }
5246 211880 : SWIGINTERN char const *OGRFieldDefnShadow_GetName(OGRFieldDefnShadow *self){
5247 211880 : 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 51 : SWIGINTERN char const *OGRFieldDefnShadow_GetAlternativeName(OGRFieldDefnShadow *self){
5256 51 : return OGR_Fld_GetAlternativeNameRef(self);
5257 : }
5258 9 : SWIGINTERN char const *OGRFieldDefnShadow_GetAlternativeNameRef(OGRFieldDefnShadow *self){
5259 9 : return OGR_Fld_GetAlternativeNameRef(self);
5260 : }
5261 19 : SWIGINTERN void OGRFieldDefnShadow_SetAlternativeName(OGRFieldDefnShadow *self,char const *alternativeName){
5262 19 : OGR_Fld_SetAlternativeName(self, alternativeName);
5263 19 : }
5264 3927 : SWIGINTERN OGRFieldType OGRFieldDefnShadow_GetType(OGRFieldDefnShadow *self){
5265 3927 : 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 88502 : SWIGINTERN OGRFieldSubType OGRFieldDefnShadow_GetSubType(OGRFieldDefnShadow *self){
5272 88502 : return OGR_Fld_GetSubType(self);
5273 : }
5274 555 : SWIGINTERN void OGRFieldDefnShadow_SetSubType(OGRFieldDefnShadow *self,OGRFieldSubType type){
5275 555 : if (ValidateOGRFieldSubType(type))
5276 555 : OGR_Fld_SetSubType(self, type);
5277 555 : }
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 2731 : SWIGINTERN int OGRFieldDefnShadow_GetWidth(OGRFieldDefnShadow *self){
5285 2731 : return OGR_Fld_GetWidth(self);
5286 : }
5287 321 : SWIGINTERN void OGRFieldDefnShadow_SetWidth(OGRFieldDefnShadow *self,int width){
5288 321 : OGR_Fld_SetWidth(self, width);
5289 321 : }
5290 1604 : SWIGINTERN int OGRFieldDefnShadow_GetPrecision(OGRFieldDefnShadow *self){
5291 1604 : 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 141 : SWIGINTERN char const *OGRFieldDefnShadow_GetDefault(OGRFieldDefnShadow *self){
5327 141 : return OGR_Fld_GetDefault( self );
5328 : }
5329 154 : SWIGINTERN void OGRFieldDefnShadow_SetDefault(OGRFieldDefnShadow *self,char const *pszValue){
5330 154 : OGR_Fld_SetDefault( self, pszValue );
5331 154 : }
5332 3 : SWIGINTERN int OGRFieldDefnShadow_IsDefaultDriverSpecific(OGRFieldDefnShadow *self){
5333 3 : return OGR_Fld_IsDefaultDriverSpecific( self );
5334 : }
5335 34 : SWIGINTERN char const *OGRFieldDefnShadow_GetDomainName(OGRFieldDefnShadow *self){
5336 34 : return OGR_Fld_GetDomainName(self);
5337 : }
5338 21 : SWIGINTERN void OGRFieldDefnShadow_SetDomainName(OGRFieldDefnShadow *self,char const *name){
5339 21 : OGR_Fld_SetDomainName( self, name );
5340 21 : }
5341 58 : SWIGINTERN char const *OGRFieldDefnShadow_GetComment(OGRFieldDefnShadow *self){
5342 58 : return OGR_Fld_GetComment(self);
5343 : }
5344 32 : SWIGINTERN void OGRFieldDefnShadow_SetComment(OGRFieldDefnShadow *self,char const *comment){
5345 32 : OGR_Fld_SetComment( self, comment );
5346 32 : }
5347 171 : SWIGINTERN void delete_OGRGeomFieldDefnShadow(OGRGeomFieldDefnShadow *self){
5348 171 : OGR_GFld_Destroy(self);
5349 171 : }
5350 171 : SWIGINTERN OGRGeomFieldDefnShadow *new_OGRGeomFieldDefnShadow(char const *name_null_ok="",OGRwkbGeometryType field_type=wkbUnknown){
5351 171 : if( ValidateOGRGeometryType(field_type) )
5352 171 : return (OGRGeomFieldDefnShadow*) OGR_GFld_Create(name_null_ok, field_type);
5353 : else
5354 : return NULL;
5355 : }
5356 228 : SWIGINTERN char const *OGRGeomFieldDefnShadow_GetName(OGRGeomFieldDefnShadow *self){
5357 228 : return OGR_GFld_GetNameRef(self);
5358 : }
5359 82 : SWIGINTERN char const *OGRGeomFieldDefnShadow_GetNameRef(OGRGeomFieldDefnShadow *self){
5360 82 : return OGR_GFld_GetNameRef(self);
5361 : }
5362 4 : SWIGINTERN void OGRGeomFieldDefnShadow_SetName(OGRGeomFieldDefnShadow *self,char const *name){
5363 4 : OGR_GFld_SetName(self, name);
5364 4 : }
5365 85 : SWIGINTERN OGRwkbGeometryType OGRGeomFieldDefnShadow_GetType(OGRGeomFieldDefnShadow *self){
5366 85 : return OGR_GFld_GetType(self);
5367 : }
5368 2 : SWIGINTERN void OGRGeomFieldDefnShadow_SetType(OGRGeomFieldDefnShadow *self,OGRwkbGeometryType type){
5369 2 : if( ValidateOGRGeometryType(type) )
5370 1 : OGR_GFld_SetType(self, type);
5371 2 : }
5372 81 : SWIGINTERN OSRSpatialReferenceShadow *OGRGeomFieldDefnShadow_GetSpatialRef(OGRGeomFieldDefnShadow *self){
5373 162 : OGRSpatialReferenceH ref = OGR_GFld_GetSpatialRef(self);
5374 81 : if( ref )
5375 70 : OSRReference(ref);
5376 81 : return (OSRSpatialReferenceShadow*) ref;
5377 : }
5378 48 : SWIGINTERN void OGRGeomFieldDefnShadow_SetSpatialRef(OGRGeomFieldDefnShadow *self,OSRSpatialReferenceShadow *srs){
5379 48 : OGR_GFld_SetSpatialRef( self, (OGRSpatialReferenceH)srs );
5380 48 : }
5381 6 : SWIGINTERN int OGRGeomFieldDefnShadow_IsIgnored(OGRGeomFieldDefnShadow *self){
5382 6 : return OGR_GFld_IsIgnored( self );
5383 : }
5384 1 : SWIGINTERN void OGRGeomFieldDefnShadow_SetIgnored(OGRGeomFieldDefnShadow *self,int bIgnored){
5385 1 : OGR_GFld_SetIgnored( self, bIgnored );
5386 1 : }
5387 85 : SWIGINTERN int OGRGeomFieldDefnShadow_IsNullable(OGRGeomFieldDefnShadow *self){
5388 85 : return OGR_GFld_IsNullable( self );
5389 : }
5390 23 : SWIGINTERN void OGRGeomFieldDefnShadow_SetNullable(OGRGeomFieldDefnShadow *self,int bNullable){
5391 23 : return OGR_GFld_SetNullable( self, bNullable );
5392 : }
5393 44 : SWIGINTERN OGRGeomCoordinatePrecisionShadow *OGRGeomFieldDefnShadow_GetCoordinatePrecision(OGRGeomFieldDefnShadow *self){
5394 44 : return OGR_GFld_GetCoordinatePrecision(self);
5395 : }
5396 19 : SWIGINTERN void OGRGeomFieldDefnShadow_SetCoordinatePrecision(OGRGeomFieldDefnShadow *self,OGRGeomCoordinatePrecisionShadow *coordPrec){
5397 19 : OGR_GFld_SetCoordinatePrecision(self, coordPrec);
5398 19 : }
5399 :
5400 31028 : OGRGeometryShadow* CreateGeometryFromWkb( size_t len, char *bin_string,
5401 : OSRSpatialReferenceShadow *reference=NULL ) {
5402 31028 : OGRGeometryH geom = NULL;
5403 31028 : OGRErr err = OGR_G_CreateFromWkbEx( (unsigned char *) bin_string,
5404 : reference,
5405 : &geom,
5406 : len );
5407 31028 : if (err != 0 ) {
5408 5472 : CPLError(CE_Failure, err, "%s", OGRErrMessages(err));
5409 5472 : return NULL;
5410 : }
5411 25556 : return (OGRGeometryShadow*) geom;
5412 : }
5413 :
5414 :
5415 :
5416 : static bool
5417 31028 : GetBufferAsCharPtrSizetSize( PyObject* input, size_t *nLen, char **pBuf, int *alloc, bool *viewIsValid, Py_buffer *view ) {
5418 31028 : {
5419 31028 : if (PyObject_GetBuffer(input, view, PyBUF_SIMPLE) == 0)
5420 : {
5421 31021 : *viewIsValid = true;
5422 31021 : *nLen = view->len;
5423 31021 : *pBuf = (char*) view->buf;
5424 31021 : return true;
5425 : }
5426 : else
5427 : {
5428 7 : PyErr_Clear();
5429 : }
5430 : }
5431 7 : if (PyUnicode_Check(input))
5432 : {
5433 7 : size_t safeLen = 0;
5434 7 : int ret;
5435 7 : try {
5436 7 : ret = SWIG_AsCharPtrAndSize(input, pBuf, &safeLen, alloc);
5437 : }
5438 0 : catch( const std::exception& )
5439 : {
5440 0 : PyErr_SetString(PyExc_MemoryError, "out of memory");
5441 0 : return false;
5442 : }
5443 7 : if (!SWIG_IsOK(ret)) {
5444 0 : PyErr_SetString(PyExc_RuntimeError, "invalid Unicode string" );
5445 0 : return false;
5446 : }
5447 :
5448 7 : if (safeLen) safeLen--;
5449 7 : *nLen = safeLen;
5450 7 : return true;
5451 : }
5452 : else
5453 : {
5454 0 : PyErr_SetString(PyExc_RuntimeError, "not a unicode string, bytes, bytearray or memoryview");
5455 0 : return false;
5456 : }
5457 : }
5458 :
5459 :
5460 : SWIGINTERN int
5461 : SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
5462 : {
5463 : #if PY_VERSION_HEX < 0x03000000
5464 : if (PyInt_Check(obj)) {
5465 : long v = PyInt_AsLong(obj);
5466 : if (v >= 0) {
5467 : if (val) *val = v;
5468 : return SWIG_OK;
5469 : } else {
5470 : return SWIG_OverflowError;
5471 : }
5472 : } else
5473 : #endif
5474 : if (PyLong_Check(obj)) {
5475 : unsigned long v = PyLong_AsUnsignedLong(obj);
5476 : if (!PyErr_Occurred()) {
5477 : if (val) *val = v;
5478 : return SWIG_OK;
5479 : } else {
5480 : PyErr_Clear();
5481 : return SWIG_OverflowError;
5482 : }
5483 : }
5484 : #ifdef SWIG_PYTHON_CAST_MODE
5485 : {
5486 : int dispatch = 0;
5487 : unsigned long v = PyLong_AsUnsignedLong(obj);
5488 : if (!PyErr_Occurred()) {
5489 : if (val) *val = v;
5490 : return SWIG_AddCast(SWIG_OK);
5491 : } else {
5492 : PyErr_Clear();
5493 : }
5494 : if (!dispatch) {
5495 : double d;
5496 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
5497 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
5498 : if (val) *val = (unsigned long)(d);
5499 : return res;
5500 : }
5501 : }
5502 : }
5503 : #endif
5504 : return SWIG_TypeError;
5505 : }
5506 :
5507 :
5508 : #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
5509 : # define SWIG_LONG_LONG_AVAILABLE
5510 : #endif
5511 :
5512 :
5513 : #ifdef SWIG_LONG_LONG_AVAILABLE
5514 : SWIGINTERN int
5515 : SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
5516 : {
5517 : int res = SWIG_TypeError;
5518 : if (PyLong_Check(obj)) {
5519 : unsigned long long v = PyLong_AsUnsignedLongLong(obj);
5520 : if (!PyErr_Occurred()) {
5521 : if (val) *val = v;
5522 : return SWIG_OK;
5523 : } else {
5524 : PyErr_Clear();
5525 : res = SWIG_OverflowError;
5526 : }
5527 : } else {
5528 : unsigned long v;
5529 : res = SWIG_AsVal_unsigned_SS_long (obj,&v);
5530 : if (SWIG_IsOK(res)) {
5531 : if (val) *val = v;
5532 : return res;
5533 : }
5534 : }
5535 : #ifdef SWIG_PYTHON_CAST_MODE
5536 : {
5537 : const double mant_max = 1LL << DBL_MANT_DIG;
5538 : double d;
5539 : res = SWIG_AsVal_double (obj,&d);
5540 : if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
5541 : return SWIG_OverflowError;
5542 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
5543 : if (val) *val = (unsigned long long)(d);
5544 : return SWIG_AddCast(res);
5545 : }
5546 : res = SWIG_TypeError;
5547 : }
5548 : #endif
5549 : return res;
5550 : }
5551 : #endif
5552 :
5553 :
5554 : SWIGINTERNINLINE int
5555 : SWIG_AsVal_size_t (PyObject * obj, size_t *val)
5556 : {
5557 : int res = SWIG_TypeError;
5558 : #ifdef SWIG_LONG_LONG_AVAILABLE
5559 : if (sizeof(size_t) <= sizeof(unsigned long)) {
5560 : #endif
5561 : unsigned long v;
5562 : res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
5563 : if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
5564 : #ifdef SWIG_LONG_LONG_AVAILABLE
5565 : } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
5566 : unsigned long long v;
5567 : res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
5568 : if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
5569 : }
5570 : #endif
5571 : return res;
5572 : }
5573 :
5574 :
5575 116574 : OGRGeometryShadow* CreateGeometryFromWkt( char **val,
5576 : OSRSpatialReferenceShadow *reference=NULL ) {
5577 116574 : OGRGeometryH geom = NULL;
5578 116574 : OGRErr err = OGR_G_CreateFromWkt(val,
5579 : reference,
5580 : &geom);
5581 116574 : if (err != 0 ) {
5582 237 : CPLError(CE_Failure, err, "%s", OGRErrMessages(err));
5583 237 : return NULL;
5584 : }
5585 116337 : return (OGRGeometryShadow*) geom;
5586 : }
5587 :
5588 :
5589 :
5590 280 : OGRGeometryShadow *CreateGeometryFromGML( const char * input_string ) {
5591 280 : OGRGeometryShadow* geom = (OGRGeometryShadow*)OGR_G_CreateFromGML(input_string);
5592 280 : return geom;
5593 : }
5594 :
5595 :
5596 :
5597 42 : OGRGeometryShadow *CreateGeometryFromJson( const char * input_string ) {
5598 42 : OGRGeometryShadow* geom = (OGRGeometryShadow*)OGR_G_CreateGeometryFromJson(input_string);
5599 42 : return geom;
5600 : }
5601 :
5602 :
5603 :
5604 2 : OGRGeometryShadow *CreateGeometryFromEsriJson( const char * input_string ) {
5605 2 : OGRGeometryShadow* geom = (OGRGeometryShadow*)OGR_G_CreateGeometryFromEsriJson(input_string);
5606 2 : return geom;
5607 : }
5608 :
5609 :
5610 :
5611 5 : OGRGeometryShadow* BuildPolygonFromEdges( OGRGeometryShadow* hLineCollection,
5612 : int bBestEffort = 0,
5613 : int bAutoClose = 0,
5614 : double dfTolerance=0) {
5615 :
5616 5 : OGRGeometryH hPolygon = NULL;
5617 :
5618 5 : OGRErr eErr;
5619 :
5620 5 : hPolygon = OGRBuildPolygonFromEdges( hLineCollection, bBestEffort,
5621 : bAutoClose, dfTolerance, &eErr );
5622 :
5623 5 : if (eErr != OGRERR_NONE ) {
5624 2 : CPLError(CE_Failure, eErr, "%s", OGRErrMessages(eErr));
5625 2 : return NULL;
5626 : }
5627 :
5628 : return (OGRGeometryShadow* )hPolygon;
5629 : }
5630 :
5631 :
5632 1 : OGRGeometryShadow* ApproximateArcAngles(
5633 : double dfCenterX, double dfCenterY, double dfZ,
5634 : double dfPrimaryRadius, double dfSecondaryAxis, double dfRotation,
5635 : double dfStartAngle, double dfEndAngle,
5636 : double dfMaxAngleStepSizeDegrees ) {
5637 :
5638 1 : return (OGRGeometryShadow* )OGR_G_ApproximateArcAngles(
5639 : dfCenterX, dfCenterY, dfZ,
5640 : dfPrimaryRadius, dfSecondaryAxis, dfRotation,
5641 1 : dfStartAngle, dfEndAngle, dfMaxAngleStepSizeDegrees );
5642 : }
5643 :
5644 :
5645 46 : OGRGeometryShadow* ForceToPolygon( OGRGeometryShadow *geom_in ) {
5646 46 : if (geom_in == NULL)
5647 : return NULL;
5648 45 : return (OGRGeometryShadow* )OGR_G_ForceToPolygon( OGR_G_Clone(geom_in) );
5649 : }
5650 :
5651 :
5652 60 : OGRGeometryShadow* ForceToLineString( OGRGeometryShadow *geom_in ) {
5653 60 : if (geom_in == NULL)
5654 : return NULL;
5655 59 : return (OGRGeometryShadow* )OGR_G_ForceToLineString( OGR_G_Clone(geom_in) );
5656 : }
5657 :
5658 :
5659 47 : OGRGeometryShadow* ForceToMultiPolygon( OGRGeometryShadow *geom_in ) {
5660 47 : if (geom_in == NULL)
5661 : return NULL;
5662 46 : return (OGRGeometryShadow* )OGR_G_ForceToMultiPolygon( OGR_G_Clone(geom_in) );
5663 : }
5664 :
5665 :
5666 42 : OGRGeometryShadow* ForceToMultiPoint( OGRGeometryShadow *geom_in ) {
5667 42 : if (geom_in == NULL)
5668 : return NULL;
5669 41 : return (OGRGeometryShadow* )OGR_G_ForceToMultiPoint( OGR_G_Clone(geom_in) );
5670 : }
5671 :
5672 :
5673 50 : OGRGeometryShadow* ForceToMultiLineString( OGRGeometryShadow *geom_in ) {
5674 50 : if (geom_in == NULL)
5675 : return NULL;
5676 49 : return (OGRGeometryShadow* )OGR_G_ForceToMultiLineString( OGR_G_Clone(geom_in) );
5677 : }
5678 :
5679 :
5680 831 : OGRGeometryShadow* ForceTo( OGRGeometryShadow *geom_in, OGRwkbGeometryType eTargetType, char** options = NULL ) {
5681 831 : if (geom_in == NULL)
5682 : return NULL;
5683 819 : return (OGRGeometryShadow* )OGR_G_ForceTo( OGR_G_Clone(geom_in), eTargetType, options );
5684 : }
5685 :
5686 288706 : SWIGINTERN void delete_OGRGeometryShadow(OGRGeometryShadow *self){
5687 288706 : OGR_G_DestroyGeometry( self );
5688 288706 : }
5689 160958 : SWIGINTERN OGRGeometryShadow *new_OGRGeometryShadow(OGRwkbGeometryType type=wkbUnknown,char *wkt=0,int wkb=0,char *wkb_buf=0,char *gml=0){
5690 160958 : if (type != wkbUnknown ) {
5691 160795 : return (OGRGeometryShadow*) OGR_G_CreateGeometry( type );
5692 : }
5693 163 : else if ( wkt != 0 ) {
5694 162 : return CreateGeometryFromWkt( &wkt );
5695 : }
5696 1 : else if ( wkb != 0 ) {
5697 0 : return CreateGeometryFromWkb( wkb, wkb_buf );
5698 : }
5699 1 : else if ( gml != 0 ) {
5700 0 : return CreateGeometryFromGML( gml );
5701 : }
5702 : // throw?
5703 : else {
5704 1 : CPLError(CE_Failure, 1, "Empty geometries cannot be constructed");
5705 1 : return NULL;}
5706 :
5707 : }
5708 2396 : SWIGINTERN OGRErr OGRGeometryShadow_ExportToWkt(OGRGeometryShadow *self,char **argout){
5709 2396 : return OGR_G_ExportToWkt(self, argout);
5710 : }
5711 5407 : SWIGINTERN OGRErr OGRGeometryShadow_ExportToIsoWkt(OGRGeometryShadow *self,char **argout){
5712 5407 : return OGR_G_ExportToIsoWkt(self, argout);
5713 : }
5714 103 : SWIGINTERN OGRErr OGRGeometryShadow_ExportToWkb(OGRGeometryShadow *self,size_t *nLen,char **pBuf,OGRwkbByteOrder byte_order=wkbNDR){
5715 103 : *nLen = OGR_G_WkbSizeEx( self );
5716 103 : *pBuf = (char *) VSI_MALLOC_VERBOSE( *nLen );
5717 103 : if( *pBuf == NULL )
5718 : return 6;
5719 103 : return OGR_G_ExportToWkb(self, byte_order, (unsigned char*) *pBuf );
5720 : }
5721 10570 : SWIGINTERN OGRErr OGRGeometryShadow_ExportToIsoWkb(OGRGeometryShadow *self,size_t *nLen,char **pBuf,OGRwkbByteOrder byte_order=wkbNDR){
5722 10570 : *nLen = OGR_G_WkbSizeEx( self );
5723 10570 : *pBuf = (char *) VSI_MALLOC_VERBOSE( *nLen );
5724 10570 : if( *pBuf == NULL )
5725 : return 6;
5726 10570 : return OGR_G_ExportToIsoWkb(self, byte_order, (unsigned char*) *pBuf );
5727 : }
5728 66 : SWIGINTERN retStringAndCPLFree *OGRGeometryShadow_ExportToGML(OGRGeometryShadow *self,char **options=0){
5729 66 : return (retStringAndCPLFree*) OGR_G_ExportToGMLEx(self, options);
5730 : }
5731 0 : SWIGINTERN retStringAndCPLFree *OGRGeometryShadow_ExportToKML(OGRGeometryShadow *self,char const *altitude_mode=NULL){
5732 0 : return (retStringAndCPLFree *) OGR_G_ExportToKML(self, altitude_mode);
5733 : }
5734 88 : SWIGINTERN retStringAndCPLFree *OGRGeometryShadow_ExportToJson(OGRGeometryShadow *self,char **options=0){
5735 88 : return (retStringAndCPLFree *) OGR_G_ExportToJsonEx(self, options);
5736 : }
5737 254 : SWIGINTERN void OGRGeometryShadow_AddPoint(OGRGeometryShadow *self,double x,double y,double z=0){
5738 254 : OGR_G_AddPoint( self, x, y, z );
5739 254 : }
5740 0 : SWIGINTERN void OGRGeometryShadow_AddPointM(OGRGeometryShadow *self,double x,double y,double m){
5741 0 : OGR_G_AddPointM( self, x, y, m );
5742 0 : }
5743 0 : SWIGINTERN void OGRGeometryShadow_AddPointZM(OGRGeometryShadow *self,double x,double y,double z,double m){
5744 0 : OGR_G_AddPointZM( self, x, y, z, m );
5745 0 : }
5746 1259 : SWIGINTERN void OGRGeometryShadow_AddPoint_2D(OGRGeometryShadow *self,double x,double y){
5747 1259 : OGR_G_AddPoint_2D( self, x, y );
5748 1259 : }
5749 9 : SWIGINTERN OGRErr OGRGeometryShadow_AddGeometryDirectly(OGRGeometryShadow *self,OGRGeometryShadow *other_disown){
5750 9 : return OGR_G_AddGeometryDirectly( self, other_disown );
5751 : }
5752 106 : SWIGINTERN OGRErr OGRGeometryShadow_AddGeometry(OGRGeometryShadow *self,OGRGeometryShadow *other){
5753 106 : return OGR_G_AddGeometry( self, other );
5754 : }
5755 87 : SWIGINTERN OGRErr OGRGeometryShadow_RemoveGeometry(OGRGeometryShadow *self,int iSubGeom){
5756 87 : return OGR_G_RemoveGeometry( self, iSubGeom, TRUE );
5757 : }
5758 12445 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Clone(OGRGeometryShadow *self){
5759 12445 : return (OGRGeometryShadow*) OGR_G_Clone(self);
5760 : }
5761 3884 : SWIGINTERN OGRwkbGeometryType OGRGeometryShadow_GetGeometryType(OGRGeometryShadow *self){
5762 3884 : return (OGRwkbGeometryType) OGR_G_GetGeometryType(self);
5763 : }
5764 16069 : SWIGINTERN char const *OGRGeometryShadow_GetGeometryName(OGRGeometryShadow *self){
5765 16069 : return (const char *) OGR_G_GetGeometryName(self);
5766 : }
5767 28 : SWIGINTERN double OGRGeometryShadow_Length(OGRGeometryShadow *self){
5768 28 : return OGR_G_Length(self);
5769 : }
5770 21 : SWIGINTERN double OGRGeometryShadow_Area(OGRGeometryShadow *self){
5771 21 : return OGR_G_Area(self);
5772 : }
5773 22 : SWIGINTERN double OGRGeometryShadow_GeodesicLength(OGRGeometryShadow *self){
5774 22 : return OGR_G_GeodesicLength(self);
5775 : }
5776 24 : SWIGINTERN double OGRGeometryShadow_GeodesicArea(OGRGeometryShadow *self){
5777 24 : return OGR_G_GeodesicArea(self);
5778 : }
5779 33 : SWIGINTERN bool OGRGeometryShadow_IsClockwise(OGRGeometryShadow *self){
5780 33 : return OGR_G_IsClockwise(self);
5781 : }
5782 1386 : SWIGINTERN double OGRGeometryShadow_GetArea(OGRGeometryShadow *self){
5783 1386 : return OGR_G_Area(self);
5784 : }
5785 12833 : SWIGINTERN int OGRGeometryShadow_GetPointCount(OGRGeometryShadow *self){
5786 12833 : return OGR_G_GetPointCount(self);
5787 : }
5788 11 : SWIGINTERN void OGRGeometryShadow_GetPoints(OGRGeometryShadow *self,int *pnCount,double **ppadfXY,double **ppadfZ,int nCoordDimension=0){
5789 11 : int nPoints = OGR_G_GetPointCount(self);
5790 11 : *pnCount = nPoints;
5791 11 : if (nPoints == 0)
5792 : {
5793 1 : *ppadfXY = NULL;
5794 1 : *ppadfZ = NULL;
5795 : }
5796 11 : *ppadfXY = (double*)VSIMalloc(2 * sizeof(double) * nPoints);
5797 11 : if (*ppadfXY == NULL)
5798 : {
5799 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Cannot allocate resulting array");
5800 0 : *pnCount = 0;
5801 0 : return;
5802 : }
5803 11 : if (nCoordDimension <= 0)
5804 7 : nCoordDimension = OGR_G_GetCoordinateDimension(self);
5805 11 : *ppadfZ = (nCoordDimension == 3) ? (double*)VSIMalloc(sizeof(double) * nPoints) : NULL;
5806 11 : OGR_G_GetPoints(self,
5807 : *ppadfXY, 2 * sizeof(double),
5808 11 : (*ppadfXY) + 1, 2 * sizeof(double),
5809 : *ppadfZ, sizeof(double));
5810 : }
5811 32096 : SWIGINTERN double OGRGeometryShadow_GetX(OGRGeometryShadow *self,int point=0){
5812 32096 : return OGR_G_GetX(self, point);
5813 : }
5814 30886 : SWIGINTERN double OGRGeometryShadow_GetY(OGRGeometryShadow *self,int point=0){
5815 30886 : return OGR_G_GetY(self, point);
5816 : }
5817 15324 : SWIGINTERN double OGRGeometryShadow_GetZ(OGRGeometryShadow *self,int point=0){
5818 15324 : return OGR_G_GetZ(self, point);
5819 : }
5820 2266 : SWIGINTERN double OGRGeometryShadow_GetM(OGRGeometryShadow *self,int point=0){
5821 2266 : return OGR_G_GetM(self, point);
5822 : }
5823 217 : SWIGINTERN void OGRGeometryShadow_GetPoint(OGRGeometryShadow *self,int iPoint=0,double argout[3]=NULL){
5824 :
5825 217 : OGR_G_GetPoint( self, iPoint, argout+0, argout+1, argout+2 );
5826 217 : }
5827 1 : SWIGINTERN void OGRGeometryShadow_GetPointZM(OGRGeometryShadow *self,int iPoint=0,double argout[4]=NULL){
5828 :
5829 1 : OGR_G_GetPointZM( self, iPoint, argout+0, argout+1, argout+2, argout+3 );
5830 1 : }
5831 3 : SWIGINTERN void OGRGeometryShadow_GetPoint_2D(OGRGeometryShadow *self,int iPoint=0,double argout[2]=NULL){
5832 :
5833 3 : OGR_G_GetPoint( self, iPoint, argout+0, argout+1, NULL );
5834 3 : }
5835 12119 : SWIGINTERN int OGRGeometryShadow_GetGeometryCount(OGRGeometryShadow *self){
5836 12119 : return OGR_G_GetGeometryCount(self);
5837 : }
5838 168 : SWIGINTERN void OGRGeometryShadow_SetPoint(OGRGeometryShadow *self,int point,double x,double y,double z=0){
5839 168 : OGR_G_SetPoint(self, point, x, y, z);
5840 168 : }
5841 0 : SWIGINTERN void OGRGeometryShadow_SetPointM(OGRGeometryShadow *self,int point,double x,double y,double m){
5842 0 : OGR_G_SetPointM(self, point, x, y, m);
5843 0 : }
5844 0 : SWIGINTERN void OGRGeometryShadow_SetPointZM(OGRGeometryShadow *self,int point,double x,double y,double z,double m){
5845 0 : OGR_G_SetPointZM(self, point, x, y, z, m);
5846 0 : }
5847 160062 : SWIGINTERN void OGRGeometryShadow_SetPoint_2D(OGRGeometryShadow *self,int point,double x,double y){
5848 160062 : OGR_G_SetPoint_2D(self, point, x, y);
5849 160062 : }
5850 2 : SWIGINTERN void OGRGeometryShadow_SwapXY(OGRGeometryShadow *self){
5851 2 : OGR_G_SwapXY(self);
5852 2 : }
5853 2963 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_GetGeometryRef(OGRGeometryShadow *self,int geom){
5854 2963 : return (OGRGeometryShadow*) OGR_G_GetGeometryRef(self, geom);
5855 : }
5856 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Simplify(OGRGeometryShadow *self,double tolerance){
5857 1 : return (OGRGeometryShadow*) OGR_G_Simplify(self, tolerance);
5858 : }
5859 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_SimplifyPreserveTopology(OGRGeometryShadow *self,double tolerance){
5860 1 : return (OGRGeometryShadow*) OGR_G_SimplifyPreserveTopology(self, tolerance);
5861 : }
5862 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_DelaunayTriangulation(OGRGeometryShadow *self,double dfTolerance=0.0,int bOnlyEdges=FALSE){
5863 1 : return (OGRGeometryShadow*) OGR_G_DelaunayTriangulation(self, dfTolerance, bOnlyEdges);
5864 : }
5865 3 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Polygonize(OGRGeometryShadow *self){
5866 3 : return (OGRGeometryShadow*) OGR_G_Polygonize(self);
5867 : }
5868 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Boundary(OGRGeometryShadow *self){
5869 1 : return (OGRGeometryShadow*) OGR_G_Boundary(self);
5870 : }
5871 5 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_GetBoundary(OGRGeometryShadow *self){
5872 5 : return (OGRGeometryShadow*) OGR_G_Boundary(self);
5873 : }
5874 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_ConvexHull(OGRGeometryShadow *self){
5875 1 : return (OGRGeometryShadow*) OGR_G_ConvexHull(self);
5876 : }
5877 2 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_ConcaveHull(OGRGeometryShadow *self,double ratio,bool allowHoles){
5878 2 : return (OGRGeometryShadow*) OGR_G_ConcaveHull(self, ratio, allowHoles);
5879 : }
5880 11 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_MakeValid(OGRGeometryShadow *self,char **options=NULL){
5881 11 : return (OGRGeometryShadow*) OGR_G_MakeValidEx(self, options);
5882 : }
5883 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_SetPrecision(OGRGeometryShadow *self,double gridSize,int flags=0){
5884 1 : return (OGRGeometryShadow*) OGR_G_SetPrecision(self, gridSize, flags);
5885 : }
5886 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Normalize(OGRGeometryShadow *self){
5887 1 : return (OGRGeometryShadow*) OGR_G_Normalize(self);
5888 : }
5889 18 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_RemoveLowerDimensionSubGeoms(OGRGeometryShadow *self){
5890 18 : return (OGRGeometryShadow*) OGR_G_RemoveLowerDimensionSubGeoms(self);
5891 : }
5892 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Buffer__SWIG_0(OGRGeometryShadow *self,double distance,int quadsecs=30){
5893 : return (OGRGeometryShadow*) OGR_G_Buffer( self, distance, quadsecs );
5894 : }
5895 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Buffer__SWIG_1(OGRGeometryShadow *self,double distance,char **options){
5896 : return (OGRGeometryShadow*) OGR_G_BufferEx( self, distance, options );
5897 : }
5898 11 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Intersection(OGRGeometryShadow *self,OGRGeometryShadow *other){
5899 11 : return (OGRGeometryShadow*) OGR_G_Intersection( self, other );
5900 : }
5901 7 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Union(OGRGeometryShadow *self,OGRGeometryShadow *other){
5902 7 : return (OGRGeometryShadow*) OGR_G_Union( self, other );
5903 : }
5904 2 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_UnionCascaded(OGRGeometryShadow *self){
5905 2 : return (OGRGeometryShadow*) OGR_G_UnionCascaded( self );
5906 : }
5907 2 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_UnaryUnion(OGRGeometryShadow *self){
5908 2 : return (OGRGeometryShadow*) OGR_G_UnaryUnion( self );
5909 : }
5910 5 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Difference(OGRGeometryShadow *self,OGRGeometryShadow *other){
5911 5 : return (OGRGeometryShadow*) OGR_G_Difference( self, other );
5912 : }
5913 5 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_SymDifference(OGRGeometryShadow *self,OGRGeometryShadow *other){
5914 5 : return (OGRGeometryShadow*) OGR_G_SymDifference( self, other );
5915 : }
5916 1 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_SymmetricDifference(OGRGeometryShadow *self,OGRGeometryShadow *other){
5917 1 : return (OGRGeometryShadow*) OGR_G_SymDifference( self, other );
5918 : }
5919 1 : SWIGINTERN double OGRGeometryShadow_Distance(OGRGeometryShadow *self,OGRGeometryShadow *other){
5920 1 : return OGR_G_Distance(self, other);
5921 : }
5922 1 : SWIGINTERN double OGRGeometryShadow_Distance3D(OGRGeometryShadow *self,OGRGeometryShadow *other){
5923 1 : return OGR_G_Distance3D(self, other);
5924 : }
5925 4 : SWIGINTERN void OGRGeometryShadow_Empty(OGRGeometryShadow *self){
5926 4 : OGR_G_Empty(self);
5927 4 : }
5928 2126 : SWIGINTERN bool OGRGeometryShadow_IsEmpty(OGRGeometryShadow *self){
5929 4252 : return (OGR_G_IsEmpty(self) > 0);
5930 : }
5931 19 : SWIGINTERN bool OGRGeometryShadow_IsValid(OGRGeometryShadow *self){
5932 38 : return (OGR_G_IsValid(self) > 0);
5933 : }
5934 5 : SWIGINTERN bool OGRGeometryShadow_IsSimple(OGRGeometryShadow *self){
5935 10 : return (OGR_G_IsSimple(self) > 0);
5936 : }
5937 1 : SWIGINTERN bool OGRGeometryShadow_IsRing(OGRGeometryShadow *self){
5938 2 : return (OGR_G_IsRing(self) > 0);
5939 : }
5940 7 : SWIGINTERN bool OGRGeometryShadow_Intersects(OGRGeometryShadow *self,OGRGeometryShadow *other){
5941 14 : return (OGR_G_Intersects(self, other) > 0);
5942 : }
5943 2 : SWIGINTERN bool OGRGeometryShadow_Intersect(OGRGeometryShadow *self,OGRGeometryShadow *other){
5944 4 : return (OGR_G_Intersects(self, other) > 0);
5945 : }
5946 28071 : SWIGINTERN bool OGRGeometryShadow_Equals(OGRGeometryShadow *self,OGRGeometryShadow *other){
5947 56142 : return (OGR_G_Equals(self, other) > 0);
5948 : }
5949 170 : SWIGINTERN bool OGRGeometryShadow_Equal(OGRGeometryShadow *self,OGRGeometryShadow *other){
5950 340 : return (OGR_G_Equals(self, other) > 0);
5951 : }
5952 6 : SWIGINTERN bool OGRGeometryShadow_Disjoint(OGRGeometryShadow *self,OGRGeometryShadow *other){
5953 12 : return (OGR_G_Disjoint(self, other) > 0);
5954 : }
5955 6 : SWIGINTERN bool OGRGeometryShadow_Touches(OGRGeometryShadow *self,OGRGeometryShadow *other){
5956 12 : return (OGR_G_Touches(self, other) > 0);
5957 : }
5958 6 : SWIGINTERN bool OGRGeometryShadow_Crosses(OGRGeometryShadow *self,OGRGeometryShadow *other){
5959 12 : return (OGR_G_Crosses(self, other) > 0);
5960 : }
5961 6165 : SWIGINTERN bool OGRGeometryShadow_Within(OGRGeometryShadow *self,OGRGeometryShadow *other){
5962 12330 : return (OGR_G_Within(self, other) > 0);
5963 : }
5964 9 : SWIGINTERN bool OGRGeometryShadow_Contains(OGRGeometryShadow *self,OGRGeometryShadow *other){
5965 18 : return (OGR_G_Contains(self, other) > 0);
5966 : }
5967 6 : SWIGINTERN bool OGRGeometryShadow_Overlaps(OGRGeometryShadow *self,OGRGeometryShadow *other){
5968 12 : return (OGR_G_Overlaps(self, other) > 0);
5969 : }
5970 9 : SWIGINTERN OGRErr OGRGeometryShadow_TransformTo(OGRGeometryShadow *self,OSRSpatialReferenceShadow *reference){
5971 9 : return OGR_G_TransformTo(self, reference);
5972 : }
5973 : SWIGINTERN OGRErr OGRGeometryShadow_Transform__SWIG_0(OGRGeometryShadow *self,OSRCoordinateTransformationShadow *trans){
5974 : return OGR_G_Transform(self, trans);
5975 : }
5976 48 : SWIGINTERN OSRSpatialReferenceShadow *OGRGeometryShadow_GetSpatialReference(OGRGeometryShadow *self){
5977 96 : OGRSpatialReferenceH ref = OGR_G_GetSpatialReference(self);
5978 48 : if( ref )
5979 47 : OSRReference(ref);
5980 48 : return (OSRSpatialReferenceShadow*) ref;
5981 : }
5982 71 : SWIGINTERN void OGRGeometryShadow_AssignSpatialReference(OGRGeometryShadow *self,OSRSpatialReferenceShadow *reference){
5983 71 : OGR_G_AssignSpatialReference(self, reference);
5984 71 : }
5985 6 : SWIGINTERN void OGRGeometryShadow_CloseRings(OGRGeometryShadow *self){
5986 6 : OGR_G_CloseRings(self);
5987 6 : }
5988 31 : SWIGINTERN void OGRGeometryShadow_FlattenTo2D(OGRGeometryShadow *self){
5989 31 : OGR_G_FlattenTo2D(self);
5990 31 : }
5991 21 : SWIGINTERN void OGRGeometryShadow_Segmentize(OGRGeometryShadow *self,double dfMaxLength){
5992 21 : OGR_G_Segmentize(self, dfMaxLength);
5993 21 : }
5994 13139 : SWIGINTERN void OGRGeometryShadow_GetEnvelope(OGRGeometryShadow *self,double argout[4]){
5995 13139 : OGR_G_GetEnvelope(self, (OGREnvelope*)argout);
5996 13139 : }
5997 10 : SWIGINTERN void OGRGeometryShadow_GetEnvelope3D(OGRGeometryShadow *self,double argout[6]){
5998 10 : OGR_G_GetEnvelope3D(self, (OGREnvelope3D*)argout);
5999 10 : }
6000 5 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Centroid(OGRGeometryShadow *self){
6001 10 : OGRGeometryShadow *pt = (OGRGeometryShadow*) OGR_G_CreateGeometry( wkbPoint );
6002 5 : OGR_G_Centroid( self, pt );
6003 5 : return pt;
6004 : }
6005 4 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_PointOnSurface(OGRGeometryShadow *self){
6006 4 : return (OGRGeometryShadow*) OGR_G_PointOnSurface( self );
6007 : }
6008 2 : SWIGINTERN size_t OGRGeometryShadow_WkbSize(OGRGeometryShadow *self){
6009 2 : return OGR_G_WkbSizeEx(self);
6010 : }
6011 :
6012 : #define SWIG_From_long PyInt_FromLong
6013 :
6014 :
6015 : SWIGINTERNINLINE PyObject*
6016 2 : SWIG_From_unsigned_SS_long (unsigned long value)
6017 : {
6018 2 : return (value > LONG_MAX) ?
6019 2 : PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
6020 : }
6021 :
6022 :
6023 : #ifdef SWIG_LONG_LONG_AVAILABLE
6024 : SWIGINTERNINLINE PyObject*
6025 : SWIG_From_unsigned_SS_long_SS_long (unsigned long long value)
6026 : {
6027 : return (value > LONG_MAX) ?
6028 : PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
6029 : }
6030 : #endif
6031 :
6032 :
6033 : SWIGINTERNINLINE PyObject *
6034 2 : SWIG_From_size_t (size_t value)
6035 : {
6036 : #ifdef SWIG_LONG_LONG_AVAILABLE
6037 2 : if (sizeof(size_t) <= sizeof(unsigned long)) {
6038 : #endif
6039 2 : return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
6040 : #ifdef SWIG_LONG_LONG_AVAILABLE
6041 : } else {
6042 : /* assume sizeof(size_t) <= sizeof(unsigned long long) */
6043 : return SWIG_From_unsigned_SS_long_SS_long (static_cast< unsigned long long >(value));
6044 : }
6045 : #endif
6046 : }
6047 :
6048 77 : SWIGINTERN int OGRGeometryShadow_GetCoordinateDimension(OGRGeometryShadow *self){
6049 77 : return OGR_G_GetCoordinateDimension(self);
6050 : }
6051 4 : SWIGINTERN int OGRGeometryShadow_CoordinateDimension(OGRGeometryShadow *self){
6052 4 : return OGR_G_CoordinateDimension(self);
6053 : }
6054 34456 : SWIGINTERN int OGRGeometryShadow_Is3D(OGRGeometryShadow *self){
6055 34456 : return OGR_G_Is3D(self);
6056 : }
6057 37547 : SWIGINTERN int OGRGeometryShadow_IsMeasured(OGRGeometryShadow *self){
6058 37547 : return OGR_G_IsMeasured(self);
6059 : }
6060 56 : SWIGINTERN void OGRGeometryShadow_SetCoordinateDimension(OGRGeometryShadow *self,int dimension){
6061 56 : OGR_G_SetCoordinateDimension(self, dimension);
6062 56 : }
6063 154 : SWIGINTERN void OGRGeometryShadow_Set3D(OGRGeometryShadow *self,int b3D){
6064 154 : OGR_G_Set3D(self, b3D);
6065 154 : }
6066 154 : SWIGINTERN void OGRGeometryShadow_SetMeasured(OGRGeometryShadow *self,int bMeasured){
6067 154 : OGR_G_SetMeasured(self, bMeasured);
6068 154 : }
6069 21 : SWIGINTERN int OGRGeometryShadow_GetDimension(OGRGeometryShadow *self){
6070 21 : return OGR_G_GetDimension(self);
6071 : }
6072 29 : SWIGINTERN int OGRGeometryShadow_HasCurveGeometry(OGRGeometryShadow *self,int bLookForCircular=FALSE){
6073 29 : return OGR_G_HasCurveGeometry(self, bLookForCircular);
6074 : }
6075 3083 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_GetLinearGeometry(OGRGeometryShadow *self,double dfMaxAngleStepSizeDegrees=0.0,char **options=NULL){
6076 3083 : return (OGRGeometryShadow* )OGR_G_GetLinearGeometry(self, dfMaxAngleStepSizeDegrees, options);
6077 : }
6078 3064 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_GetCurveGeometry(OGRGeometryShadow *self,char **options=NULL){
6079 3064 : return (OGRGeometryShadow* )OGR_G_GetCurveGeometry(self, options);
6080 : }
6081 22 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Value(OGRGeometryShadow *self,double dfDistance){
6082 22 : return OGR_G_Value(self, dfDistance);
6083 : }
6084 : SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Transform__SWIG_1(OGRGeometryShadow *self,OGRGeomTransformerShadow *transformer){
6085 : return (OGRGeometryShadow*)OGR_GeomTransformer_Transform(transformer, self);
6086 : }
6087 1 : SWIGINTERN OGRPreparedGeometryShadow *OGRGeometryShadow_CreatePreparedGeometry(OGRGeometryShadow *self){
6088 1 : return (OGRPreparedGeometryShadow*)OGRCreatePreparedGeometry(self);
6089 : }
6090 1 : SWIGINTERN void delete_OGRPreparedGeometryShadow(OGRPreparedGeometryShadow *self){
6091 1 : OGRDestroyPreparedGeometry( self );
6092 1 : }
6093 3 : SWIGINTERN bool OGRPreparedGeometryShadow_Intersects(OGRPreparedGeometryShadow *self,OGRGeometryShadow const *otherGeom){
6094 6 : return OGRPreparedGeometryIntersects(self, (OGRGeometryH)otherGeom);
6095 : }
6096 3 : SWIGINTERN bool OGRPreparedGeometryShadow_Contains(OGRPreparedGeometryShadow *self,OGRGeometryShadow const *otherGeom){
6097 6 : return OGRPreparedGeometryContains(self, (OGRGeometryH)otherGeom);
6098 : }
6099 6 : SWIGINTERN OGRGeomTransformerShadow *new_OGRGeomTransformerShadow(OSRCoordinateTransformationShadow *ct,char **options=NULL){
6100 6 : return OGR_GeomTransformer_Create(ct, options);
6101 : }
6102 6 : SWIGINTERN void delete_OGRGeomTransformerShadow(OGRGeomTransformerShadow *self){
6103 6 : OGR_GeomTransformer_Destroy( self );
6104 6 : }
6105 2 : SWIGINTERN OGRGeometryShadow *OGRGeomTransformerShadow_Transform(OGRGeomTransformerShadow *self,OGRGeometryShadow *src_geom){
6106 2 : return (OGRGeometryShadow*)OGR_GeomTransformer_Transform(self, src_geom);
6107 : }
6108 44 : SWIGINTERN void delete_OGRFieldDomainShadow(OGRFieldDomainShadow *self){
6109 44 : OGR_FldDomain_Destroy(self);
6110 44 : }
6111 57 : SWIGINTERN char const *OGRFieldDomainShadow_GetName(OGRFieldDomainShadow *self){
6112 57 : return OGR_FldDomain_GetName(self);
6113 : }
6114 61 : SWIGINTERN char const *OGRFieldDomainShadow_GetDescription(OGRFieldDomainShadow *self){
6115 61 : return OGR_FldDomain_GetDescription(self);
6116 : }
6117 60 : SWIGINTERN OGRFieldType OGRFieldDomainShadow_GetFieldType(OGRFieldDomainShadow *self){
6118 60 : return OGR_FldDomain_GetFieldType(self);
6119 : }
6120 40 : SWIGINTERN OGRFieldSubType OGRFieldDomainShadow_GetFieldSubType(OGRFieldDomainShadow *self){
6121 40 : return OGR_FldDomain_GetFieldSubType(self);
6122 : }
6123 54 : SWIGINTERN OGRFieldDomainType OGRFieldDomainShadow_GetDomainType(OGRFieldDomainShadow *self){
6124 54 : return OGR_FldDomain_GetDomainType(self);
6125 : }
6126 2 : SWIGINTERN OGRFieldDomainSplitPolicy OGRFieldDomainShadow_GetSplitPolicy(OGRFieldDomainShadow *self){
6127 2 : return OGR_FldDomain_GetSplitPolicy(self);
6128 : }
6129 1 : SWIGINTERN void OGRFieldDomainShadow_SetSplitPolicy(OGRFieldDomainShadow *self,OGRFieldDomainSplitPolicy policy){
6130 1 : OGR_FldDomain_SetSplitPolicy(self, policy);
6131 1 : }
6132 2 : SWIGINTERN OGRFieldDomainMergePolicy OGRFieldDomainShadow_GetMergePolicy(OGRFieldDomainShadow *self){
6133 2 : return OGR_FldDomain_GetMergePolicy(self);
6134 : }
6135 1 : SWIGINTERN void OGRFieldDomainShadow_SetMergePolicy(OGRFieldDomainShadow *self,OGRFieldDomainMergePolicy policy){
6136 1 : OGR_FldDomain_SetMergePolicy(self, policy);
6137 1 : }
6138 38 : SWIGINTERN OGRCodedValue const *OGRFieldDomainShadow_GetEnumeration(OGRFieldDomainShadow *self){
6139 38 : return OGR_CodedFldDomain_GetEnumeration(self);
6140 : }
6141 12 : SWIGINTERN double OGRFieldDomainShadow_GetMinAsDouble(OGRFieldDomainShadow *self){
6142 12 : const OGRField* psVal = OGR_RangeFldDomain_GetMin(self, NULL);
6143 12 : if( psVal == NULL || OGR_RawField_IsUnset(psVal) )
6144 2 : return CPLAtof("-inf");
6145 10 : const OGRFieldType eType = OGR_FldDomain_GetFieldType(self);
6146 10 : if( eType == OFTInteger )
6147 6 : return psVal->Integer;
6148 4 : if( eType == OFTInteger64 )
6149 2 : return (double)psVal->Integer64;
6150 2 : if( eType == OFTReal )
6151 2 : return psVal->Real;
6152 0 : return CPLAtof("-inf");
6153 : }
6154 2 : SWIGINTERN char const *OGRFieldDomainShadow_GetMinAsString(OGRFieldDomainShadow *self){
6155 2 : const OGRField* psVal = OGR_RangeFldDomain_GetMin(self, NULL);
6156 2 : if( psVal == NULL || OGR_RawField_IsUnset(psVal) )
6157 0 : return NULL;
6158 2 : const OGRFieldType eType = OGR_FldDomain_GetFieldType(self);
6159 2 : if( eType == OFTInteger )
6160 0 : return CPLSPrintf("%d", psVal->Integer);
6161 2 : if( eType == OFTInteger64 )
6162 0 : return CPLSPrintf(CPL_FRMT_GIB, psVal->Integer64);
6163 2 : if( eType == OFTReal )
6164 0 : return CPLSPrintf("%.18g", psVal->Real);
6165 2 : if( eType == OFTDateTime )
6166 2 : return CPLSPrintf("%04d-%02d-%02dT%02d:%02d:%02d",
6167 2 : psVal->Date.Year,
6168 2 : psVal->Date.Month,
6169 2 : psVal->Date.Day,
6170 2 : psVal->Date.Hour,
6171 2 : psVal->Date.Minute,
6172 2 : static_cast<int>(psVal->Date.Second + 0.5));
6173 : return NULL;
6174 : }
6175 7 : SWIGINTERN bool OGRFieldDomainShadow_IsMinInclusive(OGRFieldDomainShadow *self){
6176 7 : bool isInclusive = false;
6177 7 : (void)OGR_RangeFldDomain_GetMin(self, &isInclusive);
6178 7 : return isInclusive;
6179 : }
6180 12 : SWIGINTERN double OGRFieldDomainShadow_GetMaxAsDouble(OGRFieldDomainShadow *self){
6181 12 : const OGRField* psVal = OGR_RangeFldDomain_GetMax(self, NULL);
6182 12 : if( psVal == NULL || OGR_RawField_IsUnset(psVal) )
6183 2 : return CPLAtof("inf");
6184 10 : const OGRFieldType eType = OGR_FldDomain_GetFieldType(self);
6185 10 : if( eType == OFTInteger )
6186 6 : return psVal->Integer;
6187 4 : if( eType == OFTInteger64 )
6188 2 : return (double)psVal->Integer64;
6189 2 : if( eType == OFTReal )
6190 2 : return psVal->Real;
6191 0 : return CPLAtof("inf");
6192 : }
6193 2 : SWIGINTERN char const *OGRFieldDomainShadow_GetMaxAsString(OGRFieldDomainShadow *self){
6194 2 : const OGRField* psVal = OGR_RangeFldDomain_GetMax(self, NULL);
6195 2 : if( psVal == NULL || OGR_RawField_IsUnset(psVal) )
6196 0 : return NULL;
6197 2 : const OGRFieldType eType = OGR_FldDomain_GetFieldType(self);
6198 2 : if( eType == OFTInteger )
6199 0 : return CPLSPrintf("%d", psVal->Integer);
6200 2 : if( eType == OFTInteger64 )
6201 0 : return CPLSPrintf(CPL_FRMT_GIB, psVal->Integer64);
6202 2 : if( eType == OFTReal )
6203 0 : return CPLSPrintf("%.18g", psVal->Real);
6204 2 : if( eType == OFTDateTime )
6205 2 : return CPLSPrintf("%04d-%02d-%02dT%02d:%02d:%02d",
6206 2 : psVal->Date.Year,
6207 2 : psVal->Date.Month,
6208 2 : psVal->Date.Day,
6209 2 : psVal->Date.Hour,
6210 2 : psVal->Date.Minute,
6211 2 : static_cast<int>(psVal->Date.Second + 0.5));
6212 : return NULL;
6213 : }
6214 7 : SWIGINTERN bool OGRFieldDomainShadow_IsMaxInclusive(OGRFieldDomainShadow *self){
6215 7 : bool isInclusive = false;
6216 7 : (void)OGR_RangeFldDomain_GetMax(self, &isInclusive);
6217 7 : return isInclusive;
6218 : }
6219 9 : SWIGINTERN char const *OGRFieldDomainShadow_GetGlob(OGRFieldDomainShadow *self){
6220 9 : return OGR_GlobFldDomain_GetGlob(self);
6221 : }
6222 :
6223 : static
6224 20 : OGRFieldDomainShadow* CreateCodedFieldDomain( const char *name,
6225 : const char* description,
6226 : OGRFieldType type,
6227 : OGRFieldSubType subtype,
6228 : const OGRCodedValue* enumeration) {
6229 20 : return (OGRFieldDomainShadow*) OGR_CodedFldDomain_Create( name,
6230 : description,
6231 : type,
6232 : subtype,
6233 : enumeration );
6234 : }
6235 :
6236 :
6237 : static
6238 11 : OGRFieldDomainShadow* CreateRangeFieldDomain( const char *name,
6239 : const char* description,
6240 : OGRFieldType type,
6241 : OGRFieldSubType subtype,
6242 : double min,
6243 : bool minIsInclusive,
6244 : double max,
6245 : double maxIsInclusive) {
6246 11 : OGRField sMin;
6247 11 : if( type == OFTInteger )
6248 5 : sMin.Integer = static_cast<int>(min);
6249 6 : else if( type == OFTInteger64 )
6250 2 : sMin.Integer64 = static_cast<GIntBig>(min);
6251 4 : else if( type == OFTReal )
6252 3 : sMin.Real = min;
6253 : else
6254 : return NULL;
6255 10 : OGRField sMax;
6256 10 : if( type == OFTInteger )
6257 5 : sMax.Integer = static_cast<int>(max);
6258 5 : else if( type == OFTInteger64 )
6259 2 : sMax.Integer64 = static_cast<GIntBig>(max);
6260 3 : else if( type == OFTReal )
6261 3 : sMax.Real = max;
6262 : else
6263 : return NULL;
6264 10 : return (OGRFieldDomainShadow*) OGR_RangeFldDomain_Create( name,
6265 : description,
6266 : type,
6267 : subtype,
6268 : &sMin,
6269 : minIsInclusive,
6270 : &sMax,
6271 : maxIsInclusive );
6272 : }
6273 :
6274 :
6275 : static
6276 2 : OGRFieldDomainShadow* CreateRangeFieldDomainDateTime( const char *name,
6277 : const char* description,
6278 : const char* min,
6279 : bool minIsInclusive,
6280 : const char* max,
6281 : double maxIsInclusive) {
6282 2 : OGRField sMin;
6283 2 : OGRField sMax;
6284 2 : if( !OGRParseXMLDateTime(min, &sMin))
6285 : {
6286 0 : CPLError(CE_Failure, CPLE_AppDefined,
6287 : "Invalid min: %s",
6288 : min);
6289 0 : return NULL;
6290 : }
6291 2 : if( !OGRParseXMLDateTime(max, &sMax))
6292 : {
6293 0 : CPLError(CE_Failure, CPLE_AppDefined,
6294 : "Invalid max: %s",
6295 : max);
6296 0 : return NULL;
6297 : }
6298 2 : return (OGRFieldDomainShadow*) OGR_RangeFldDomain_Create( name,
6299 : description,
6300 : OFTDateTime,
6301 : OFSTNone,
6302 : &sMin,
6303 : minIsInclusive,
6304 : &sMax,
6305 : maxIsInclusive );
6306 : }
6307 :
6308 :
6309 : static
6310 14 : OGRFieldDomainShadow* CreateGlobFieldDomain( const char *name,
6311 : const char* description,
6312 : OGRFieldType type,
6313 : OGRFieldSubType subtype,
6314 : const char* glob ) {
6315 14 : return (OGRFieldDomainShadow*) OGR_GlobFldDomain_Create( name,
6316 : description,
6317 : type,
6318 : subtype,
6319 : glob );
6320 : }
6321 :
6322 20 : SWIGINTERN void delete_OGRGeomCoordinatePrecisionShadow(OGRGeomCoordinatePrecisionShadow *self){
6323 20 : OGRGeomCoordinatePrecisionDestroy(self);
6324 20 : }
6325 20 : SWIGINTERN void OGRGeomCoordinatePrecisionShadow_Set(OGRGeomCoordinatePrecisionShadow *self,double xyResolution,double zResolution,double mResolution){
6326 20 : OGRGeomCoordinatePrecisionSet(self, xyResolution, zResolution, mResolution);
6327 20 : }
6328 3 : SWIGINTERN void OGRGeomCoordinatePrecisionShadow_SetFromMeter(OGRGeomCoordinatePrecisionShadow *self,OSRSpatialReferenceShadow *srs,double xyMeterResolution,double zMeterResolution,double mResolution){
6329 3 : OGRGeomCoordinatePrecisionSetFromMeter(self, srs, xyMeterResolution, zMeterResolution, mResolution);
6330 3 : }
6331 47 : SWIGINTERN double OGRGeomCoordinatePrecisionShadow_GetXYResolution(OGRGeomCoordinatePrecisionShadow *self){
6332 47 : return OGRGeomCoordinatePrecisionGetXYResolution(self);
6333 : }
6334 44 : SWIGINTERN double OGRGeomCoordinatePrecisionShadow_GetZResolution(OGRGeomCoordinatePrecisionShadow *self){
6335 44 : return OGRGeomCoordinatePrecisionGetZResolution(self);
6336 : }
6337 29 : SWIGINTERN double OGRGeomCoordinatePrecisionShadow_GetMResolution(OGRGeomCoordinatePrecisionShadow *self){
6338 29 : return OGRGeomCoordinatePrecisionGetMResolution(self);
6339 : }
6340 6 : SWIGINTERN char **OGRGeomCoordinatePrecisionShadow_GetFormats(OGRGeomCoordinatePrecisionShadow *self){
6341 6 : return OGRGeomCoordinatePrecisionGetFormats(self);
6342 : }
6343 7 : SWIGINTERN char **OGRGeomCoordinatePrecisionShadow_GetFormatSpecificOptions(OGRGeomCoordinatePrecisionShadow *self,char const *formatName){
6344 7 : return OGRGeomCoordinatePrecisionGetFormatSpecificOptions(self, formatName);
6345 : }
6346 1 : SWIGINTERN void OGRGeomCoordinatePrecisionShadow_SetFormatSpecificOptions(OGRGeomCoordinatePrecisionShadow *self,char const *formatName,char **formatSpecificOptions){
6347 1 : OGRGeomCoordinatePrecisionSetFormatSpecificOptions(self, formatName, formatSpecificOptions);
6348 1 : }
6349 :
6350 : static
6351 20 : OGRGeomCoordinatePrecisionShadow* CreateGeomCoordinatePrecision() {
6352 20 : return OGRGeomCoordinatePrecisionCreate();
6353 : }
6354 :
6355 :
6356 0 : char const *OGRDriverShadow_get_name( OGRDriverShadow *h ) {
6357 0 : return OGR_Dr_GetName( h );
6358 : }
6359 :
6360 0 : char const *OGRDataSourceShadow_get_name( OGRDataSourceShadow *h ) {
6361 0 : return OGR_DS_GetName( h );
6362 : }
6363 :
6364 0 : char const *OGRDriverShadow_name_get( OGRDriverShadow *h ) {
6365 0 : return OGR_Dr_GetName( h );
6366 : }
6367 :
6368 0 : char const *OGRDataSourceShadow_name_get( OGRDataSourceShadow *h ) {
6369 0 : return OGR_DS_GetName( h );
6370 : }
6371 :
6372 :
6373 18 : OGRwkbGeometryType GT_SetModifier( OGRwkbGeometryType eType, int bSetZ, int bSetM = FALSE)
6374 : {
6375 18 : return OGR_GT_SetModifier(eType, bSetZ, bSetM);
6376 : }
6377 :
6378 :
6379 1 : OGRDataSourceShadow* GetOpenDS(int ds_number) {
6380 1 : OGRDataSourceShadow* layer = (OGRDataSourceShadow*) OGRGetOpenDS(ds_number);
6381 1 : return layer;
6382 : }
6383 :
6384 :
6385 6956 : OGRDataSourceShadow* Open( const char *utf8_path, int update =0 ) {
6386 6956 : CPLErrorReset();
6387 6956 : int nOpenFlags = GDAL_OF_VECTOR;
6388 6956 : if( update )
6389 1636 : nOpenFlags |= GDAL_OF_UPDATE;
6390 : #ifdef SWIGPYTHON
6391 9028 : if( GetUseExceptions() )
6392 2630 : nOpenFlags |= GDAL_OF_VERBOSE_ERROR;
6393 : #endif
6394 6956 : OGRDataSourceShadow* ds = (OGRDataSourceShadow*)GDALOpenEx( utf8_path, nOpenFlags, NULL,
6395 : NULL, NULL );
6396 : #ifndef SWIGPYTHON
6397 : if( CPLGetLastErrorType() == CE_Failure && ds != NULL )
6398 : {
6399 : CPLDebug( "SWIG",
6400 : "OGROpen() succeeded, but an error is posted, so we destroy"
6401 : " the datasource and fail at swig level." );
6402 : OGRReleaseDataSource(ds);
6403 : ds = NULL;
6404 : }
6405 : #endif
6406 6956 : return ds;
6407 : }
6408 :
6409 :
6410 23 : OGRDataSourceShadow* OpenShared( const char *utf8_path, int update =0 ) {
6411 23 : CPLErrorReset();
6412 23 : int nOpenFlags = GDAL_OF_VECTOR | GDAL_OF_SHARED;
6413 23 : if( update )
6414 12 : nOpenFlags |= GDAL_OF_UPDATE;
6415 : #ifdef SWIGPYTHON
6416 37 : if( GetUseExceptions() )
6417 14 : nOpenFlags |= GDAL_OF_VERBOSE_ERROR;
6418 : #endif
6419 23 : OGRDataSourceShadow* ds = (OGRDataSourceShadow*)GDALOpenEx( utf8_path, nOpenFlags, NULL,
6420 : NULL, NULL );
6421 : #ifndef SWIGPYTHON
6422 : if( CPLGetLastErrorType() == CE_Failure && ds != NULL )
6423 : {
6424 : OGRReleaseDataSource(ds);
6425 : ds = NULL;
6426 : }
6427 : #endif
6428 23 : return ds;
6429 : }
6430 :
6431 :
6432 : static
6433 2603 : OGRDriverShadow* GetDriverByName( char const *name ) {
6434 2603 : return (OGRDriverShadow*) OGRGetDriverByName( name );
6435 : }
6436 :
6437 : static
6438 0 : OGRDriverShadow* GetDriver(int driver_number) {
6439 0 : return (OGRDriverShadow*) OGRGetDriver(driver_number);
6440 : }
6441 :
6442 :
6443 59 : char **GeneralCmdLineProcessor( char **papszArgv, int nOptions = 0 ) {
6444 59 : int nResArgCount;
6445 :
6446 59 : if( papszArgv == NULL )
6447 : return NULL;
6448 :
6449 118 : bool bReloadDrivers = ( CSLFindString(papszArgv, "GDAL_SKIP") >= 0 ||
6450 59 : CSLFindString(papszArgv, "OGR_SKIP") >= 0 );
6451 :
6452 59 : nResArgCount =
6453 59 : GDALGeneralCmdLineProcessor( CSLCount(papszArgv), &papszArgv, GDAL_OF_VECTOR | nOptions );
6454 :
6455 59 : if( bReloadDrivers )
6456 : {
6457 0 : GDALAllRegister();
6458 : }
6459 :
6460 59 : if( nResArgCount <= 0 )
6461 : return NULL;
6462 : else
6463 57 : return papszArgv;
6464 : }
6465 :
6466 :
6467 : static
6468 11 : int GDALTermProgress_nocb( double dfProgress, const char * pszMessage=NULL, void *pData=NULL ) {
6469 11 : return GDALTermProgress( dfProgress, pszMessage, pData);
6470 : }
6471 :
6472 : #ifdef __cplusplus
6473 : extern "C" {
6474 : #endif
6475 0 : SWIGINTERN PyObject *_wrap_GetUseExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6476 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6477 0 : int result;
6478 :
6479 0 : if (!SWIG_Python_UnpackTuple(args, "GetUseExceptions", 0, 0, 0)) SWIG_fail;
6480 0 : {
6481 : #ifdef SED_HACKS
6482 0 : if( ReturnSame(TRUE) ) bLocalUseExceptionsCode = FALSE;
6483 : #endif
6484 0 : result = GetUseExceptions();
6485 : }
6486 0 : resultobj = SWIG_From_int(static_cast< int >(result));
6487 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
6488 : return resultobj;
6489 0 : fail:
6490 0 : return NULL;
6491 : }
6492 :
6493 :
6494 9231 : SWIGINTERN PyObject *_wrap__GetExceptionsLocal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6495 9231 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6496 9231 : int result;
6497 :
6498 9231 : if (!SWIG_Python_UnpackTuple(args, "_GetExceptionsLocal", 0, 0, 0)) SWIG_fail;
6499 9231 : {
6500 : #ifdef SED_HACKS
6501 9231 : if( ReturnSame(TRUE) ) bLocalUseExceptionsCode = FALSE;
6502 : #endif
6503 9231 : result = (int)_GetExceptionsLocal();
6504 : }
6505 9231 : resultobj = SWIG_From_int(static_cast< int >(result));
6506 9231 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
6507 : return resultobj;
6508 0 : fail:
6509 0 : return NULL;
6510 : }
6511 :
6512 :
6513 18462 : SWIGINTERN PyObject *_wrap__SetExceptionsLocal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6514 18462 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6515 18462 : int arg1 ;
6516 18462 : int val1 ;
6517 18462 : int ecode1 = 0 ;
6518 18462 : PyObject *swig_obj[1] ;
6519 :
6520 18462 : if (!args) SWIG_fail;
6521 18462 : swig_obj[0] = args;
6522 18462 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6523 18462 : if (!SWIG_IsOK(ecode1)) {
6524 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_SetExceptionsLocal" "', argument " "1"" of type '" "int""'");
6525 : }
6526 18462 : arg1 = static_cast< int >(val1);
6527 18462 : {
6528 : #ifdef SED_HACKS
6529 18462 : if( ReturnSame(TRUE) ) bLocalUseExceptionsCode = FALSE;
6530 : #endif
6531 18462 : _SetExceptionsLocal(arg1);
6532 : }
6533 18462 : resultobj = SWIG_Py_Void();
6534 18462 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
6535 : return resultobj;
6536 : fail:
6537 : return NULL;
6538 : }
6539 :
6540 :
6541 26 : SWIGINTERN PyObject *_wrap__UseExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6542 26 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6543 :
6544 26 : if (!SWIG_Python_UnpackTuple(args, "_UseExceptions", 0, 0, 0)) SWIG_fail;
6545 26 : _UseExceptions();
6546 26 : resultobj = SWIG_Py_Void();
6547 26 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
6548 : return resultobj;
6549 0 : fail:
6550 0 : return NULL;
6551 : }
6552 :
6553 :
6554 5 : SWIGINTERN PyObject *_wrap__DontUseExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6555 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6556 :
6557 5 : if (!SWIG_Python_UnpackTuple(args, "_DontUseExceptions", 0, 0, 0)) SWIG_fail;
6558 5 : _DontUseExceptions();
6559 5 : resultobj = SWIG_Py_Void();
6560 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
6561 : return resultobj;
6562 0 : fail:
6563 0 : return NULL;
6564 : }
6565 :
6566 :
6567 18480 : SWIGINTERN PyObject *_wrap__UserHasSpecifiedIfUsingExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6568 18480 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6569 18480 : int result;
6570 :
6571 18480 : if (!SWIG_Python_UnpackTuple(args, "_UserHasSpecifiedIfUsingExceptions", 0, 0, 0)) SWIG_fail;
6572 18480 : {
6573 : #ifdef SED_HACKS
6574 18480 : if( ReturnSame(TRUE) ) bLocalUseExceptionsCode = FALSE;
6575 : #endif
6576 18480 : result = (int)_UserHasSpecifiedIfUsingExceptions();
6577 : }
6578 18480 : resultobj = SWIG_From_int(static_cast< int >(result));
6579 18480 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
6580 : return resultobj;
6581 0 : fail:
6582 0 : return NULL;
6583 : }
6584 :
6585 :
6586 19 : SWIGINTERN PyObject *_wrap_MajorObject_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6587 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6588 19 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
6589 19 : void *argp1 = 0 ;
6590 19 : int res1 = 0 ;
6591 19 : PyObject *swig_obj[1] ;
6592 19 : char *result = 0 ;
6593 :
6594 19 : if (!args) SWIG_fail;
6595 19 : swig_obj[0] = args;
6596 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
6597 19 : if (!SWIG_IsOK(res1)) {
6598 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetDescription" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
6599 : }
6600 19 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
6601 19 : {
6602 19 : const int bLocalUseExceptions = GetUseExceptions();
6603 19 : if ( bLocalUseExceptions ) {
6604 2 : pushErrorHandler();
6605 : }
6606 19 : {
6607 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6608 19 : result = (char *)GDALMajorObjectShadow_GetDescription(arg1);
6609 19 : SWIG_PYTHON_THREAD_END_ALLOW;
6610 : }
6611 19 : if ( bLocalUseExceptions ) {
6612 2 : popErrorHandler();
6613 : }
6614 : #ifndef SED_HACKS
6615 : if ( bLocalUseExceptions ) {
6616 : CPLErr eclass = CPLGetLastErrorType();
6617 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6618 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6619 : }
6620 : }
6621 : #endif
6622 : }
6623 19 : resultobj = SWIG_FromCharPtr((const char *)result);
6624 19 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
6625 : return resultobj;
6626 : fail:
6627 : return NULL;
6628 : }
6629 :
6630 :
6631 0 : SWIGINTERN PyObject *_wrap_MajorObject_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6632 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6633 0 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
6634 0 : char *arg2 = (char *) 0 ;
6635 0 : void *argp1 = 0 ;
6636 0 : int res1 = 0 ;
6637 0 : int res2 ;
6638 0 : char *buf2 = 0 ;
6639 0 : int alloc2 = 0 ;
6640 0 : PyObject *swig_obj[2] ;
6641 :
6642 0 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_SetDescription", 2, 2, swig_obj)) SWIG_fail;
6643 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
6644 0 : if (!SWIG_IsOK(res1)) {
6645 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_SetDescription" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
6646 : }
6647 0 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
6648 0 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
6649 0 : if (!SWIG_IsOK(res2)) {
6650 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_SetDescription" "', argument " "2"" of type '" "char const *""'");
6651 : }
6652 0 : arg2 = reinterpret_cast< char * >(buf2);
6653 0 : {
6654 0 : if (!arg2) {
6655 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
6656 : }
6657 : }
6658 0 : {
6659 0 : const int bLocalUseExceptions = GetUseExceptions();
6660 0 : if ( bLocalUseExceptions ) {
6661 0 : pushErrorHandler();
6662 : }
6663 0 : {
6664 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6665 0 : GDALMajorObjectShadow_SetDescription(arg1,(char const *)arg2);
6666 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6667 : }
6668 0 : if ( bLocalUseExceptions ) {
6669 0 : popErrorHandler();
6670 : }
6671 : #ifndef SED_HACKS
6672 : if ( bLocalUseExceptions ) {
6673 : CPLErr eclass = CPLGetLastErrorType();
6674 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6675 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6676 : }
6677 : }
6678 : #endif
6679 : }
6680 0 : resultobj = SWIG_Py_Void();
6681 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6682 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
6683 : return resultobj;
6684 0 : fail:
6685 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6686 : return NULL;
6687 : }
6688 :
6689 :
6690 8 : SWIGINTERN PyObject *_wrap_MajorObject_GetMetadataDomainList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6691 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6692 8 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
6693 8 : void *argp1 = 0 ;
6694 8 : int res1 = 0 ;
6695 8 : PyObject *swig_obj[1] ;
6696 8 : char **result = 0 ;
6697 :
6698 8 : if (!args) SWIG_fail;
6699 8 : swig_obj[0] = args;
6700 8 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
6701 8 : if (!SWIG_IsOK(res1)) {
6702 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetMetadataDomainList" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
6703 : }
6704 8 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
6705 8 : {
6706 8 : const int bLocalUseExceptions = GetUseExceptions();
6707 8 : if ( bLocalUseExceptions ) {
6708 0 : pushErrorHandler();
6709 : }
6710 8 : {
6711 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6712 8 : result = (char **)GDALMajorObjectShadow_GetMetadataDomainList(arg1);
6713 8 : SWIG_PYTHON_THREAD_END_ALLOW;
6714 : }
6715 8 : if ( bLocalUseExceptions ) {
6716 0 : popErrorHandler();
6717 : }
6718 : #ifndef SED_HACKS
6719 : if ( bLocalUseExceptions ) {
6720 : CPLErr eclass = CPLGetLastErrorType();
6721 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6722 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6723 : }
6724 : }
6725 : #endif
6726 : }
6727 8 : {
6728 : /* %typemap(out) char **CSL -> ( string ) */
6729 8 : bool bErr = false;
6730 8 : resultobj = CSLToList(result, &bErr);
6731 8 : CSLDestroy(result);
6732 8 : if( bErr ) {
6733 0 : SWIG_fail;
6734 : }
6735 : }
6736 8 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
6737 : return resultobj;
6738 : fail:
6739 : return NULL;
6740 : }
6741 :
6742 :
6743 75 : SWIGINTERN PyObject *_wrap_MajorObject_GetMetadata_Dict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6744 75 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6745 75 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
6746 75 : char *arg2 = (char *) "" ;
6747 75 : void *argp1 = 0 ;
6748 75 : int res1 = 0 ;
6749 75 : int res2 ;
6750 75 : char *buf2 = 0 ;
6751 75 : int alloc2 = 0 ;
6752 75 : PyObject *swig_obj[2] ;
6753 75 : char **result = 0 ;
6754 :
6755 75 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_GetMetadata_Dict", 1, 2, swig_obj)) SWIG_fail;
6756 75 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
6757 75 : if (!SWIG_IsOK(res1)) {
6758 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetMetadata_Dict" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
6759 : }
6760 75 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
6761 75 : if (swig_obj[1]) {
6762 62 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
6763 62 : if (!SWIG_IsOK(res2)) {
6764 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_GetMetadata_Dict" "', argument " "2"" of type '" "char const *""'");
6765 : }
6766 62 : arg2 = reinterpret_cast< char * >(buf2);
6767 : }
6768 75 : {
6769 75 : const int bLocalUseExceptions = GetUseExceptions();
6770 75 : if ( bLocalUseExceptions ) {
6771 44 : pushErrorHandler();
6772 : }
6773 75 : {
6774 75 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6775 75 : result = (char **)GDALMajorObjectShadow_GetMetadata_Dict(arg1,(char const *)arg2);
6776 75 : SWIG_PYTHON_THREAD_END_ALLOW;
6777 : }
6778 75 : if ( bLocalUseExceptions ) {
6779 44 : popErrorHandler();
6780 : }
6781 : #ifndef SED_HACKS
6782 : if ( bLocalUseExceptions ) {
6783 : CPLErr eclass = CPLGetLastErrorType();
6784 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6785 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6786 : }
6787 : }
6788 : #endif
6789 : }
6790 75 : {
6791 : /* %typemap(out) char **dict */
6792 75 : resultobj = GetCSLStringAsPyDict(result, false);
6793 : }
6794 75 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6795 75 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
6796 : return resultobj;
6797 0 : fail:
6798 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6799 : return NULL;
6800 : }
6801 :
6802 :
6803 9 : SWIGINTERN PyObject *_wrap_MajorObject_GetMetadata_List(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6804 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6805 9 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
6806 9 : char *arg2 = (char *) "" ;
6807 9 : void *argp1 = 0 ;
6808 9 : int res1 = 0 ;
6809 9 : int res2 ;
6810 9 : char *buf2 = 0 ;
6811 9 : int alloc2 = 0 ;
6812 9 : PyObject *swig_obj[2] ;
6813 9 : char **result = 0 ;
6814 :
6815 9 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_GetMetadata_List", 1, 2, swig_obj)) SWIG_fail;
6816 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
6817 9 : if (!SWIG_IsOK(res1)) {
6818 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetMetadata_List" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
6819 : }
6820 9 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
6821 9 : if (swig_obj[1]) {
6822 5 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
6823 5 : if (!SWIG_IsOK(res2)) {
6824 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_GetMetadata_List" "', argument " "2"" of type '" "char const *""'");
6825 : }
6826 5 : arg2 = reinterpret_cast< char * >(buf2);
6827 : }
6828 9 : {
6829 9 : const int bLocalUseExceptions = GetUseExceptions();
6830 9 : if ( bLocalUseExceptions ) {
6831 5 : pushErrorHandler();
6832 : }
6833 9 : {
6834 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6835 9 : result = (char **)GDALMajorObjectShadow_GetMetadata_List(arg1,(char const *)arg2);
6836 9 : SWIG_PYTHON_THREAD_END_ALLOW;
6837 : }
6838 9 : if ( bLocalUseExceptions ) {
6839 5 : popErrorHandler();
6840 : }
6841 : #ifndef SED_HACKS
6842 : if ( bLocalUseExceptions ) {
6843 : CPLErr eclass = CPLGetLastErrorType();
6844 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6845 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6846 : }
6847 : }
6848 : #endif
6849 : }
6850 9 : {
6851 : /* %typemap(out) char **options -> ( string ) */
6852 9 : bool bErr = false;
6853 9 : resultobj = CSLToList(result, &bErr);
6854 9 : if( bErr ) {
6855 0 : SWIG_fail;
6856 : }
6857 : }
6858 9 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6859 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
6860 : return resultobj;
6861 0 : fail:
6862 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6863 : return NULL;
6864 : }
6865 :
6866 :
6867 : SWIGINTERN PyObject *_wrap_MajorObject_SetMetadata__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
6868 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6869 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
6870 : char **arg2 = (char **) 0 ;
6871 : char *arg3 = (char *) "" ;
6872 : void *argp1 = 0 ;
6873 : int res1 = 0 ;
6874 : int res3 ;
6875 : char *buf3 = 0 ;
6876 : int alloc3 = 0 ;
6877 : CPLErr result;
6878 :
6879 : if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
6880 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
6881 : if (!SWIG_IsOK(res1)) {
6882 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_SetMetadata" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
6883 : }
6884 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
6885 : {
6886 : /* %typemap(in) char **dict */
6887 : arg2 = NULL;
6888 : if ( PySequence_Check( swig_obj[1] ) ) {
6889 : int bErr = FALSE;
6890 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
6891 : if ( bErr )
6892 : {
6893 : SWIG_fail;
6894 : }
6895 : }
6896 : else if ( PyMapping_Check( swig_obj[1] ) ) {
6897 : int bErr = FALSE;
6898 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
6899 : if ( bErr )
6900 : {
6901 : SWIG_fail;
6902 : }
6903 : }
6904 : else {
6905 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
6906 : SWIG_fail;
6907 : }
6908 : }
6909 : if (swig_obj[2]) {
6910 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
6911 : if (!SWIG_IsOK(res3)) {
6912 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MajorObject_SetMetadata" "', argument " "3"" of type '" "char const *""'");
6913 : }
6914 : arg3 = reinterpret_cast< char * >(buf3);
6915 : }
6916 : {
6917 : const int bLocalUseExceptions = GetUseExceptions();
6918 : if ( bLocalUseExceptions ) {
6919 : pushErrorHandler();
6920 : }
6921 : {
6922 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6923 : result = (CPLErr)GDALMajorObjectShadow_SetMetadata__SWIG_0(arg1,arg2,(char const *)arg3);
6924 : SWIG_PYTHON_THREAD_END_ALLOW;
6925 : }
6926 : if ( bLocalUseExceptions ) {
6927 : popErrorHandler();
6928 : }
6929 : #ifndef SED_HACKS
6930 : if ( bLocalUseExceptions ) {
6931 : CPLErr eclass = CPLGetLastErrorType();
6932 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6933 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6934 : }
6935 : }
6936 : #endif
6937 : }
6938 : resultobj = SWIG_From_int(static_cast< int >(result));
6939 : {
6940 : /* %typemap(freearg) char **dict */
6941 : CSLDestroy( arg2 );
6942 : }
6943 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
6944 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
6945 : return resultobj;
6946 : fail:
6947 : {
6948 : /* %typemap(freearg) char **dict */
6949 : CSLDestroy( arg2 );
6950 : }
6951 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
6952 : return NULL;
6953 : }
6954 :
6955 :
6956 : SWIGINTERN PyObject *_wrap_MajorObject_SetMetadata__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
6957 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
6958 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
6959 : char *arg2 = (char *) 0 ;
6960 : char *arg3 = (char *) "" ;
6961 : void *argp1 = 0 ;
6962 : int res1 = 0 ;
6963 : int res2 ;
6964 : char *buf2 = 0 ;
6965 : int alloc2 = 0 ;
6966 : int res3 ;
6967 : char *buf3 = 0 ;
6968 : int alloc3 = 0 ;
6969 : CPLErr result;
6970 :
6971 : if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
6972 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
6973 : if (!SWIG_IsOK(res1)) {
6974 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_SetMetadata" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
6975 : }
6976 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
6977 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
6978 : if (!SWIG_IsOK(res2)) {
6979 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_SetMetadata" "', argument " "2"" of type '" "char *""'");
6980 : }
6981 : arg2 = reinterpret_cast< char * >(buf2);
6982 : if (swig_obj[2]) {
6983 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
6984 : if (!SWIG_IsOK(res3)) {
6985 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MajorObject_SetMetadata" "', argument " "3"" of type '" "char const *""'");
6986 : }
6987 : arg3 = reinterpret_cast< char * >(buf3);
6988 : }
6989 : {
6990 : const int bLocalUseExceptions = GetUseExceptions();
6991 : if ( bLocalUseExceptions ) {
6992 : pushErrorHandler();
6993 : }
6994 : {
6995 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6996 : result = (CPLErr)GDALMajorObjectShadow_SetMetadata__SWIG_1(arg1,arg2,(char const *)arg3);
6997 : SWIG_PYTHON_THREAD_END_ALLOW;
6998 : }
6999 : if ( bLocalUseExceptions ) {
7000 : popErrorHandler();
7001 : }
7002 : #ifndef SED_HACKS
7003 : if ( bLocalUseExceptions ) {
7004 : CPLErr eclass = CPLGetLastErrorType();
7005 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7006 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7007 : }
7008 : }
7009 : #endif
7010 : }
7011 : resultobj = SWIG_From_int(static_cast< int >(result));
7012 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7013 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7014 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7015 : return resultobj;
7016 : fail:
7017 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7018 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7019 : return NULL;
7020 : }
7021 :
7022 :
7023 35 : SWIGINTERN PyObject *_wrap_MajorObject_SetMetadata(PyObject *self, PyObject *args) {
7024 35 : Py_ssize_t argc;
7025 35 : PyObject *argv[4] = {
7026 : 0
7027 : };
7028 :
7029 35 : if (!(argc = SWIG_Python_UnpackTuple(args, "MajorObject_SetMetadata", 0, 3, argv))) SWIG_fail;
7030 35 : --argc;
7031 35 : if ((argc >= 2) && (argc <= 3)) {
7032 35 : int _v;
7033 35 : void *vptr = 0;
7034 35 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GDALMajorObjectShadow, 0);
7035 39 : _v = SWIG_CheckState(res);
7036 35 : if (_v) {
7037 35 : {
7038 : /* %typecheck(SWIG_TYPECHECK_POINTER) (char **dict) */
7039 : /* Note: we exclude explicitly strings, because they can be considered as a sequence of characters, */
7040 : /* which is not desirable since it makes it impossible to define bindings such as SetMetadata(string) and SetMetadata(array_of_string) */
7041 : /* (see #4816) */
7042 35 : _v = ((PyMapping_Check(argv[1]) || PySequence_Check(argv[1]) ) && !SWIG_CheckState(SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0)) ) ? 1 : 0;
7043 : }
7044 31 : if (_v) {
7045 31 : if (argc <= 2) {
7046 31 : return _wrap_MajorObject_SetMetadata__SWIG_0(self, argc, argv);
7047 : }
7048 3 : int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
7049 3 : _v = SWIG_CheckState(res);
7050 3 : if (_v) {
7051 3 : return _wrap_MajorObject_SetMetadata__SWIG_0(self, argc, argv);
7052 : }
7053 : }
7054 : }
7055 : }
7056 4 : if ((argc >= 2) && (argc <= 3)) {
7057 4 : int _v;
7058 4 : void *vptr = 0;
7059 4 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GDALMajorObjectShadow, 0);
7060 4 : _v = SWIG_CheckState(res);
7061 4 : if (_v) {
7062 4 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
7063 4 : _v = SWIG_CheckState(res);
7064 4 : if (_v) {
7065 4 : if (argc <= 2) {
7066 4 : return _wrap_MajorObject_SetMetadata__SWIG_1(self, argc, argv);
7067 : }
7068 1 : int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
7069 1 : _v = SWIG_CheckState(res);
7070 1 : if (_v) {
7071 1 : return _wrap_MajorObject_SetMetadata__SWIG_1(self, argc, argv);
7072 : }
7073 : }
7074 : }
7075 : }
7076 :
7077 0 : fail:
7078 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MajorObject_SetMetadata'.\n"
7079 : " Possible C/C++ prototypes are:\n"
7080 : " GDALMajorObjectShadow::SetMetadata(char **,char const *)\n"
7081 : " GDALMajorObjectShadow::SetMetadata(char *,char const *)\n");
7082 : return 0;
7083 : }
7084 :
7085 :
7086 478 : SWIGINTERN PyObject *_wrap_MajorObject_GetMetadataItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7087 478 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7088 478 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
7089 478 : char *arg2 = (char *) 0 ;
7090 478 : char *arg3 = (char *) "" ;
7091 478 : void *argp1 = 0 ;
7092 478 : int res1 = 0 ;
7093 478 : int res2 ;
7094 478 : char *buf2 = 0 ;
7095 478 : int alloc2 = 0 ;
7096 478 : int res3 ;
7097 478 : char *buf3 = 0 ;
7098 478 : int alloc3 = 0 ;
7099 478 : PyObject *swig_obj[3] ;
7100 478 : char *result = 0 ;
7101 :
7102 478 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_GetMetadataItem", 2, 3, swig_obj)) SWIG_fail;
7103 478 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
7104 478 : if (!SWIG_IsOK(res1)) {
7105 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetMetadataItem" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
7106 : }
7107 478 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
7108 478 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
7109 478 : if (!SWIG_IsOK(res2)) {
7110 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_GetMetadataItem" "', argument " "2"" of type '" "char const *""'");
7111 : }
7112 478 : arg2 = reinterpret_cast< char * >(buf2);
7113 478 : if (swig_obj[2]) {
7114 424 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
7115 424 : if (!SWIG_IsOK(res3)) {
7116 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MajorObject_GetMetadataItem" "', argument " "3"" of type '" "char const *""'");
7117 : }
7118 424 : arg3 = reinterpret_cast< char * >(buf3);
7119 : }
7120 478 : {
7121 478 : if (!arg2) {
7122 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
7123 : }
7124 : }
7125 478 : {
7126 478 : const int bLocalUseExceptions = GetUseExceptions();
7127 478 : if ( bLocalUseExceptions ) {
7128 432 : pushErrorHandler();
7129 : }
7130 478 : {
7131 478 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7132 478 : result = (char *)GDALMajorObjectShadow_GetMetadataItem(arg1,(char const *)arg2,(char const *)arg3);
7133 478 : SWIG_PYTHON_THREAD_END_ALLOW;
7134 : }
7135 478 : if ( bLocalUseExceptions ) {
7136 432 : popErrorHandler();
7137 : }
7138 : #ifndef SED_HACKS
7139 : if ( bLocalUseExceptions ) {
7140 : CPLErr eclass = CPLGetLastErrorType();
7141 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7142 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7143 : }
7144 : }
7145 : #endif
7146 : }
7147 478 : resultobj = SWIG_FromCharPtr((const char *)result);
7148 478 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7149 478 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7150 478 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7151 : return resultobj;
7152 0 : fail:
7153 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7154 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7155 : return NULL;
7156 : }
7157 :
7158 :
7159 295 : SWIGINTERN PyObject *_wrap_MajorObject_SetMetadataItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7160 295 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7161 295 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
7162 295 : char *arg2 = (char *) 0 ;
7163 295 : char *arg3 = (char *) 0 ;
7164 295 : char *arg4 = (char *) "" ;
7165 295 : void *argp1 = 0 ;
7166 295 : int res1 = 0 ;
7167 295 : int res2 ;
7168 295 : char *buf2 = 0 ;
7169 295 : int alloc2 = 0 ;
7170 295 : int res3 ;
7171 295 : char *buf3 = 0 ;
7172 295 : int alloc3 = 0 ;
7173 295 : int res4 ;
7174 295 : char *buf4 = 0 ;
7175 295 : int alloc4 = 0 ;
7176 295 : PyObject *swig_obj[4] ;
7177 295 : CPLErr result;
7178 :
7179 295 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_SetMetadataItem", 3, 4, swig_obj)) SWIG_fail;
7180 295 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
7181 295 : if (!SWIG_IsOK(res1)) {
7182 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_SetMetadataItem" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
7183 : }
7184 295 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
7185 295 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
7186 295 : if (!SWIG_IsOK(res2)) {
7187 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_SetMetadataItem" "', argument " "2"" of type '" "char const *""'");
7188 : }
7189 295 : arg2 = reinterpret_cast< char * >(buf2);
7190 295 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
7191 295 : if (!SWIG_IsOK(res3)) {
7192 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MajorObject_SetMetadataItem" "', argument " "3"" of type '" "char const *""'");
7193 : }
7194 295 : arg3 = reinterpret_cast< char * >(buf3);
7195 295 : if (swig_obj[3]) {
7196 5 : res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
7197 5 : if (!SWIG_IsOK(res4)) {
7198 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MajorObject_SetMetadataItem" "', argument " "4"" of type '" "char const *""'");
7199 : }
7200 5 : arg4 = reinterpret_cast< char * >(buf4);
7201 : }
7202 295 : {
7203 295 : if (!arg2) {
7204 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
7205 : }
7206 : }
7207 295 : {
7208 295 : const int bLocalUseExceptions = GetUseExceptions();
7209 295 : if ( bLocalUseExceptions ) {
7210 268 : pushErrorHandler();
7211 : }
7212 295 : {
7213 295 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7214 295 : result = (CPLErr)GDALMajorObjectShadow_SetMetadataItem(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
7215 295 : SWIG_PYTHON_THREAD_END_ALLOW;
7216 : }
7217 295 : if ( bLocalUseExceptions ) {
7218 268 : popErrorHandler();
7219 : }
7220 : #ifndef SED_HACKS
7221 : if ( bLocalUseExceptions ) {
7222 : CPLErr eclass = CPLGetLastErrorType();
7223 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7224 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7225 : }
7226 : }
7227 : #endif
7228 : }
7229 295 : resultobj = SWIG_From_int(static_cast< int >(result));
7230 295 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7231 295 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7232 295 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
7233 295 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7234 : return resultobj;
7235 0 : fail:
7236 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7237 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7238 0 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
7239 : return NULL;
7240 : }
7241 :
7242 :
7243 275 : SWIGINTERN PyObject *MajorObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7244 275 : PyObject *obj;
7245 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
7246 275 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALMajorObjectShadow, SWIG_NewClientData(obj));
7247 275 : return SWIG_Py_Void();
7248 : }
7249 :
7250 4456 : SWIGINTERN PyObject *_wrap_GetGEOSVersionMajor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7251 4456 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7252 4456 : int result;
7253 :
7254 4456 : if (!SWIG_Python_UnpackTuple(args, "GetGEOSVersionMajor", 0, 0, 0)) SWIG_fail;
7255 4456 : {
7256 4456 : const int bLocalUseExceptions = GetUseExceptions();
7257 4456 : if ( bLocalUseExceptions ) {
7258 459 : pushErrorHandler();
7259 : }
7260 4456 : {
7261 4456 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7262 4456 : result = (int)GetGEOSVersionMajor();
7263 4456 : SWIG_PYTHON_THREAD_END_ALLOW;
7264 : }
7265 4456 : if ( bLocalUseExceptions ) {
7266 459 : popErrorHandler();
7267 : }
7268 : #ifndef SED_HACKS
7269 : if ( bLocalUseExceptions ) {
7270 : CPLErr eclass = CPLGetLastErrorType();
7271 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7272 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7273 : }
7274 : }
7275 : #endif
7276 : }
7277 4456 : resultobj = SWIG_From_int(static_cast< int >(result));
7278 4456 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7279 : return resultobj;
7280 0 : fail:
7281 0 : return NULL;
7282 : }
7283 :
7284 :
7285 215 : SWIGINTERN PyObject *_wrap_GetGEOSVersionMinor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7286 215 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7287 215 : int result;
7288 :
7289 215 : if (!SWIG_Python_UnpackTuple(args, "GetGEOSVersionMinor", 0, 0, 0)) SWIG_fail;
7290 215 : {
7291 215 : const int bLocalUseExceptions = GetUseExceptions();
7292 215 : if ( bLocalUseExceptions ) {
7293 214 : pushErrorHandler();
7294 : }
7295 215 : {
7296 215 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7297 215 : result = (int)GetGEOSVersionMinor();
7298 215 : SWIG_PYTHON_THREAD_END_ALLOW;
7299 : }
7300 215 : if ( bLocalUseExceptions ) {
7301 214 : popErrorHandler();
7302 : }
7303 : #ifndef SED_HACKS
7304 : if ( bLocalUseExceptions ) {
7305 : CPLErr eclass = CPLGetLastErrorType();
7306 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7307 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7308 : }
7309 : }
7310 : #endif
7311 : }
7312 215 : resultobj = SWIG_From_int(static_cast< int >(result));
7313 215 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7314 : return resultobj;
7315 0 : fail:
7316 0 : return NULL;
7317 : }
7318 :
7319 :
7320 215 : SWIGINTERN PyObject *_wrap_GetGEOSVersionMicro(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7321 215 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7322 215 : int result;
7323 :
7324 215 : if (!SWIG_Python_UnpackTuple(args, "GetGEOSVersionMicro", 0, 0, 0)) SWIG_fail;
7325 215 : {
7326 215 : const int bLocalUseExceptions = GetUseExceptions();
7327 215 : if ( bLocalUseExceptions ) {
7328 214 : pushErrorHandler();
7329 : }
7330 215 : {
7331 215 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7332 215 : result = (int)GetGEOSVersionMicro();
7333 215 : SWIG_PYTHON_THREAD_END_ALLOW;
7334 : }
7335 215 : if ( bLocalUseExceptions ) {
7336 214 : popErrorHandler();
7337 : }
7338 : #ifndef SED_HACKS
7339 : if ( bLocalUseExceptions ) {
7340 : CPLErr eclass = CPLGetLastErrorType();
7341 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7342 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7343 : }
7344 : }
7345 : #endif
7346 : }
7347 215 : resultobj = SWIG_From_int(static_cast< int >(result));
7348 215 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7349 : return resultobj;
7350 0 : fail:
7351 0 : return NULL;
7352 : }
7353 :
7354 :
7355 4 : SWIGINTERN PyObject *_wrap_new_StyleTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7356 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7357 4 : OGRStyleTableShadow *result = 0 ;
7358 :
7359 4 : if (!SWIG_Python_UnpackTuple(args, "new_StyleTable", 0, 0, 0)) SWIG_fail;
7360 4 : {
7361 4 : const int bLocalUseExceptions = GetUseExceptions();
7362 4 : if ( bLocalUseExceptions ) {
7363 4 : pushErrorHandler();
7364 : }
7365 4 : {
7366 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7367 4 : result = (OGRStyleTableShadow *)new_OGRStyleTableShadow();
7368 4 : SWIG_PYTHON_THREAD_END_ALLOW;
7369 : }
7370 4 : if ( bLocalUseExceptions ) {
7371 4 : popErrorHandler();
7372 : }
7373 : #ifndef SED_HACKS
7374 : if ( bLocalUseExceptions ) {
7375 : CPLErr eclass = CPLGetLastErrorType();
7376 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7377 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7378 : }
7379 : }
7380 : #endif
7381 : }
7382 4 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRStyleTableShadow, SWIG_POINTER_NEW | 0 );
7383 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7384 : return resultobj;
7385 0 : fail:
7386 0 : return NULL;
7387 : }
7388 :
7389 :
7390 4 : SWIGINTERN PyObject *_wrap_delete_StyleTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7391 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7392 4 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7393 4 : void *argp1 = 0 ;
7394 4 : int res1 = 0 ;
7395 4 : PyObject *swig_obj[1] ;
7396 :
7397 4 : if (!args) SWIG_fail;
7398 4 : swig_obj[0] = args;
7399 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, SWIG_POINTER_DISOWN | 0 );
7400 4 : if (!SWIG_IsOK(res1)) {
7401 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StyleTable" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7402 : }
7403 4 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7404 4 : {
7405 4 : const int bLocalUseExceptions = GetUseExceptions();
7406 4 : if ( bLocalUseExceptions ) {
7407 4 : pushErrorHandler();
7408 : }
7409 4 : {
7410 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7411 4 : delete_OGRStyleTableShadow(arg1);
7412 4 : SWIG_PYTHON_THREAD_END_ALLOW;
7413 : }
7414 4 : if ( bLocalUseExceptions ) {
7415 4 : popErrorHandler();
7416 : }
7417 : #ifndef SED_HACKS
7418 : if ( bLocalUseExceptions ) {
7419 : CPLErr eclass = CPLGetLastErrorType();
7420 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7421 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7422 : }
7423 : }
7424 : #endif
7425 : }
7426 4 : resultobj = SWIG_Py_Void();
7427 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7428 : return resultobj;
7429 : fail:
7430 : return NULL;
7431 : }
7432 :
7433 :
7434 5 : SWIGINTERN PyObject *_wrap_StyleTable_AddStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7435 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7436 5 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7437 5 : char *arg2 = (char *) 0 ;
7438 5 : char *arg3 = (char *) 0 ;
7439 5 : void *argp1 = 0 ;
7440 5 : int res1 = 0 ;
7441 5 : int res2 ;
7442 5 : char *buf2 = 0 ;
7443 5 : int alloc2 = 0 ;
7444 5 : int res3 ;
7445 5 : char *buf3 = 0 ;
7446 5 : int alloc3 = 0 ;
7447 5 : PyObject *swig_obj[3] ;
7448 5 : int result;
7449 :
7450 5 : if (!SWIG_Python_UnpackTuple(args, "StyleTable_AddStyle", 3, 3, swig_obj)) SWIG_fail;
7451 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
7452 5 : if (!SWIG_IsOK(res1)) {
7453 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyleTable_AddStyle" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7454 : }
7455 5 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7456 5 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
7457 5 : if (!SWIG_IsOK(res2)) {
7458 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StyleTable_AddStyle" "', argument " "2"" of type '" "char const *""'");
7459 : }
7460 5 : arg2 = reinterpret_cast< char * >(buf2);
7461 5 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
7462 5 : if (!SWIG_IsOK(res3)) {
7463 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StyleTable_AddStyle" "', argument " "3"" of type '" "char const *""'");
7464 : }
7465 5 : arg3 = reinterpret_cast< char * >(buf3);
7466 5 : {
7467 5 : const int bLocalUseExceptions = GetUseExceptions();
7468 5 : if ( bLocalUseExceptions ) {
7469 5 : pushErrorHandler();
7470 : }
7471 5 : {
7472 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7473 5 : result = (int)OGRStyleTableShadow_AddStyle(arg1,(char const *)arg2,(char const *)arg3);
7474 5 : SWIG_PYTHON_THREAD_END_ALLOW;
7475 : }
7476 5 : if ( bLocalUseExceptions ) {
7477 5 : popErrorHandler();
7478 : }
7479 : #ifndef SED_HACKS
7480 : if ( bLocalUseExceptions ) {
7481 : CPLErr eclass = CPLGetLastErrorType();
7482 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7483 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7484 : }
7485 : }
7486 : #endif
7487 : }
7488 5 : resultobj = SWIG_From_int(static_cast< int >(result));
7489 5 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7490 5 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7491 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7492 : return resultobj;
7493 0 : fail:
7494 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7495 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
7496 : return NULL;
7497 : }
7498 :
7499 :
7500 2 : SWIGINTERN PyObject *_wrap_StyleTable_LoadStyleTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7501 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7502 2 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7503 2 : char *arg2 = (char *) 0 ;
7504 2 : void *argp1 = 0 ;
7505 2 : int res1 = 0 ;
7506 2 : int bToFree2 = 0 ;
7507 2 : PyObject *swig_obj[2] ;
7508 2 : int result;
7509 :
7510 2 : if (!SWIG_Python_UnpackTuple(args, "StyleTable_LoadStyleTable", 2, 2, swig_obj)) SWIG_fail;
7511 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
7512 2 : if (!SWIG_IsOK(res1)) {
7513 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyleTable_LoadStyleTable" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7514 : }
7515 2 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7516 2 : {
7517 : /* %typemap(in) (const char *utf8_path) */
7518 2 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
7519 : {
7520 2 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
7521 : }
7522 : else
7523 : {
7524 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
7525 :
7526 : }
7527 2 : if (arg2 == NULL)
7528 : {
7529 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
7530 0 : SWIG_fail;
7531 : }
7532 : }
7533 2 : {
7534 2 : const int bLocalUseExceptions = GetUseExceptions();
7535 2 : if ( bLocalUseExceptions ) {
7536 2 : pushErrorHandler();
7537 : }
7538 2 : {
7539 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7540 2 : result = (int)OGRStyleTableShadow_LoadStyleTable(arg1,(char const *)arg2);
7541 2 : SWIG_PYTHON_THREAD_END_ALLOW;
7542 : }
7543 2 : if ( bLocalUseExceptions ) {
7544 2 : popErrorHandler();
7545 : }
7546 : #ifndef SED_HACKS
7547 : if ( bLocalUseExceptions ) {
7548 : CPLErr eclass = CPLGetLastErrorType();
7549 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7550 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7551 : }
7552 : }
7553 : #endif
7554 : }
7555 2 : resultobj = SWIG_From_int(static_cast< int >(result));
7556 2 : {
7557 : /* %typemap(freearg) (const char *utf8_path) */
7558 2 : GDALPythonFreeCStr(arg2, bToFree2);
7559 : }
7560 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7561 : return resultobj;
7562 0 : fail:
7563 0 : {
7564 : /* %typemap(freearg) (const char *utf8_path) */
7565 2 : GDALPythonFreeCStr(arg2, bToFree2);
7566 : }
7567 : return NULL;
7568 : }
7569 :
7570 :
7571 2 : SWIGINTERN PyObject *_wrap_StyleTable_SaveStyleTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7572 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7573 2 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7574 2 : char *arg2 = (char *) 0 ;
7575 2 : void *argp1 = 0 ;
7576 2 : int res1 = 0 ;
7577 2 : int bToFree2 = 0 ;
7578 2 : PyObject *swig_obj[2] ;
7579 2 : int result;
7580 :
7581 2 : if (!SWIG_Python_UnpackTuple(args, "StyleTable_SaveStyleTable", 2, 2, swig_obj)) SWIG_fail;
7582 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
7583 2 : if (!SWIG_IsOK(res1)) {
7584 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyleTable_SaveStyleTable" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7585 : }
7586 2 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7587 2 : {
7588 : /* %typemap(in) (const char *utf8_path) */
7589 2 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
7590 : {
7591 2 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
7592 : }
7593 : else
7594 : {
7595 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
7596 :
7597 : }
7598 2 : if (arg2 == NULL)
7599 : {
7600 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
7601 0 : SWIG_fail;
7602 : }
7603 : }
7604 2 : {
7605 2 : const int bLocalUseExceptions = GetUseExceptions();
7606 2 : if ( bLocalUseExceptions ) {
7607 2 : pushErrorHandler();
7608 : }
7609 2 : {
7610 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7611 2 : result = (int)OGRStyleTableShadow_SaveStyleTable(arg1,(char const *)arg2);
7612 2 : SWIG_PYTHON_THREAD_END_ALLOW;
7613 : }
7614 2 : if ( bLocalUseExceptions ) {
7615 2 : popErrorHandler();
7616 : }
7617 : #ifndef SED_HACKS
7618 : if ( bLocalUseExceptions ) {
7619 : CPLErr eclass = CPLGetLastErrorType();
7620 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7621 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7622 : }
7623 : }
7624 : #endif
7625 : }
7626 2 : resultobj = SWIG_From_int(static_cast< int >(result));
7627 2 : {
7628 : /* %typemap(freearg) (const char *utf8_path) */
7629 2 : GDALPythonFreeCStr(arg2, bToFree2);
7630 : }
7631 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7632 : return resultobj;
7633 0 : fail:
7634 0 : {
7635 : /* %typemap(freearg) (const char *utf8_path) */
7636 2 : GDALPythonFreeCStr(arg2, bToFree2);
7637 : }
7638 : return NULL;
7639 : }
7640 :
7641 :
7642 2 : SWIGINTERN PyObject *_wrap_StyleTable_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7643 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7644 2 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7645 2 : char *arg2 = (char *) 0 ;
7646 2 : void *argp1 = 0 ;
7647 2 : int res1 = 0 ;
7648 2 : int res2 ;
7649 2 : char *buf2 = 0 ;
7650 2 : int alloc2 = 0 ;
7651 2 : PyObject *swig_obj[2] ;
7652 2 : char *result = 0 ;
7653 :
7654 2 : if (!SWIG_Python_UnpackTuple(args, "StyleTable_Find", 2, 2, swig_obj)) SWIG_fail;
7655 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
7656 2 : if (!SWIG_IsOK(res1)) {
7657 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyleTable_Find" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7658 : }
7659 2 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7660 2 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
7661 2 : if (!SWIG_IsOK(res2)) {
7662 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StyleTable_Find" "', argument " "2"" of type '" "char const *""'");
7663 : }
7664 2 : arg2 = reinterpret_cast< char * >(buf2);
7665 2 : {
7666 2 : const int bLocalUseExceptions = GetUseExceptions();
7667 2 : if ( bLocalUseExceptions ) {
7668 2 : pushErrorHandler();
7669 : }
7670 2 : {
7671 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7672 2 : result = (char *)OGRStyleTableShadow_Find(arg1,(char const *)arg2);
7673 2 : SWIG_PYTHON_THREAD_END_ALLOW;
7674 : }
7675 2 : if ( bLocalUseExceptions ) {
7676 2 : popErrorHandler();
7677 : }
7678 : #ifndef SED_HACKS
7679 : if ( bLocalUseExceptions ) {
7680 : CPLErr eclass = CPLGetLastErrorType();
7681 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7682 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7683 : }
7684 : }
7685 : #endif
7686 : }
7687 2 : resultobj = SWIG_FromCharPtr((const char *)result);
7688 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7689 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7690 : return resultobj;
7691 0 : fail:
7692 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7693 : return NULL;
7694 : }
7695 :
7696 :
7697 1 : SWIGINTERN PyObject *_wrap_StyleTable_ResetStyleStringReading(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7698 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7699 1 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7700 1 : void *argp1 = 0 ;
7701 1 : int res1 = 0 ;
7702 1 : PyObject *swig_obj[1] ;
7703 :
7704 1 : if (!args) SWIG_fail;
7705 1 : swig_obj[0] = args;
7706 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
7707 1 : if (!SWIG_IsOK(res1)) {
7708 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyleTable_ResetStyleStringReading" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7709 : }
7710 1 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7711 1 : {
7712 1 : const int bLocalUseExceptions = GetUseExceptions();
7713 1 : if ( bLocalUseExceptions ) {
7714 1 : pushErrorHandler();
7715 : }
7716 1 : {
7717 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7718 1 : OGRStyleTableShadow_ResetStyleStringReading(arg1);
7719 1 : SWIG_PYTHON_THREAD_END_ALLOW;
7720 : }
7721 1 : if ( bLocalUseExceptions ) {
7722 1 : popErrorHandler();
7723 : }
7724 : #ifndef SED_HACKS
7725 : if ( bLocalUseExceptions ) {
7726 : CPLErr eclass = CPLGetLastErrorType();
7727 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7728 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7729 : }
7730 : }
7731 : #endif
7732 : }
7733 1 : resultobj = SWIG_Py_Void();
7734 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7735 : return resultobj;
7736 : fail:
7737 : return NULL;
7738 : }
7739 :
7740 :
7741 5 : SWIGINTERN PyObject *_wrap_StyleTable_GetNextStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7742 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7743 5 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7744 5 : void *argp1 = 0 ;
7745 5 : int res1 = 0 ;
7746 5 : PyObject *swig_obj[1] ;
7747 5 : char *result = 0 ;
7748 :
7749 5 : if (!args) SWIG_fail;
7750 5 : swig_obj[0] = args;
7751 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
7752 5 : if (!SWIG_IsOK(res1)) {
7753 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyleTable_GetNextStyle" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7754 : }
7755 5 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7756 5 : {
7757 5 : const int bLocalUseExceptions = GetUseExceptions();
7758 5 : if ( bLocalUseExceptions ) {
7759 5 : pushErrorHandler();
7760 : }
7761 5 : {
7762 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7763 5 : result = (char *)OGRStyleTableShadow_GetNextStyle(arg1);
7764 5 : SWIG_PYTHON_THREAD_END_ALLOW;
7765 : }
7766 5 : if ( bLocalUseExceptions ) {
7767 5 : popErrorHandler();
7768 : }
7769 : #ifndef SED_HACKS
7770 : if ( bLocalUseExceptions ) {
7771 : CPLErr eclass = CPLGetLastErrorType();
7772 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7773 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7774 : }
7775 : }
7776 : #endif
7777 : }
7778 5 : resultobj = SWIG_FromCharPtr((const char *)result);
7779 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7780 : return resultobj;
7781 : fail:
7782 : return NULL;
7783 : }
7784 :
7785 :
7786 1 : SWIGINTERN PyObject *_wrap_StyleTable_GetLastStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7787 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7788 1 : OGRStyleTableShadow *arg1 = (OGRStyleTableShadow *) 0 ;
7789 1 : void *argp1 = 0 ;
7790 1 : int res1 = 0 ;
7791 1 : PyObject *swig_obj[1] ;
7792 1 : char *result = 0 ;
7793 :
7794 1 : if (!args) SWIG_fail;
7795 1 : swig_obj[0] = args;
7796 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
7797 1 : if (!SWIG_IsOK(res1)) {
7798 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyleTable_GetLastStyleName" "', argument " "1"" of type '" "OGRStyleTableShadow *""'");
7799 : }
7800 1 : arg1 = reinterpret_cast< OGRStyleTableShadow * >(argp1);
7801 1 : {
7802 1 : const int bLocalUseExceptions = GetUseExceptions();
7803 1 : if ( bLocalUseExceptions ) {
7804 1 : pushErrorHandler();
7805 : }
7806 1 : {
7807 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7808 1 : result = (char *)OGRStyleTableShadow_GetLastStyleName(arg1);
7809 1 : SWIG_PYTHON_THREAD_END_ALLOW;
7810 : }
7811 1 : if ( bLocalUseExceptions ) {
7812 1 : popErrorHandler();
7813 : }
7814 : #ifndef SED_HACKS
7815 : if ( bLocalUseExceptions ) {
7816 : CPLErr eclass = CPLGetLastErrorType();
7817 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7818 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7819 : }
7820 : }
7821 : #endif
7822 : }
7823 1 : resultobj = SWIG_FromCharPtr((const char *)result);
7824 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7825 : return resultobj;
7826 : fail:
7827 : return NULL;
7828 : }
7829 :
7830 :
7831 275 : SWIGINTERN PyObject *StyleTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7832 275 : PyObject *obj;
7833 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
7834 275 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRStyleTableShadow, SWIG_NewClientData(obj));
7835 275 : return SWIG_Py_Void();
7836 : }
7837 :
7838 4 : SWIGINTERN PyObject *StyleTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7839 4 : return SWIG_Python_InitShadowInstance(args);
7840 : }
7841 :
7842 4 : SWIGINTERN PyObject *_wrap_new_ArrowArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7843 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7844 4 : ArrowArray *result = 0 ;
7845 :
7846 4 : if (!SWIG_Python_UnpackTuple(args, "new_ArrowArray", 0, 0, 0)) SWIG_fail;
7847 4 : {
7848 4 : const int bLocalUseExceptions = GetUseExceptions();
7849 4 : if ( bLocalUseExceptions ) {
7850 4 : pushErrorHandler();
7851 : }
7852 4 : {
7853 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7854 4 : result = (ArrowArray *)new_ArrowArray();
7855 4 : SWIG_PYTHON_THREAD_END_ALLOW;
7856 : }
7857 4 : if ( bLocalUseExceptions ) {
7858 4 : popErrorHandler();
7859 : }
7860 : #ifndef SED_HACKS
7861 : if ( bLocalUseExceptions ) {
7862 : CPLErr eclass = CPLGetLastErrorType();
7863 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7864 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7865 : }
7866 : }
7867 : #endif
7868 : }
7869 4 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ArrowArray, SWIG_POINTER_NEW | 0 );
7870 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7871 : return resultobj;
7872 0 : fail:
7873 0 : return NULL;
7874 : }
7875 :
7876 :
7877 564 : SWIGINTERN PyObject *_wrap_delete_ArrowArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7878 564 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7879 564 : ArrowArray *arg1 = (ArrowArray *) 0 ;
7880 564 : void *argp1 = 0 ;
7881 564 : int res1 = 0 ;
7882 564 : PyObject *swig_obj[1] ;
7883 :
7884 564 : if (!args) SWIG_fail;
7885 564 : swig_obj[0] = args;
7886 564 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowArray, SWIG_POINTER_DISOWN | 0 );
7887 564 : if (!SWIG_IsOK(res1)) {
7888 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArrowArray" "', argument " "1"" of type '" "ArrowArray *""'");
7889 : }
7890 564 : arg1 = reinterpret_cast< ArrowArray * >(argp1);
7891 564 : {
7892 564 : const int bLocalUseExceptions = GetUseExceptions();
7893 564 : if ( bLocalUseExceptions ) {
7894 248 : pushErrorHandler();
7895 : }
7896 564 : {
7897 564 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7898 564 : delete_ArrowArray(arg1);
7899 564 : SWIG_PYTHON_THREAD_END_ALLOW;
7900 : }
7901 564 : if ( bLocalUseExceptions ) {
7902 248 : popErrorHandler();
7903 : }
7904 : #ifndef SED_HACKS
7905 : if ( bLocalUseExceptions ) {
7906 : CPLErr eclass = CPLGetLastErrorType();
7907 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7908 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7909 : }
7910 : }
7911 : #endif
7912 : }
7913 564 : resultobj = SWIG_Py_Void();
7914 564 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7915 : return resultobj;
7916 : fail:
7917 : return NULL;
7918 : }
7919 :
7920 :
7921 521 : SWIGINTERN PyObject *_wrap_ArrowArray__getPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7922 521 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7923 521 : ArrowArray *arg1 = (ArrowArray *) 0 ;
7924 521 : void *argp1 = 0 ;
7925 521 : int res1 = 0 ;
7926 521 : PyObject *swig_obj[1] ;
7927 521 : VoidPtrAsLong result;
7928 :
7929 521 : if (!args) SWIG_fail;
7930 521 : swig_obj[0] = args;
7931 521 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowArray, 0 | 0 );
7932 521 : if (!SWIG_IsOK(res1)) {
7933 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowArray__getPtr" "', argument " "1"" of type '" "ArrowArray *""'");
7934 : }
7935 521 : arg1 = reinterpret_cast< ArrowArray * >(argp1);
7936 521 : {
7937 521 : const int bLocalUseExceptions = GetUseExceptions();
7938 521 : if ( bLocalUseExceptions ) {
7939 206 : pushErrorHandler();
7940 : }
7941 521 : {
7942 521 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7943 521 : result = (VoidPtrAsLong)ArrowArray__getPtr(arg1);
7944 521 : SWIG_PYTHON_THREAD_END_ALLOW;
7945 : }
7946 521 : if ( bLocalUseExceptions ) {
7947 206 : popErrorHandler();
7948 : }
7949 : #ifndef SED_HACKS
7950 : if ( bLocalUseExceptions ) {
7951 : CPLErr eclass = CPLGetLastErrorType();
7952 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7953 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7954 : }
7955 : }
7956 : #endif
7957 : }
7958 521 : {
7959 521 : resultobj = PyLong_FromVoidPtr(result);
7960 : }
7961 521 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
7962 : return resultobj;
7963 : fail:
7964 : return NULL;
7965 : }
7966 :
7967 :
7968 1 : SWIGINTERN PyObject *_wrap_ArrowArray_GetChildrenCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7969 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
7970 1 : ArrowArray *arg1 = (ArrowArray *) 0 ;
7971 1 : void *argp1 = 0 ;
7972 1 : int res1 = 0 ;
7973 1 : PyObject *swig_obj[1] ;
7974 1 : GIntBig result;
7975 :
7976 1 : if (!args) SWIG_fail;
7977 1 : swig_obj[0] = args;
7978 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowArray, 0 | 0 );
7979 1 : if (!SWIG_IsOK(res1)) {
7980 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowArray_GetChildrenCount" "', argument " "1"" of type '" "ArrowArray *""'");
7981 : }
7982 1 : arg1 = reinterpret_cast< ArrowArray * >(argp1);
7983 1 : {
7984 1 : const int bLocalUseExceptions = GetUseExceptions();
7985 1 : if ( bLocalUseExceptions ) {
7986 0 : pushErrorHandler();
7987 : }
7988 1 : {
7989 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7990 1 : result = ArrowArray_GetChildrenCount(arg1);
7991 1 : SWIG_PYTHON_THREAD_END_ALLOW;
7992 : }
7993 1 : if ( bLocalUseExceptions ) {
7994 0 : popErrorHandler();
7995 : }
7996 : #ifndef SED_HACKS
7997 : if ( bLocalUseExceptions ) {
7998 : CPLErr eclass = CPLGetLastErrorType();
7999 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8000 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8001 : }
8002 : }
8003 : #endif
8004 : }
8005 1 : {
8006 1 : resultobj = PyLong_FromLongLong(result);
8007 : }
8008 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8009 : return resultobj;
8010 : fail:
8011 : return NULL;
8012 : }
8013 :
8014 :
8015 0 : SWIGINTERN PyObject *_wrap_ArrowArray_GetLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8016 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8017 0 : ArrowArray *arg1 = (ArrowArray *) 0 ;
8018 0 : void *argp1 = 0 ;
8019 0 : int res1 = 0 ;
8020 0 : PyObject *swig_obj[1] ;
8021 0 : GIntBig result;
8022 :
8023 0 : if (!args) SWIG_fail;
8024 0 : swig_obj[0] = args;
8025 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowArray, 0 | 0 );
8026 0 : if (!SWIG_IsOK(res1)) {
8027 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowArray_GetLength" "', argument " "1"" of type '" "ArrowArray *""'");
8028 : }
8029 0 : arg1 = reinterpret_cast< ArrowArray * >(argp1);
8030 0 : {
8031 0 : const int bLocalUseExceptions = GetUseExceptions();
8032 0 : if ( bLocalUseExceptions ) {
8033 0 : pushErrorHandler();
8034 : }
8035 0 : {
8036 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8037 0 : result = ArrowArray_GetLength(arg1);
8038 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8039 : }
8040 0 : if ( bLocalUseExceptions ) {
8041 0 : popErrorHandler();
8042 : }
8043 : #ifndef SED_HACKS
8044 : if ( bLocalUseExceptions ) {
8045 : CPLErr eclass = CPLGetLastErrorType();
8046 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8047 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8048 : }
8049 : }
8050 : #endif
8051 : }
8052 0 : {
8053 0 : resultobj = PyLong_FromLongLong(result);
8054 : }
8055 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8056 : return resultobj;
8057 : fail:
8058 : return NULL;
8059 : }
8060 :
8061 :
8062 275 : SWIGINTERN PyObject *ArrowArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8063 275 : PyObject *obj;
8064 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
8065 275 : SWIG_TypeNewClientData(SWIGTYPE_p_ArrowArray, SWIG_NewClientData(obj));
8066 275 : return SWIG_Py_Void();
8067 : }
8068 :
8069 4 : SWIGINTERN PyObject *ArrowArray_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8070 4 : return SWIG_Python_InitShadowInstance(args);
8071 : }
8072 :
8073 126 : SWIGINTERN PyObject *_wrap_new_ArrowSchema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8074 126 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8075 126 : ArrowSchema *result = 0 ;
8076 :
8077 126 : if (!SWIG_Python_UnpackTuple(args, "new_ArrowSchema", 0, 0, 0)) SWIG_fail;
8078 126 : {
8079 126 : const int bLocalUseExceptions = GetUseExceptions();
8080 126 : if ( bLocalUseExceptions ) {
8081 126 : pushErrorHandler();
8082 : }
8083 126 : {
8084 126 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8085 126 : result = (ArrowSchema *)new_ArrowSchema();
8086 126 : SWIG_PYTHON_THREAD_END_ALLOW;
8087 : }
8088 126 : if ( bLocalUseExceptions ) {
8089 126 : popErrorHandler();
8090 : }
8091 : #ifndef SED_HACKS
8092 : if ( bLocalUseExceptions ) {
8093 : CPLErr eclass = CPLGetLastErrorType();
8094 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8095 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8096 : }
8097 : }
8098 : #endif
8099 : }
8100 126 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ArrowSchema, SWIG_POINTER_NEW | 0 );
8101 126 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8102 : return resultobj;
8103 0 : fail:
8104 0 : return NULL;
8105 : }
8106 :
8107 :
8108 499 : SWIGINTERN PyObject *_wrap_delete_ArrowSchema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8109 499 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8110 499 : ArrowSchema *arg1 = (ArrowSchema *) 0 ;
8111 499 : void *argp1 = 0 ;
8112 499 : int res1 = 0 ;
8113 499 : PyObject *swig_obj[1] ;
8114 :
8115 499 : if (!args) SWIG_fail;
8116 499 : swig_obj[0] = args;
8117 499 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowSchema, SWIG_POINTER_DISOWN | 0 );
8118 499 : if (!SWIG_IsOK(res1)) {
8119 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArrowSchema" "', argument " "1"" of type '" "ArrowSchema *""'");
8120 : }
8121 499 : arg1 = reinterpret_cast< ArrowSchema * >(argp1);
8122 499 : {
8123 499 : const int bLocalUseExceptions = GetUseExceptions();
8124 499 : if ( bLocalUseExceptions ) {
8125 386 : pushErrorHandler();
8126 : }
8127 499 : {
8128 499 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8129 499 : delete_ArrowSchema(arg1);
8130 499 : SWIG_PYTHON_THREAD_END_ALLOW;
8131 : }
8132 499 : if ( bLocalUseExceptions ) {
8133 386 : popErrorHandler();
8134 : }
8135 : #ifndef SED_HACKS
8136 : if ( bLocalUseExceptions ) {
8137 : CPLErr eclass = CPLGetLastErrorType();
8138 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8139 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8140 : }
8141 : }
8142 : #endif
8143 : }
8144 499 : resultobj = SWIG_Py_Void();
8145 499 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8146 : return resultobj;
8147 : fail:
8148 : return NULL;
8149 : }
8150 :
8151 :
8152 676 : SWIGINTERN PyObject *_wrap_ArrowSchema__getPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8153 676 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8154 676 : ArrowSchema *arg1 = (ArrowSchema *) 0 ;
8155 676 : void *argp1 = 0 ;
8156 676 : int res1 = 0 ;
8157 676 : PyObject *swig_obj[1] ;
8158 676 : VoidPtrAsLong result;
8159 :
8160 676 : if (!args) SWIG_fail;
8161 676 : swig_obj[0] = args;
8162 676 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowSchema, 0 | 0 );
8163 676 : if (!SWIG_IsOK(res1)) {
8164 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowSchema__getPtr" "', argument " "1"" of type '" "ArrowSchema *""'");
8165 : }
8166 676 : arg1 = reinterpret_cast< ArrowSchema * >(argp1);
8167 676 : {
8168 676 : const int bLocalUseExceptions = GetUseExceptions();
8169 676 : if ( bLocalUseExceptions ) {
8170 352 : pushErrorHandler();
8171 : }
8172 676 : {
8173 676 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8174 676 : result = (VoidPtrAsLong)ArrowSchema__getPtr(arg1);
8175 676 : SWIG_PYTHON_THREAD_END_ALLOW;
8176 : }
8177 676 : if ( bLocalUseExceptions ) {
8178 352 : popErrorHandler();
8179 : }
8180 : #ifndef SED_HACKS
8181 : if ( bLocalUseExceptions ) {
8182 : CPLErr eclass = CPLGetLastErrorType();
8183 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8184 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8185 : }
8186 : }
8187 : #endif
8188 : }
8189 676 : {
8190 676 : resultobj = PyLong_FromVoidPtr(result);
8191 : }
8192 676 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8193 : return resultobj;
8194 : fail:
8195 : return NULL;
8196 : }
8197 :
8198 :
8199 426 : SWIGINTERN PyObject *_wrap_ArrowSchema_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8200 426 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8201 426 : ArrowSchema *arg1 = (ArrowSchema *) 0 ;
8202 426 : void *argp1 = 0 ;
8203 426 : int res1 = 0 ;
8204 426 : PyObject *swig_obj[1] ;
8205 426 : char *result = 0 ;
8206 :
8207 426 : if (!args) SWIG_fail;
8208 426 : swig_obj[0] = args;
8209 426 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowSchema, 0 | 0 );
8210 426 : if (!SWIG_IsOK(res1)) {
8211 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowSchema_GetName" "', argument " "1"" of type '" "ArrowSchema *""'");
8212 : }
8213 426 : arg1 = reinterpret_cast< ArrowSchema * >(argp1);
8214 426 : {
8215 426 : const int bLocalUseExceptions = GetUseExceptions();
8216 426 : if ( bLocalUseExceptions ) {
8217 426 : pushErrorHandler();
8218 : }
8219 426 : {
8220 426 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8221 426 : result = (char *)ArrowSchema_GetName(arg1);
8222 426 : SWIG_PYTHON_THREAD_END_ALLOW;
8223 : }
8224 426 : if ( bLocalUseExceptions ) {
8225 426 : popErrorHandler();
8226 : }
8227 : #ifndef SED_HACKS
8228 : if ( bLocalUseExceptions ) {
8229 : CPLErr eclass = CPLGetLastErrorType();
8230 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8231 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8232 : }
8233 : }
8234 : #endif
8235 : }
8236 426 : resultobj = SWIG_FromCharPtr((const char *)result);
8237 426 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8238 : return resultobj;
8239 : fail:
8240 : return NULL;
8241 : }
8242 :
8243 :
8244 25 : SWIGINTERN PyObject *_wrap_ArrowSchema_GetChildrenCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8245 25 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8246 25 : ArrowSchema *arg1 = (ArrowSchema *) 0 ;
8247 25 : void *argp1 = 0 ;
8248 25 : int res1 = 0 ;
8249 25 : PyObject *swig_obj[1] ;
8250 25 : GIntBig result;
8251 :
8252 25 : if (!args) SWIG_fail;
8253 25 : swig_obj[0] = args;
8254 25 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowSchema, 0 | 0 );
8255 25 : if (!SWIG_IsOK(res1)) {
8256 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowSchema_GetChildrenCount" "', argument " "1"" of type '" "ArrowSchema *""'");
8257 : }
8258 25 : arg1 = reinterpret_cast< ArrowSchema * >(argp1);
8259 25 : {
8260 25 : const int bLocalUseExceptions = GetUseExceptions();
8261 25 : if ( bLocalUseExceptions ) {
8262 25 : pushErrorHandler();
8263 : }
8264 25 : {
8265 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8266 25 : result = ArrowSchema_GetChildrenCount(arg1);
8267 25 : SWIG_PYTHON_THREAD_END_ALLOW;
8268 : }
8269 25 : if ( bLocalUseExceptions ) {
8270 25 : popErrorHandler();
8271 : }
8272 : #ifndef SED_HACKS
8273 : if ( bLocalUseExceptions ) {
8274 : CPLErr eclass = CPLGetLastErrorType();
8275 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8276 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8277 : }
8278 : }
8279 : #endif
8280 : }
8281 25 : {
8282 25 : resultobj = PyLong_FromLongLong(result);
8283 : }
8284 25 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8285 : return resultobj;
8286 : fail:
8287 : return NULL;
8288 : }
8289 :
8290 :
8291 831 : SWIGINTERN PyObject *_wrap_ArrowSchema_GetChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8292 831 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8293 831 : ArrowSchema *arg1 = (ArrowSchema *) 0 ;
8294 831 : int arg2 ;
8295 831 : void *argp1 = 0 ;
8296 831 : int res1 = 0 ;
8297 831 : int val2 ;
8298 831 : int ecode2 = 0 ;
8299 831 : PyObject *swig_obj[2] ;
8300 831 : ArrowSchema *result = 0 ;
8301 :
8302 831 : if (!SWIG_Python_UnpackTuple(args, "ArrowSchema_GetChild", 2, 2, swig_obj)) SWIG_fail;
8303 831 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowSchema, 0 | 0 );
8304 831 : if (!SWIG_IsOK(res1)) {
8305 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowSchema_GetChild" "', argument " "1"" of type '" "ArrowSchema *""'");
8306 : }
8307 831 : arg1 = reinterpret_cast< ArrowSchema * >(argp1);
8308 831 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8309 831 : if (!SWIG_IsOK(ecode2)) {
8310 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArrowSchema_GetChild" "', argument " "2"" of type '" "int""'");
8311 : }
8312 831 : arg2 = static_cast< int >(val2);
8313 831 : {
8314 831 : const int bLocalUseExceptions = GetUseExceptions();
8315 831 : if ( bLocalUseExceptions ) {
8316 831 : pushErrorHandler();
8317 : }
8318 831 : {
8319 831 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8320 831 : result = (ArrowSchema *)ArrowSchema_GetChild(arg1,arg2);
8321 831 : SWIG_PYTHON_THREAD_END_ALLOW;
8322 : }
8323 831 : if ( bLocalUseExceptions ) {
8324 831 : popErrorHandler();
8325 : }
8326 : #ifndef SED_HACKS
8327 : if ( bLocalUseExceptions ) {
8328 : CPLErr eclass = CPLGetLastErrorType();
8329 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8330 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8331 : }
8332 : }
8333 : #endif
8334 : }
8335 831 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ArrowSchema, 0 | 0 );
8336 831 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8337 : return resultobj;
8338 : fail:
8339 : return NULL;
8340 : }
8341 :
8342 :
8343 275 : SWIGINTERN PyObject *ArrowSchema_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8344 275 : PyObject *obj;
8345 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
8346 275 : SWIG_TypeNewClientData(SWIGTYPE_p_ArrowSchema, SWIG_NewClientData(obj));
8347 275 : return SWIG_Py_Void();
8348 : }
8349 :
8350 126 : SWIGINTERN PyObject *ArrowSchema_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8351 126 : return SWIG_Python_InitShadowInstance(args);
8352 : }
8353 :
8354 343 : SWIGINTERN PyObject *_wrap_delete_ArrowArrayStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8355 343 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8356 343 : ArrowArrayStream *arg1 = (ArrowArrayStream *) 0 ;
8357 343 : void *argp1 = 0 ;
8358 343 : int res1 = 0 ;
8359 343 : PyObject *swig_obj[1] ;
8360 :
8361 343 : if (!args) SWIG_fail;
8362 343 : swig_obj[0] = args;
8363 343 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowArrayStream, SWIG_POINTER_DISOWN | 0 );
8364 343 : if (!SWIG_IsOK(res1)) {
8365 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArrowArrayStream" "', argument " "1"" of type '" "ArrowArrayStream *""'");
8366 : }
8367 343 : arg1 = reinterpret_cast< ArrowArrayStream * >(argp1);
8368 343 : {
8369 343 : const int bLocalUseExceptions = GetUseExceptions();
8370 343 : if ( bLocalUseExceptions ) {
8371 247 : pushErrorHandler();
8372 : }
8373 343 : {
8374 343 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8375 343 : delete_ArrowArrayStream(arg1);
8376 343 : SWIG_PYTHON_THREAD_END_ALLOW;
8377 : }
8378 343 : if ( bLocalUseExceptions ) {
8379 247 : popErrorHandler();
8380 : }
8381 : #ifndef SED_HACKS
8382 : if ( bLocalUseExceptions ) {
8383 : CPLErr eclass = CPLGetLastErrorType();
8384 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8385 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8386 : }
8387 : }
8388 : #endif
8389 : }
8390 343 : resultobj = SWIG_Py_Void();
8391 343 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8392 : return resultobj;
8393 : fail:
8394 : return NULL;
8395 : }
8396 :
8397 :
8398 373 : SWIGINTERN PyObject *_wrap_ArrowArrayStream_GetSchema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8399 373 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8400 373 : ArrowArrayStream *arg1 = (ArrowArrayStream *) 0 ;
8401 373 : void *argp1 = 0 ;
8402 373 : int res1 = 0 ;
8403 373 : PyObject *swig_obj[1] ;
8404 373 : ArrowSchema *result = 0 ;
8405 :
8406 373 : if (!args) SWIG_fail;
8407 373 : swig_obj[0] = args;
8408 373 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowArrayStream, 0 | 0 );
8409 373 : if (!SWIG_IsOK(res1)) {
8410 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowArrayStream_GetSchema" "', argument " "1"" of type '" "ArrowArrayStream *""'");
8411 : }
8412 373 : arg1 = reinterpret_cast< ArrowArrayStream * >(argp1);
8413 373 : {
8414 373 : const int bLocalUseExceptions = GetUseExceptions();
8415 373 : if ( bLocalUseExceptions ) {
8416 260 : pushErrorHandler();
8417 : }
8418 373 : {
8419 373 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8420 373 : result = (ArrowSchema *)ArrowArrayStream_GetSchema(arg1);
8421 373 : SWIG_PYTHON_THREAD_END_ALLOW;
8422 : }
8423 373 : if ( bLocalUseExceptions ) {
8424 260 : popErrorHandler();
8425 : }
8426 : #ifndef SED_HACKS
8427 : if ( bLocalUseExceptions ) {
8428 : CPLErr eclass = CPLGetLastErrorType();
8429 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8430 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8431 : }
8432 : }
8433 : #endif
8434 : }
8435 373 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ArrowSchema, SWIG_POINTER_OWN | 0 );
8436 373 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8437 : return resultobj;
8438 : fail:
8439 : return NULL;
8440 : }
8441 :
8442 :
8443 874 : SWIGINTERN PyObject *_wrap_ArrowArrayStream_GetNextRecordBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8444 874 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8445 874 : ArrowArrayStream *arg1 = (ArrowArrayStream *) 0 ;
8446 874 : char **arg2 = (char **) NULL ;
8447 874 : void *argp1 = 0 ;
8448 874 : int res1 = 0 ;
8449 874 : PyObject *swig_obj[2] ;
8450 874 : ArrowArray *result = 0 ;
8451 :
8452 874 : if (!SWIG_Python_UnpackTuple(args, "ArrowArrayStream_GetNextRecordBatch", 1, 2, swig_obj)) SWIG_fail;
8453 874 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ArrowArrayStream, 0 | 0 );
8454 874 : if (!SWIG_IsOK(res1)) {
8455 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArrowArrayStream_GetNextRecordBatch" "', argument " "1"" of type '" "ArrowArrayStream *""'");
8456 : }
8457 874 : arg1 = reinterpret_cast< ArrowArrayStream * >(argp1);
8458 874 : if (swig_obj[1]) {
8459 0 : {
8460 : /* %typemap(in) char **dict */
8461 0 : arg2 = NULL;
8462 0 : if ( PySequence_Check( swig_obj[1] ) ) {
8463 0 : int bErr = FALSE;
8464 0 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
8465 0 : if ( bErr )
8466 : {
8467 0 : SWIG_fail;
8468 : }
8469 : }
8470 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
8471 0 : int bErr = FALSE;
8472 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
8473 0 : if ( bErr )
8474 : {
8475 0 : SWIG_fail;
8476 : }
8477 : }
8478 : else {
8479 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
8480 0 : SWIG_fail;
8481 : }
8482 : }
8483 : }
8484 874 : {
8485 874 : const int bLocalUseExceptions = GetUseExceptions();
8486 874 : if ( bLocalUseExceptions ) {
8487 472 : pushErrorHandler();
8488 : }
8489 874 : {
8490 874 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8491 874 : result = (ArrowArray *)ArrowArrayStream_GetNextRecordBatch(arg1,arg2);
8492 874 : SWIG_PYTHON_THREAD_END_ALLOW;
8493 : }
8494 874 : if ( bLocalUseExceptions ) {
8495 472 : popErrorHandler();
8496 : }
8497 : #ifndef SED_HACKS
8498 : if ( bLocalUseExceptions ) {
8499 : CPLErr eclass = CPLGetLastErrorType();
8500 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8501 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8502 : }
8503 : }
8504 : #endif
8505 : }
8506 874 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ArrowArray, SWIG_POINTER_OWN | 0 );
8507 874 : {
8508 : /* %typemap(freearg) char **dict */
8509 874 : CSLDestroy( arg2 );
8510 : }
8511 892 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8512 : return resultobj;
8513 0 : fail:
8514 0 : {
8515 : /* %typemap(freearg) char **dict */
8516 0 : CSLDestroy( arg2 );
8517 : }
8518 : return NULL;
8519 : }
8520 :
8521 :
8522 275 : SWIGINTERN PyObject *ArrowArrayStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8523 275 : PyObject *obj;
8524 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
8525 275 : SWIG_TypeNewClientData(SWIGTYPE_p_ArrowArrayStream, SWIG_NewClientData(obj));
8526 275 : return SWIG_Py_Void();
8527 : }
8528 :
8529 268 : SWIGINTERN PyObject *_wrap_Layer_GetDataset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8530 268 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8531 268 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
8532 268 : void *argp1 = 0 ;
8533 268 : int res1 = 0 ;
8534 268 : PyObject *swig_obj[1] ;
8535 268 : GDALDatasetShadow *result = 0 ;
8536 :
8537 268 : if (!args) SWIG_fail;
8538 268 : swig_obj[0] = args;
8539 268 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
8540 268 : if (!SWIG_IsOK(res1)) {
8541 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetDataset" "', argument " "1"" of type '" "OGRLayerShadow *""'");
8542 : }
8543 268 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
8544 268 : {
8545 268 : const int bLocalUseExceptions = GetUseExceptions();
8546 268 : if ( bLocalUseExceptions ) {
8547 124 : pushErrorHandler();
8548 : }
8549 268 : {
8550 268 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8551 268 : result = (GDALDatasetShadow *)OGRLayerShadow_GetDataset(arg1);
8552 268 : SWIG_PYTHON_THREAD_END_ALLOW;
8553 : }
8554 268 : if ( bLocalUseExceptions ) {
8555 124 : popErrorHandler();
8556 : }
8557 : #ifndef SED_HACKS
8558 : if ( bLocalUseExceptions ) {
8559 : CPLErr eclass = CPLGetLastErrorType();
8560 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8561 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8562 : }
8563 : }
8564 : #endif
8565 : }
8566 268 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
8567 268 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8568 : return resultobj;
8569 : fail:
8570 : return NULL;
8571 : }
8572 :
8573 :
8574 37 : SWIGINTERN PyObject *_wrap_Layer_Rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8575 37 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8576 37 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
8577 37 : char *arg2 = (char *) 0 ;
8578 37 : void *argp1 = 0 ;
8579 37 : int res1 = 0 ;
8580 37 : int res2 ;
8581 37 : char *buf2 = 0 ;
8582 37 : int alloc2 = 0 ;
8583 37 : PyObject *swig_obj[2] ;
8584 37 : OGRErr result;
8585 :
8586 37 : if (!SWIG_Python_UnpackTuple(args, "Layer_Rename", 2, 2, swig_obj)) SWIG_fail;
8587 37 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
8588 37 : if (!SWIG_IsOK(res1)) {
8589 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_Rename" "', argument " "1"" of type '" "OGRLayerShadow *""'");
8590 : }
8591 37 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
8592 37 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
8593 37 : if (!SWIG_IsOK(res2)) {
8594 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_Rename" "', argument " "2"" of type '" "char const *""'");
8595 : }
8596 37 : arg2 = reinterpret_cast< char * >(buf2);
8597 37 : {
8598 37 : if (!arg2) {
8599 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
8600 : }
8601 : }
8602 37 : {
8603 37 : const int bLocalUseExceptions = GetUseExceptions();
8604 37 : if ( bLocalUseExceptions ) {
8605 3 : pushErrorHandler();
8606 : }
8607 37 : {
8608 37 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8609 37 : result = (OGRErr)OGRLayerShadow_Rename(arg1,(char const *)arg2);
8610 37 : SWIG_PYTHON_THREAD_END_ALLOW;
8611 : }
8612 37 : if ( bLocalUseExceptions ) {
8613 3 : popErrorHandler();
8614 : }
8615 : #ifndef SED_HACKS
8616 : if ( bLocalUseExceptions ) {
8617 : CPLErr eclass = CPLGetLastErrorType();
8618 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8619 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8620 : }
8621 : }
8622 : #endif
8623 : }
8624 37 : {
8625 : /* %typemap(out) OGRErr */
8626 53 : if ( result != 0 && GetUseExceptions()) {
8627 0 : const char* pszMessage = CPLGetLastErrorMsg();
8628 0 : if( pszMessage[0] != '\0' )
8629 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
8630 : else
8631 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
8632 0 : SWIG_fail;
8633 : }
8634 : }
8635 37 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8636 37 : {
8637 : /* %typemap(ret) OGRErr */
8638 37 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
8639 37 : resultobj = PyInt_FromLong( result );
8640 : }
8641 : }
8642 37 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8643 : return resultobj;
8644 0 : fail:
8645 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8646 : return NULL;
8647 : }
8648 :
8649 :
8650 0 : SWIGINTERN PyObject *_wrap_Layer_GetRefCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8651 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8652 0 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
8653 0 : void *argp1 = 0 ;
8654 0 : int res1 = 0 ;
8655 0 : PyObject *swig_obj[1] ;
8656 0 : int result;
8657 :
8658 0 : if (!args) SWIG_fail;
8659 0 : swig_obj[0] = args;
8660 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
8661 0 : if (!SWIG_IsOK(res1)) {
8662 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetRefCount" "', argument " "1"" of type '" "OGRLayerShadow *""'");
8663 : }
8664 0 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
8665 0 : {
8666 0 : const int bLocalUseExceptions = GetUseExceptions();
8667 0 : if ( bLocalUseExceptions ) {
8668 0 : pushErrorHandler();
8669 : }
8670 0 : {
8671 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8672 0 : result = (int)OGRLayerShadow_GetRefCount(arg1);
8673 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8674 : }
8675 0 : if ( bLocalUseExceptions ) {
8676 0 : popErrorHandler();
8677 : }
8678 : #ifndef SED_HACKS
8679 : if ( bLocalUseExceptions ) {
8680 : CPLErr eclass = CPLGetLastErrorType();
8681 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8682 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8683 : }
8684 : }
8685 : #endif
8686 : }
8687 0 : resultobj = SWIG_From_int(static_cast< int >(result));
8688 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8689 : return resultobj;
8690 : fail:
8691 : return NULL;
8692 : }
8693 :
8694 :
8695 : SWIGINTERN PyObject *_wrap_Layer_SetSpatialFilter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
8696 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8697 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
8698 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8699 : void *argp1 = 0 ;
8700 : int res1 = 0 ;
8701 : void *argp2 = 0 ;
8702 : int res2 = 0 ;
8703 :
8704 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
8705 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
8706 : if (!SWIG_IsOK(res1)) {
8707 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetSpatialFilter" "', argument " "1"" of type '" "OGRLayerShadow *""'");
8708 : }
8709 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
8710 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
8711 : if (!SWIG_IsOK(res2)) {
8712 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_SetSpatialFilter" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
8713 : }
8714 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8715 : {
8716 : const int bLocalUseExceptions = GetUseExceptions();
8717 : if ( bLocalUseExceptions ) {
8718 : pushErrorHandler();
8719 : }
8720 : {
8721 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8722 : OGRLayerShadow_SetSpatialFilter__SWIG_0(arg1,arg2);
8723 : SWIG_PYTHON_THREAD_END_ALLOW;
8724 : }
8725 : if ( bLocalUseExceptions ) {
8726 : popErrorHandler();
8727 : }
8728 : #ifndef SED_HACKS
8729 : if ( bLocalUseExceptions ) {
8730 : CPLErr eclass = CPLGetLastErrorType();
8731 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8732 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8733 : }
8734 : }
8735 : #endif
8736 : }
8737 : resultobj = SWIG_Py_Void();
8738 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8739 : return resultobj;
8740 : fail:
8741 : return NULL;
8742 : }
8743 :
8744 :
8745 : SWIGINTERN PyObject *_wrap_Layer_SetSpatialFilterRect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
8746 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8747 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
8748 : double arg2 ;
8749 : double arg3 ;
8750 : double arg4 ;
8751 : double arg5 ;
8752 : void *argp1 = 0 ;
8753 : int res1 = 0 ;
8754 : double val2 ;
8755 : int ecode2 = 0 ;
8756 : double val3 ;
8757 : int ecode3 = 0 ;
8758 : double val4 ;
8759 : int ecode4 = 0 ;
8760 : double val5 ;
8761 : int ecode5 = 0 ;
8762 :
8763 : if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
8764 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
8765 : if (!SWIG_IsOK(res1)) {
8766 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetSpatialFilterRect" "', argument " "1"" of type '" "OGRLayerShadow *""'");
8767 : }
8768 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
8769 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8770 : if (!SWIG_IsOK(ecode2)) {
8771 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_SetSpatialFilterRect" "', argument " "2"" of type '" "double""'");
8772 : }
8773 : arg2 = static_cast< double >(val2);
8774 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8775 : if (!SWIG_IsOK(ecode3)) {
8776 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Layer_SetSpatialFilterRect" "', argument " "3"" of type '" "double""'");
8777 : }
8778 : arg3 = static_cast< double >(val3);
8779 : ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8780 : if (!SWIG_IsOK(ecode4)) {
8781 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_SetSpatialFilterRect" "', argument " "4"" of type '" "double""'");
8782 : }
8783 : arg4 = static_cast< double >(val4);
8784 : ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
8785 : if (!SWIG_IsOK(ecode5)) {
8786 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Layer_SetSpatialFilterRect" "', argument " "5"" of type '" "double""'");
8787 : }
8788 : arg5 = static_cast< double >(val5);
8789 : {
8790 : const int bLocalUseExceptions = GetUseExceptions();
8791 : if ( bLocalUseExceptions ) {
8792 : pushErrorHandler();
8793 : }
8794 : {
8795 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8796 : OGRLayerShadow_SetSpatialFilterRect__SWIG_0(arg1,arg2,arg3,arg4,arg5);
8797 : SWIG_PYTHON_THREAD_END_ALLOW;
8798 : }
8799 : if ( bLocalUseExceptions ) {
8800 : popErrorHandler();
8801 : }
8802 : #ifndef SED_HACKS
8803 : if ( bLocalUseExceptions ) {
8804 : CPLErr eclass = CPLGetLastErrorType();
8805 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8806 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8807 : }
8808 : }
8809 : #endif
8810 : }
8811 : resultobj = SWIG_Py_Void();
8812 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8813 : return resultobj;
8814 : fail:
8815 : return NULL;
8816 : }
8817 :
8818 :
8819 : SWIGINTERN PyObject *_wrap_Layer_SetSpatialFilter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
8820 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8821 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
8822 : int arg2 ;
8823 : OGRGeometryShadow *arg3 = (OGRGeometryShadow *) 0 ;
8824 : void *argp1 = 0 ;
8825 : int res1 = 0 ;
8826 : int val2 ;
8827 : int ecode2 = 0 ;
8828 : void *argp3 = 0 ;
8829 : int res3 = 0 ;
8830 :
8831 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
8832 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
8833 : if (!SWIG_IsOK(res1)) {
8834 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetSpatialFilter" "', argument " "1"" of type '" "OGRLayerShadow *""'");
8835 : }
8836 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
8837 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8838 : if (!SWIG_IsOK(ecode2)) {
8839 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_SetSpatialFilter" "', argument " "2"" of type '" "int""'");
8840 : }
8841 : arg2 = static_cast< int >(val2);
8842 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
8843 : if (!SWIG_IsOK(res3)) {
8844 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_SetSpatialFilter" "', argument " "3"" of type '" "OGRGeometryShadow *""'");
8845 : }
8846 : arg3 = reinterpret_cast< OGRGeometryShadow * >(argp3);
8847 : {
8848 : const int bLocalUseExceptions = GetUseExceptions();
8849 : if ( bLocalUseExceptions ) {
8850 : pushErrorHandler();
8851 : }
8852 : {
8853 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8854 : OGRLayerShadow_SetSpatialFilter__SWIG_1(arg1,arg2,arg3);
8855 : SWIG_PYTHON_THREAD_END_ALLOW;
8856 : }
8857 : if ( bLocalUseExceptions ) {
8858 : popErrorHandler();
8859 : }
8860 : #ifndef SED_HACKS
8861 : if ( bLocalUseExceptions ) {
8862 : CPLErr eclass = CPLGetLastErrorType();
8863 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8864 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8865 : }
8866 : }
8867 : #endif
8868 : }
8869 : resultobj = SWIG_Py_Void();
8870 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
8871 : return resultobj;
8872 : fail:
8873 : return NULL;
8874 : }
8875 :
8876 :
8877 655 : SWIGINTERN PyObject *_wrap_Layer_SetSpatialFilter(PyObject *self, PyObject *args) {
8878 655 : Py_ssize_t argc;
8879 655 : PyObject *argv[4] = {
8880 : 0
8881 : };
8882 :
8883 655 : if (!(argc = SWIG_Python_UnpackTuple(args, "Layer_SetSpatialFilter", 0, 3, argv))) SWIG_fail;
8884 655 : --argc;
8885 655 : if (argc == 2) {
8886 643 : int _v;
8887 643 : void *vptr = 0;
8888 643 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRLayerShadow, 0);
8889 643 : _v = SWIG_CheckState(res);
8890 643 : if (_v) {
8891 643 : void *vptr = 0;
8892 643 : int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
8893 643 : _v = SWIG_CheckState(res);
8894 0 : if (_v) {
8895 643 : return _wrap_Layer_SetSpatialFilter__SWIG_0(self, argc, argv);
8896 : }
8897 : }
8898 : }
8899 12 : if (argc == 3) {
8900 12 : int _v;
8901 12 : void *vptr = 0;
8902 12 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRLayerShadow, 0);
8903 12 : _v = SWIG_CheckState(res);
8904 12 : if (_v) {
8905 12 : {
8906 12 : int res = SWIG_AsVal_int(argv[1], NULL);
8907 12 : _v = SWIG_CheckState(res);
8908 : }
8909 12 : if (_v) {
8910 12 : void *vptr = 0;
8911 12 : int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
8912 12 : _v = SWIG_CheckState(res);
8913 0 : if (_v) {
8914 12 : return _wrap_Layer_SetSpatialFilter__SWIG_1(self, argc, argv);
8915 : }
8916 : }
8917 : }
8918 : }
8919 :
8920 0 : fail:
8921 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Layer_SetSpatialFilter'.\n"
8922 : " Possible C/C++ prototypes are:\n"
8923 : " OGRLayerShadow::SetSpatialFilter(OGRGeometryShadow *)\n"
8924 : " OGRLayerShadow::SetSpatialFilter(int,OGRGeometryShadow *)\n");
8925 : return 0;
8926 : }
8927 :
8928 :
8929 : SWIGINTERN PyObject *_wrap_Layer_SetSpatialFilterRect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
8930 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
8931 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
8932 : int arg2 ;
8933 : double arg3 ;
8934 : double arg4 ;
8935 : double arg5 ;
8936 : double arg6 ;
8937 : void *argp1 = 0 ;
8938 : int res1 = 0 ;
8939 : int val2 ;
8940 : int ecode2 = 0 ;
8941 : double val3 ;
8942 : int ecode3 = 0 ;
8943 : double val4 ;
8944 : int ecode4 = 0 ;
8945 : double val5 ;
8946 : int ecode5 = 0 ;
8947 : double val6 ;
8948 : int ecode6 = 0 ;
8949 :
8950 : if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
8951 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
8952 : if (!SWIG_IsOK(res1)) {
8953 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetSpatialFilterRect" "', argument " "1"" of type '" "OGRLayerShadow *""'");
8954 : }
8955 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
8956 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8957 : if (!SWIG_IsOK(ecode2)) {
8958 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_SetSpatialFilterRect" "', argument " "2"" of type '" "int""'");
8959 : }
8960 : arg2 = static_cast< int >(val2);
8961 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8962 : if (!SWIG_IsOK(ecode3)) {
8963 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Layer_SetSpatialFilterRect" "', argument " "3"" of type '" "double""'");
8964 : }
8965 : arg3 = static_cast< double >(val3);
8966 : ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8967 : if (!SWIG_IsOK(ecode4)) {
8968 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_SetSpatialFilterRect" "', argument " "4"" of type '" "double""'");
8969 : }
8970 : arg4 = static_cast< double >(val4);
8971 : ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
8972 : if (!SWIG_IsOK(ecode5)) {
8973 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Layer_SetSpatialFilterRect" "', argument " "5"" of type '" "double""'");
8974 : }
8975 : arg5 = static_cast< double >(val5);
8976 : ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
8977 : if (!SWIG_IsOK(ecode6)) {
8978 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Layer_SetSpatialFilterRect" "', argument " "6"" of type '" "double""'");
8979 : }
8980 : arg6 = static_cast< double >(val6);
8981 : {
8982 : const int bLocalUseExceptions = GetUseExceptions();
8983 : if ( bLocalUseExceptions ) {
8984 : pushErrorHandler();
8985 : }
8986 : {
8987 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8988 : OGRLayerShadow_SetSpatialFilterRect__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
8989 : SWIG_PYTHON_THREAD_END_ALLOW;
8990 : }
8991 : if ( bLocalUseExceptions ) {
8992 : popErrorHandler();
8993 : }
8994 : #ifndef SED_HACKS
8995 : if ( bLocalUseExceptions ) {
8996 : CPLErr eclass = CPLGetLastErrorType();
8997 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8998 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8999 : }
9000 : }
9001 : #endif
9002 : }
9003 : resultobj = SWIG_Py_Void();
9004 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9005 : return resultobj;
9006 : fail:
9007 : return NULL;
9008 : }
9009 :
9010 :
9011 47727 : SWIGINTERN PyObject *_wrap_Layer_SetSpatialFilterRect(PyObject *self, PyObject *args) {
9012 47727 : Py_ssize_t argc;
9013 47727 : PyObject *argv[7] = {
9014 : 0
9015 : };
9016 :
9017 47727 : if (!(argc = SWIG_Python_UnpackTuple(args, "Layer_SetSpatialFilterRect", 0, 6, argv))) SWIG_fail;
9018 47727 : --argc;
9019 47727 : if (argc == 5) {
9020 47712 : int _v;
9021 47712 : void *vptr = 0;
9022 47712 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRLayerShadow, 0);
9023 47712 : _v = SWIG_CheckState(res);
9024 47712 : if (_v) {
9025 47712 : {
9026 47712 : int res = SWIG_AsVal_double(argv[1], NULL);
9027 47712 : _v = SWIG_CheckState(res);
9028 : }
9029 47712 : if (_v) {
9030 47712 : {
9031 47712 : int res = SWIG_AsVal_double(argv[2], NULL);
9032 47712 : _v = SWIG_CheckState(res);
9033 : }
9034 47712 : if (_v) {
9035 47712 : {
9036 47712 : int res = SWIG_AsVal_double(argv[3], NULL);
9037 47712 : _v = SWIG_CheckState(res);
9038 : }
9039 47712 : if (_v) {
9040 47712 : {
9041 47712 : int res = SWIG_AsVal_double(argv[4], NULL);
9042 47712 : _v = SWIG_CheckState(res);
9043 : }
9044 47712 : if (_v) {
9045 47712 : return _wrap_Layer_SetSpatialFilterRect__SWIG_0(self, argc, argv);
9046 : }
9047 : }
9048 : }
9049 : }
9050 : }
9051 : }
9052 15 : if (argc == 6) {
9053 15 : int _v;
9054 15 : void *vptr = 0;
9055 15 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRLayerShadow, 0);
9056 15 : _v = SWIG_CheckState(res);
9057 15 : if (_v) {
9058 15 : {
9059 15 : int res = SWIG_AsVal_int(argv[1], NULL);
9060 15 : _v = SWIG_CheckState(res);
9061 : }
9062 15 : if (_v) {
9063 15 : {
9064 15 : int res = SWIG_AsVal_double(argv[2], NULL);
9065 15 : _v = SWIG_CheckState(res);
9066 : }
9067 15 : if (_v) {
9068 15 : {
9069 15 : int res = SWIG_AsVal_double(argv[3], NULL);
9070 15 : _v = SWIG_CheckState(res);
9071 : }
9072 15 : if (_v) {
9073 15 : {
9074 15 : int res = SWIG_AsVal_double(argv[4], NULL);
9075 15 : _v = SWIG_CheckState(res);
9076 : }
9077 15 : if (_v) {
9078 15 : {
9079 15 : int res = SWIG_AsVal_double(argv[5], NULL);
9080 15 : _v = SWIG_CheckState(res);
9081 : }
9082 15 : if (_v) {
9083 15 : return _wrap_Layer_SetSpatialFilterRect__SWIG_1(self, argc, argv);
9084 : }
9085 : }
9086 : }
9087 : }
9088 : }
9089 : }
9090 : }
9091 :
9092 0 : fail:
9093 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Layer_SetSpatialFilterRect'.\n"
9094 : " Possible C/C++ prototypes are:\n"
9095 : " OGRLayerShadow::SetSpatialFilterRect(double,double,double,double)\n"
9096 : " OGRLayerShadow::SetSpatialFilterRect(int,double,double,double,double)\n");
9097 : return 0;
9098 : }
9099 :
9100 :
9101 5 : SWIGINTERN PyObject *_wrap_Layer_GetSpatialFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9102 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9103 5 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9104 5 : void *argp1 = 0 ;
9105 5 : int res1 = 0 ;
9106 5 : PyObject *swig_obj[1] ;
9107 5 : OGRGeometryShadow *result = 0 ;
9108 :
9109 5 : if (!args) SWIG_fail;
9110 5 : swig_obj[0] = args;
9111 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9112 5 : if (!SWIG_IsOK(res1)) {
9113 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetSpatialFilter" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9114 : }
9115 5 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9116 5 : {
9117 5 : const int bLocalUseExceptions = GetUseExceptions();
9118 5 : if ( bLocalUseExceptions ) {
9119 1 : pushErrorHandler();
9120 : }
9121 5 : {
9122 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9123 5 : result = (OGRGeometryShadow *)OGRLayerShadow_GetSpatialFilter(arg1);
9124 5 : SWIG_PYTHON_THREAD_END_ALLOW;
9125 : }
9126 5 : if ( bLocalUseExceptions ) {
9127 1 : popErrorHandler();
9128 : }
9129 : #ifndef SED_HACKS
9130 : if ( bLocalUseExceptions ) {
9131 : CPLErr eclass = CPLGetLastErrorType();
9132 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9133 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9134 : }
9135 : }
9136 : #endif
9137 : }
9138 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
9139 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9140 : return resultobj;
9141 : fail:
9142 : return NULL;
9143 : }
9144 :
9145 :
9146 1438 : SWIGINTERN PyObject *_wrap_Layer_SetAttributeFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9147 1438 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9148 1438 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9149 1438 : char *arg2 = (char *) 0 ;
9150 1438 : void *argp1 = 0 ;
9151 1438 : int res1 = 0 ;
9152 1438 : int res2 ;
9153 1438 : char *buf2 = 0 ;
9154 1438 : int alloc2 = 0 ;
9155 1438 : PyObject *swig_obj[2] ;
9156 1438 : OGRErr result;
9157 :
9158 1438 : if (!SWIG_Python_UnpackTuple(args, "Layer_SetAttributeFilter", 2, 2, swig_obj)) SWIG_fail;
9159 1438 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9160 1438 : if (!SWIG_IsOK(res1)) {
9161 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetAttributeFilter" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9162 : }
9163 1438 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9164 1438 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
9165 1438 : if (!SWIG_IsOK(res2)) {
9166 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_SetAttributeFilter" "', argument " "2"" of type '" "char *""'");
9167 : }
9168 1438 : arg2 = reinterpret_cast< char * >(buf2);
9169 1438 : {
9170 1438 : const int bLocalUseExceptions = GetUseExceptions();
9171 1438 : if ( bLocalUseExceptions ) {
9172 861 : pushErrorHandler();
9173 : }
9174 1438 : {
9175 1438 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9176 1438 : result = (OGRErr)OGRLayerShadow_SetAttributeFilter(arg1,arg2);
9177 1438 : SWIG_PYTHON_THREAD_END_ALLOW;
9178 : }
9179 1438 : if ( bLocalUseExceptions ) {
9180 861 : popErrorHandler();
9181 : }
9182 : #ifndef SED_HACKS
9183 : if ( bLocalUseExceptions ) {
9184 : CPLErr eclass = CPLGetLastErrorType();
9185 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9186 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9187 : }
9188 : }
9189 : #endif
9190 : }
9191 1438 : {
9192 : /* %typemap(out) OGRErr */
9193 1474 : if ( result != 0 && GetUseExceptions()) {
9194 4 : const char* pszMessage = CPLGetLastErrorMsg();
9195 4 : if( pszMessage[0] != '\0' )
9196 4 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
9197 : else
9198 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9199 4 : SWIG_fail;
9200 : }
9201 : }
9202 1434 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9203 1434 : {
9204 : /* %typemap(ret) OGRErr */
9205 1434 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
9206 1434 : resultobj = PyInt_FromLong( result );
9207 : }
9208 : }
9209 1438 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9210 : return resultobj;
9211 4 : fail:
9212 4 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9213 : return NULL;
9214 : }
9215 :
9216 :
9217 17629 : SWIGINTERN PyObject *_wrap_Layer_ResetReading(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9218 17629 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9219 17629 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9220 17629 : void *argp1 = 0 ;
9221 17629 : int res1 = 0 ;
9222 17629 : PyObject *swig_obj[1] ;
9223 :
9224 17629 : if (!args) SWIG_fail;
9225 17629 : swig_obj[0] = args;
9226 17629 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9227 17629 : if (!SWIG_IsOK(res1)) {
9228 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_ResetReading" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9229 : }
9230 17629 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9231 17629 : {
9232 17629 : const int bLocalUseExceptions = GetUseExceptions();
9233 17629 : if ( bLocalUseExceptions ) {
9234 13301 : pushErrorHandler();
9235 : }
9236 17629 : {
9237 17629 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9238 17629 : OGRLayerShadow_ResetReading(arg1);
9239 17629 : SWIG_PYTHON_THREAD_END_ALLOW;
9240 : }
9241 17629 : if ( bLocalUseExceptions ) {
9242 13301 : popErrorHandler();
9243 : }
9244 : #ifndef SED_HACKS
9245 : if ( bLocalUseExceptions ) {
9246 : CPLErr eclass = CPLGetLastErrorType();
9247 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9248 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9249 : }
9250 : }
9251 : #endif
9252 : }
9253 17629 : resultobj = SWIG_Py_Void();
9254 17629 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9255 : return resultobj;
9256 : fail:
9257 : return NULL;
9258 : }
9259 :
9260 :
9261 1254 : SWIGINTERN PyObject *_wrap_Layer_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9262 1254 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9263 1254 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9264 1254 : void *argp1 = 0 ;
9265 1254 : int res1 = 0 ;
9266 1254 : PyObject *swig_obj[1] ;
9267 1254 : char *result = 0 ;
9268 :
9269 1254 : if (!args) SWIG_fail;
9270 1254 : swig_obj[0] = args;
9271 1254 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9272 1254 : if (!SWIG_IsOK(res1)) {
9273 12 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetName" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9274 : }
9275 1248 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9276 1248 : {
9277 1248 : const int bLocalUseExceptions = GetUseExceptions();
9278 1248 : if ( bLocalUseExceptions ) {
9279 821 : pushErrorHandler();
9280 : }
9281 1248 : {
9282 1248 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9283 1248 : result = (char *)OGRLayerShadow_GetName(arg1);
9284 1248 : SWIG_PYTHON_THREAD_END_ALLOW;
9285 : }
9286 1248 : if ( bLocalUseExceptions ) {
9287 821 : popErrorHandler();
9288 : }
9289 : #ifndef SED_HACKS
9290 : if ( bLocalUseExceptions ) {
9291 : CPLErr eclass = CPLGetLastErrorType();
9292 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9293 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9294 : }
9295 : }
9296 : #endif
9297 : }
9298 1248 : resultobj = SWIG_FromCharPtr((const char *)result);
9299 1255 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9300 : return resultobj;
9301 : fail:
9302 : return NULL;
9303 : }
9304 :
9305 :
9306 1104 : SWIGINTERN PyObject *_wrap_Layer_GetGeomType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9307 1104 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9308 1104 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9309 1104 : void *argp1 = 0 ;
9310 1104 : int res1 = 0 ;
9311 1104 : PyObject *swig_obj[1] ;
9312 1104 : OGRwkbGeometryType result;
9313 :
9314 1104 : if (!args) SWIG_fail;
9315 1104 : swig_obj[0] = args;
9316 1104 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9317 1104 : if (!SWIG_IsOK(res1)) {
9318 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetGeomType" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9319 : }
9320 1104 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9321 1104 : {
9322 1104 : const int bLocalUseExceptions = GetUseExceptions();
9323 1104 : if ( bLocalUseExceptions ) {
9324 612 : pushErrorHandler();
9325 : }
9326 1104 : {
9327 1104 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9328 1104 : result = (OGRwkbGeometryType)OGRLayerShadow_GetGeomType(arg1);
9329 1104 : SWIG_PYTHON_THREAD_END_ALLOW;
9330 : }
9331 1104 : if ( bLocalUseExceptions ) {
9332 612 : popErrorHandler();
9333 : }
9334 : #ifndef SED_HACKS
9335 : if ( bLocalUseExceptions ) {
9336 : CPLErr eclass = CPLGetLastErrorType();
9337 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9338 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9339 : }
9340 : }
9341 : #endif
9342 : }
9343 1104 : resultobj = SWIG_From_int(static_cast< int >(result));
9344 1104 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9345 : return resultobj;
9346 : fail:
9347 : return NULL;
9348 : }
9349 :
9350 :
9351 580 : SWIGINTERN PyObject *_wrap_Layer_GetGeometryColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9352 580 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9353 580 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9354 580 : void *argp1 = 0 ;
9355 580 : int res1 = 0 ;
9356 580 : PyObject *swig_obj[1] ;
9357 580 : char *result = 0 ;
9358 :
9359 580 : if (!args) SWIG_fail;
9360 580 : swig_obj[0] = args;
9361 580 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9362 580 : if (!SWIG_IsOK(res1)) {
9363 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetGeometryColumn" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9364 : }
9365 580 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9366 580 : {
9367 580 : const int bLocalUseExceptions = GetUseExceptions();
9368 580 : if ( bLocalUseExceptions ) {
9369 513 : pushErrorHandler();
9370 : }
9371 580 : {
9372 580 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9373 580 : result = (char *)OGRLayerShadow_GetGeometryColumn(arg1);
9374 580 : SWIG_PYTHON_THREAD_END_ALLOW;
9375 : }
9376 580 : if ( bLocalUseExceptions ) {
9377 513 : popErrorHandler();
9378 : }
9379 : #ifndef SED_HACKS
9380 : if ( bLocalUseExceptions ) {
9381 : CPLErr eclass = CPLGetLastErrorType();
9382 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9383 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9384 : }
9385 : }
9386 : #endif
9387 : }
9388 580 : resultobj = SWIG_FromCharPtr((const char *)result);
9389 580 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9390 : return resultobj;
9391 : fail:
9392 : return NULL;
9393 : }
9394 :
9395 :
9396 383 : SWIGINTERN PyObject *_wrap_Layer_GetFIDColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9397 383 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9398 383 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9399 383 : void *argp1 = 0 ;
9400 383 : int res1 = 0 ;
9401 383 : PyObject *swig_obj[1] ;
9402 383 : char *result = 0 ;
9403 :
9404 383 : if (!args) SWIG_fail;
9405 383 : swig_obj[0] = args;
9406 383 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9407 383 : if (!SWIG_IsOK(res1)) {
9408 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetFIDColumn" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9409 : }
9410 383 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9411 383 : {
9412 383 : const int bLocalUseExceptions = GetUseExceptions();
9413 383 : if ( bLocalUseExceptions ) {
9414 121 : pushErrorHandler();
9415 : }
9416 383 : {
9417 383 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9418 383 : result = (char *)OGRLayerShadow_GetFIDColumn(arg1);
9419 383 : SWIG_PYTHON_THREAD_END_ALLOW;
9420 : }
9421 383 : if ( bLocalUseExceptions ) {
9422 121 : popErrorHandler();
9423 : }
9424 : #ifndef SED_HACKS
9425 : if ( bLocalUseExceptions ) {
9426 : CPLErr eclass = CPLGetLastErrorType();
9427 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9428 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9429 : }
9430 : }
9431 : #endif
9432 : }
9433 383 : resultobj = SWIG_FromCharPtr((const char *)result);
9434 383 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9435 : return resultobj;
9436 : fail:
9437 : return NULL;
9438 : }
9439 :
9440 :
9441 2526 : SWIGINTERN PyObject *_wrap_Layer_GetFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9442 2526 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9443 2526 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9444 2526 : GIntBig arg2 ;
9445 2526 : void *argp1 = 0 ;
9446 2526 : int res1 = 0 ;
9447 2526 : PyObject *swig_obj[2] ;
9448 2526 : OGRFeatureShadow *result = 0 ;
9449 :
9450 2526 : if (!SWIG_Python_UnpackTuple(args, "Layer_GetFeature", 2, 2, swig_obj)) SWIG_fail;
9451 2526 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9452 2526 : if (!SWIG_IsOK(res1)) {
9453 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9454 : }
9455 2526 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9456 2526 : {
9457 2526 : arg2 = (GIntBig)PyLong_AsLongLong(swig_obj[1]);
9458 : }
9459 2526 : {
9460 2526 : const int bLocalUseExceptions = GetUseExceptions();
9461 2526 : if ( bLocalUseExceptions ) {
9462 2089 : pushErrorHandler();
9463 : }
9464 2526 : {
9465 2526 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9466 2526 : result = (OGRFeatureShadow *)OGRLayerShadow_GetFeature(arg1,arg2);
9467 2526 : SWIG_PYTHON_THREAD_END_ALLOW;
9468 : }
9469 2526 : if ( bLocalUseExceptions ) {
9470 2089 : popErrorHandler();
9471 : }
9472 : #ifndef SED_HACKS
9473 : if ( bLocalUseExceptions ) {
9474 : CPLErr eclass = CPLGetLastErrorType();
9475 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9476 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9477 : }
9478 : }
9479 : #endif
9480 : }
9481 2526 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_OWN | 0 );
9482 2530 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9483 : return resultobj;
9484 : fail:
9485 : return NULL;
9486 : }
9487 :
9488 :
9489 78966 : SWIGINTERN PyObject *_wrap_Layer_GetNextFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9490 78966 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9491 78966 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9492 78966 : void *argp1 = 0 ;
9493 78966 : int res1 = 0 ;
9494 78966 : PyObject *swig_obj[1] ;
9495 78966 : OGRFeatureShadow *result = 0 ;
9496 :
9497 78966 : if (!args) SWIG_fail;
9498 78966 : swig_obj[0] = args;
9499 78966 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9500 78966 : if (!SWIG_IsOK(res1)) {
9501 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetNextFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9502 : }
9503 78966 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9504 78966 : {
9505 78966 : const int bLocalUseExceptions = GetUseExceptions();
9506 78966 : if ( bLocalUseExceptions ) {
9507 50224 : pushErrorHandler();
9508 : }
9509 78966 : {
9510 78966 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9511 78966 : result = (OGRFeatureShadow *)OGRLayerShadow_GetNextFeature(arg1);
9512 78966 : SWIG_PYTHON_THREAD_END_ALLOW;
9513 : }
9514 78966 : if ( bLocalUseExceptions ) {
9515 50224 : popErrorHandler();
9516 : }
9517 : #ifndef SED_HACKS
9518 : if ( bLocalUseExceptions ) {
9519 : CPLErr eclass = CPLGetLastErrorType();
9520 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9521 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9522 : }
9523 : }
9524 : #endif
9525 : }
9526 78966 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_OWN | 0 );
9527 78984 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9528 : return resultobj;
9529 : fail:
9530 : return NULL;
9531 : }
9532 :
9533 :
9534 39 : SWIGINTERN PyObject *_wrap_Layer_SetNextByIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9535 39 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9536 39 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9537 39 : GIntBig arg2 ;
9538 39 : void *argp1 = 0 ;
9539 39 : int res1 = 0 ;
9540 39 : PyObject *swig_obj[2] ;
9541 39 : OGRErr result;
9542 :
9543 39 : if (!SWIG_Python_UnpackTuple(args, "Layer_SetNextByIndex", 2, 2, swig_obj)) SWIG_fail;
9544 39 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9545 39 : if (!SWIG_IsOK(res1)) {
9546 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetNextByIndex" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9547 : }
9548 39 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9549 39 : {
9550 39 : arg2 = (GIntBig)PyLong_AsLongLong(swig_obj[1]);
9551 : }
9552 39 : {
9553 39 : const int bLocalUseExceptions = GetUseExceptions();
9554 39 : if ( bLocalUseExceptions ) {
9555 0 : pushErrorHandler();
9556 : }
9557 39 : {
9558 39 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9559 39 : result = (OGRErr)OGRLayerShadow_SetNextByIndex(arg1,arg2);
9560 39 : SWIG_PYTHON_THREAD_END_ALLOW;
9561 : }
9562 39 : if ( bLocalUseExceptions ) {
9563 0 : popErrorHandler();
9564 : }
9565 : #ifndef SED_HACKS
9566 : if ( bLocalUseExceptions ) {
9567 : CPLErr eclass = CPLGetLastErrorType();
9568 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9569 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9570 : }
9571 : }
9572 : #endif
9573 : }
9574 39 : {
9575 : /* %typemap(out) OGRErr */
9576 49 : if ( result != 0 && GetUseExceptions()) {
9577 0 : const char* pszMessage = CPLGetLastErrorMsg();
9578 0 : if( pszMessage[0] != '\0' )
9579 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
9580 : else
9581 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9582 0 : SWIG_fail;
9583 : }
9584 : }
9585 39 : {
9586 : /* %typemap(ret) OGRErr */
9587 39 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
9588 39 : resultobj = PyInt_FromLong( result );
9589 : }
9590 : }
9591 39 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9592 : return resultobj;
9593 : fail:
9594 : return NULL;
9595 : }
9596 :
9597 :
9598 2480 : SWIGINTERN PyObject *_wrap_Layer_SetFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9599 2480 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9600 2480 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9601 2480 : OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
9602 2480 : void *argp1 = 0 ;
9603 2480 : int res1 = 0 ;
9604 2480 : void *argp2 = 0 ;
9605 2480 : int res2 = 0 ;
9606 2480 : PyObject *swig_obj[2] ;
9607 2480 : OGRErr result;
9608 :
9609 2480 : if (!SWIG_Python_UnpackTuple(args, "Layer_SetFeature", 2, 2, swig_obj)) SWIG_fail;
9610 2480 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9611 2480 : if (!SWIG_IsOK(res1)) {
9612 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9613 : }
9614 2480 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9615 2480 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
9616 2480 : if (!SWIG_IsOK(res2)) {
9617 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_SetFeature" "', argument " "2"" of type '" "OGRFeatureShadow *""'");
9618 : }
9619 2480 : arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
9620 2480 : {
9621 2480 : if (!arg2) {
9622 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
9623 : }
9624 : }
9625 2480 : {
9626 2480 : const int bLocalUseExceptions = GetUseExceptions();
9627 2480 : if ( bLocalUseExceptions ) {
9628 24 : pushErrorHandler();
9629 : }
9630 2480 : {
9631 2480 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9632 2480 : result = (OGRErr)OGRLayerShadow_SetFeature(arg1,arg2);
9633 2480 : SWIG_PYTHON_THREAD_END_ALLOW;
9634 : }
9635 2480 : if ( bLocalUseExceptions ) {
9636 24 : popErrorHandler();
9637 : }
9638 : #ifndef SED_HACKS
9639 : if ( bLocalUseExceptions ) {
9640 : CPLErr eclass = CPLGetLastErrorType();
9641 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9642 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9643 : }
9644 : }
9645 : #endif
9646 : }
9647 2480 : {
9648 : /* %typemap(out) OGRErr */
9649 2535 : if ( result != 0 && GetUseExceptions()) {
9650 3 : const char* pszMessage = CPLGetLastErrorMsg();
9651 3 : if( pszMessage[0] != '\0' )
9652 3 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
9653 : else
9654 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9655 3 : SWIG_fail;
9656 : }
9657 : }
9658 2477 : {
9659 : /* %typemap(ret) OGRErr */
9660 2477 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
9661 2477 : resultobj = PyInt_FromLong( result );
9662 : }
9663 : }
9664 2480 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9665 : return resultobj;
9666 : fail:
9667 : return NULL;
9668 : }
9669 :
9670 :
9671 283131 : SWIGINTERN PyObject *_wrap_Layer_CreateFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9672 283131 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9673 283131 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9674 283131 : OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
9675 283131 : void *argp1 = 0 ;
9676 283131 : int res1 = 0 ;
9677 283131 : void *argp2 = 0 ;
9678 283131 : int res2 = 0 ;
9679 283131 : PyObject *swig_obj[2] ;
9680 283131 : OGRErr result;
9681 :
9682 283131 : if (!SWIG_Python_UnpackTuple(args, "Layer_CreateFeature", 2, 2, swig_obj)) SWIG_fail;
9683 283131 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9684 283131 : if (!SWIG_IsOK(res1)) {
9685 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_CreateFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9686 : }
9687 283131 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9688 283131 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
9689 283131 : if (!SWIG_IsOK(res2)) {
9690 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_CreateFeature" "', argument " "2"" of type '" "OGRFeatureShadow *""'");
9691 : }
9692 283131 : arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
9693 283131 : {
9694 283131 : if (!arg2) {
9695 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
9696 : }
9697 : }
9698 283131 : {
9699 283131 : const int bLocalUseExceptions = GetUseExceptions();
9700 283131 : if ( bLocalUseExceptions ) {
9701 221404 : pushErrorHandler();
9702 : }
9703 283131 : {
9704 283131 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9705 283131 : result = (OGRErr)OGRLayerShadow_CreateFeature(arg1,arg2);
9706 283131 : SWIG_PYTHON_THREAD_END_ALLOW;
9707 : }
9708 283131 : if ( bLocalUseExceptions ) {
9709 221404 : popErrorHandler();
9710 : }
9711 : #ifndef SED_HACKS
9712 : if ( bLocalUseExceptions ) {
9713 : CPLErr eclass = CPLGetLastErrorType();
9714 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9715 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9716 : }
9717 : }
9718 : #endif
9719 : }
9720 283131 : {
9721 : /* %typemap(out) OGRErr */
9722 283291 : if ( result != 0 && GetUseExceptions()) {
9723 28 : const char* pszMessage = CPLGetLastErrorMsg();
9724 28 : if( pszMessage[0] != '\0' )
9725 28 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
9726 : else
9727 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9728 28 : SWIG_fail;
9729 : }
9730 : }
9731 283103 : {
9732 : /* %typemap(ret) OGRErr */
9733 283103 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
9734 283103 : resultobj = PyInt_FromLong( result );
9735 : }
9736 : }
9737 283131 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9738 : return resultobj;
9739 : fail:
9740 : return NULL;
9741 : }
9742 :
9743 :
9744 31 : SWIGINTERN PyObject *_wrap_Layer_UpsertFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9745 31 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9746 31 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9747 31 : OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
9748 31 : void *argp1 = 0 ;
9749 31 : int res1 = 0 ;
9750 31 : void *argp2 = 0 ;
9751 31 : int res2 = 0 ;
9752 31 : PyObject *swig_obj[2] ;
9753 31 : OGRErr result;
9754 :
9755 31 : if (!SWIG_Python_UnpackTuple(args, "Layer_UpsertFeature", 2, 2, swig_obj)) SWIG_fail;
9756 31 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9757 31 : if (!SWIG_IsOK(res1)) {
9758 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_UpsertFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9759 : }
9760 31 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9761 31 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
9762 31 : if (!SWIG_IsOK(res2)) {
9763 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_UpsertFeature" "', argument " "2"" of type '" "OGRFeatureShadow *""'");
9764 : }
9765 31 : arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
9766 31 : {
9767 31 : if (!arg2) {
9768 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
9769 : }
9770 : }
9771 31 : {
9772 31 : const int bLocalUseExceptions = GetUseExceptions();
9773 31 : if ( bLocalUseExceptions ) {
9774 0 : pushErrorHandler();
9775 : }
9776 31 : {
9777 31 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9778 31 : result = (OGRErr)OGRLayerShadow_UpsertFeature(arg1,arg2);
9779 31 : SWIG_PYTHON_THREAD_END_ALLOW;
9780 : }
9781 31 : if ( bLocalUseExceptions ) {
9782 0 : popErrorHandler();
9783 : }
9784 : #ifndef SED_HACKS
9785 : if ( bLocalUseExceptions ) {
9786 : CPLErr eclass = CPLGetLastErrorType();
9787 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9788 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9789 : }
9790 : }
9791 : #endif
9792 : }
9793 31 : {
9794 : /* %typemap(out) OGRErr */
9795 32 : if ( result != 0 && GetUseExceptions()) {
9796 0 : const char* pszMessage = CPLGetLastErrorMsg();
9797 0 : if( pszMessage[0] != '\0' )
9798 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
9799 : else
9800 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9801 0 : SWIG_fail;
9802 : }
9803 : }
9804 31 : {
9805 : /* %typemap(ret) OGRErr */
9806 31 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
9807 31 : resultobj = PyInt_FromLong( result );
9808 : }
9809 : }
9810 31 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9811 : return resultobj;
9812 : fail:
9813 : return NULL;
9814 : }
9815 :
9816 :
9817 31 : SWIGINTERN PyObject *_wrap_Layer_UpdateFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9818 31 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9819 31 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9820 31 : OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
9821 31 : int arg3 ;
9822 31 : int *arg4 = (int *) 0 ;
9823 31 : int arg5 ;
9824 31 : int *arg6 = (int *) 0 ;
9825 31 : bool arg7 ;
9826 31 : void *argp1 = 0 ;
9827 31 : int res1 = 0 ;
9828 31 : void *argp2 = 0 ;
9829 31 : int res2 = 0 ;
9830 31 : bool val7 ;
9831 31 : int ecode7 = 0 ;
9832 31 : PyObject *swig_obj[5] ;
9833 31 : OGRErr result;
9834 :
9835 31 : if (!SWIG_Python_UnpackTuple(args, "Layer_UpdateFeature", 5, 5, swig_obj)) SWIG_fail;
9836 31 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9837 31 : if (!SWIG_IsOK(res1)) {
9838 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_UpdateFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9839 : }
9840 31 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9841 31 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
9842 31 : if (!SWIG_IsOK(res2)) {
9843 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_UpdateFeature" "', argument " "2"" of type '" "OGRFeatureShadow *""'");
9844 : }
9845 31 : arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
9846 31 : {
9847 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
9848 31 : arg4 = CreateCIntListFromSequence(swig_obj[2], &arg3);
9849 31 : if( arg3 < 0 ) {
9850 0 : SWIG_fail;
9851 : }
9852 : }
9853 31 : {
9854 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
9855 31 : arg6 = CreateCIntListFromSequence(swig_obj[3], &arg5);
9856 31 : if( arg5 < 0 ) {
9857 0 : SWIG_fail;
9858 : }
9859 : }
9860 31 : ecode7 = SWIG_AsVal_bool(swig_obj[4], &val7);
9861 31 : if (!SWIG_IsOK(ecode7)) {
9862 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Layer_UpdateFeature" "', argument " "7"" of type '" "bool""'");
9863 : }
9864 31 : arg7 = static_cast< bool >(val7);
9865 31 : {
9866 31 : if (!arg2) {
9867 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
9868 : }
9869 : }
9870 31 : {
9871 31 : const int bLocalUseExceptions = GetUseExceptions();
9872 31 : if ( bLocalUseExceptions ) {
9873 4 : pushErrorHandler();
9874 : }
9875 31 : {
9876 31 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9877 31 : result = (OGRErr)OGRLayerShadow_UpdateFeature(arg1,arg2,arg3,(int const *)arg4,arg5,(int const *)arg6,arg7);
9878 31 : SWIG_PYTHON_THREAD_END_ALLOW;
9879 : }
9880 31 : if ( bLocalUseExceptions ) {
9881 4 : popErrorHandler();
9882 : }
9883 : #ifndef SED_HACKS
9884 : if ( bLocalUseExceptions ) {
9885 : CPLErr eclass = CPLGetLastErrorType();
9886 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9887 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9888 : }
9889 : }
9890 : #endif
9891 : }
9892 31 : {
9893 : /* %typemap(out) OGRErr */
9894 43 : if ( result != 0 && GetUseExceptions()) {
9895 0 : const char* pszMessage = CPLGetLastErrorMsg();
9896 0 : if( pszMessage[0] != '\0' )
9897 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
9898 : else
9899 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9900 0 : SWIG_fail;
9901 : }
9902 : }
9903 31 : {
9904 : /* %typemap(freearg) (int nList, int* pList) */
9905 31 : free(arg4);
9906 : }
9907 31 : {
9908 : /* %typemap(freearg) (int nList, int* pList) */
9909 31 : free(arg6);
9910 : }
9911 31 : {
9912 : /* %typemap(ret) OGRErr */
9913 31 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
9914 31 : resultobj = PyInt_FromLong( result );
9915 : }
9916 : }
9917 31 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9918 : return resultobj;
9919 0 : fail:
9920 0 : {
9921 : /* %typemap(freearg) (int nList, int* pList) */
9922 0 : free(arg4);
9923 : }
9924 0 : {
9925 : /* %typemap(freearg) (int nList, int* pList) */
9926 0 : free(arg6);
9927 : }
9928 0 : return NULL;
9929 : }
9930 :
9931 :
9932 3336 : SWIGINTERN PyObject *_wrap_Layer_DeleteFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9933 3336 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9934 3336 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9935 3336 : GIntBig arg2 ;
9936 3336 : void *argp1 = 0 ;
9937 3336 : int res1 = 0 ;
9938 3336 : PyObject *swig_obj[2] ;
9939 3336 : OGRErr result;
9940 :
9941 3336 : if (!SWIG_Python_UnpackTuple(args, "Layer_DeleteFeature", 2, 2, swig_obj)) SWIG_fail;
9942 3336 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
9943 3336 : if (!SWIG_IsOK(res1)) {
9944 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_DeleteFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'");
9945 : }
9946 3336 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
9947 3336 : {
9948 3336 : arg2 = (GIntBig)PyLong_AsLongLong(swig_obj[1]);
9949 : }
9950 3336 : {
9951 3336 : const int bLocalUseExceptions = GetUseExceptions();
9952 3336 : if ( bLocalUseExceptions ) {
9953 16 : pushErrorHandler();
9954 : }
9955 3336 : {
9956 3336 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9957 3336 : result = (OGRErr)OGRLayerShadow_DeleteFeature(arg1,arg2);
9958 3336 : SWIG_PYTHON_THREAD_END_ALLOW;
9959 : }
9960 3336 : if ( bLocalUseExceptions ) {
9961 16 : popErrorHandler();
9962 : }
9963 : #ifndef SED_HACKS
9964 : if ( bLocalUseExceptions ) {
9965 : CPLErr eclass = CPLGetLastErrorType();
9966 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9967 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9968 : }
9969 : }
9970 : #endif
9971 : }
9972 3336 : {
9973 : /* %typemap(out) OGRErr */
9974 3385 : if ( result != 0 && GetUseExceptions()) {
9975 7 : const char* pszMessage = CPLGetLastErrorMsg();
9976 7 : if( pszMessage[0] != '\0' )
9977 2 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
9978 : else
9979 5 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
9980 7 : SWIG_fail;
9981 : }
9982 : }
9983 3329 : {
9984 : /* %typemap(ret) OGRErr */
9985 3329 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
9986 3329 : resultobj = PyInt_FromLong( result );
9987 : }
9988 : }
9989 3336 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
9990 : return resultobj;
9991 : fail:
9992 : return NULL;
9993 : }
9994 :
9995 :
9996 251 : SWIGINTERN PyObject *_wrap_Layer_SyncToDisk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9997 251 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
9998 251 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
9999 251 : void *argp1 = 0 ;
10000 251 : int res1 = 0 ;
10001 251 : PyObject *swig_obj[1] ;
10002 251 : OGRErr result;
10003 :
10004 251 : if (!args) SWIG_fail;
10005 251 : swig_obj[0] = args;
10006 251 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10007 251 : if (!SWIG_IsOK(res1)) {
10008 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SyncToDisk" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10009 : }
10010 251 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10011 251 : {
10012 251 : const int bLocalUseExceptions = GetUseExceptions();
10013 251 : if ( bLocalUseExceptions ) {
10014 19 : pushErrorHandler();
10015 : }
10016 251 : {
10017 251 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10018 251 : result = (OGRErr)OGRLayerShadow_SyncToDisk(arg1);
10019 251 : SWIG_PYTHON_THREAD_END_ALLOW;
10020 : }
10021 251 : if ( bLocalUseExceptions ) {
10022 19 : popErrorHandler();
10023 : }
10024 : #ifndef SED_HACKS
10025 : if ( bLocalUseExceptions ) {
10026 : CPLErr eclass = CPLGetLastErrorType();
10027 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10028 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10029 : }
10030 : }
10031 : #endif
10032 : }
10033 251 : {
10034 : /* %typemap(out) OGRErr */
10035 253 : if ( result != 0 && GetUseExceptions()) {
10036 0 : const char* pszMessage = CPLGetLastErrorMsg();
10037 0 : if( pszMessage[0] != '\0' )
10038 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10039 : else
10040 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10041 0 : SWIG_fail;
10042 : }
10043 : }
10044 251 : {
10045 : /* %typemap(ret) OGRErr */
10046 251 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10047 251 : resultobj = PyInt_FromLong( result );
10048 : }
10049 : }
10050 251 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
10051 : return resultobj;
10052 : fail:
10053 : return NULL;
10054 : }
10055 :
10056 :
10057 125351 : SWIGINTERN PyObject *_wrap_Layer_GetLayerDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10058 125351 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10059 125351 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10060 125351 : void *argp1 = 0 ;
10061 125351 : int res1 = 0 ;
10062 125351 : PyObject *swig_obj[1] ;
10063 125351 : OGRFeatureDefnShadow *result = 0 ;
10064 :
10065 125351 : if (!args) SWIG_fail;
10066 125351 : swig_obj[0] = args;
10067 125351 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10068 125351 : if (!SWIG_IsOK(res1)) {
10069 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetLayerDefn" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10070 : }
10071 125351 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10072 125351 : {
10073 125351 : const int bLocalUseExceptions = GetUseExceptions();
10074 125351 : if ( bLocalUseExceptions ) {
10075 64337 : pushErrorHandler();
10076 : }
10077 125351 : {
10078 125351 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10079 125351 : result = (OGRFeatureDefnShadow *)OGRLayerShadow_GetLayerDefn(arg1);
10080 125351 : SWIG_PYTHON_THREAD_END_ALLOW;
10081 : }
10082 125351 : if ( bLocalUseExceptions ) {
10083 64337 : popErrorHandler();
10084 : }
10085 : #ifndef SED_HACKS
10086 : if ( bLocalUseExceptions ) {
10087 : CPLErr eclass = CPLGetLastErrorType();
10088 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10089 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10090 : }
10091 : }
10092 : #endif
10093 : }
10094 125351 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureDefnShadow, SWIG_POINTER_OWN | 0 );
10095 125355 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
10096 : return resultobj;
10097 : fail:
10098 : return NULL;
10099 : }
10100 :
10101 :
10102 36685 : SWIGINTERN PyObject *_wrap_Layer_GetFeatureCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10103 36685 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10104 36685 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10105 36685 : int arg2 = (int) 1 ;
10106 36685 : void *argp1 = 0 ;
10107 36685 : int res1 = 0 ;
10108 36685 : int val2 ;
10109 36685 : int ecode2 = 0 ;
10110 36685 : PyObject * obj0 = 0 ;
10111 36685 : PyObject * obj1 = 0 ;
10112 36685 : char * kwnames[] = {
10113 : (char *)"self", (char *)"force", NULL
10114 : };
10115 36685 : GIntBig result;
10116 :
10117 36685 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Layer_GetFeatureCount", kwnames, &obj0, &obj1)) SWIG_fail;
10118 36685 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10119 36685 : if (!SWIG_IsOK(res1)) {
10120 16 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetFeatureCount" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10121 : }
10122 36677 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10123 36677 : if (obj1) {
10124 54 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10125 54 : if (!SWIG_IsOK(ecode2)) {
10126 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_GetFeatureCount" "', argument " "2"" of type '" "int""'");
10127 : }
10128 : arg2 = static_cast< int >(val2);
10129 : }
10130 36677 : {
10131 36677 : const int bLocalUseExceptions = GetUseExceptions();
10132 36677 : if ( bLocalUseExceptions ) {
10133 2648 : pushErrorHandler();
10134 : }
10135 36677 : {
10136 36677 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10137 36677 : result = OGRLayerShadow_GetFeatureCount(arg1,arg2);
10138 36677 : SWIG_PYTHON_THREAD_END_ALLOW;
10139 : }
10140 36677 : if ( bLocalUseExceptions ) {
10141 2648 : popErrorHandler();
10142 : }
10143 : #ifndef SED_HACKS
10144 : if ( bLocalUseExceptions ) {
10145 : CPLErr eclass = CPLGetLastErrorType();
10146 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10147 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10148 : }
10149 : }
10150 : #endif
10151 : }
10152 36677 : {
10153 36677 : resultobj = PyLong_FromLongLong(result);
10154 : }
10155 36694 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
10156 : return resultobj;
10157 : fail:
10158 : return NULL;
10159 : }
10160 :
10161 :
10162 369 : SWIGINTERN PyObject *_wrap_Layer_GetExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10163 369 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10164 369 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10165 369 : double *arg2 ;
10166 369 : int *arg3 = (int *) NULL ;
10167 369 : int arg4 = (int) 1 ;
10168 369 : int arg5 = (int) 0 ;
10169 369 : int arg6 = (int) 0 ;
10170 369 : void *argp1 = 0 ;
10171 369 : int res1 = 0 ;
10172 369 : double argout2[4] ;
10173 369 : int isvalid2 ;
10174 369 : int val4 ;
10175 369 : int ecode4 = 0 ;
10176 369 : int val5 ;
10177 369 : int ecode5 = 0 ;
10178 369 : int val6 ;
10179 369 : int ecode6 = 0 ;
10180 369 : PyObject * obj0 = 0 ;
10181 369 : PyObject * obj1 = 0 ;
10182 369 : PyObject * obj2 = 0 ;
10183 369 : PyObject * obj3 = 0 ;
10184 369 : char * kwnames[] = {
10185 : (char *)"self", (char *)"force", (char *)"can_return_null", (char *)"geom_field", NULL
10186 : };
10187 :
10188 369 : {
10189 : /* %typemap(in,numinputs=0) (double argout2[4], int* isvalid2) */
10190 369 : arg2 = argout2;
10191 369 : arg3 = &isvalid2;
10192 : }
10193 369 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Layer_GetExtent", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
10194 369 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10195 369 : if (!SWIG_IsOK(res1)) {
10196 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetExtent" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10197 : }
10198 369 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10199 369 : if (obj1) {
10200 53 : ecode4 = SWIG_AsVal_int(obj1, &val4);
10201 53 : if (!SWIG_IsOK(ecode4)) {
10202 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_GetExtent" "', argument " "4"" of type '" "int""'");
10203 : }
10204 : arg4 = static_cast< int >(val4);
10205 : }
10206 369 : if (obj2) {
10207 35 : ecode5 = SWIG_AsVal_int(obj2, &val5);
10208 35 : if (!SWIG_IsOK(ecode5)) {
10209 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Layer_GetExtent" "', argument " "5"" of type '" "int""'");
10210 : }
10211 : arg5 = static_cast< int >(val5);
10212 : }
10213 369 : if (obj3) {
10214 78 : ecode6 = SWIG_AsVal_int(obj3, &val6);
10215 78 : if (!SWIG_IsOK(ecode6)) {
10216 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Layer_GetExtent" "', argument " "6"" of type '" "int""'");
10217 : }
10218 : arg6 = static_cast< int >(val6);
10219 : }
10220 369 : {
10221 369 : const int bLocalUseExceptions = GetUseExceptions();
10222 369 : if ( bLocalUseExceptions ) {
10223 230 : pushErrorHandler();
10224 : }
10225 369 : {
10226 369 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10227 369 : OGRLayerShadow_GetExtent(arg1,arg2,arg3,arg4,arg5,arg6);
10228 369 : SWIG_PYTHON_THREAD_END_ALLOW;
10229 : }
10230 369 : if ( bLocalUseExceptions ) {
10231 230 : popErrorHandler();
10232 : }
10233 : #ifndef SED_HACKS
10234 : if ( bLocalUseExceptions ) {
10235 : CPLErr eclass = CPLGetLastErrorType();
10236 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10237 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10238 : }
10239 : }
10240 : #endif
10241 : }
10242 369 : resultobj = SWIG_Py_Void();
10243 369 : {
10244 : /* %typemap(argout) (double argout[4], int* isvalid) */
10245 369 : PyObject *r;
10246 369 : if ( !*arg3 ) {
10247 8 : Py_INCREF(Py_None);
10248 8 : r = Py_None;
10249 : }
10250 : else {
10251 361 : r = CreateTupleFromDoubleArray(arg2, 4);
10252 : }
10253 : #if 0x040001 >= 0x040300
10254 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
10255 : #else
10256 369 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
10257 : #endif
10258 : }
10259 408 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
10260 : return resultobj;
10261 : fail:
10262 : return NULL;
10263 : }
10264 :
10265 :
10266 60 : SWIGINTERN PyObject *_wrap_Layer_GetExtent3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10267 60 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10268 60 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10269 60 : double *arg2 ;
10270 60 : int *arg3 = (int *) NULL ;
10271 60 : int arg4 = (int) 1 ;
10272 60 : int arg5 = (int) 0 ;
10273 60 : int arg6 = (int) 0 ;
10274 60 : void *argp1 = 0 ;
10275 60 : int res1 = 0 ;
10276 60 : double argout2[6] ;
10277 60 : int isvalid2 ;
10278 60 : int val4 ;
10279 60 : int ecode4 = 0 ;
10280 60 : int val5 ;
10281 60 : int ecode5 = 0 ;
10282 60 : int val6 ;
10283 60 : int ecode6 = 0 ;
10284 60 : PyObject * obj0 = 0 ;
10285 60 : PyObject * obj1 = 0 ;
10286 60 : PyObject * obj2 = 0 ;
10287 60 : PyObject * obj3 = 0 ;
10288 60 : char * kwnames[] = {
10289 : (char *)"self", (char *)"force", (char *)"can_return_null", (char *)"geom_field", NULL
10290 : };
10291 :
10292 60 : {
10293 : /* %typemap(in,numinputs=0) (double argout2[6], int* isvalid2) */
10294 60 : arg2 = argout2;
10295 60 : arg3 = &isvalid2;
10296 : }
10297 60 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Layer_GetExtent3D", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
10298 60 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10299 60 : if (!SWIG_IsOK(res1)) {
10300 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetExtent3D" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10301 : }
10302 60 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10303 60 : if (obj1) {
10304 0 : ecode4 = SWIG_AsVal_int(obj1, &val4);
10305 0 : if (!SWIG_IsOK(ecode4)) {
10306 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_GetExtent3D" "', argument " "4"" of type '" "int""'");
10307 : }
10308 : arg4 = static_cast< int >(val4);
10309 : }
10310 60 : if (obj2) {
10311 1 : ecode5 = SWIG_AsVal_int(obj2, &val5);
10312 1 : if (!SWIG_IsOK(ecode5)) {
10313 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Layer_GetExtent3D" "', argument " "5"" of type '" "int""'");
10314 : }
10315 : arg5 = static_cast< int >(val5);
10316 : }
10317 60 : if (obj3) {
10318 0 : ecode6 = SWIG_AsVal_int(obj3, &val6);
10319 0 : if (!SWIG_IsOK(ecode6)) {
10320 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Layer_GetExtent3D" "', argument " "6"" of type '" "int""'");
10321 : }
10322 : arg6 = static_cast< int >(val6);
10323 : }
10324 60 : {
10325 60 : const int bLocalUseExceptions = GetUseExceptions();
10326 60 : if ( bLocalUseExceptions ) {
10327 35 : pushErrorHandler();
10328 : }
10329 60 : {
10330 60 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10331 60 : OGRLayerShadow_GetExtent3D(arg1,arg2,arg3,arg4,arg5,arg6);
10332 60 : SWIG_PYTHON_THREAD_END_ALLOW;
10333 : }
10334 60 : if ( bLocalUseExceptions ) {
10335 35 : popErrorHandler();
10336 : }
10337 : #ifndef SED_HACKS
10338 : if ( bLocalUseExceptions ) {
10339 : CPLErr eclass = CPLGetLastErrorType();
10340 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10341 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10342 : }
10343 : }
10344 : #endif
10345 : }
10346 60 : resultobj = SWIG_Py_Void();
10347 60 : {
10348 : /* %typemap(argout) (double argout[6], int* isvalid) */
10349 60 : PyObject *r;
10350 60 : if ( !*arg3 ) {
10351 1 : Py_INCREF(Py_None);
10352 1 : r = Py_None;
10353 : }
10354 : else {
10355 59 : r = CreateTupleFromDoubleArray(arg2, 6);
10356 : }
10357 : #if 0x040001 >= 0x040300
10358 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
10359 : #else
10360 60 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
10361 : #endif
10362 : }
10363 60 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
10364 : return resultobj;
10365 : fail:
10366 : return NULL;
10367 : }
10368 :
10369 :
10370 751 : SWIGINTERN PyObject *_wrap_Layer_TestCapability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10371 751 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10372 751 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10373 751 : char *arg2 = (char *) 0 ;
10374 751 : void *argp1 = 0 ;
10375 751 : int res1 = 0 ;
10376 751 : int res2 ;
10377 751 : char *buf2 = 0 ;
10378 751 : int alloc2 = 0 ;
10379 751 : PyObject *swig_obj[2] ;
10380 751 : bool result;
10381 :
10382 751 : if (!SWIG_Python_UnpackTuple(args, "Layer_TestCapability", 2, 2, swig_obj)) SWIG_fail;
10383 751 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10384 751 : if (!SWIG_IsOK(res1)) {
10385 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_TestCapability" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10386 : }
10387 751 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10388 751 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
10389 751 : if (!SWIG_IsOK(res2)) {
10390 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_TestCapability" "', argument " "2"" of type '" "char const *""'");
10391 : }
10392 751 : arg2 = reinterpret_cast< char * >(buf2);
10393 751 : {
10394 751 : const int bLocalUseExceptions = GetUseExceptions();
10395 751 : if ( bLocalUseExceptions ) {
10396 386 : pushErrorHandler();
10397 : }
10398 751 : {
10399 751 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10400 751 : result = (bool)OGRLayerShadow_TestCapability(arg1,(char const *)arg2);
10401 751 : SWIG_PYTHON_THREAD_END_ALLOW;
10402 : }
10403 751 : if ( bLocalUseExceptions ) {
10404 386 : popErrorHandler();
10405 : }
10406 : #ifndef SED_HACKS
10407 : if ( bLocalUseExceptions ) {
10408 : CPLErr eclass = CPLGetLastErrorType();
10409 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10410 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10411 : }
10412 : }
10413 : #endif
10414 : }
10415 751 : resultobj = SWIG_From_bool(static_cast< bool >(result));
10416 751 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10417 753 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
10418 : return resultobj;
10419 0 : fail:
10420 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10421 : return NULL;
10422 : }
10423 :
10424 :
10425 77671 : SWIGINTERN PyObject *_wrap_Layer_CreateField(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10426 77671 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10427 77671 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10428 77671 : OGRFieldDefnShadow *arg2 = (OGRFieldDefnShadow *) 0 ;
10429 77671 : int arg3 = (int) 1 ;
10430 77671 : void *argp1 = 0 ;
10431 77671 : int res1 = 0 ;
10432 77671 : void *argp2 = 0 ;
10433 77671 : int res2 = 0 ;
10434 77671 : int val3 ;
10435 77671 : int ecode3 = 0 ;
10436 77671 : PyObject * obj0 = 0 ;
10437 77671 : PyObject * obj1 = 0 ;
10438 77671 : PyObject * obj2 = 0 ;
10439 77671 : char * kwnames[] = {
10440 : (char *)"self", (char *)"field_def", (char *)"approx_ok", NULL
10441 : };
10442 77671 : OGRErr result;
10443 :
10444 77671 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Layer_CreateField", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
10445 77671 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10446 77671 : if (!SWIG_IsOK(res1)) {
10447 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_CreateField" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10448 : }
10449 77671 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10450 77671 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
10451 77671 : if (!SWIG_IsOK(res2)) {
10452 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_CreateField" "', argument " "2"" of type '" "OGRFieldDefnShadow *""'");
10453 : }
10454 77671 : arg2 = reinterpret_cast< OGRFieldDefnShadow * >(argp2);
10455 77671 : if (obj2) {
10456 24 : ecode3 = SWIG_AsVal_int(obj2, &val3);
10457 24 : if (!SWIG_IsOK(ecode3)) {
10458 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Layer_CreateField" "', argument " "3"" of type '" "int""'");
10459 : }
10460 : arg3 = static_cast< int >(val3);
10461 : }
10462 77671 : {
10463 77671 : if (!arg2) {
10464 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10465 : }
10466 : }
10467 77671 : {
10468 77671 : const int bLocalUseExceptions = GetUseExceptions();
10469 77671 : if ( bLocalUseExceptions ) {
10470 69264 : pushErrorHandler();
10471 : }
10472 77671 : {
10473 77671 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10474 77671 : result = (OGRErr)OGRLayerShadow_CreateField(arg1,arg2,arg3);
10475 77671 : SWIG_PYTHON_THREAD_END_ALLOW;
10476 : }
10477 77671 : if ( bLocalUseExceptions ) {
10478 69264 : popErrorHandler();
10479 : }
10480 : #ifndef SED_HACKS
10481 : if ( bLocalUseExceptions ) {
10482 : CPLErr eclass = CPLGetLastErrorType();
10483 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10484 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10485 : }
10486 : }
10487 : #endif
10488 : }
10489 77671 : {
10490 : /* %typemap(out) OGRErr */
10491 77731 : if ( result != 0 && GetUseExceptions()) {
10492 16 : const char* pszMessage = CPLGetLastErrorMsg();
10493 16 : if( pszMessage[0] != '\0' )
10494 16 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10495 : else
10496 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10497 16 : SWIG_fail;
10498 : }
10499 : }
10500 77655 : {
10501 : /* %typemap(ret) OGRErr */
10502 77655 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10503 77655 : resultobj = PyInt_FromLong( result );
10504 : }
10505 : }
10506 77671 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
10507 : return resultobj;
10508 : fail:
10509 : return NULL;
10510 : }
10511 :
10512 :
10513 69 : SWIGINTERN PyObject *_wrap_Layer_DeleteField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10514 69 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10515 69 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10516 69 : int arg2 ;
10517 69 : void *argp1 = 0 ;
10518 69 : int res1 = 0 ;
10519 69 : int val2 ;
10520 69 : int ecode2 = 0 ;
10521 69 : PyObject *swig_obj[2] ;
10522 69 : OGRErr result;
10523 :
10524 69 : if (!SWIG_Python_UnpackTuple(args, "Layer_DeleteField", 2, 2, swig_obj)) SWIG_fail;
10525 69 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10526 69 : if (!SWIG_IsOK(res1)) {
10527 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_DeleteField" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10528 : }
10529 69 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10530 69 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10531 69 : if (!SWIG_IsOK(ecode2)) {
10532 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_DeleteField" "', argument " "2"" of type '" "int""'");
10533 : }
10534 69 : arg2 = static_cast< int >(val2);
10535 69 : {
10536 69 : const int bLocalUseExceptions = GetUseExceptions();
10537 69 : if ( bLocalUseExceptions ) {
10538 6 : pushErrorHandler();
10539 : }
10540 69 : {
10541 69 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10542 69 : result = (OGRErr)OGRLayerShadow_DeleteField(arg1,arg2);
10543 69 : SWIG_PYTHON_THREAD_END_ALLOW;
10544 : }
10545 69 : if ( bLocalUseExceptions ) {
10546 6 : popErrorHandler();
10547 : }
10548 : #ifndef SED_HACKS
10549 : if ( bLocalUseExceptions ) {
10550 : CPLErr eclass = CPLGetLastErrorType();
10551 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10552 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10553 : }
10554 : }
10555 : #endif
10556 : }
10557 69 : {
10558 : /* %typemap(out) OGRErr */
10559 90 : if ( result != 0 && GetUseExceptions()) {
10560 3 : const char* pszMessage = CPLGetLastErrorMsg();
10561 3 : if( pszMessage[0] != '\0' )
10562 3 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10563 : else
10564 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10565 3 : SWIG_fail;
10566 : }
10567 : }
10568 66 : {
10569 : /* %typemap(ret) OGRErr */
10570 66 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10571 66 : resultobj = PyInt_FromLong( result );
10572 : }
10573 : }
10574 69 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
10575 : return resultobj;
10576 : fail:
10577 : return NULL;
10578 : }
10579 :
10580 :
10581 34 : SWIGINTERN PyObject *_wrap_Layer_ReorderField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10582 34 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10583 34 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10584 34 : int arg2 ;
10585 34 : int arg3 ;
10586 34 : void *argp1 = 0 ;
10587 34 : int res1 = 0 ;
10588 34 : int val2 ;
10589 34 : int ecode2 = 0 ;
10590 34 : int val3 ;
10591 34 : int ecode3 = 0 ;
10592 34 : PyObject *swig_obj[3] ;
10593 34 : OGRErr result;
10594 :
10595 34 : if (!SWIG_Python_UnpackTuple(args, "Layer_ReorderField", 3, 3, swig_obj)) SWIG_fail;
10596 34 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10597 34 : if (!SWIG_IsOK(res1)) {
10598 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_ReorderField" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10599 : }
10600 34 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10601 34 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10602 34 : if (!SWIG_IsOK(ecode2)) {
10603 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_ReorderField" "', argument " "2"" of type '" "int""'");
10604 : }
10605 34 : arg2 = static_cast< int >(val2);
10606 34 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10607 34 : if (!SWIG_IsOK(ecode3)) {
10608 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Layer_ReorderField" "', argument " "3"" of type '" "int""'");
10609 : }
10610 34 : arg3 = static_cast< int >(val3);
10611 34 : {
10612 34 : const int bLocalUseExceptions = GetUseExceptions();
10613 34 : if ( bLocalUseExceptions ) {
10614 0 : pushErrorHandler();
10615 : }
10616 34 : {
10617 34 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10618 34 : result = (OGRErr)OGRLayerShadow_ReorderField(arg1,arg2,arg3);
10619 34 : SWIG_PYTHON_THREAD_END_ALLOW;
10620 : }
10621 34 : if ( bLocalUseExceptions ) {
10622 0 : popErrorHandler();
10623 : }
10624 : #ifndef SED_HACKS
10625 : if ( bLocalUseExceptions ) {
10626 : CPLErr eclass = CPLGetLastErrorType();
10627 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10628 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10629 : }
10630 : }
10631 : #endif
10632 : }
10633 34 : {
10634 : /* %typemap(out) OGRErr */
10635 34 : if ( result != 0 && GetUseExceptions()) {
10636 0 : const char* pszMessage = CPLGetLastErrorMsg();
10637 0 : if( pszMessage[0] != '\0' )
10638 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10639 : else
10640 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10641 0 : SWIG_fail;
10642 : }
10643 : }
10644 34 : {
10645 : /* %typemap(ret) OGRErr */
10646 34 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10647 34 : resultobj = PyInt_FromLong( result );
10648 : }
10649 : }
10650 34 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
10651 : return resultobj;
10652 : fail:
10653 : return NULL;
10654 : }
10655 :
10656 :
10657 43 : SWIGINTERN PyObject *_wrap_Layer_ReorderFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10658 43 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10659 43 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10660 43 : int arg2 ;
10661 43 : int *arg3 = (int *) 0 ;
10662 43 : void *argp1 = 0 ;
10663 43 : int res1 = 0 ;
10664 43 : PyObject *swig_obj[2] ;
10665 43 : OGRErr result;
10666 :
10667 43 : if (!SWIG_Python_UnpackTuple(args, "Layer_ReorderFields", 2, 2, swig_obj)) SWIG_fail;
10668 43 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10669 43 : if (!SWIG_IsOK(res1)) {
10670 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_ReorderFields" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10671 : }
10672 43 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10673 43 : {
10674 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
10675 43 : arg3 = CreateCIntListFromSequence(swig_obj[1], &arg2);
10676 43 : if( arg2 < 0 ) {
10677 0 : SWIG_fail;
10678 : }
10679 : }
10680 43 : {
10681 43 : const int bLocalUseExceptions = GetUseExceptions();
10682 43 : if ( bLocalUseExceptions ) {
10683 0 : pushErrorHandler();
10684 : }
10685 43 : {
10686 43 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10687 43 : result = (OGRErr)OGRLayerShadow_ReorderFields(arg1,arg2,arg3);
10688 43 : SWIG_PYTHON_THREAD_END_ALLOW;
10689 : }
10690 43 : if ( bLocalUseExceptions ) {
10691 0 : popErrorHandler();
10692 : }
10693 : #ifndef SED_HACKS
10694 : if ( bLocalUseExceptions ) {
10695 : CPLErr eclass = CPLGetLastErrorType();
10696 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10697 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10698 : }
10699 : }
10700 : #endif
10701 : }
10702 43 : {
10703 : /* %typemap(out) OGRErr */
10704 53 : if ( result != 0 && GetUseExceptions()) {
10705 0 : const char* pszMessage = CPLGetLastErrorMsg();
10706 0 : if( pszMessage[0] != '\0' )
10707 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10708 : else
10709 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10710 0 : SWIG_fail;
10711 : }
10712 : }
10713 43 : {
10714 : /* %typemap(freearg) (int nList, int* pList) */
10715 43 : free(arg3);
10716 : }
10717 43 : {
10718 : /* %typemap(ret) OGRErr */
10719 43 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10720 43 : resultobj = PyInt_FromLong( result );
10721 : }
10722 : }
10723 43 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
10724 : return resultobj;
10725 0 : fail:
10726 0 : {
10727 : /* %typemap(freearg) (int nList, int* pList) */
10728 0 : free(arg3);
10729 : }
10730 0 : return NULL;
10731 : }
10732 :
10733 :
10734 118 : SWIGINTERN PyObject *_wrap_Layer_AlterFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10735 118 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10736 118 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10737 118 : int arg2 ;
10738 118 : OGRFieldDefnShadow *arg3 = (OGRFieldDefnShadow *) 0 ;
10739 118 : int arg4 ;
10740 118 : void *argp1 = 0 ;
10741 118 : int res1 = 0 ;
10742 118 : int val2 ;
10743 118 : int ecode2 = 0 ;
10744 118 : void *argp3 = 0 ;
10745 118 : int res3 = 0 ;
10746 118 : int val4 ;
10747 118 : int ecode4 = 0 ;
10748 118 : PyObject *swig_obj[4] ;
10749 118 : OGRErr result;
10750 :
10751 118 : if (!SWIG_Python_UnpackTuple(args, "Layer_AlterFieldDefn", 4, 4, swig_obj)) SWIG_fail;
10752 118 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10753 118 : if (!SWIG_IsOK(res1)) {
10754 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_AlterFieldDefn" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10755 : }
10756 118 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10757 118 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10758 118 : if (!SWIG_IsOK(ecode2)) {
10759 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_AlterFieldDefn" "', argument " "2"" of type '" "int""'");
10760 : }
10761 118 : arg2 = static_cast< int >(val2);
10762 118 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
10763 118 : if (!SWIG_IsOK(res3)) {
10764 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_AlterFieldDefn" "', argument " "3"" of type '" "OGRFieldDefnShadow *""'");
10765 : }
10766 118 : arg3 = reinterpret_cast< OGRFieldDefnShadow * >(argp3);
10767 118 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
10768 118 : if (!SWIG_IsOK(ecode4)) {
10769 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_AlterFieldDefn" "', argument " "4"" of type '" "int""'");
10770 : }
10771 118 : arg4 = static_cast< int >(val4);
10772 118 : {
10773 118 : if (!arg3) {
10774 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10775 : }
10776 : }
10777 118 : {
10778 118 : const int bLocalUseExceptions = GetUseExceptions();
10779 118 : if ( bLocalUseExceptions ) {
10780 1 : pushErrorHandler();
10781 : }
10782 118 : {
10783 118 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10784 118 : result = (OGRErr)OGRLayerShadow_AlterFieldDefn(arg1,arg2,arg3,arg4);
10785 118 : SWIG_PYTHON_THREAD_END_ALLOW;
10786 : }
10787 118 : if ( bLocalUseExceptions ) {
10788 1 : popErrorHandler();
10789 : }
10790 : #ifndef SED_HACKS
10791 : if ( bLocalUseExceptions ) {
10792 : CPLErr eclass = CPLGetLastErrorType();
10793 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10794 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10795 : }
10796 : }
10797 : #endif
10798 : }
10799 118 : {
10800 : /* %typemap(out) OGRErr */
10801 152 : if ( result != 0 && GetUseExceptions()) {
10802 0 : const char* pszMessage = CPLGetLastErrorMsg();
10803 0 : if( pszMessage[0] != '\0' )
10804 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10805 : else
10806 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10807 0 : SWIG_fail;
10808 : }
10809 : }
10810 118 : {
10811 : /* %typemap(ret) OGRErr */
10812 118 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10813 118 : resultobj = PyInt_FromLong( result );
10814 : }
10815 : }
10816 118 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
10817 : return resultobj;
10818 : fail:
10819 : return NULL;
10820 : }
10821 :
10822 :
10823 33 : SWIGINTERN PyObject *_wrap_Layer_AlterGeomFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10824 33 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10825 33 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10826 33 : int arg2 ;
10827 33 : OGRGeomFieldDefnShadow *arg3 = (OGRGeomFieldDefnShadow *) 0 ;
10828 33 : int arg4 ;
10829 33 : void *argp1 = 0 ;
10830 33 : int res1 = 0 ;
10831 33 : int val2 ;
10832 33 : int ecode2 = 0 ;
10833 33 : void *argp3 = 0 ;
10834 33 : int res3 = 0 ;
10835 33 : int val4 ;
10836 33 : int ecode4 = 0 ;
10837 33 : PyObject *swig_obj[4] ;
10838 33 : OGRErr result;
10839 :
10840 33 : if (!SWIG_Python_UnpackTuple(args, "Layer_AlterGeomFieldDefn", 4, 4, swig_obj)) SWIG_fail;
10841 33 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10842 33 : if (!SWIG_IsOK(res1)) {
10843 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_AlterGeomFieldDefn" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10844 : }
10845 33 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10846 33 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10847 33 : if (!SWIG_IsOK(ecode2)) {
10848 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_AlterGeomFieldDefn" "', argument " "2"" of type '" "int""'");
10849 : }
10850 33 : arg2 = static_cast< int >(val2);
10851 33 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
10852 33 : if (!SWIG_IsOK(res3)) {
10853 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_AlterGeomFieldDefn" "', argument " "3"" of type '" "OGRGeomFieldDefnShadow const *""'");
10854 : }
10855 33 : arg3 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp3);
10856 33 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
10857 33 : if (!SWIG_IsOK(ecode4)) {
10858 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_AlterGeomFieldDefn" "', argument " "4"" of type '" "int""'");
10859 : }
10860 33 : arg4 = static_cast< int >(val4);
10861 33 : {
10862 33 : if (!arg3) {
10863 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10864 : }
10865 : }
10866 33 : {
10867 33 : const int bLocalUseExceptions = GetUseExceptions();
10868 33 : if ( bLocalUseExceptions ) {
10869 4 : pushErrorHandler();
10870 : }
10871 33 : {
10872 33 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10873 33 : result = (OGRErr)OGRLayerShadow_AlterGeomFieldDefn(arg1,arg2,(OGRGeomFieldDefnShadow const *)arg3,arg4);
10874 33 : SWIG_PYTHON_THREAD_END_ALLOW;
10875 : }
10876 33 : if ( bLocalUseExceptions ) {
10877 4 : popErrorHandler();
10878 : }
10879 : #ifndef SED_HACKS
10880 : if ( bLocalUseExceptions ) {
10881 : CPLErr eclass = CPLGetLastErrorType();
10882 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10883 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10884 : }
10885 : }
10886 : #endif
10887 : }
10888 33 : {
10889 : /* %typemap(out) OGRErr */
10890 41 : if ( result != 0 && GetUseExceptions()) {
10891 0 : const char* pszMessage = CPLGetLastErrorMsg();
10892 0 : if( pszMessage[0] != '\0' )
10893 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10894 : else
10895 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10896 0 : SWIG_fail;
10897 : }
10898 : }
10899 33 : {
10900 : /* %typemap(ret) OGRErr */
10901 33 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10902 33 : resultobj = PyInt_FromLong( result );
10903 : }
10904 : }
10905 33 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
10906 : return resultobj;
10907 : fail:
10908 : return NULL;
10909 : }
10910 :
10911 :
10912 118 : SWIGINTERN PyObject *_wrap_Layer_CreateGeomField(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10913 118 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10914 118 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
10915 118 : OGRGeomFieldDefnShadow *arg2 = (OGRGeomFieldDefnShadow *) 0 ;
10916 118 : int arg3 = (int) 1 ;
10917 118 : void *argp1 = 0 ;
10918 118 : int res1 = 0 ;
10919 118 : void *argp2 = 0 ;
10920 118 : int res2 = 0 ;
10921 118 : int val3 ;
10922 118 : int ecode3 = 0 ;
10923 118 : PyObject * obj0 = 0 ;
10924 118 : PyObject * obj1 = 0 ;
10925 118 : PyObject * obj2 = 0 ;
10926 118 : char * kwnames[] = {
10927 : (char *)"self", (char *)"field_def", (char *)"approx_ok", NULL
10928 : };
10929 118 : OGRErr result;
10930 :
10931 118 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Layer_CreateGeomField", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
10932 118 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
10933 118 : if (!SWIG_IsOK(res1)) {
10934 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_CreateGeomField" "', argument " "1"" of type '" "OGRLayerShadow *""'");
10935 : }
10936 118 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
10937 118 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
10938 118 : if (!SWIG_IsOK(res2)) {
10939 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_CreateGeomField" "', argument " "2"" of type '" "OGRGeomFieldDefnShadow *""'");
10940 : }
10941 118 : arg2 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp2);
10942 118 : if (obj2) {
10943 2 : ecode3 = SWIG_AsVal_int(obj2, &val3);
10944 2 : if (!SWIG_IsOK(ecode3)) {
10945 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Layer_CreateGeomField" "', argument " "3"" of type '" "int""'");
10946 : }
10947 : arg3 = static_cast< int >(val3);
10948 : }
10949 118 : {
10950 118 : if (!arg2) {
10951 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10952 : }
10953 : }
10954 118 : {
10955 118 : const int bLocalUseExceptions = GetUseExceptions();
10956 118 : if ( bLocalUseExceptions ) {
10957 37 : pushErrorHandler();
10958 : }
10959 118 : {
10960 118 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10961 118 : result = (OGRErr)OGRLayerShadow_CreateGeomField(arg1,arg2,arg3);
10962 118 : SWIG_PYTHON_THREAD_END_ALLOW;
10963 : }
10964 118 : if ( bLocalUseExceptions ) {
10965 37 : popErrorHandler();
10966 : }
10967 : #ifndef SED_HACKS
10968 : if ( bLocalUseExceptions ) {
10969 : CPLErr eclass = CPLGetLastErrorType();
10970 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10971 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10972 : }
10973 : }
10974 : #endif
10975 : }
10976 118 : {
10977 : /* %typemap(out) OGRErr */
10978 128 : if ( result != 0 && GetUseExceptions()) {
10979 1 : const char* pszMessage = CPLGetLastErrorMsg();
10980 1 : if( pszMessage[0] != '\0' )
10981 1 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
10982 : else
10983 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
10984 1 : SWIG_fail;
10985 : }
10986 : }
10987 117 : {
10988 : /* %typemap(ret) OGRErr */
10989 117 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
10990 117 : resultobj = PyInt_FromLong( result );
10991 : }
10992 : }
10993 118 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
10994 : return resultobj;
10995 : fail:
10996 : return NULL;
10997 : }
10998 :
10999 :
11000 149 : SWIGINTERN PyObject *_wrap_Layer_StartTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11001 149 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11002 149 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11003 149 : void *argp1 = 0 ;
11004 149 : int res1 = 0 ;
11005 149 : PyObject *swig_obj[1] ;
11006 149 : OGRErr result;
11007 :
11008 149 : if (!args) SWIG_fail;
11009 149 : swig_obj[0] = args;
11010 149 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11011 149 : if (!SWIG_IsOK(res1)) {
11012 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_StartTransaction" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11013 : }
11014 149 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11015 149 : {
11016 149 : const int bLocalUseExceptions = GetUseExceptions();
11017 149 : if ( bLocalUseExceptions ) {
11018 16 : pushErrorHandler();
11019 : }
11020 149 : {
11021 149 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11022 149 : result = (OGRErr)OGRLayerShadow_StartTransaction(arg1);
11023 149 : SWIG_PYTHON_THREAD_END_ALLOW;
11024 : }
11025 149 : if ( bLocalUseExceptions ) {
11026 16 : popErrorHandler();
11027 : }
11028 : #ifndef SED_HACKS
11029 : if ( bLocalUseExceptions ) {
11030 : CPLErr eclass = CPLGetLastErrorType();
11031 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11032 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11033 : }
11034 : }
11035 : #endif
11036 : }
11037 149 : {
11038 : /* %typemap(out) OGRErr */
11039 153 : if ( result != 0 && GetUseExceptions()) {
11040 0 : const char* pszMessage = CPLGetLastErrorMsg();
11041 0 : if( pszMessage[0] != '\0' )
11042 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
11043 : else
11044 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11045 0 : SWIG_fail;
11046 : }
11047 : }
11048 149 : {
11049 : /* %typemap(ret) OGRErr */
11050 149 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
11051 149 : resultobj = PyInt_FromLong( result );
11052 : }
11053 : }
11054 149 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
11055 : return resultobj;
11056 : fail:
11057 : return NULL;
11058 : }
11059 :
11060 :
11061 129 : SWIGINTERN PyObject *_wrap_Layer_CommitTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11062 129 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11063 129 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11064 129 : void *argp1 = 0 ;
11065 129 : int res1 = 0 ;
11066 129 : PyObject *swig_obj[1] ;
11067 129 : OGRErr result;
11068 :
11069 129 : if (!args) SWIG_fail;
11070 129 : swig_obj[0] = args;
11071 129 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11072 129 : if (!SWIG_IsOK(res1)) {
11073 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_CommitTransaction" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11074 : }
11075 129 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11076 129 : {
11077 129 : const int bLocalUseExceptions = GetUseExceptions();
11078 129 : if ( bLocalUseExceptions ) {
11079 16 : pushErrorHandler();
11080 : }
11081 129 : {
11082 129 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11083 129 : result = (OGRErr)OGRLayerShadow_CommitTransaction(arg1);
11084 129 : SWIG_PYTHON_THREAD_END_ALLOW;
11085 : }
11086 129 : if ( bLocalUseExceptions ) {
11087 16 : popErrorHandler();
11088 : }
11089 : #ifndef SED_HACKS
11090 : if ( bLocalUseExceptions ) {
11091 : CPLErr eclass = CPLGetLastErrorType();
11092 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11093 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11094 : }
11095 : }
11096 : #endif
11097 : }
11098 129 : {
11099 : /* %typemap(out) OGRErr */
11100 147 : if ( result != 0 && GetUseExceptions()) {
11101 0 : const char* pszMessage = CPLGetLastErrorMsg();
11102 0 : if( pszMessage[0] != '\0' )
11103 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
11104 : else
11105 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11106 0 : SWIG_fail;
11107 : }
11108 : }
11109 129 : {
11110 : /* %typemap(ret) OGRErr */
11111 129 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
11112 129 : resultobj = PyInt_FromLong( result );
11113 : }
11114 : }
11115 129 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
11116 : return resultobj;
11117 : fail:
11118 : return NULL;
11119 : }
11120 :
11121 :
11122 26 : SWIGINTERN PyObject *_wrap_Layer_RollbackTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11123 26 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11124 26 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11125 26 : void *argp1 = 0 ;
11126 26 : int res1 = 0 ;
11127 26 : PyObject *swig_obj[1] ;
11128 26 : OGRErr result;
11129 :
11130 26 : if (!args) SWIG_fail;
11131 26 : swig_obj[0] = args;
11132 26 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11133 26 : if (!SWIG_IsOK(res1)) {
11134 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_RollbackTransaction" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11135 : }
11136 26 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11137 26 : {
11138 26 : const int bLocalUseExceptions = GetUseExceptions();
11139 26 : if ( bLocalUseExceptions ) {
11140 0 : pushErrorHandler();
11141 : }
11142 26 : {
11143 26 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11144 26 : result = (OGRErr)OGRLayerShadow_RollbackTransaction(arg1);
11145 26 : SWIG_PYTHON_THREAD_END_ALLOW;
11146 : }
11147 26 : if ( bLocalUseExceptions ) {
11148 0 : popErrorHandler();
11149 : }
11150 : #ifndef SED_HACKS
11151 : if ( bLocalUseExceptions ) {
11152 : CPLErr eclass = CPLGetLastErrorType();
11153 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11154 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11155 : }
11156 : }
11157 : #endif
11158 : }
11159 26 : {
11160 : /* %typemap(out) OGRErr */
11161 33 : if ( result != 0 && GetUseExceptions()) {
11162 0 : const char* pszMessage = CPLGetLastErrorMsg();
11163 0 : if( pszMessage[0] != '\0' )
11164 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
11165 : else
11166 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11167 0 : SWIG_fail;
11168 : }
11169 : }
11170 26 : {
11171 : /* %typemap(ret) OGRErr */
11172 26 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
11173 26 : resultobj = PyInt_FromLong( result );
11174 : }
11175 : }
11176 26 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
11177 : return resultobj;
11178 : fail:
11179 : return NULL;
11180 : }
11181 :
11182 :
11183 2 : SWIGINTERN PyObject *_wrap_Layer_FindFieldIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11184 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11185 2 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11186 2 : char *arg2 = (char *) 0 ;
11187 2 : int arg3 ;
11188 2 : void *argp1 = 0 ;
11189 2 : int res1 = 0 ;
11190 2 : int res2 ;
11191 2 : char *buf2 = 0 ;
11192 2 : int alloc2 = 0 ;
11193 2 : int val3 ;
11194 2 : int ecode3 = 0 ;
11195 2 : PyObject *swig_obj[3] ;
11196 2 : int result;
11197 :
11198 2 : if (!SWIG_Python_UnpackTuple(args, "Layer_FindFieldIndex", 3, 3, swig_obj)) SWIG_fail;
11199 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11200 2 : if (!SWIG_IsOK(res1)) {
11201 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_FindFieldIndex" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11202 : }
11203 2 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11204 2 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
11205 2 : if (!SWIG_IsOK(res2)) {
11206 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_FindFieldIndex" "', argument " "2"" of type '" "char const *""'");
11207 : }
11208 2 : arg2 = reinterpret_cast< char * >(buf2);
11209 2 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11210 2 : if (!SWIG_IsOK(ecode3)) {
11211 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Layer_FindFieldIndex" "', argument " "3"" of type '" "int""'");
11212 : }
11213 2 : arg3 = static_cast< int >(val3);
11214 2 : {
11215 2 : const int bLocalUseExceptions = GetUseExceptions();
11216 2 : if ( bLocalUseExceptions ) {
11217 0 : pushErrorHandler();
11218 : }
11219 2 : {
11220 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11221 2 : result = (int)OGRLayerShadow_FindFieldIndex(arg1,(char const *)arg2,arg3);
11222 2 : SWIG_PYTHON_THREAD_END_ALLOW;
11223 : }
11224 2 : if ( bLocalUseExceptions ) {
11225 0 : popErrorHandler();
11226 : }
11227 : #ifndef SED_HACKS
11228 : if ( bLocalUseExceptions ) {
11229 : CPLErr eclass = CPLGetLastErrorType();
11230 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11231 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11232 : }
11233 : }
11234 : #endif
11235 : }
11236 2 : resultobj = SWIG_From_int(static_cast< int >(result));
11237 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11238 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
11239 : return resultobj;
11240 0 : fail:
11241 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11242 : return NULL;
11243 : }
11244 :
11245 :
11246 913 : SWIGINTERN PyObject *_wrap_Layer_GetSpatialRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11247 913 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11248 913 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11249 913 : void *argp1 = 0 ;
11250 913 : int res1 = 0 ;
11251 913 : PyObject *swig_obj[1] ;
11252 913 : OSRSpatialReferenceShadow *result = 0 ;
11253 :
11254 913 : if (!args) SWIG_fail;
11255 913 : swig_obj[0] = args;
11256 913 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11257 913 : if (!SWIG_IsOK(res1)) {
11258 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetSpatialRef" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11259 : }
11260 913 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11261 913 : {
11262 913 : const int bLocalUseExceptions = GetUseExceptions();
11263 913 : if ( bLocalUseExceptions ) {
11264 496 : pushErrorHandler();
11265 : }
11266 913 : {
11267 913 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11268 913 : result = (OSRSpatialReferenceShadow *)OGRLayerShadow_GetSpatialRef(arg1);
11269 913 : SWIG_PYTHON_THREAD_END_ALLOW;
11270 : }
11271 913 : if ( bLocalUseExceptions ) {
11272 496 : popErrorHandler();
11273 : }
11274 : #ifndef SED_HACKS
11275 : if ( bLocalUseExceptions ) {
11276 : CPLErr eclass = CPLGetLastErrorType();
11277 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11278 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11279 : }
11280 : }
11281 : #endif
11282 : }
11283 913 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_OWN | 0 );
11284 913 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
11285 : return resultobj;
11286 : fail:
11287 : return NULL;
11288 : }
11289 :
11290 :
11291 0 : SWIGINTERN PyObject *_wrap_Layer_GetFeaturesRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11292 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11293 0 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11294 0 : void *argp1 = 0 ;
11295 0 : int res1 = 0 ;
11296 0 : PyObject *swig_obj[1] ;
11297 0 : GIntBig result;
11298 :
11299 0 : if (!args) SWIG_fail;
11300 0 : swig_obj[0] = args;
11301 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11302 0 : if (!SWIG_IsOK(res1)) {
11303 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetFeaturesRead" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11304 : }
11305 0 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11306 0 : {
11307 0 : const int bLocalUseExceptions = GetUseExceptions();
11308 0 : if ( bLocalUseExceptions ) {
11309 0 : pushErrorHandler();
11310 : }
11311 0 : {
11312 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11313 0 : result = OGRLayerShadow_GetFeaturesRead(arg1);
11314 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11315 : }
11316 0 : if ( bLocalUseExceptions ) {
11317 0 : popErrorHandler();
11318 : }
11319 : #ifndef SED_HACKS
11320 : if ( bLocalUseExceptions ) {
11321 : CPLErr eclass = CPLGetLastErrorType();
11322 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11323 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11324 : }
11325 : }
11326 : #endif
11327 : }
11328 0 : {
11329 0 : resultobj = PyLong_FromLongLong(result);
11330 : }
11331 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
11332 : return resultobj;
11333 : fail:
11334 : return NULL;
11335 : }
11336 :
11337 :
11338 265 : SWIGINTERN PyObject *_wrap_Layer_SetIgnoredFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11339 265 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11340 265 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11341 265 : char **arg2 = (char **) 0 ;
11342 265 : void *argp1 = 0 ;
11343 265 : int res1 = 0 ;
11344 265 : PyObject *swig_obj[2] ;
11345 265 : OGRErr result;
11346 :
11347 265 : if (!SWIG_Python_UnpackTuple(args, "Layer_SetIgnoredFields", 2, 2, swig_obj)) SWIG_fail;
11348 265 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11349 265 : if (!SWIG_IsOK(res1)) {
11350 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetIgnoredFields" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11351 : }
11352 265 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11353 265 : {
11354 : /* %typemap(in) char **dict */
11355 265 : arg2 = NULL;
11356 265 : if ( PySequence_Check( swig_obj[1] ) ) {
11357 265 : int bErr = FALSE;
11358 265 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
11359 265 : if ( bErr )
11360 : {
11361 0 : SWIG_fail;
11362 : }
11363 : }
11364 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
11365 0 : int bErr = FALSE;
11366 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
11367 0 : if ( bErr )
11368 : {
11369 0 : SWIG_fail;
11370 : }
11371 : }
11372 : else {
11373 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
11374 0 : SWIG_fail;
11375 : }
11376 : }
11377 265 : {
11378 265 : const int bLocalUseExceptions = GetUseExceptions();
11379 265 : if ( bLocalUseExceptions ) {
11380 246 : pushErrorHandler();
11381 : }
11382 265 : {
11383 265 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11384 265 : result = (OGRErr)OGRLayerShadow_SetIgnoredFields(arg1,(char const **)arg2);
11385 265 : SWIG_PYTHON_THREAD_END_ALLOW;
11386 : }
11387 265 : if ( bLocalUseExceptions ) {
11388 246 : popErrorHandler();
11389 : }
11390 : #ifndef SED_HACKS
11391 : if ( bLocalUseExceptions ) {
11392 : CPLErr eclass = CPLGetLastErrorType();
11393 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11394 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11395 : }
11396 : }
11397 : #endif
11398 : }
11399 265 : {
11400 : /* %typemap(out) OGRErr */
11401 265 : if ( result != 0 && GetUseExceptions()) {
11402 0 : const char* pszMessage = CPLGetLastErrorMsg();
11403 0 : if( pszMessage[0] != '\0' )
11404 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
11405 : else
11406 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11407 0 : SWIG_fail;
11408 : }
11409 : }
11410 265 : {
11411 : /* %typemap(freearg) char **dict */
11412 265 : CSLDestroy( arg2 );
11413 : }
11414 265 : {
11415 : /* %typemap(ret) OGRErr */
11416 265 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
11417 265 : resultobj = PyInt_FromLong( result );
11418 : }
11419 : }
11420 266 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
11421 : return resultobj;
11422 0 : fail:
11423 0 : {
11424 : /* %typemap(freearg) char **dict */
11425 0 : CSLDestroy( arg2 );
11426 : }
11427 : return NULL;
11428 : }
11429 :
11430 :
11431 7 : SWIGINTERN PyObject *_wrap_Layer_Intersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11432 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11433 7 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11434 7 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
11435 7 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
11436 7 : char **arg4 = (char **) NULL ;
11437 7 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
11438 7 : void *arg6 = (void *) NULL ;
11439 7 : void *argp1 = 0 ;
11440 7 : int res1 = 0 ;
11441 7 : void *argp2 = 0 ;
11442 7 : int res2 = 0 ;
11443 7 : void *argp3 = 0 ;
11444 7 : int res3 = 0 ;
11445 7 : PyObject * obj0 = 0 ;
11446 7 : PyObject * obj1 = 0 ;
11447 7 : PyObject * obj2 = 0 ;
11448 7 : PyObject * obj3 = 0 ;
11449 7 : PyObject * obj4 = 0 ;
11450 7 : PyObject * obj5 = 0 ;
11451 7 : char * kwnames[] = {
11452 : (char *)"self", (char *)"method_layer", (char *)"result_layer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
11453 : };
11454 7 : OGRErr result;
11455 :
11456 : /* %typemap(arginit) ( const char* callback_data=NULL) */
11457 7 : PyProgressData *psProgressInfo;
11458 7 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
11459 7 : psProgressInfo->nLastReported = -1;
11460 7 : psProgressInfo->psPyCallback = NULL;
11461 7 : psProgressInfo->psPyCallbackData = NULL;
11462 7 : arg6 = psProgressInfo;
11463 7 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:Layer_Intersection", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
11464 7 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11465 7 : if (!SWIG_IsOK(res1)) {
11466 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_Intersection" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11467 : }
11468 7 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11469 7 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11470 7 : if (!SWIG_IsOK(res2)) {
11471 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_Intersection" "', argument " "2"" of type '" "OGRLayerShadow *""'");
11472 : }
11473 7 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
11474 7 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11475 7 : if (!SWIG_IsOK(res3)) {
11476 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_Intersection" "', argument " "3"" of type '" "OGRLayerShadow *""'");
11477 : }
11478 7 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
11479 7 : if (obj3) {
11480 6 : {
11481 : /* %typemap(in) char **dict */
11482 6 : arg4 = NULL;
11483 6 : if ( PySequence_Check( obj3 ) ) {
11484 6 : int bErr = FALSE;
11485 6 : arg4 = CSLFromPySequence(obj3, &bErr);
11486 6 : if ( bErr )
11487 : {
11488 0 : SWIG_fail;
11489 : }
11490 : }
11491 0 : else if ( PyMapping_Check( obj3 ) ) {
11492 0 : int bErr = FALSE;
11493 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
11494 0 : if ( bErr )
11495 : {
11496 0 : SWIG_fail;
11497 : }
11498 : }
11499 : else {
11500 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
11501 0 : SWIG_fail;
11502 : }
11503 : }
11504 : }
11505 7 : if (obj4) {
11506 1 : {
11507 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
11508 : /* callback_func typemap */
11509 :
11510 : /* In some cases 0 is passed instead of None. */
11511 : /* See https://github.com/OSGeo/gdal/pull/219 */
11512 1 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
11513 : {
11514 0 : if( PyLong_AsLong(obj4) == 0 )
11515 : {
11516 0 : obj4 = Py_None;
11517 : }
11518 : }
11519 :
11520 1 : if (obj4 && obj4 != Py_None ) {
11521 1 : void* cbfunction = NULL;
11522 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
11523 : (void**)&cbfunction,
11524 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
11525 : SWIG_POINTER_EXCEPTION | 0 ));
11526 :
11527 1 : if ( cbfunction == GDALTermProgress ) {
11528 : arg5 = GDALTermProgress;
11529 : } else {
11530 1 : if (!PyCallable_Check(obj4)) {
11531 0 : PyErr_SetString( PyExc_RuntimeError,
11532 : "Object given is not a Python function" );
11533 0 : SWIG_fail;
11534 : }
11535 1 : psProgressInfo->psPyCallback = obj4;
11536 1 : arg5 = PyProgressProxy;
11537 : }
11538 :
11539 : }
11540 :
11541 : }
11542 : }
11543 7 : if (obj5) {
11544 0 : {
11545 : /* %typemap(in) ( void* callback_data=NULL) */
11546 0 : psProgressInfo->psPyCallbackData = obj5 ;
11547 : }
11548 : }
11549 7 : {
11550 7 : const int bLocalUseExceptions = GetUseExceptions();
11551 7 : if ( bLocalUseExceptions ) {
11552 7 : pushErrorHandler();
11553 : }
11554 7 : {
11555 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11556 7 : result = (OGRErr)OGRLayerShadow_Intersection(arg1,arg2,arg3,arg4,arg5,arg6);
11557 7 : SWIG_PYTHON_THREAD_END_ALLOW;
11558 : }
11559 7 : if ( bLocalUseExceptions ) {
11560 7 : popErrorHandler();
11561 : }
11562 : #ifndef SED_HACKS
11563 : if ( bLocalUseExceptions ) {
11564 : CPLErr eclass = CPLGetLastErrorType();
11565 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11566 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11567 : }
11568 : }
11569 : #endif
11570 : }
11571 7 : {
11572 : /* %typemap(out) OGRErr */
11573 7 : if ( result != 0 && GetUseExceptions()) {
11574 0 : const char* pszMessage = CPLGetLastErrorMsg();
11575 0 : if( pszMessage[0] != '\0' )
11576 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
11577 : else
11578 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11579 0 : SWIG_fail;
11580 : }
11581 : }
11582 7 : {
11583 : /* %typemap(freearg) char **dict */
11584 7 : CSLDestroy( arg4 );
11585 : }
11586 7 : {
11587 : /* %typemap(freearg) ( void* callback_data=NULL) */
11588 :
11589 7 : CPLFree(psProgressInfo);
11590 :
11591 : }
11592 7 : {
11593 : /* %typemap(ret) OGRErr */
11594 7 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
11595 7 : resultobj = PyInt_FromLong( result );
11596 : }
11597 : }
11598 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
11599 : return resultobj;
11600 0 : fail:
11601 0 : {
11602 : /* %typemap(freearg) char **dict */
11603 0 : CSLDestroy( arg4 );
11604 : }
11605 0 : {
11606 : /* %typemap(freearg) ( void* callback_data=NULL) */
11607 :
11608 0 : CPLFree(psProgressInfo);
11609 :
11610 : }
11611 : return NULL;
11612 : }
11613 :
11614 :
11615 7 : SWIGINTERN PyObject *_wrap_Layer_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11616 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11617 7 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11618 7 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
11619 7 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
11620 7 : char **arg4 = (char **) NULL ;
11621 7 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
11622 7 : void *arg6 = (void *) NULL ;
11623 7 : void *argp1 = 0 ;
11624 7 : int res1 = 0 ;
11625 7 : void *argp2 = 0 ;
11626 7 : int res2 = 0 ;
11627 7 : void *argp3 = 0 ;
11628 7 : int res3 = 0 ;
11629 7 : PyObject * obj0 = 0 ;
11630 7 : PyObject * obj1 = 0 ;
11631 7 : PyObject * obj2 = 0 ;
11632 7 : PyObject * obj3 = 0 ;
11633 7 : PyObject * obj4 = 0 ;
11634 7 : PyObject * obj5 = 0 ;
11635 7 : char * kwnames[] = {
11636 : (char *)"self", (char *)"method_layer", (char *)"result_layer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
11637 : };
11638 7 : OGRErr result;
11639 :
11640 : /* %typemap(arginit) ( const char* callback_data=NULL) */
11641 7 : PyProgressData *psProgressInfo;
11642 7 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
11643 7 : psProgressInfo->nLastReported = -1;
11644 7 : psProgressInfo->psPyCallback = NULL;
11645 7 : psProgressInfo->psPyCallbackData = NULL;
11646 7 : arg6 = psProgressInfo;
11647 7 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:Layer_Union", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
11648 7 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11649 7 : if (!SWIG_IsOK(res1)) {
11650 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_Union" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11651 : }
11652 7 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11653 7 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11654 7 : if (!SWIG_IsOK(res2)) {
11655 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_Union" "', argument " "2"" of type '" "OGRLayerShadow *""'");
11656 : }
11657 7 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
11658 7 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11659 7 : if (!SWIG_IsOK(res3)) {
11660 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_Union" "', argument " "3"" of type '" "OGRLayerShadow *""'");
11661 : }
11662 7 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
11663 7 : if (obj3) {
11664 5 : {
11665 : /* %typemap(in) char **dict */
11666 5 : arg4 = NULL;
11667 5 : if ( PySequence_Check( obj3 ) ) {
11668 5 : int bErr = FALSE;
11669 5 : arg4 = CSLFromPySequence(obj3, &bErr);
11670 5 : if ( bErr )
11671 : {
11672 0 : SWIG_fail;
11673 : }
11674 : }
11675 0 : else if ( PyMapping_Check( obj3 ) ) {
11676 0 : int bErr = FALSE;
11677 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
11678 0 : if ( bErr )
11679 : {
11680 0 : SWIG_fail;
11681 : }
11682 : }
11683 : else {
11684 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
11685 0 : SWIG_fail;
11686 : }
11687 : }
11688 : }
11689 7 : if (obj4) {
11690 1 : {
11691 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
11692 : /* callback_func typemap */
11693 :
11694 : /* In some cases 0 is passed instead of None. */
11695 : /* See https://github.com/OSGeo/gdal/pull/219 */
11696 1 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
11697 : {
11698 0 : if( PyLong_AsLong(obj4) == 0 )
11699 : {
11700 0 : obj4 = Py_None;
11701 : }
11702 : }
11703 :
11704 1 : if (obj4 && obj4 != Py_None ) {
11705 1 : void* cbfunction = NULL;
11706 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
11707 : (void**)&cbfunction,
11708 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
11709 : SWIG_POINTER_EXCEPTION | 0 ));
11710 :
11711 1 : if ( cbfunction == GDALTermProgress ) {
11712 : arg5 = GDALTermProgress;
11713 : } else {
11714 1 : if (!PyCallable_Check(obj4)) {
11715 0 : PyErr_SetString( PyExc_RuntimeError,
11716 : "Object given is not a Python function" );
11717 0 : SWIG_fail;
11718 : }
11719 1 : psProgressInfo->psPyCallback = obj4;
11720 1 : arg5 = PyProgressProxy;
11721 : }
11722 :
11723 : }
11724 :
11725 : }
11726 : }
11727 7 : if (obj5) {
11728 0 : {
11729 : /* %typemap(in) ( void* callback_data=NULL) */
11730 0 : psProgressInfo->psPyCallbackData = obj5 ;
11731 : }
11732 : }
11733 7 : {
11734 7 : const int bLocalUseExceptions = GetUseExceptions();
11735 7 : if ( bLocalUseExceptions ) {
11736 7 : pushErrorHandler();
11737 : }
11738 7 : {
11739 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11740 7 : result = (OGRErr)OGRLayerShadow_Union(arg1,arg2,arg3,arg4,arg5,arg6);
11741 7 : SWIG_PYTHON_THREAD_END_ALLOW;
11742 : }
11743 7 : if ( bLocalUseExceptions ) {
11744 7 : popErrorHandler();
11745 : }
11746 : #ifndef SED_HACKS
11747 : if ( bLocalUseExceptions ) {
11748 : CPLErr eclass = CPLGetLastErrorType();
11749 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11750 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11751 : }
11752 : }
11753 : #endif
11754 : }
11755 7 : {
11756 : /* %typemap(out) OGRErr */
11757 7 : if ( result != 0 && GetUseExceptions()) {
11758 0 : const char* pszMessage = CPLGetLastErrorMsg();
11759 0 : if( pszMessage[0] != '\0' )
11760 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
11761 : else
11762 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11763 0 : SWIG_fail;
11764 : }
11765 : }
11766 7 : {
11767 : /* %typemap(freearg) char **dict */
11768 7 : CSLDestroy( arg4 );
11769 : }
11770 7 : {
11771 : /* %typemap(freearg) ( void* callback_data=NULL) */
11772 :
11773 7 : CPLFree(psProgressInfo);
11774 :
11775 : }
11776 7 : {
11777 : /* %typemap(ret) OGRErr */
11778 7 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
11779 7 : resultobj = PyInt_FromLong( result );
11780 : }
11781 : }
11782 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
11783 : return resultobj;
11784 0 : fail:
11785 0 : {
11786 : /* %typemap(freearg) char **dict */
11787 0 : CSLDestroy( arg4 );
11788 : }
11789 0 : {
11790 : /* %typemap(freearg) ( void* callback_data=NULL) */
11791 :
11792 0 : CPLFree(psProgressInfo);
11793 :
11794 : }
11795 : return NULL;
11796 : }
11797 :
11798 :
11799 4 : SWIGINTERN PyObject *_wrap_Layer_SymDifference(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11800 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11801 4 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11802 4 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
11803 4 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
11804 4 : char **arg4 = (char **) NULL ;
11805 4 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
11806 4 : void *arg6 = (void *) NULL ;
11807 4 : void *argp1 = 0 ;
11808 4 : int res1 = 0 ;
11809 4 : void *argp2 = 0 ;
11810 4 : int res2 = 0 ;
11811 4 : void *argp3 = 0 ;
11812 4 : int res3 = 0 ;
11813 4 : PyObject * obj0 = 0 ;
11814 4 : PyObject * obj1 = 0 ;
11815 4 : PyObject * obj2 = 0 ;
11816 4 : PyObject * obj3 = 0 ;
11817 4 : PyObject * obj4 = 0 ;
11818 4 : PyObject * obj5 = 0 ;
11819 4 : char * kwnames[] = {
11820 : (char *)"self", (char *)"method_layer", (char *)"result_layer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
11821 : };
11822 4 : OGRErr result;
11823 :
11824 : /* %typemap(arginit) ( const char* callback_data=NULL) */
11825 4 : PyProgressData *psProgressInfo;
11826 4 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
11827 4 : psProgressInfo->nLastReported = -1;
11828 4 : psProgressInfo->psPyCallback = NULL;
11829 4 : psProgressInfo->psPyCallbackData = NULL;
11830 4 : arg6 = psProgressInfo;
11831 4 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:Layer_SymDifference", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
11832 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11833 4 : if (!SWIG_IsOK(res1)) {
11834 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SymDifference" "', argument " "1"" of type '" "OGRLayerShadow *""'");
11835 : }
11836 4 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
11837 4 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11838 4 : if (!SWIG_IsOK(res2)) {
11839 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_SymDifference" "', argument " "2"" of type '" "OGRLayerShadow *""'");
11840 : }
11841 4 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
11842 4 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
11843 4 : if (!SWIG_IsOK(res3)) {
11844 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_SymDifference" "', argument " "3"" of type '" "OGRLayerShadow *""'");
11845 : }
11846 4 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
11847 4 : if (obj3) {
11848 2 : {
11849 : /* %typemap(in) char **dict */
11850 2 : arg4 = NULL;
11851 2 : if ( PySequence_Check( obj3 ) ) {
11852 2 : int bErr = FALSE;
11853 2 : arg4 = CSLFromPySequence(obj3, &bErr);
11854 2 : if ( bErr )
11855 : {
11856 0 : SWIG_fail;
11857 : }
11858 : }
11859 0 : else if ( PyMapping_Check( obj3 ) ) {
11860 0 : int bErr = FALSE;
11861 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
11862 0 : if ( bErr )
11863 : {
11864 0 : SWIG_fail;
11865 : }
11866 : }
11867 : else {
11868 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
11869 0 : SWIG_fail;
11870 : }
11871 : }
11872 : }
11873 4 : if (obj4) {
11874 1 : {
11875 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
11876 : /* callback_func typemap */
11877 :
11878 : /* In some cases 0 is passed instead of None. */
11879 : /* See https://github.com/OSGeo/gdal/pull/219 */
11880 1 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
11881 : {
11882 0 : if( PyLong_AsLong(obj4) == 0 )
11883 : {
11884 0 : obj4 = Py_None;
11885 : }
11886 : }
11887 :
11888 1 : if (obj4 && obj4 != Py_None ) {
11889 1 : void* cbfunction = NULL;
11890 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
11891 : (void**)&cbfunction,
11892 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
11893 : SWIG_POINTER_EXCEPTION | 0 ));
11894 :
11895 1 : if ( cbfunction == GDALTermProgress ) {
11896 : arg5 = GDALTermProgress;
11897 : } else {
11898 1 : if (!PyCallable_Check(obj4)) {
11899 0 : PyErr_SetString( PyExc_RuntimeError,
11900 : "Object given is not a Python function" );
11901 0 : SWIG_fail;
11902 : }
11903 1 : psProgressInfo->psPyCallback = obj4;
11904 1 : arg5 = PyProgressProxy;
11905 : }
11906 :
11907 : }
11908 :
11909 : }
11910 : }
11911 4 : if (obj5) {
11912 0 : {
11913 : /* %typemap(in) ( void* callback_data=NULL) */
11914 0 : psProgressInfo->psPyCallbackData = obj5 ;
11915 : }
11916 : }
11917 4 : {
11918 4 : const int bLocalUseExceptions = GetUseExceptions();
11919 4 : if ( bLocalUseExceptions ) {
11920 4 : pushErrorHandler();
11921 : }
11922 4 : {
11923 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11924 4 : result = (OGRErr)OGRLayerShadow_SymDifference(arg1,arg2,arg3,arg4,arg5,arg6);
11925 4 : SWIG_PYTHON_THREAD_END_ALLOW;
11926 : }
11927 4 : if ( bLocalUseExceptions ) {
11928 4 : popErrorHandler();
11929 : }
11930 : #ifndef SED_HACKS
11931 : if ( bLocalUseExceptions ) {
11932 : CPLErr eclass = CPLGetLastErrorType();
11933 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11934 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11935 : }
11936 : }
11937 : #endif
11938 : }
11939 4 : {
11940 : /* %typemap(out) OGRErr */
11941 4 : if ( result != 0 && GetUseExceptions()) {
11942 0 : const char* pszMessage = CPLGetLastErrorMsg();
11943 0 : if( pszMessage[0] != '\0' )
11944 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
11945 : else
11946 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
11947 0 : SWIG_fail;
11948 : }
11949 : }
11950 4 : {
11951 : /* %typemap(freearg) char **dict */
11952 4 : CSLDestroy( arg4 );
11953 : }
11954 4 : {
11955 : /* %typemap(freearg) ( void* callback_data=NULL) */
11956 :
11957 4 : CPLFree(psProgressInfo);
11958 :
11959 : }
11960 4 : {
11961 : /* %typemap(ret) OGRErr */
11962 4 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
11963 4 : resultobj = PyInt_FromLong( result );
11964 : }
11965 : }
11966 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
11967 : return resultobj;
11968 0 : fail:
11969 0 : {
11970 : /* %typemap(freearg) char **dict */
11971 0 : CSLDestroy( arg4 );
11972 : }
11973 0 : {
11974 : /* %typemap(freearg) ( void* callback_data=NULL) */
11975 :
11976 0 : CPLFree(psProgressInfo);
11977 :
11978 : }
11979 : return NULL;
11980 : }
11981 :
11982 :
11983 6 : SWIGINTERN PyObject *_wrap_Layer_Identity(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11984 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11985 6 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
11986 6 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
11987 6 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
11988 6 : char **arg4 = (char **) NULL ;
11989 6 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
11990 6 : void *arg6 = (void *) NULL ;
11991 6 : void *argp1 = 0 ;
11992 6 : int res1 = 0 ;
11993 6 : void *argp2 = 0 ;
11994 6 : int res2 = 0 ;
11995 6 : void *argp3 = 0 ;
11996 6 : int res3 = 0 ;
11997 6 : PyObject * obj0 = 0 ;
11998 6 : PyObject * obj1 = 0 ;
11999 6 : PyObject * obj2 = 0 ;
12000 6 : PyObject * obj3 = 0 ;
12001 6 : PyObject * obj4 = 0 ;
12002 6 : PyObject * obj5 = 0 ;
12003 6 : char * kwnames[] = {
12004 : (char *)"self", (char *)"method_layer", (char *)"result_layer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
12005 : };
12006 6 : OGRErr result;
12007 :
12008 : /* %typemap(arginit) ( const char* callback_data=NULL) */
12009 6 : PyProgressData *psProgressInfo;
12010 6 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
12011 6 : psProgressInfo->nLastReported = -1;
12012 6 : psProgressInfo->psPyCallback = NULL;
12013 6 : psProgressInfo->psPyCallbackData = NULL;
12014 6 : arg6 = psProgressInfo;
12015 6 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:Layer_Identity", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
12016 6 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12017 6 : if (!SWIG_IsOK(res1)) {
12018 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_Identity" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12019 : }
12020 6 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12021 6 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12022 6 : if (!SWIG_IsOK(res2)) {
12023 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_Identity" "', argument " "2"" of type '" "OGRLayerShadow *""'");
12024 : }
12025 6 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
12026 6 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12027 6 : if (!SWIG_IsOK(res3)) {
12028 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_Identity" "', argument " "3"" of type '" "OGRLayerShadow *""'");
12029 : }
12030 6 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
12031 6 : if (obj3) {
12032 5 : {
12033 : /* %typemap(in) char **dict */
12034 5 : arg4 = NULL;
12035 5 : if ( PySequence_Check( obj3 ) ) {
12036 5 : int bErr = FALSE;
12037 5 : arg4 = CSLFromPySequence(obj3, &bErr);
12038 5 : if ( bErr )
12039 : {
12040 0 : SWIG_fail;
12041 : }
12042 : }
12043 0 : else if ( PyMapping_Check( obj3 ) ) {
12044 0 : int bErr = FALSE;
12045 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
12046 0 : if ( bErr )
12047 : {
12048 0 : SWIG_fail;
12049 : }
12050 : }
12051 : else {
12052 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
12053 0 : SWIG_fail;
12054 : }
12055 : }
12056 : }
12057 6 : if (obj4) {
12058 1 : {
12059 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
12060 : /* callback_func typemap */
12061 :
12062 : /* In some cases 0 is passed instead of None. */
12063 : /* See https://github.com/OSGeo/gdal/pull/219 */
12064 1 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
12065 : {
12066 0 : if( PyLong_AsLong(obj4) == 0 )
12067 : {
12068 0 : obj4 = Py_None;
12069 : }
12070 : }
12071 :
12072 1 : if (obj4 && obj4 != Py_None ) {
12073 1 : void* cbfunction = NULL;
12074 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
12075 : (void**)&cbfunction,
12076 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
12077 : SWIG_POINTER_EXCEPTION | 0 ));
12078 :
12079 1 : if ( cbfunction == GDALTermProgress ) {
12080 : arg5 = GDALTermProgress;
12081 : } else {
12082 1 : if (!PyCallable_Check(obj4)) {
12083 0 : PyErr_SetString( PyExc_RuntimeError,
12084 : "Object given is not a Python function" );
12085 0 : SWIG_fail;
12086 : }
12087 1 : psProgressInfo->psPyCallback = obj4;
12088 1 : arg5 = PyProgressProxy;
12089 : }
12090 :
12091 : }
12092 :
12093 : }
12094 : }
12095 6 : if (obj5) {
12096 0 : {
12097 : /* %typemap(in) ( void* callback_data=NULL) */
12098 0 : psProgressInfo->psPyCallbackData = obj5 ;
12099 : }
12100 : }
12101 6 : {
12102 6 : const int bLocalUseExceptions = GetUseExceptions();
12103 6 : if ( bLocalUseExceptions ) {
12104 6 : pushErrorHandler();
12105 : }
12106 6 : {
12107 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12108 6 : result = (OGRErr)OGRLayerShadow_Identity(arg1,arg2,arg3,arg4,arg5,arg6);
12109 6 : SWIG_PYTHON_THREAD_END_ALLOW;
12110 : }
12111 6 : if ( bLocalUseExceptions ) {
12112 6 : popErrorHandler();
12113 : }
12114 : #ifndef SED_HACKS
12115 : if ( bLocalUseExceptions ) {
12116 : CPLErr eclass = CPLGetLastErrorType();
12117 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12118 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12119 : }
12120 : }
12121 : #endif
12122 : }
12123 6 : {
12124 : /* %typemap(out) OGRErr */
12125 6 : if ( result != 0 && GetUseExceptions()) {
12126 0 : const char* pszMessage = CPLGetLastErrorMsg();
12127 0 : if( pszMessage[0] != '\0' )
12128 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
12129 : else
12130 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12131 0 : SWIG_fail;
12132 : }
12133 : }
12134 6 : {
12135 : /* %typemap(freearg) char **dict */
12136 6 : CSLDestroy( arg4 );
12137 : }
12138 6 : {
12139 : /* %typemap(freearg) ( void* callback_data=NULL) */
12140 :
12141 6 : CPLFree(psProgressInfo);
12142 :
12143 : }
12144 6 : {
12145 : /* %typemap(ret) OGRErr */
12146 6 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
12147 6 : resultobj = PyInt_FromLong( result );
12148 : }
12149 : }
12150 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
12151 : return resultobj;
12152 0 : fail:
12153 0 : {
12154 : /* %typemap(freearg) char **dict */
12155 0 : CSLDestroy( arg4 );
12156 : }
12157 0 : {
12158 : /* %typemap(freearg) ( void* callback_data=NULL) */
12159 :
12160 0 : CPLFree(psProgressInfo);
12161 :
12162 : }
12163 : return NULL;
12164 : }
12165 :
12166 :
12167 5 : SWIGINTERN PyObject *_wrap_Layer_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12168 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12169 5 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12170 5 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
12171 5 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
12172 5 : char **arg4 = (char **) NULL ;
12173 5 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
12174 5 : void *arg6 = (void *) NULL ;
12175 5 : void *argp1 = 0 ;
12176 5 : int res1 = 0 ;
12177 5 : void *argp2 = 0 ;
12178 5 : int res2 = 0 ;
12179 5 : void *argp3 = 0 ;
12180 5 : int res3 = 0 ;
12181 5 : PyObject * obj0 = 0 ;
12182 5 : PyObject * obj1 = 0 ;
12183 5 : PyObject * obj2 = 0 ;
12184 5 : PyObject * obj3 = 0 ;
12185 5 : PyObject * obj4 = 0 ;
12186 5 : PyObject * obj5 = 0 ;
12187 5 : char * kwnames[] = {
12188 : (char *)"self", (char *)"method_layer", (char *)"result_layer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
12189 : };
12190 5 : OGRErr result;
12191 :
12192 : /* %typemap(arginit) ( const char* callback_data=NULL) */
12193 5 : PyProgressData *psProgressInfo;
12194 5 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
12195 5 : psProgressInfo->nLastReported = -1;
12196 5 : psProgressInfo->psPyCallback = NULL;
12197 5 : psProgressInfo->psPyCallbackData = NULL;
12198 5 : arg6 = psProgressInfo;
12199 5 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:Layer_Update", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
12200 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12201 5 : if (!SWIG_IsOK(res1)) {
12202 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_Update" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12203 : }
12204 5 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12205 5 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12206 5 : if (!SWIG_IsOK(res2)) {
12207 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_Update" "', argument " "2"" of type '" "OGRLayerShadow *""'");
12208 : }
12209 5 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
12210 5 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12211 5 : if (!SWIG_IsOK(res3)) {
12212 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_Update" "', argument " "3"" of type '" "OGRLayerShadow *""'");
12213 : }
12214 5 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
12215 5 : if (obj3) {
12216 2 : {
12217 : /* %typemap(in) char **dict */
12218 2 : arg4 = NULL;
12219 2 : if ( PySequence_Check( obj3 ) ) {
12220 2 : int bErr = FALSE;
12221 2 : arg4 = CSLFromPySequence(obj3, &bErr);
12222 2 : if ( bErr )
12223 : {
12224 0 : SWIG_fail;
12225 : }
12226 : }
12227 0 : else if ( PyMapping_Check( obj3 ) ) {
12228 0 : int bErr = FALSE;
12229 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
12230 0 : if ( bErr )
12231 : {
12232 0 : SWIG_fail;
12233 : }
12234 : }
12235 : else {
12236 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
12237 0 : SWIG_fail;
12238 : }
12239 : }
12240 : }
12241 5 : if (obj4) {
12242 1 : {
12243 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
12244 : /* callback_func typemap */
12245 :
12246 : /* In some cases 0 is passed instead of None. */
12247 : /* See https://github.com/OSGeo/gdal/pull/219 */
12248 1 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
12249 : {
12250 0 : if( PyLong_AsLong(obj4) == 0 )
12251 : {
12252 0 : obj4 = Py_None;
12253 : }
12254 : }
12255 :
12256 1 : if (obj4 && obj4 != Py_None ) {
12257 1 : void* cbfunction = NULL;
12258 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
12259 : (void**)&cbfunction,
12260 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
12261 : SWIG_POINTER_EXCEPTION | 0 ));
12262 :
12263 1 : if ( cbfunction == GDALTermProgress ) {
12264 : arg5 = GDALTermProgress;
12265 : } else {
12266 1 : if (!PyCallable_Check(obj4)) {
12267 0 : PyErr_SetString( PyExc_RuntimeError,
12268 : "Object given is not a Python function" );
12269 0 : SWIG_fail;
12270 : }
12271 1 : psProgressInfo->psPyCallback = obj4;
12272 1 : arg5 = PyProgressProxy;
12273 : }
12274 :
12275 : }
12276 :
12277 : }
12278 : }
12279 5 : if (obj5) {
12280 0 : {
12281 : /* %typemap(in) ( void* callback_data=NULL) */
12282 0 : psProgressInfo->psPyCallbackData = obj5 ;
12283 : }
12284 : }
12285 5 : {
12286 5 : const int bLocalUseExceptions = GetUseExceptions();
12287 5 : if ( bLocalUseExceptions ) {
12288 5 : pushErrorHandler();
12289 : }
12290 5 : {
12291 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12292 5 : result = (OGRErr)OGRLayerShadow_Update(arg1,arg2,arg3,arg4,arg5,arg6);
12293 5 : SWIG_PYTHON_THREAD_END_ALLOW;
12294 : }
12295 5 : if ( bLocalUseExceptions ) {
12296 5 : popErrorHandler();
12297 : }
12298 : #ifndef SED_HACKS
12299 : if ( bLocalUseExceptions ) {
12300 : CPLErr eclass = CPLGetLastErrorType();
12301 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12302 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12303 : }
12304 : }
12305 : #endif
12306 : }
12307 5 : {
12308 : /* %typemap(out) OGRErr */
12309 5 : if ( result != 0 && GetUseExceptions()) {
12310 0 : const char* pszMessage = CPLGetLastErrorMsg();
12311 0 : if( pszMessage[0] != '\0' )
12312 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
12313 : else
12314 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12315 0 : SWIG_fail;
12316 : }
12317 : }
12318 5 : {
12319 : /* %typemap(freearg) char **dict */
12320 5 : CSLDestroy( arg4 );
12321 : }
12322 5 : {
12323 : /* %typemap(freearg) ( void* callback_data=NULL) */
12324 :
12325 5 : CPLFree(psProgressInfo);
12326 :
12327 : }
12328 5 : {
12329 : /* %typemap(ret) OGRErr */
12330 5 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
12331 5 : resultobj = PyInt_FromLong( result );
12332 : }
12333 : }
12334 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
12335 : return resultobj;
12336 0 : fail:
12337 0 : {
12338 : /* %typemap(freearg) char **dict */
12339 0 : CSLDestroy( arg4 );
12340 : }
12341 0 : {
12342 : /* %typemap(freearg) ( void* callback_data=NULL) */
12343 :
12344 0 : CPLFree(psProgressInfo);
12345 :
12346 : }
12347 : return NULL;
12348 : }
12349 :
12350 :
12351 3 : SWIGINTERN PyObject *_wrap_Layer_Clip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12352 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12353 3 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12354 3 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
12355 3 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
12356 3 : char **arg4 = (char **) NULL ;
12357 3 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
12358 3 : void *arg6 = (void *) NULL ;
12359 3 : void *argp1 = 0 ;
12360 3 : int res1 = 0 ;
12361 3 : void *argp2 = 0 ;
12362 3 : int res2 = 0 ;
12363 3 : void *argp3 = 0 ;
12364 3 : int res3 = 0 ;
12365 3 : PyObject * obj0 = 0 ;
12366 3 : PyObject * obj1 = 0 ;
12367 3 : PyObject * obj2 = 0 ;
12368 3 : PyObject * obj3 = 0 ;
12369 3 : PyObject * obj4 = 0 ;
12370 3 : PyObject * obj5 = 0 ;
12371 3 : char * kwnames[] = {
12372 : (char *)"self", (char *)"method_layer", (char *)"result_layer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
12373 : };
12374 3 : OGRErr result;
12375 :
12376 : /* %typemap(arginit) ( const char* callback_data=NULL) */
12377 3 : PyProgressData *psProgressInfo;
12378 3 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
12379 3 : psProgressInfo->nLastReported = -1;
12380 3 : psProgressInfo->psPyCallback = NULL;
12381 3 : psProgressInfo->psPyCallbackData = NULL;
12382 3 : arg6 = psProgressInfo;
12383 3 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:Layer_Clip", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
12384 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12385 3 : if (!SWIG_IsOK(res1)) {
12386 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_Clip" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12387 : }
12388 3 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12389 3 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12390 3 : if (!SWIG_IsOK(res2)) {
12391 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_Clip" "', argument " "2"" of type '" "OGRLayerShadow *""'");
12392 : }
12393 3 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
12394 3 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12395 3 : if (!SWIG_IsOK(res3)) {
12396 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_Clip" "', argument " "3"" of type '" "OGRLayerShadow *""'");
12397 : }
12398 3 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
12399 3 : if (obj3) {
12400 2 : {
12401 : /* %typemap(in) char **dict */
12402 2 : arg4 = NULL;
12403 2 : if ( PySequence_Check( obj3 ) ) {
12404 2 : int bErr = FALSE;
12405 2 : arg4 = CSLFromPySequence(obj3, &bErr);
12406 2 : if ( bErr )
12407 : {
12408 0 : SWIG_fail;
12409 : }
12410 : }
12411 0 : else if ( PyMapping_Check( obj3 ) ) {
12412 0 : int bErr = FALSE;
12413 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
12414 0 : if ( bErr )
12415 : {
12416 0 : SWIG_fail;
12417 : }
12418 : }
12419 : else {
12420 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
12421 0 : SWIG_fail;
12422 : }
12423 : }
12424 : }
12425 3 : if (obj4) {
12426 1 : {
12427 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
12428 : /* callback_func typemap */
12429 :
12430 : /* In some cases 0 is passed instead of None. */
12431 : /* See https://github.com/OSGeo/gdal/pull/219 */
12432 1 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
12433 : {
12434 0 : if( PyLong_AsLong(obj4) == 0 )
12435 : {
12436 0 : obj4 = Py_None;
12437 : }
12438 : }
12439 :
12440 1 : if (obj4 && obj4 != Py_None ) {
12441 1 : void* cbfunction = NULL;
12442 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
12443 : (void**)&cbfunction,
12444 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
12445 : SWIG_POINTER_EXCEPTION | 0 ));
12446 :
12447 1 : if ( cbfunction == GDALTermProgress ) {
12448 : arg5 = GDALTermProgress;
12449 : } else {
12450 1 : if (!PyCallable_Check(obj4)) {
12451 0 : PyErr_SetString( PyExc_RuntimeError,
12452 : "Object given is not a Python function" );
12453 0 : SWIG_fail;
12454 : }
12455 1 : psProgressInfo->psPyCallback = obj4;
12456 1 : arg5 = PyProgressProxy;
12457 : }
12458 :
12459 : }
12460 :
12461 : }
12462 : }
12463 3 : if (obj5) {
12464 0 : {
12465 : /* %typemap(in) ( void* callback_data=NULL) */
12466 0 : psProgressInfo->psPyCallbackData = obj5 ;
12467 : }
12468 : }
12469 3 : {
12470 3 : const int bLocalUseExceptions = GetUseExceptions();
12471 3 : if ( bLocalUseExceptions ) {
12472 3 : pushErrorHandler();
12473 : }
12474 3 : {
12475 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12476 3 : result = (OGRErr)OGRLayerShadow_Clip(arg1,arg2,arg3,arg4,arg5,arg6);
12477 3 : SWIG_PYTHON_THREAD_END_ALLOW;
12478 : }
12479 3 : if ( bLocalUseExceptions ) {
12480 3 : popErrorHandler();
12481 : }
12482 : #ifndef SED_HACKS
12483 : if ( bLocalUseExceptions ) {
12484 : CPLErr eclass = CPLGetLastErrorType();
12485 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12486 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12487 : }
12488 : }
12489 : #endif
12490 : }
12491 3 : {
12492 : /* %typemap(out) OGRErr */
12493 3 : if ( result != 0 && GetUseExceptions()) {
12494 0 : const char* pszMessage = CPLGetLastErrorMsg();
12495 0 : if( pszMessage[0] != '\0' )
12496 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
12497 : else
12498 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12499 0 : SWIG_fail;
12500 : }
12501 : }
12502 3 : {
12503 : /* %typemap(freearg) char **dict */
12504 3 : CSLDestroy( arg4 );
12505 : }
12506 3 : {
12507 : /* %typemap(freearg) ( void* callback_data=NULL) */
12508 :
12509 3 : CPLFree(psProgressInfo);
12510 :
12511 : }
12512 3 : {
12513 : /* %typemap(ret) OGRErr */
12514 3 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
12515 3 : resultobj = PyInt_FromLong( result );
12516 : }
12517 : }
12518 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
12519 : return resultobj;
12520 0 : fail:
12521 0 : {
12522 : /* %typemap(freearg) char **dict */
12523 0 : CSLDestroy( arg4 );
12524 : }
12525 0 : {
12526 : /* %typemap(freearg) ( void* callback_data=NULL) */
12527 :
12528 0 : CPLFree(psProgressInfo);
12529 :
12530 : }
12531 : return NULL;
12532 : }
12533 :
12534 :
12535 6 : SWIGINTERN PyObject *_wrap_Layer_Erase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12536 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12537 6 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12538 6 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
12539 6 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
12540 6 : char **arg4 = (char **) NULL ;
12541 6 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
12542 6 : void *arg6 = (void *) NULL ;
12543 6 : void *argp1 = 0 ;
12544 6 : int res1 = 0 ;
12545 6 : void *argp2 = 0 ;
12546 6 : int res2 = 0 ;
12547 6 : void *argp3 = 0 ;
12548 6 : int res3 = 0 ;
12549 6 : PyObject * obj0 = 0 ;
12550 6 : PyObject * obj1 = 0 ;
12551 6 : PyObject * obj2 = 0 ;
12552 6 : PyObject * obj3 = 0 ;
12553 6 : PyObject * obj4 = 0 ;
12554 6 : PyObject * obj5 = 0 ;
12555 6 : char * kwnames[] = {
12556 : (char *)"self", (char *)"method_layer", (char *)"result_layer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
12557 : };
12558 6 : OGRErr result;
12559 :
12560 : /* %typemap(arginit) ( const char* callback_data=NULL) */
12561 6 : PyProgressData *psProgressInfo;
12562 6 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
12563 6 : psProgressInfo->nLastReported = -1;
12564 6 : psProgressInfo->psPyCallback = NULL;
12565 6 : psProgressInfo->psPyCallbackData = NULL;
12566 6 : arg6 = psProgressInfo;
12567 6 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:Layer_Erase", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
12568 6 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12569 6 : if (!SWIG_IsOK(res1)) {
12570 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_Erase" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12571 : }
12572 6 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12573 6 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12574 6 : if (!SWIG_IsOK(res2)) {
12575 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_Erase" "', argument " "2"" of type '" "OGRLayerShadow *""'");
12576 : }
12577 6 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
12578 6 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12579 6 : if (!SWIG_IsOK(res3)) {
12580 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_Erase" "', argument " "3"" of type '" "OGRLayerShadow *""'");
12581 : }
12582 6 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
12583 6 : if (obj3) {
12584 3 : {
12585 : /* %typemap(in) char **dict */
12586 3 : arg4 = NULL;
12587 3 : if ( PySequence_Check( obj3 ) ) {
12588 3 : int bErr = FALSE;
12589 3 : arg4 = CSLFromPySequence(obj3, &bErr);
12590 3 : if ( bErr )
12591 : {
12592 0 : SWIG_fail;
12593 : }
12594 : }
12595 0 : else if ( PyMapping_Check( obj3 ) ) {
12596 0 : int bErr = FALSE;
12597 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
12598 0 : if ( bErr )
12599 : {
12600 0 : SWIG_fail;
12601 : }
12602 : }
12603 : else {
12604 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
12605 0 : SWIG_fail;
12606 : }
12607 : }
12608 : }
12609 6 : if (obj4) {
12610 1 : {
12611 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
12612 : /* callback_func typemap */
12613 :
12614 : /* In some cases 0 is passed instead of None. */
12615 : /* See https://github.com/OSGeo/gdal/pull/219 */
12616 1 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
12617 : {
12618 0 : if( PyLong_AsLong(obj4) == 0 )
12619 : {
12620 0 : obj4 = Py_None;
12621 : }
12622 : }
12623 :
12624 1 : if (obj4 && obj4 != Py_None ) {
12625 1 : void* cbfunction = NULL;
12626 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
12627 : (void**)&cbfunction,
12628 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
12629 : SWIG_POINTER_EXCEPTION | 0 ));
12630 :
12631 1 : if ( cbfunction == GDALTermProgress ) {
12632 : arg5 = GDALTermProgress;
12633 : } else {
12634 1 : if (!PyCallable_Check(obj4)) {
12635 0 : PyErr_SetString( PyExc_RuntimeError,
12636 : "Object given is not a Python function" );
12637 0 : SWIG_fail;
12638 : }
12639 1 : psProgressInfo->psPyCallback = obj4;
12640 1 : arg5 = PyProgressProxy;
12641 : }
12642 :
12643 : }
12644 :
12645 : }
12646 : }
12647 6 : if (obj5) {
12648 0 : {
12649 : /* %typemap(in) ( void* callback_data=NULL) */
12650 0 : psProgressInfo->psPyCallbackData = obj5 ;
12651 : }
12652 : }
12653 6 : {
12654 6 : const int bLocalUseExceptions = GetUseExceptions();
12655 6 : if ( bLocalUseExceptions ) {
12656 6 : pushErrorHandler();
12657 : }
12658 6 : {
12659 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12660 6 : result = (OGRErr)OGRLayerShadow_Erase(arg1,arg2,arg3,arg4,arg5,arg6);
12661 6 : SWIG_PYTHON_THREAD_END_ALLOW;
12662 : }
12663 6 : if ( bLocalUseExceptions ) {
12664 6 : popErrorHandler();
12665 : }
12666 : #ifndef SED_HACKS
12667 : if ( bLocalUseExceptions ) {
12668 : CPLErr eclass = CPLGetLastErrorType();
12669 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12670 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12671 : }
12672 : }
12673 : #endif
12674 : }
12675 6 : {
12676 : /* %typemap(out) OGRErr */
12677 6 : if ( result != 0 && GetUseExceptions()) {
12678 0 : const char* pszMessage = CPLGetLastErrorMsg();
12679 0 : if( pszMessage[0] != '\0' )
12680 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
12681 : else
12682 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
12683 0 : SWIG_fail;
12684 : }
12685 : }
12686 6 : {
12687 : /* %typemap(freearg) char **dict */
12688 6 : CSLDestroy( arg4 );
12689 : }
12690 6 : {
12691 : /* %typemap(freearg) ( void* callback_data=NULL) */
12692 :
12693 6 : CPLFree(psProgressInfo);
12694 :
12695 : }
12696 6 : {
12697 : /* %typemap(ret) OGRErr */
12698 6 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
12699 6 : resultobj = PyInt_FromLong( result );
12700 : }
12701 : }
12702 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
12703 : return resultobj;
12704 0 : fail:
12705 0 : {
12706 : /* %typemap(freearg) char **dict */
12707 0 : CSLDestroy( arg4 );
12708 : }
12709 0 : {
12710 : /* %typemap(freearg) ( void* callback_data=NULL) */
12711 :
12712 0 : CPLFree(psProgressInfo);
12713 :
12714 : }
12715 : return NULL;
12716 : }
12717 :
12718 :
12719 3 : SWIGINTERN PyObject *_wrap_Layer_GetStyleTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12720 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12721 3 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12722 3 : void *argp1 = 0 ;
12723 3 : int res1 = 0 ;
12724 3 : PyObject *swig_obj[1] ;
12725 3 : OGRStyleTableShadow *result = 0 ;
12726 :
12727 3 : if (!args) SWIG_fail;
12728 3 : swig_obj[0] = args;
12729 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12730 3 : if (!SWIG_IsOK(res1)) {
12731 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetStyleTable" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12732 : }
12733 3 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12734 3 : {
12735 3 : const int bLocalUseExceptions = GetUseExceptions();
12736 3 : if ( bLocalUseExceptions ) {
12737 3 : pushErrorHandler();
12738 : }
12739 3 : {
12740 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12741 3 : result = (OGRStyleTableShadow *)OGRLayerShadow_GetStyleTable(arg1);
12742 3 : SWIG_PYTHON_THREAD_END_ALLOW;
12743 : }
12744 3 : if ( bLocalUseExceptions ) {
12745 3 : popErrorHandler();
12746 : }
12747 : #ifndef SED_HACKS
12748 : if ( bLocalUseExceptions ) {
12749 : CPLErr eclass = CPLGetLastErrorType();
12750 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12751 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12752 : }
12753 : }
12754 : #endif
12755 : }
12756 3 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
12757 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
12758 : return resultobj;
12759 : fail:
12760 : return NULL;
12761 : }
12762 :
12763 :
12764 2 : SWIGINTERN PyObject *_wrap_Layer_SetStyleTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12765 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12766 2 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12767 2 : OGRStyleTableShadow *arg2 = (OGRStyleTableShadow *) 0 ;
12768 2 : void *argp1 = 0 ;
12769 2 : int res1 = 0 ;
12770 2 : void *argp2 = 0 ;
12771 2 : int res2 = 0 ;
12772 2 : PyObject *swig_obj[2] ;
12773 :
12774 2 : if (!SWIG_Python_UnpackTuple(args, "Layer_SetStyleTable", 2, 2, swig_obj)) SWIG_fail;
12775 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12776 2 : if (!SWIG_IsOK(res1)) {
12777 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetStyleTable" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12778 : }
12779 2 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12780 2 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
12781 2 : if (!SWIG_IsOK(res2)) {
12782 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_SetStyleTable" "', argument " "2"" of type '" "OGRStyleTableShadow *""'");
12783 : }
12784 2 : arg2 = reinterpret_cast< OGRStyleTableShadow * >(argp2);
12785 2 : {
12786 2 : const int bLocalUseExceptions = GetUseExceptions();
12787 2 : if ( bLocalUseExceptions ) {
12788 2 : pushErrorHandler();
12789 : }
12790 2 : {
12791 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12792 2 : OGRLayerShadow_SetStyleTable(arg1,arg2);
12793 2 : SWIG_PYTHON_THREAD_END_ALLOW;
12794 : }
12795 2 : if ( bLocalUseExceptions ) {
12796 2 : popErrorHandler();
12797 : }
12798 : #ifndef SED_HACKS
12799 : if ( bLocalUseExceptions ) {
12800 : CPLErr eclass = CPLGetLastErrorType();
12801 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12802 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12803 : }
12804 : }
12805 : #endif
12806 : }
12807 2 : resultobj = SWIG_Py_Void();
12808 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
12809 : return resultobj;
12810 : fail:
12811 : return NULL;
12812 : }
12813 :
12814 :
12815 16 : SWIGINTERN PyObject *_wrap_Layer_ExportArrowArrayStreamPyCapsule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12816 16 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12817 16 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12818 16 : char **arg2 = (char **) NULL ;
12819 16 : void *argp1 = 0 ;
12820 16 : int res1 = 0 ;
12821 16 : PyObject *swig_obj[2] ;
12822 16 : PyObject *result = 0 ;
12823 :
12824 16 : if (!SWIG_Python_UnpackTuple(args, "Layer_ExportArrowArrayStreamPyCapsule", 1, 2, swig_obj)) SWIG_fail;
12825 16 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12826 16 : if (!SWIG_IsOK(res1)) {
12827 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_ExportArrowArrayStreamPyCapsule" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12828 : }
12829 16 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12830 16 : if (swig_obj[1]) {
12831 1 : {
12832 : /* %typemap(in) char **dict */
12833 1 : arg2 = NULL;
12834 1 : if ( PySequence_Check( swig_obj[1] ) ) {
12835 0 : int bErr = FALSE;
12836 0 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
12837 0 : if ( bErr )
12838 : {
12839 0 : SWIG_fail;
12840 : }
12841 : }
12842 1 : else if ( PyMapping_Check( swig_obj[1] ) ) {
12843 1 : int bErr = FALSE;
12844 1 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
12845 1 : if ( bErr )
12846 : {
12847 0 : SWIG_fail;
12848 : }
12849 : }
12850 : else {
12851 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
12852 0 : SWIG_fail;
12853 : }
12854 : }
12855 : }
12856 16 : {
12857 16 : const int bLocalUseExceptions = GetUseExceptions();
12858 16 : if ( bLocalUseExceptions ) {
12859 16 : pushErrorHandler();
12860 : }
12861 16 : {
12862 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12863 16 : result = (PyObject *)OGRLayerShadow_ExportArrowArrayStreamPyCapsule(arg1,arg2);
12864 16 : SWIG_PYTHON_THREAD_END_ALLOW;
12865 : }
12866 16 : if ( bLocalUseExceptions ) {
12867 16 : popErrorHandler();
12868 : }
12869 : #ifndef SED_HACKS
12870 : if ( bLocalUseExceptions ) {
12871 : CPLErr eclass = CPLGetLastErrorType();
12872 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12873 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12874 : }
12875 : }
12876 : #endif
12877 : }
12878 16 : resultobj = result;
12879 16 : {
12880 : /* %typemap(freearg) char **dict */
12881 16 : CSLDestroy( arg2 );
12882 : }
12883 17 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
12884 : return resultobj;
12885 0 : fail:
12886 0 : {
12887 : /* %typemap(freearg) char **dict */
12888 0 : CSLDestroy( arg2 );
12889 : }
12890 : return NULL;
12891 : }
12892 :
12893 :
12894 345 : SWIGINTERN PyObject *_wrap_Layer_GetArrowStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12895 345 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12896 345 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12897 345 : char **arg2 = (char **) NULL ;
12898 345 : void *argp1 = 0 ;
12899 345 : int res1 = 0 ;
12900 345 : PyObject *swig_obj[2] ;
12901 345 : ArrowArrayStream *result = 0 ;
12902 :
12903 345 : if (!SWIG_Python_UnpackTuple(args, "Layer_GetArrowStream", 1, 2, swig_obj)) SWIG_fail;
12904 345 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12905 345 : if (!SWIG_IsOK(res1)) {
12906 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetArrowStream" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12907 : }
12908 345 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12909 345 : if (swig_obj[1]) {
12910 318 : {
12911 : /* %typemap(in) char **dict */
12912 318 : arg2 = NULL;
12913 318 : if ( PySequence_Check( swig_obj[1] ) ) {
12914 318 : int bErr = FALSE;
12915 318 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
12916 318 : if ( bErr )
12917 : {
12918 0 : SWIG_fail;
12919 : }
12920 : }
12921 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
12922 0 : int bErr = FALSE;
12923 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
12924 0 : if ( bErr )
12925 : {
12926 0 : SWIG_fail;
12927 : }
12928 : }
12929 : else {
12930 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
12931 0 : SWIG_fail;
12932 : }
12933 : }
12934 : }
12935 345 : {
12936 345 : const int bLocalUseExceptions = GetUseExceptions();
12937 345 : if ( bLocalUseExceptions ) {
12938 231 : pushErrorHandler();
12939 : }
12940 345 : {
12941 345 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12942 345 : result = (ArrowArrayStream *)OGRLayerShadow_GetArrowStream(arg1,arg2);
12943 345 : SWIG_PYTHON_THREAD_END_ALLOW;
12944 : }
12945 345 : if ( bLocalUseExceptions ) {
12946 231 : popErrorHandler();
12947 : }
12948 : #ifndef SED_HACKS
12949 : if ( bLocalUseExceptions ) {
12950 : CPLErr eclass = CPLGetLastErrorType();
12951 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12952 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12953 : }
12954 : }
12955 : #endif
12956 : }
12957 345 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ArrowArrayStream, SWIG_POINTER_OWN | 0 );
12958 345 : {
12959 : /* %typemap(freearg) char **dict */
12960 345 : CSLDestroy( arg2 );
12961 : }
12962 345 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
12963 : return resultobj;
12964 0 : fail:
12965 0 : {
12966 : /* %typemap(freearg) char **dict */
12967 0 : CSLDestroy( arg2 );
12968 : }
12969 : return NULL;
12970 : }
12971 :
12972 :
12973 19 : SWIGINTERN PyObject *_wrap_Layer_IsArrowSchemaSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12974 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12975 19 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
12976 19 : ArrowSchema *arg2 = (ArrowSchema *) 0 ;
12977 19 : bool *arg3 = (bool *) 0 ;
12978 19 : char **arg4 = (char **) 0 ;
12979 19 : char **arg5 = (char **) NULL ;
12980 19 : void *argp1 = 0 ;
12981 19 : int res1 = 0 ;
12982 19 : void *argp2 = 0 ;
12983 19 : int res2 = 0 ;
12984 19 : bool ret3 ;
12985 19 : char *errorMsg3 ;
12986 19 : PyObject *swig_obj[3] ;
12987 :
12988 19 : {
12989 : /* %typemap(in,numinputs=0) (bool* pbRet, char **errorMsg3) */
12990 19 : arg3 = &ret3;
12991 19 : arg4 = &errorMsg3;
12992 : }
12993 19 : if (!SWIG_Python_UnpackTuple(args, "Layer_IsArrowSchemaSupported", 2, 3, swig_obj)) SWIG_fail;
12994 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
12995 19 : if (!SWIG_IsOK(res1)) {
12996 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_IsArrowSchemaSupported" "', argument " "1"" of type '" "OGRLayerShadow *""'");
12997 : }
12998 19 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
12999 19 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ArrowSchema, 0 | 0 );
13000 19 : if (!SWIG_IsOK(res2)) {
13001 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_IsArrowSchemaSupported" "', argument " "2"" of type '" "ArrowSchema const *""'");
13002 : }
13003 19 : arg2 = reinterpret_cast< ArrowSchema * >(argp2);
13004 19 : if (swig_obj[2]) {
13005 3 : {
13006 : /* %typemap(in) char **dict */
13007 3 : arg5 = NULL;
13008 3 : if ( PySequence_Check( swig_obj[2] ) ) {
13009 3 : int bErr = FALSE;
13010 3 : arg5 = CSLFromPySequence(swig_obj[2], &bErr);
13011 3 : if ( bErr )
13012 : {
13013 0 : SWIG_fail;
13014 : }
13015 : }
13016 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
13017 0 : int bErr = FALSE;
13018 0 : arg5 = CSLFromPyMapping(swig_obj[2], &bErr);
13019 0 : if ( bErr )
13020 : {
13021 0 : SWIG_fail;
13022 : }
13023 : }
13024 : else {
13025 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
13026 0 : SWIG_fail;
13027 : }
13028 : }
13029 : }
13030 19 : {
13031 19 : const int bLocalUseExceptions = GetUseExceptions();
13032 19 : if ( bLocalUseExceptions ) {
13033 19 : pushErrorHandler();
13034 : }
13035 19 : {
13036 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13037 19 : OGRLayerShadow_IsArrowSchemaSupported(arg1,(ArrowSchema const *)arg2,arg3,arg4,arg5);
13038 19 : SWIG_PYTHON_THREAD_END_ALLOW;
13039 : }
13040 19 : if ( bLocalUseExceptions ) {
13041 19 : popErrorHandler();
13042 : }
13043 : #ifndef SED_HACKS
13044 : if ( bLocalUseExceptions ) {
13045 : CPLErr eclass = CPLGetLastErrorType();
13046 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13047 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13048 : }
13049 : }
13050 : #endif
13051 : }
13052 19 : resultobj = SWIG_Py_Void();
13053 19 : {
13054 : /* %typemap(argout) (bool* pbRet, char **errorMsg)*/
13055 19 : Py_DECREF(resultobj);
13056 19 : resultobj = PyTuple_New(2);
13057 19 : PyTuple_SetItem(resultobj, 0, PyBool_FromLong(*arg3));
13058 19 : if( *arg4 )
13059 : {
13060 4 : PyTuple_SetItem(resultobj, 1, PyUnicode_FromString(*arg4));
13061 4 : VSIFree(*arg4);
13062 : }
13063 : else
13064 : {
13065 15 : PyTuple_SetItem(resultobj, 1, Py_None);
13066 15 : Py_INCREF(Py_None);
13067 : }
13068 : }
13069 19 : {
13070 : /* %typemap(freearg) char **dict */
13071 19 : CSLDestroy( arg5 );
13072 : }
13073 19 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
13074 : return resultobj;
13075 0 : fail:
13076 0 : {
13077 : /* %typemap(freearg) char **dict */
13078 0 : CSLDestroy( arg5 );
13079 : }
13080 : return NULL;
13081 : }
13082 :
13083 :
13084 524 : SWIGINTERN PyObject *_wrap_Layer_CreateFieldFromArrowSchema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13085 524 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13086 524 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
13087 524 : ArrowSchema *arg2 = (ArrowSchema *) 0 ;
13088 524 : char **arg3 = (char **) NULL ;
13089 524 : void *argp1 = 0 ;
13090 524 : int res1 = 0 ;
13091 524 : void *argp2 = 0 ;
13092 524 : int res2 = 0 ;
13093 524 : PyObject *swig_obj[3] ;
13094 524 : OGRErr result;
13095 :
13096 524 : if (!SWIG_Python_UnpackTuple(args, "Layer_CreateFieldFromArrowSchema", 2, 3, swig_obj)) SWIG_fail;
13097 524 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13098 524 : if (!SWIG_IsOK(res1)) {
13099 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_CreateFieldFromArrowSchema" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13100 : }
13101 524 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13102 524 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ArrowSchema, 0 | 0 );
13103 524 : if (!SWIG_IsOK(res2)) {
13104 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_CreateFieldFromArrowSchema" "', argument " "2"" of type '" "ArrowSchema const *""'");
13105 : }
13106 524 : arg2 = reinterpret_cast< ArrowSchema * >(argp2);
13107 524 : if (swig_obj[2]) {
13108 119 : {
13109 : /* %typemap(in) char **dict */
13110 119 : arg3 = NULL;
13111 119 : if ( PySequence_Check( swig_obj[2] ) ) {
13112 119 : int bErr = FALSE;
13113 119 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
13114 119 : if ( bErr )
13115 : {
13116 0 : SWIG_fail;
13117 : }
13118 : }
13119 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
13120 0 : int bErr = FALSE;
13121 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
13122 0 : if ( bErr )
13123 : {
13124 0 : SWIG_fail;
13125 : }
13126 : }
13127 : else {
13128 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
13129 0 : SWIG_fail;
13130 : }
13131 : }
13132 : }
13133 524 : {
13134 524 : const int bLocalUseExceptions = GetUseExceptions();
13135 524 : if ( bLocalUseExceptions ) {
13136 524 : pushErrorHandler();
13137 : }
13138 524 : {
13139 524 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13140 524 : result = (OGRErr)OGRLayerShadow_CreateFieldFromArrowSchema(arg1,(ArrowSchema const *)arg2,arg3);
13141 524 : SWIG_PYTHON_THREAD_END_ALLOW;
13142 : }
13143 524 : if ( bLocalUseExceptions ) {
13144 524 : popErrorHandler();
13145 : }
13146 : #ifndef SED_HACKS
13147 : if ( bLocalUseExceptions ) {
13148 : CPLErr eclass = CPLGetLastErrorType();
13149 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13150 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13151 : }
13152 : }
13153 : #endif
13154 : }
13155 524 : {
13156 : /* %typemap(out) OGRErr */
13157 524 : if ( result != 0 && GetUseExceptions()) {
13158 0 : const char* pszMessage = CPLGetLastErrorMsg();
13159 0 : if( pszMessage[0] != '\0' )
13160 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13161 : else
13162 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
13163 0 : SWIG_fail;
13164 : }
13165 : }
13166 524 : {
13167 : /* %typemap(freearg) char **dict */
13168 524 : CSLDestroy( arg3 );
13169 : }
13170 524 : {
13171 : /* %typemap(ret) OGRErr */
13172 524 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
13173 524 : resultobj = PyInt_FromLong( result );
13174 : }
13175 : }
13176 524 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
13177 : return resultobj;
13178 0 : fail:
13179 0 : {
13180 : /* %typemap(freearg) char **dict */
13181 0 : CSLDestroy( arg3 );
13182 : }
13183 : return NULL;
13184 : }
13185 :
13186 :
13187 46 : SWIGINTERN PyObject *_wrap_Layer_WriteArrowBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13188 46 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13189 46 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
13190 46 : ArrowSchema *arg2 = (ArrowSchema *) 0 ;
13191 46 : ArrowArray *arg3 = (ArrowArray *) 0 ;
13192 46 : char **arg4 = (char **) NULL ;
13193 46 : void *argp1 = 0 ;
13194 46 : int res1 = 0 ;
13195 46 : void *argp2 = 0 ;
13196 46 : int res2 = 0 ;
13197 46 : void *argp3 = 0 ;
13198 46 : int res3 = 0 ;
13199 46 : PyObject *swig_obj[4] ;
13200 46 : OGRErr result;
13201 :
13202 46 : if (!SWIG_Python_UnpackTuple(args, "Layer_WriteArrowBatch", 3, 4, swig_obj)) SWIG_fail;
13203 46 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13204 46 : if (!SWIG_IsOK(res1)) {
13205 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_WriteArrowBatch" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13206 : }
13207 46 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13208 46 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ArrowSchema, 0 | 0 );
13209 46 : if (!SWIG_IsOK(res2)) {
13210 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Layer_WriteArrowBatch" "', argument " "2"" of type '" "ArrowSchema const *""'");
13211 : }
13212 46 : arg2 = reinterpret_cast< ArrowSchema * >(argp2);
13213 46 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ArrowArray, 0 | 0 );
13214 46 : if (!SWIG_IsOK(res3)) {
13215 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_WriteArrowBatch" "', argument " "3"" of type '" "ArrowArray *""'");
13216 : }
13217 46 : arg3 = reinterpret_cast< ArrowArray * >(argp3);
13218 46 : if (swig_obj[3]) {
13219 23 : {
13220 : /* %typemap(in) char **dict */
13221 23 : arg4 = NULL;
13222 23 : if ( PySequence_Check( swig_obj[3] ) ) {
13223 11 : int bErr = FALSE;
13224 11 : arg4 = CSLFromPySequence(swig_obj[3], &bErr);
13225 11 : if ( bErr )
13226 : {
13227 0 : SWIG_fail;
13228 : }
13229 : }
13230 12 : else if ( PyMapping_Check( swig_obj[3] ) ) {
13231 12 : int bErr = FALSE;
13232 12 : arg4 = CSLFromPyMapping(swig_obj[3], &bErr);
13233 12 : if ( bErr )
13234 : {
13235 0 : SWIG_fail;
13236 : }
13237 : }
13238 : else {
13239 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
13240 0 : SWIG_fail;
13241 : }
13242 : }
13243 : }
13244 46 : {
13245 46 : const int bLocalUseExceptions = GetUseExceptions();
13246 46 : if ( bLocalUseExceptions ) {
13247 46 : pushErrorHandler();
13248 : }
13249 46 : {
13250 46 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13251 46 : result = (OGRErr)OGRLayerShadow_WriteArrowBatch(arg1,(ArrowSchema const *)arg2,arg3,arg4);
13252 46 : SWIG_PYTHON_THREAD_END_ALLOW;
13253 : }
13254 46 : if ( bLocalUseExceptions ) {
13255 46 : popErrorHandler();
13256 : }
13257 : #ifndef SED_HACKS
13258 : if ( bLocalUseExceptions ) {
13259 : CPLErr eclass = CPLGetLastErrorType();
13260 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13261 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13262 : }
13263 : }
13264 : #endif
13265 : }
13266 46 : {
13267 : /* %typemap(out) OGRErr */
13268 57 : if ( result != 0 && GetUseExceptions()) {
13269 11 : const char* pszMessage = CPLGetLastErrorMsg();
13270 11 : if( pszMessage[0] != '\0' )
13271 11 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13272 : else
13273 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
13274 11 : SWIG_fail;
13275 : }
13276 : }
13277 35 : {
13278 : /* %typemap(freearg) char **dict */
13279 35 : CSLDestroy( arg4 );
13280 : }
13281 35 : {
13282 : /* %typemap(ret) OGRErr */
13283 35 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
13284 35 : resultobj = PyInt_FromLong( result );
13285 : }
13286 : }
13287 46 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
13288 : return resultobj;
13289 11 : fail:
13290 11 : {
13291 : /* %typemap(freearg) char **dict */
13292 11 : CSLDestroy( arg4 );
13293 : }
13294 : return NULL;
13295 : }
13296 :
13297 :
13298 12 : SWIGINTERN PyObject *_wrap_Layer_WriteArrowStreamCapsule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13299 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13300 12 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
13301 12 : PyObject *arg2 = (PyObject *) 0 ;
13302 12 : int arg3 ;
13303 12 : char **arg4 = (char **) NULL ;
13304 12 : void *argp1 = 0 ;
13305 12 : int res1 = 0 ;
13306 12 : int val3 ;
13307 12 : int ecode3 = 0 ;
13308 12 : PyObject *swig_obj[4] ;
13309 12 : OGRErr result;
13310 :
13311 12 : if (!SWIG_Python_UnpackTuple(args, "Layer_WriteArrowStreamCapsule", 3, 4, swig_obj)) SWIG_fail;
13312 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13313 12 : if (!SWIG_IsOK(res1)) {
13314 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_WriteArrowStreamCapsule" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13315 : }
13316 12 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13317 12 : arg2 = swig_obj[1];
13318 12 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
13319 12 : if (!SWIG_IsOK(ecode3)) {
13320 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Layer_WriteArrowStreamCapsule" "', argument " "3"" of type '" "int""'");
13321 : }
13322 12 : arg3 = static_cast< int >(val3);
13323 12 : if (swig_obj[3]) {
13324 12 : {
13325 : /* %typemap(in) char **dict */
13326 12 : arg4 = NULL;
13327 12 : if ( PySequence_Check( swig_obj[3] ) ) {
13328 12 : int bErr = FALSE;
13329 12 : arg4 = CSLFromPySequence(swig_obj[3], &bErr);
13330 12 : if ( bErr )
13331 : {
13332 0 : SWIG_fail;
13333 : }
13334 : }
13335 0 : else if ( PyMapping_Check( swig_obj[3] ) ) {
13336 0 : int bErr = FALSE;
13337 0 : arg4 = CSLFromPyMapping(swig_obj[3], &bErr);
13338 0 : if ( bErr )
13339 : {
13340 0 : SWIG_fail;
13341 : }
13342 : }
13343 : else {
13344 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
13345 0 : SWIG_fail;
13346 : }
13347 : }
13348 : }
13349 12 : {
13350 12 : const int bLocalUseExceptions = GetUseExceptions();
13351 12 : if ( bLocalUseExceptions ) {
13352 12 : pushErrorHandler();
13353 : }
13354 12 : {
13355 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13356 12 : result = (OGRErr)OGRLayerShadow_WriteArrowStreamCapsule(arg1,arg2,arg3,arg4);
13357 12 : SWIG_PYTHON_THREAD_END_ALLOW;
13358 : }
13359 12 : if ( bLocalUseExceptions ) {
13360 12 : popErrorHandler();
13361 : }
13362 : #ifndef SED_HACKS
13363 : if ( bLocalUseExceptions ) {
13364 : CPLErr eclass = CPLGetLastErrorType();
13365 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13366 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13367 : }
13368 : }
13369 : #endif
13370 : }
13371 12 : {
13372 : /* %typemap(out) OGRErr */
13373 12 : if ( result != 0 && GetUseExceptions()) {
13374 0 : const char* pszMessage = CPLGetLastErrorMsg();
13375 0 : if( pszMessage[0] != '\0' )
13376 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13377 : else
13378 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
13379 0 : SWIG_fail;
13380 : }
13381 : }
13382 12 : {
13383 : /* %typemap(freearg) char **dict */
13384 12 : CSLDestroy( arg4 );
13385 : }
13386 12 : {
13387 : /* %typemap(ret) OGRErr */
13388 12 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
13389 12 : resultobj = PyInt_FromLong( result );
13390 : }
13391 : }
13392 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
13393 : return resultobj;
13394 0 : fail:
13395 0 : {
13396 : /* %typemap(freearg) char **dict */
13397 0 : CSLDestroy( arg4 );
13398 : }
13399 : return NULL;
13400 : }
13401 :
13402 :
13403 0 : SWIGINTERN PyObject *_wrap_Layer_WriteArrowSchemaAndArrowArrayCapsule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13404 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13405 0 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
13406 0 : PyObject *arg2 = (PyObject *) 0 ;
13407 0 : PyObject *arg3 = (PyObject *) 0 ;
13408 0 : int arg4 ;
13409 0 : char **arg5 = (char **) NULL ;
13410 0 : void *argp1 = 0 ;
13411 0 : int res1 = 0 ;
13412 0 : int val4 ;
13413 0 : int ecode4 = 0 ;
13414 0 : PyObject *swig_obj[5] ;
13415 0 : OGRErr result;
13416 :
13417 0 : if (!SWIG_Python_UnpackTuple(args, "Layer_WriteArrowSchemaAndArrowArrayCapsule", 4, 5, swig_obj)) SWIG_fail;
13418 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13419 0 : if (!SWIG_IsOK(res1)) {
13420 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_WriteArrowSchemaAndArrowArrayCapsule" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13421 : }
13422 0 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13423 0 : arg2 = swig_obj[1];
13424 0 : arg3 = swig_obj[2];
13425 0 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
13426 0 : if (!SWIG_IsOK(ecode4)) {
13427 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_WriteArrowSchemaAndArrowArrayCapsule" "', argument " "4"" of type '" "int""'");
13428 : }
13429 0 : arg4 = static_cast< int >(val4);
13430 0 : if (swig_obj[4]) {
13431 0 : {
13432 : /* %typemap(in) char **dict */
13433 0 : arg5 = NULL;
13434 0 : if ( PySequence_Check( swig_obj[4] ) ) {
13435 0 : int bErr = FALSE;
13436 0 : arg5 = CSLFromPySequence(swig_obj[4], &bErr);
13437 0 : if ( bErr )
13438 : {
13439 0 : SWIG_fail;
13440 : }
13441 : }
13442 0 : else if ( PyMapping_Check( swig_obj[4] ) ) {
13443 0 : int bErr = FALSE;
13444 0 : arg5 = CSLFromPyMapping(swig_obj[4], &bErr);
13445 0 : if ( bErr )
13446 : {
13447 0 : SWIG_fail;
13448 : }
13449 : }
13450 : else {
13451 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
13452 0 : SWIG_fail;
13453 : }
13454 : }
13455 : }
13456 0 : {
13457 0 : const int bLocalUseExceptions = GetUseExceptions();
13458 0 : if ( bLocalUseExceptions ) {
13459 0 : pushErrorHandler();
13460 : }
13461 0 : {
13462 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13463 0 : result = (OGRErr)OGRLayerShadow_WriteArrowSchemaAndArrowArrayCapsule(arg1,arg2,arg3,arg4,arg5);
13464 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13465 : }
13466 0 : if ( bLocalUseExceptions ) {
13467 0 : popErrorHandler();
13468 : }
13469 : #ifndef SED_HACKS
13470 : if ( bLocalUseExceptions ) {
13471 : CPLErr eclass = CPLGetLastErrorType();
13472 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13473 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13474 : }
13475 : }
13476 : #endif
13477 : }
13478 0 : {
13479 : /* %typemap(out) OGRErr */
13480 0 : if ( result != 0 && GetUseExceptions()) {
13481 0 : const char* pszMessage = CPLGetLastErrorMsg();
13482 0 : if( pszMessage[0] != '\0' )
13483 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13484 : else
13485 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
13486 0 : SWIG_fail;
13487 : }
13488 : }
13489 0 : {
13490 : /* %typemap(freearg) char **dict */
13491 0 : CSLDestroy( arg5 );
13492 : }
13493 0 : {
13494 : /* %typemap(ret) OGRErr */
13495 0 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
13496 0 : resultobj = PyInt_FromLong( result );
13497 : }
13498 : }
13499 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
13500 : return resultobj;
13501 0 : fail:
13502 0 : {
13503 : /* %typemap(freearg) char **dict */
13504 0 : CSLDestroy( arg5 );
13505 : }
13506 : return NULL;
13507 : }
13508 :
13509 :
13510 54 : SWIGINTERN PyObject *_wrap_Layer_GetGeometryTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13511 54 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13512 54 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
13513 54 : OGRGeometryTypeCounter **arg2 = (OGRGeometryTypeCounter **) 0 ;
13514 54 : int *arg3 = (int *) 0 ;
13515 54 : int arg4 = (int) 0 ;
13516 54 : int arg5 = (int) 0 ;
13517 54 : GDALProgressFunc arg6 = (GDALProgressFunc) NULL ;
13518 54 : void *arg7 = (void *) NULL ;
13519 54 : void *argp1 = 0 ;
13520 54 : int res1 = 0 ;
13521 54 : OGRGeometryTypeCounter *pRet2 = NULL ;
13522 54 : int nEntryCount2 = 0 ;
13523 54 : int val4 ;
13524 54 : int ecode4 = 0 ;
13525 54 : int val5 ;
13526 54 : int ecode5 = 0 ;
13527 54 : PyObject * obj0 = 0 ;
13528 54 : PyObject * obj1 = 0 ;
13529 54 : PyObject * obj2 = 0 ;
13530 54 : PyObject * obj3 = 0 ;
13531 54 : PyObject * obj4 = 0 ;
13532 54 : char * kwnames[] = {
13533 : (char *)"self", (char *)"geom_field", (char *)"flags", (char *)"callback", (char *)"callback_data", NULL
13534 : };
13535 :
13536 : /* %typemap(arginit) ( const char* callback_data=NULL) */
13537 54 : PyProgressData *psProgressInfo;
13538 54 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
13539 54 : psProgressInfo->nLastReported = -1;
13540 54 : psProgressInfo->psPyCallback = NULL;
13541 54 : psProgressInfo->psPyCallbackData = NULL;
13542 54 : arg7 = psProgressInfo;
13543 54 : {
13544 : /* %typemap(in,numinputs=0) (OGRGeometryTypeCounter** ppRet, int* pnEntryCount) */
13545 54 : arg2 = &pRet2;
13546 54 : arg3 = &nEntryCount2;
13547 : }
13548 54 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOO:Layer_GetGeometryTypes", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
13549 54 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13550 54 : if (!SWIG_IsOK(res1)) {
13551 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetGeometryTypes" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13552 : }
13553 54 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13554 54 : if (obj1) {
13555 6 : ecode4 = SWIG_AsVal_int(obj1, &val4);
13556 6 : if (!SWIG_IsOK(ecode4)) {
13557 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_GetGeometryTypes" "', argument " "4"" of type '" "int""'");
13558 : }
13559 : arg4 = static_cast< int >(val4);
13560 : }
13561 54 : if (obj2) {
13562 19 : ecode5 = SWIG_AsVal_int(obj2, &val5);
13563 19 : if (!SWIG_IsOK(ecode5)) {
13564 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Layer_GetGeometryTypes" "', argument " "5"" of type '" "int""'");
13565 : }
13566 : arg5 = static_cast< int >(val5);
13567 : }
13568 54 : if (obj3) {
13569 6 : {
13570 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
13571 : /* callback_func typemap */
13572 :
13573 : /* In some cases 0 is passed instead of None. */
13574 : /* See https://github.com/OSGeo/gdal/pull/219 */
13575 6 : if ( PyLong_Check(obj3) || PyInt_Check(obj3) )
13576 : {
13577 0 : if( PyLong_AsLong(obj3) == 0 )
13578 : {
13579 0 : obj3 = Py_None;
13580 : }
13581 : }
13582 :
13583 6 : if (obj3 && obj3 != Py_None ) {
13584 6 : void* cbfunction = NULL;
13585 6 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj3,
13586 : (void**)&cbfunction,
13587 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
13588 : SWIG_POINTER_EXCEPTION | 0 ));
13589 :
13590 6 : if ( cbfunction == GDALTermProgress ) {
13591 : arg6 = GDALTermProgress;
13592 : } else {
13593 6 : if (!PyCallable_Check(obj3)) {
13594 0 : PyErr_SetString( PyExc_RuntimeError,
13595 : "Object given is not a Python function" );
13596 0 : SWIG_fail;
13597 : }
13598 6 : psProgressInfo->psPyCallback = obj3;
13599 6 : arg6 = PyProgressProxy;
13600 : }
13601 :
13602 : }
13603 :
13604 : }
13605 : }
13606 54 : if (obj4) {
13607 0 : {
13608 : /* %typemap(in) ( void* callback_data=NULL) */
13609 0 : psProgressInfo->psPyCallbackData = obj4 ;
13610 : }
13611 : }
13612 54 : {
13613 54 : const int bLocalUseExceptions = GetUseExceptions();
13614 54 : if ( bLocalUseExceptions ) {
13615 12 : pushErrorHandler();
13616 : }
13617 54 : {
13618 54 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13619 54 : OGRLayerShadow_GetGeometryTypes(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
13620 54 : SWIG_PYTHON_THREAD_END_ALLOW;
13621 : }
13622 54 : if ( bLocalUseExceptions ) {
13623 12 : popErrorHandler();
13624 : }
13625 : #ifndef SED_HACKS
13626 : if ( bLocalUseExceptions ) {
13627 : CPLErr eclass = CPLGetLastErrorType();
13628 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13629 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13630 : }
13631 : }
13632 : #endif
13633 : }
13634 54 : resultobj = SWIG_Py_Void();
13635 54 : {
13636 : /* %typemap(argout) (OGRGeometryTypeCounter** ppRet, int* pnEntryCount) */
13637 54 : Py_DECREF(resultobj);
13638 54 : int nEntryCount = *(arg3);
13639 54 : OGRGeometryTypeCounter* pRet = *(arg2);
13640 54 : if( pRet == NULL )
13641 : {
13642 6 : PyErr_SetString( PyExc_RuntimeError, CPLGetLastErrorMsg() );
13643 6 : SWIG_fail;
13644 : }
13645 48 : resultobj = PyDict_New();
13646 153 : for(int i = 0; i < nEntryCount; ++ i)
13647 : {
13648 105 : PyObject *key = PyInt_FromLong( (int)(pRet[i].eGeomType) );
13649 105 : PyObject *val = PyLong_FromLongLong( pRet[i].nCount );
13650 105 : PyDict_SetItem(resultobj, key, val );
13651 105 : Py_DECREF(key);
13652 105 : Py_DECREF(val);
13653 : }
13654 : }
13655 48 : {
13656 : /* %typemap(freearg) (OGRGeometryTypeCounter** ppRet, int* pnEntryCount) */
13657 48 : VSIFree(*arg2);
13658 : }
13659 48 : {
13660 : /* %typemap(freearg) ( void* callback_data=NULL) */
13661 :
13662 48 : CPLFree(psProgressInfo);
13663 :
13664 : }
13665 54 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
13666 : return resultobj;
13667 6 : fail:
13668 6 : {
13669 : /* %typemap(freearg) (OGRGeometryTypeCounter** ppRet, int* pnEntryCount) */
13670 6 : VSIFree(*arg2);
13671 : }
13672 6 : {
13673 : /* %typemap(freearg) ( void* callback_data=NULL) */
13674 :
13675 6 : CPLFree(psProgressInfo);
13676 :
13677 : }
13678 : return NULL;
13679 : }
13680 :
13681 :
13682 4 : SWIGINTERN PyObject *_wrap_Layer_GetSupportedSRSList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13683 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13684 4 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
13685 4 : OGRSpatialReferenceH **arg2 = (OGRSpatialReferenceH **) 0 ;
13686 4 : int *arg3 = (int *) 0 ;
13687 4 : int arg4 = (int) 0 ;
13688 4 : void *argp1 = 0 ;
13689 4 : int res1 = 0 ;
13690 4 : OGRSpatialReferenceH *pRet2 = NULL ;
13691 4 : int nEntryCount2 = 0 ;
13692 4 : int val4 ;
13693 4 : int ecode4 = 0 ;
13694 4 : PyObject * obj0 = 0 ;
13695 4 : PyObject * obj1 = 0 ;
13696 4 : char * kwnames[] = {
13697 : (char *)"self", (char *)"geom_field", NULL
13698 : };
13699 :
13700 4 : {
13701 : /* %typemap(in,numinputs=0) (OGRSpatialReferenceH** ppRet, int* pnEntryCount) */
13702 4 : arg2 = &pRet2;
13703 4 : arg3 = &nEntryCount2;
13704 : }
13705 4 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Layer_GetSupportedSRSList", kwnames, &obj0, &obj1)) SWIG_fail;
13706 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13707 4 : if (!SWIG_IsOK(res1)) {
13708 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_GetSupportedSRSList" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13709 : }
13710 4 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13711 4 : if (obj1) {
13712 0 : ecode4 = SWIG_AsVal_int(obj1, &val4);
13713 0 : if (!SWIG_IsOK(ecode4)) {
13714 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Layer_GetSupportedSRSList" "', argument " "4"" of type '" "int""'");
13715 : }
13716 : arg4 = static_cast< int >(val4);
13717 : }
13718 4 : {
13719 4 : const int bLocalUseExceptions = GetUseExceptions();
13720 4 : if ( bLocalUseExceptions ) {
13721 2 : pushErrorHandler();
13722 : }
13723 4 : {
13724 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13725 4 : OGRLayerShadow_GetSupportedSRSList(arg1,arg2,arg3,arg4);
13726 4 : SWIG_PYTHON_THREAD_END_ALLOW;
13727 : }
13728 4 : if ( bLocalUseExceptions ) {
13729 2 : popErrorHandler();
13730 : }
13731 : #ifndef SED_HACKS
13732 : if ( bLocalUseExceptions ) {
13733 : CPLErr eclass = CPLGetLastErrorType();
13734 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13735 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13736 : }
13737 : }
13738 : #endif
13739 : }
13740 4 : resultobj = SWIG_Py_Void();
13741 4 : {
13742 : /* %typemap(argout) (OGRSpatialReferenceH** ppRet, int* pnEntryCount) */
13743 4 : Py_DECREF(resultobj);
13744 4 : int nEntryCount = *(arg3);
13745 4 : OGRSpatialReferenceH* pRet = *(arg2);
13746 4 : if( nEntryCount == 0)
13747 : {
13748 2 : Py_INCREF(Py_None);
13749 2 : resultobj = Py_None;
13750 : }
13751 : else
13752 : {
13753 2 : resultobj = PyList_New(nEntryCount);
13754 2 : if( !resultobj ) {
13755 0 : SWIG_fail;
13756 : }
13757 7 : for(int i = 0; i < nEntryCount; ++ i)
13758 : {
13759 5 : OSRReference(pRet[i]);
13760 5 : PyList_SetItem(resultobj, i, SWIG_NewPointerObj(
13761 : SWIG_as_voidptr(pRet[i]),SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_OWN) );
13762 : }
13763 : }
13764 : }
13765 4 : {
13766 : /* %typemap(freearg) (OGRSpatialReferenceH** ppRet, int* pnEntryCount) */
13767 4 : OSRFreeSRSArray(*arg2);
13768 : }
13769 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
13770 : return resultobj;
13771 0 : fail:
13772 0 : {
13773 : /* %typemap(freearg) (OGRSpatialReferenceH** ppRet, int* pnEntryCount) */
13774 0 : OSRFreeSRSArray(*arg2);
13775 : }
13776 : return NULL;
13777 : }
13778 :
13779 :
13780 9 : SWIGINTERN PyObject *_wrap_Layer_SetActiveSRS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13781 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13782 9 : OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
13783 9 : int arg2 ;
13784 9 : OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) 0 ;
13785 9 : void *argp1 = 0 ;
13786 9 : int res1 = 0 ;
13787 9 : int val2 ;
13788 9 : int ecode2 = 0 ;
13789 9 : void *argp3 = 0 ;
13790 9 : int res3 = 0 ;
13791 9 : PyObject *swig_obj[3] ;
13792 9 : OGRErr result;
13793 :
13794 9 : if (!SWIG_Python_UnpackTuple(args, "Layer_SetActiveSRS", 3, 3, swig_obj)) SWIG_fail;
13795 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
13796 9 : if (!SWIG_IsOK(res1)) {
13797 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Layer_SetActiveSRS" "', argument " "1"" of type '" "OGRLayerShadow *""'");
13798 : }
13799 9 : arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
13800 9 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13801 9 : if (!SWIG_IsOK(ecode2)) {
13802 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Layer_SetActiveSRS" "', argument " "2"" of type '" "int""'");
13803 : }
13804 9 : arg2 = static_cast< int >(val2);
13805 9 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
13806 9 : if (!SWIG_IsOK(res3)) {
13807 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Layer_SetActiveSRS" "', argument " "3"" of type '" "OSRSpatialReferenceShadow *""'");
13808 : }
13809 9 : arg3 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp3);
13810 9 : {
13811 9 : const int bLocalUseExceptions = GetUseExceptions();
13812 9 : if ( bLocalUseExceptions ) {
13813 4 : pushErrorHandler();
13814 : }
13815 9 : {
13816 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13817 9 : result = (OGRErr)OGRLayerShadow_SetActiveSRS(arg1,arg2,arg3);
13818 9 : SWIG_PYTHON_THREAD_END_ALLOW;
13819 : }
13820 9 : if ( bLocalUseExceptions ) {
13821 4 : popErrorHandler();
13822 : }
13823 : #ifndef SED_HACKS
13824 : if ( bLocalUseExceptions ) {
13825 : CPLErr eclass = CPLGetLastErrorType();
13826 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13827 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13828 : }
13829 : }
13830 : #endif
13831 : }
13832 9 : {
13833 : /* %typemap(out) OGRErr */
13834 14 : if ( result != 0 && GetUseExceptions()) {
13835 2 : const char* pszMessage = CPLGetLastErrorMsg();
13836 2 : if( pszMessage[0] != '\0' )
13837 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13838 : else
13839 2 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
13840 2 : SWIG_fail;
13841 : }
13842 : }
13843 7 : {
13844 : /* %typemap(ret) OGRErr */
13845 7 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
13846 7 : resultobj = PyInt_FromLong( result );
13847 : }
13848 : }
13849 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
13850 : return resultobj;
13851 : fail:
13852 : return NULL;
13853 : }
13854 :
13855 :
13856 275 : SWIGINTERN PyObject *Layer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13857 275 : PyObject *obj;
13858 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
13859 275 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRLayerShadow, SWIG_NewClientData(obj));
13860 275 : return SWIG_Py_Void();
13861 : }
13862 :
13863 202158 : SWIGINTERN PyObject *_wrap_delete_Feature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13864 202158 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13865 202158 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
13866 202158 : void *argp1 = 0 ;
13867 202158 : int res1 = 0 ;
13868 202158 : PyObject *swig_obj[1] ;
13869 :
13870 202158 : if (!args) SWIG_fail;
13871 202158 : swig_obj[0] = args;
13872 202158 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_DISOWN | 0 );
13873 202158 : if (!SWIG_IsOK(res1)) {
13874 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Feature" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
13875 : }
13876 202158 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
13877 202158 : {
13878 202158 : const int bLocalUseExceptions = GetUseExceptions();
13879 202158 : if ( bLocalUseExceptions ) {
13880 112396 : pushErrorHandler();
13881 : }
13882 202158 : {
13883 202158 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13884 202158 : delete_OGRFeatureShadow(arg1);
13885 202158 : SWIG_PYTHON_THREAD_END_ALLOW;
13886 : }
13887 202158 : if ( bLocalUseExceptions ) {
13888 112396 : popErrorHandler();
13889 : }
13890 : #ifndef SED_HACKS
13891 : if ( bLocalUseExceptions ) {
13892 : CPLErr eclass = CPLGetLastErrorType();
13893 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13894 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13895 : }
13896 : }
13897 : #endif
13898 : }
13899 202158 : resultobj = SWIG_Py_Void();
13900 202158 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
13901 : return resultobj;
13902 : fail:
13903 : return NULL;
13904 : }
13905 :
13906 :
13907 121863 : SWIGINTERN PyObject *_wrap_new_Feature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13908 121863 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13909 121863 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
13910 121863 : void *argp1 = 0 ;
13911 121863 : int res1 = 0 ;
13912 121863 : PyObject * obj0 = 0 ;
13913 121863 : char * kwnames[] = {
13914 : (char *)"feature_def", NULL
13915 : };
13916 121863 : OGRFeatureShadow *result = 0 ;
13917 :
13918 121863 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_Feature", kwnames, &obj0)) SWIG_fail;
13919 121863 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
13920 121863 : if (!SWIG_IsOK(res1)) {
13921 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Feature" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
13922 : }
13923 121863 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
13924 121863 : {
13925 121863 : if (!arg1) {
13926 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
13927 : }
13928 : }
13929 121863 : {
13930 121863 : const int bLocalUseExceptions = GetUseExceptions();
13931 121863 : if ( bLocalUseExceptions ) {
13932 61471 : pushErrorHandler();
13933 : }
13934 121863 : {
13935 121863 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13936 121863 : result = (OGRFeatureShadow *)new_OGRFeatureShadow(arg1);
13937 121863 : SWIG_PYTHON_THREAD_END_ALLOW;
13938 : }
13939 121863 : if ( bLocalUseExceptions ) {
13940 61471 : popErrorHandler();
13941 : }
13942 : #ifndef SED_HACKS
13943 : if ( bLocalUseExceptions ) {
13944 : CPLErr eclass = CPLGetLastErrorType();
13945 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13946 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13947 : }
13948 : }
13949 : #endif
13950 : }
13951 121863 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_NEW | 0 );
13952 121863 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
13953 : return resultobj;
13954 : fail:
13955 : return NULL;
13956 : }
13957 :
13958 :
13959 47755 : SWIGINTERN PyObject *_wrap_Feature_GetDefnRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13960 47755 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13961 47755 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
13962 47755 : void *argp1 = 0 ;
13963 47755 : int res1 = 0 ;
13964 47755 : PyObject *swig_obj[1] ;
13965 47755 : OGRFeatureDefnShadow *result = 0 ;
13966 :
13967 47755 : if (!args) SWIG_fail;
13968 47755 : swig_obj[0] = args;
13969 47755 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
13970 47755 : if (!SWIG_IsOK(res1)) {
13971 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetDefnRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
13972 : }
13973 47755 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
13974 47755 : {
13975 47755 : const int bLocalUseExceptions = GetUseExceptions();
13976 47755 : if ( bLocalUseExceptions ) {
13977 21513 : pushErrorHandler();
13978 : }
13979 47755 : {
13980 47755 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13981 47755 : result = (OGRFeatureDefnShadow *)OGRFeatureShadow_GetDefnRef(arg1);
13982 47755 : SWIG_PYTHON_THREAD_END_ALLOW;
13983 : }
13984 47755 : if ( bLocalUseExceptions ) {
13985 21513 : popErrorHandler();
13986 : }
13987 : #ifndef SED_HACKS
13988 : if ( bLocalUseExceptions ) {
13989 : CPLErr eclass = CPLGetLastErrorType();
13990 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13991 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13992 : }
13993 : }
13994 : #endif
13995 : }
13996 47755 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
13997 47755 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
13998 : return resultobj;
13999 : fail:
14000 : return NULL;
14001 : }
14002 :
14003 :
14004 236668 : SWIGINTERN PyObject *_wrap_Feature_SetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14005 236668 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14006 236668 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14007 236668 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
14008 236668 : void *argp1 = 0 ;
14009 236668 : int res1 = 0 ;
14010 236668 : void *argp2 = 0 ;
14011 236668 : int res2 = 0 ;
14012 236668 : PyObject *swig_obj[2] ;
14013 236668 : OGRErr result;
14014 :
14015 236668 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetGeometry", 2, 2, swig_obj)) SWIG_fail;
14016 236668 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14017 236668 : if (!SWIG_IsOK(res1)) {
14018 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetGeometry" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14019 : }
14020 236668 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14021 236668 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
14022 236668 : if (!SWIG_IsOK(res2)) {
14023 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_SetGeometry" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
14024 : }
14025 236668 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
14026 236668 : {
14027 236668 : const int bLocalUseExceptions = GetUseExceptions();
14028 236668 : if ( bLocalUseExceptions ) {
14029 218075 : pushErrorHandler();
14030 : }
14031 236668 : {
14032 236668 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14033 236668 : result = (OGRErr)OGRFeatureShadow_SetGeometry(arg1,arg2);
14034 236668 : SWIG_PYTHON_THREAD_END_ALLOW;
14035 : }
14036 236668 : if ( bLocalUseExceptions ) {
14037 218075 : popErrorHandler();
14038 : }
14039 : #ifndef SED_HACKS
14040 : if ( bLocalUseExceptions ) {
14041 : CPLErr eclass = CPLGetLastErrorType();
14042 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14043 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14044 : }
14045 : }
14046 : #endif
14047 : }
14048 236668 : {
14049 : /* %typemap(out) OGRErr */
14050 236670 : if ( result != 0 && GetUseExceptions()) {
14051 0 : const char* pszMessage = CPLGetLastErrorMsg();
14052 0 : if( pszMessage[0] != '\0' )
14053 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
14054 : else
14055 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
14056 0 : SWIG_fail;
14057 : }
14058 : }
14059 236668 : {
14060 : /* %typemap(ret) OGRErr */
14061 236668 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
14062 236668 : resultobj = PyInt_FromLong( result );
14063 : }
14064 : }
14065 236668 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
14066 : return resultobj;
14067 : fail:
14068 : return NULL;
14069 : }
14070 :
14071 :
14072 33929 : SWIGINTERN PyObject *_wrap_Feature_SetGeometryDirectly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14073 33929 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14074 33929 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14075 33929 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
14076 33929 : void *argp1 = 0 ;
14077 33929 : int res1 = 0 ;
14078 33929 : int res2 = 0 ;
14079 33929 : PyObject *swig_obj[2] ;
14080 33929 : OGRErr result;
14081 :
14082 33929 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetGeometryDirectly", 2, 2, swig_obj)) SWIG_fail;
14083 33929 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14084 33929 : if (!SWIG_IsOK(res1)) {
14085 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetGeometryDirectly" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14086 : }
14087 33929 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14088 33929 : res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN | 0 );
14089 33929 : if (!SWIG_IsOK(res2)) {
14090 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_SetGeometryDirectly" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
14091 : }
14092 33929 : {
14093 33929 : const int bLocalUseExceptions = GetUseExceptions();
14094 33929 : if ( bLocalUseExceptions ) {
14095 1050 : pushErrorHandler();
14096 : }
14097 33929 : {
14098 33929 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14099 33929 : result = (OGRErr)OGRFeatureShadow_SetGeometryDirectly(arg1,arg2);
14100 33929 : SWIG_PYTHON_THREAD_END_ALLOW;
14101 : }
14102 33929 : if ( bLocalUseExceptions ) {
14103 1050 : popErrorHandler();
14104 : }
14105 : #ifndef SED_HACKS
14106 : if ( bLocalUseExceptions ) {
14107 : CPLErr eclass = CPLGetLastErrorType();
14108 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14109 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14110 : }
14111 : }
14112 : #endif
14113 : }
14114 33929 : {
14115 : /* %typemap(out) OGRErr */
14116 33930 : if ( result != 0 && GetUseExceptions()) {
14117 0 : const char* pszMessage = CPLGetLastErrorMsg();
14118 0 : if( pszMessage[0] != '\0' )
14119 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
14120 : else
14121 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
14122 0 : SWIG_fail;
14123 : }
14124 : }
14125 33929 : {
14126 : /* %typemap(ret) OGRErr */
14127 33929 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
14128 33929 : resultobj = PyInt_FromLong( result );
14129 : }
14130 : }
14131 33929 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
14132 : return resultobj;
14133 : fail:
14134 : return NULL;
14135 : }
14136 :
14137 :
14138 38305 : SWIGINTERN PyObject *_wrap_Feature_GetGeometryRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14139 38305 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14140 38305 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14141 38305 : void *argp1 = 0 ;
14142 38305 : int res1 = 0 ;
14143 38305 : PyObject *swig_obj[1] ;
14144 38305 : OGRGeometryShadow *result = 0 ;
14145 :
14146 38305 : if (!args) SWIG_fail;
14147 38305 : swig_obj[0] = args;
14148 38305 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14149 38305 : if (!SWIG_IsOK(res1)) {
14150 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetGeometryRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14151 : }
14152 38305 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14153 38305 : {
14154 38305 : const int bLocalUseExceptions = GetUseExceptions();
14155 38305 : if ( bLocalUseExceptions ) {
14156 32974 : pushErrorHandler();
14157 : }
14158 38305 : {
14159 38305 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14160 38305 : result = (OGRGeometryShadow *)OGRFeatureShadow_GetGeometryRef(arg1);
14161 38305 : SWIG_PYTHON_THREAD_END_ALLOW;
14162 : }
14163 38305 : if ( bLocalUseExceptions ) {
14164 32974 : popErrorHandler();
14165 : }
14166 : #ifndef SED_HACKS
14167 : if ( bLocalUseExceptions ) {
14168 : CPLErr eclass = CPLGetLastErrorType();
14169 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14170 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14171 : }
14172 : }
14173 : #endif
14174 : }
14175 38305 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
14176 38305 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
14177 : return resultobj;
14178 : fail:
14179 : return NULL;
14180 : }
14181 :
14182 :
14183 : SWIGINTERN PyObject *_wrap_Feature_SetGeomField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14184 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14185 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14186 : int arg2 ;
14187 : OGRGeometryShadow *arg3 = (OGRGeometryShadow *) 0 ;
14188 : void *argp1 = 0 ;
14189 : int res1 = 0 ;
14190 : int val2 ;
14191 : int ecode2 = 0 ;
14192 : void *argp3 = 0 ;
14193 : int res3 = 0 ;
14194 : OGRErr result;
14195 :
14196 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
14197 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14198 : if (!SWIG_IsOK(res1)) {
14199 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetGeomField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14200 : }
14201 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14202 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14203 : if (!SWIG_IsOK(ecode2)) {
14204 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetGeomField" "', argument " "2"" of type '" "int""'");
14205 : }
14206 : arg2 = static_cast< int >(val2);
14207 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
14208 : if (!SWIG_IsOK(res3)) {
14209 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Feature_SetGeomField" "', argument " "3"" of type '" "OGRGeometryShadow *""'");
14210 : }
14211 : arg3 = reinterpret_cast< OGRGeometryShadow * >(argp3);
14212 : {
14213 : const int bLocalUseExceptions = GetUseExceptions();
14214 : if ( bLocalUseExceptions ) {
14215 : pushErrorHandler();
14216 : }
14217 : {
14218 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14219 : result = (OGRErr)OGRFeatureShadow_SetGeomField__SWIG_0(arg1,arg2,arg3);
14220 : SWIG_PYTHON_THREAD_END_ALLOW;
14221 : }
14222 : if ( bLocalUseExceptions ) {
14223 : popErrorHandler();
14224 : }
14225 : #ifndef SED_HACKS
14226 : if ( bLocalUseExceptions ) {
14227 : CPLErr eclass = CPLGetLastErrorType();
14228 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14229 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14230 : }
14231 : }
14232 : #endif
14233 : }
14234 : {
14235 : /* %typemap(out) OGRErr */
14236 : if ( result != 0 && GetUseExceptions()) {
14237 : const char* pszMessage = CPLGetLastErrorMsg();
14238 : if( pszMessage[0] != '\0' )
14239 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
14240 : else
14241 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
14242 : SWIG_fail;
14243 : }
14244 : }
14245 : {
14246 : /* %typemap(ret) OGRErr */
14247 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
14248 : resultobj = PyInt_FromLong( result );
14249 : }
14250 : }
14251 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
14252 : return resultobj;
14253 : fail:
14254 : return NULL;
14255 : }
14256 :
14257 :
14258 : SWIGINTERN PyObject *_wrap_Feature_SetGeomField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14259 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14260 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14261 : char *arg2 = (char *) 0 ;
14262 : OGRGeometryShadow *arg3 = (OGRGeometryShadow *) 0 ;
14263 : void *argp1 = 0 ;
14264 : int res1 = 0 ;
14265 : int bToFree2 = 0 ;
14266 : void *argp3 = 0 ;
14267 : int res3 = 0 ;
14268 : OGRErr result;
14269 :
14270 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
14271 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14272 : if (!SWIG_IsOK(res1)) {
14273 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetGeomField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14274 : }
14275 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14276 : {
14277 : /* %typemap(in) (const char *utf8_path) */
14278 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
14279 : {
14280 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
14281 : }
14282 : else
14283 : {
14284 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
14285 :
14286 : }
14287 : if (arg2 == NULL)
14288 : {
14289 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
14290 : SWIG_fail;
14291 : }
14292 : }
14293 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
14294 : if (!SWIG_IsOK(res3)) {
14295 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Feature_SetGeomField" "', argument " "3"" of type '" "OGRGeometryShadow *""'");
14296 : }
14297 : arg3 = reinterpret_cast< OGRGeometryShadow * >(argp3);
14298 : {
14299 : const int bLocalUseExceptions = GetUseExceptions();
14300 : if ( bLocalUseExceptions ) {
14301 : pushErrorHandler();
14302 : }
14303 : {
14304 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14305 : result = (OGRErr)OGRFeatureShadow_SetGeomField__SWIG_1(arg1,(char const *)arg2,arg3);
14306 : SWIG_PYTHON_THREAD_END_ALLOW;
14307 : }
14308 : if ( bLocalUseExceptions ) {
14309 : popErrorHandler();
14310 : }
14311 : #ifndef SED_HACKS
14312 : if ( bLocalUseExceptions ) {
14313 : CPLErr eclass = CPLGetLastErrorType();
14314 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14315 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14316 : }
14317 : }
14318 : #endif
14319 : }
14320 : {
14321 : /* %typemap(out) OGRErr */
14322 : if ( result != 0 && GetUseExceptions()) {
14323 : const char* pszMessage = CPLGetLastErrorMsg();
14324 : if( pszMessage[0] != '\0' )
14325 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
14326 : else
14327 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
14328 : SWIG_fail;
14329 : }
14330 : }
14331 : {
14332 : /* %typemap(freearg) (const char *utf8_path) */
14333 : GDALPythonFreeCStr(arg2, bToFree2);
14334 : }
14335 : {
14336 : /* %typemap(ret) OGRErr */
14337 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
14338 : resultobj = PyInt_FromLong( result );
14339 : }
14340 : }
14341 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
14342 : return resultobj;
14343 : fail:
14344 : {
14345 : /* %typemap(freearg) (const char *utf8_path) */
14346 : GDALPythonFreeCStr(arg2, bToFree2);
14347 : }
14348 : return NULL;
14349 : }
14350 :
14351 :
14352 221 : SWIGINTERN PyObject *_wrap_Feature_SetGeomField(PyObject *self, PyObject *args) {
14353 221 : Py_ssize_t argc;
14354 221 : PyObject *argv[4] = {
14355 : 0
14356 : };
14357 :
14358 221 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_SetGeomField", 0, 3, argv))) SWIG_fail;
14359 221 : --argc;
14360 221 : if (argc == 3) {
14361 221 : int _v;
14362 221 : void *vptr = 0;
14363 221 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
14364 222 : _v = SWIG_CheckState(res);
14365 221 : if (_v) {
14366 221 : {
14367 221 : int res = SWIG_AsVal_int(argv[1], NULL);
14368 221 : _v = SWIG_CheckState(res);
14369 : }
14370 220 : if (_v) {
14371 220 : void *vptr = 0;
14372 220 : int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
14373 220 : _v = SWIG_CheckState(res);
14374 0 : if (_v) {
14375 220 : return _wrap_Feature_SetGeomField__SWIG_0(self, argc, argv);
14376 : }
14377 : }
14378 : }
14379 : }
14380 1 : if (argc == 3) {
14381 1 : int _v;
14382 1 : void *vptr = 0;
14383 1 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
14384 1 : _v = SWIG_CheckState(res);
14385 1 : if (_v) {
14386 1 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
14387 1 : _v = SWIG_CheckState(res);
14388 1 : if (_v) {
14389 1 : void *vptr = 0;
14390 1 : int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
14391 1 : _v = SWIG_CheckState(res);
14392 0 : if (_v) {
14393 1 : return _wrap_Feature_SetGeomField__SWIG_1(self, argc, argv);
14394 : }
14395 : }
14396 : }
14397 : }
14398 :
14399 0 : fail:
14400 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_SetGeomField'.\n"
14401 : " Possible C/C++ prototypes are:\n"
14402 : " OGRFeatureShadow::SetGeomField(int,OGRGeometryShadow *)\n"
14403 : " OGRFeatureShadow::SetGeomField(char const *,OGRGeometryShadow *)\n");
14404 : return 0;
14405 : }
14406 :
14407 :
14408 : SWIGINTERN PyObject *_wrap_Feature_SetGeomFieldDirectly__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14409 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14410 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14411 : int arg2 ;
14412 : OGRGeometryShadow *arg3 = (OGRGeometryShadow *) 0 ;
14413 : void *argp1 = 0 ;
14414 : int res1 = 0 ;
14415 : int val2 ;
14416 : int ecode2 = 0 ;
14417 : int res3 = 0 ;
14418 : OGRErr result;
14419 :
14420 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
14421 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14422 : if (!SWIG_IsOK(res1)) {
14423 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetGeomFieldDirectly" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14424 : }
14425 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14426 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14427 : if (!SWIG_IsOK(ecode2)) {
14428 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetGeomFieldDirectly" "', argument " "2"" of type '" "int""'");
14429 : }
14430 : arg2 = static_cast< int >(val2);
14431 : res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN | 0 );
14432 : if (!SWIG_IsOK(res3)) {
14433 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Feature_SetGeomFieldDirectly" "', argument " "3"" of type '" "OGRGeometryShadow *""'");
14434 : }
14435 : {
14436 : const int bLocalUseExceptions = GetUseExceptions();
14437 : if ( bLocalUseExceptions ) {
14438 : pushErrorHandler();
14439 : }
14440 : {
14441 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14442 : result = (OGRErr)OGRFeatureShadow_SetGeomFieldDirectly__SWIG_0(arg1,arg2,arg3);
14443 : SWIG_PYTHON_THREAD_END_ALLOW;
14444 : }
14445 : if ( bLocalUseExceptions ) {
14446 : popErrorHandler();
14447 : }
14448 : #ifndef SED_HACKS
14449 : if ( bLocalUseExceptions ) {
14450 : CPLErr eclass = CPLGetLastErrorType();
14451 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14452 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14453 : }
14454 : }
14455 : #endif
14456 : }
14457 : {
14458 : /* %typemap(out) OGRErr */
14459 : if ( result != 0 && GetUseExceptions()) {
14460 : const char* pszMessage = CPLGetLastErrorMsg();
14461 : if( pszMessage[0] != '\0' )
14462 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
14463 : else
14464 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
14465 : SWIG_fail;
14466 : }
14467 : }
14468 : {
14469 : /* %typemap(ret) OGRErr */
14470 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
14471 : resultobj = PyInt_FromLong( result );
14472 : }
14473 : }
14474 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
14475 : return resultobj;
14476 : fail:
14477 : return NULL;
14478 : }
14479 :
14480 :
14481 : SWIGINTERN PyObject *_wrap_Feature_SetGeomFieldDirectly__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14482 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14483 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14484 : char *arg2 = (char *) 0 ;
14485 : OGRGeometryShadow *arg3 = (OGRGeometryShadow *) 0 ;
14486 : void *argp1 = 0 ;
14487 : int res1 = 0 ;
14488 : int bToFree2 = 0 ;
14489 : int res3 = 0 ;
14490 : OGRErr result;
14491 :
14492 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
14493 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14494 : if (!SWIG_IsOK(res1)) {
14495 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetGeomFieldDirectly" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14496 : }
14497 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14498 : {
14499 : /* %typemap(in) (const char *utf8_path) */
14500 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
14501 : {
14502 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
14503 : }
14504 : else
14505 : {
14506 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
14507 :
14508 : }
14509 : if (arg2 == NULL)
14510 : {
14511 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
14512 : SWIG_fail;
14513 : }
14514 : }
14515 : res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN | 0 );
14516 : if (!SWIG_IsOK(res3)) {
14517 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Feature_SetGeomFieldDirectly" "', argument " "3"" of type '" "OGRGeometryShadow *""'");
14518 : }
14519 : {
14520 : const int bLocalUseExceptions = GetUseExceptions();
14521 : if ( bLocalUseExceptions ) {
14522 : pushErrorHandler();
14523 : }
14524 : {
14525 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14526 : result = (OGRErr)OGRFeatureShadow_SetGeomFieldDirectly__SWIG_1(arg1,(char const *)arg2,arg3);
14527 : SWIG_PYTHON_THREAD_END_ALLOW;
14528 : }
14529 : if ( bLocalUseExceptions ) {
14530 : popErrorHandler();
14531 : }
14532 : #ifndef SED_HACKS
14533 : if ( bLocalUseExceptions ) {
14534 : CPLErr eclass = CPLGetLastErrorType();
14535 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14536 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14537 : }
14538 : }
14539 : #endif
14540 : }
14541 : {
14542 : /* %typemap(out) OGRErr */
14543 : if ( result != 0 && GetUseExceptions()) {
14544 : const char* pszMessage = CPLGetLastErrorMsg();
14545 : if( pszMessage[0] != '\0' )
14546 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
14547 : else
14548 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
14549 : SWIG_fail;
14550 : }
14551 : }
14552 : {
14553 : /* %typemap(freearg) (const char *utf8_path) */
14554 : GDALPythonFreeCStr(arg2, bToFree2);
14555 : }
14556 : {
14557 : /* %typemap(ret) OGRErr */
14558 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
14559 : resultobj = PyInt_FromLong( result );
14560 : }
14561 : }
14562 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
14563 : return resultobj;
14564 : fail:
14565 : {
14566 : /* %typemap(freearg) (const char *utf8_path) */
14567 : GDALPythonFreeCStr(arg2, bToFree2);
14568 : }
14569 : return NULL;
14570 : }
14571 :
14572 :
14573 35 : SWIGINTERN PyObject *_wrap_Feature_SetGeomFieldDirectly(PyObject *self, PyObject *args) {
14574 35 : Py_ssize_t argc;
14575 35 : PyObject *argv[4] = {
14576 : 0
14577 : };
14578 :
14579 35 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_SetGeomFieldDirectly", 0, 3, argv))) SWIG_fail;
14580 35 : --argc;
14581 35 : if (argc == 3) {
14582 35 : int _v;
14583 35 : void *vptr = 0;
14584 35 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
14585 51 : _v = SWIG_CheckState(res);
14586 35 : if (_v) {
14587 35 : {
14588 35 : int res = SWIG_AsVal_int(argv[1], NULL);
14589 35 : _v = SWIG_CheckState(res);
14590 : }
14591 19 : if (_v) {
14592 19 : void *vptr = 0;
14593 19 : int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
14594 19 : _v = SWIG_CheckState(res);
14595 0 : if (_v) {
14596 19 : return _wrap_Feature_SetGeomFieldDirectly__SWIG_0(self, argc, argv);
14597 : }
14598 : }
14599 : }
14600 : }
14601 16 : if (argc == 3) {
14602 16 : int _v;
14603 16 : void *vptr = 0;
14604 16 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
14605 16 : _v = SWIG_CheckState(res);
14606 16 : if (_v) {
14607 16 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
14608 16 : _v = SWIG_CheckState(res);
14609 16 : if (_v) {
14610 16 : void *vptr = 0;
14611 16 : int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
14612 16 : _v = SWIG_CheckState(res);
14613 0 : if (_v) {
14614 16 : return _wrap_Feature_SetGeomFieldDirectly__SWIG_1(self, argc, argv);
14615 : }
14616 : }
14617 : }
14618 : }
14619 :
14620 0 : fail:
14621 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_SetGeomFieldDirectly'.\n"
14622 : " Possible C/C++ prototypes are:\n"
14623 : " OGRFeatureShadow::SetGeomFieldDirectly(int,OGRGeometryShadow *)\n"
14624 : " OGRFeatureShadow::SetGeomFieldDirectly(char const *,OGRGeometryShadow *)\n");
14625 : return 0;
14626 : }
14627 :
14628 :
14629 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14630 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14631 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14632 : int arg2 ;
14633 : void *argp1 = 0 ;
14634 : int res1 = 0 ;
14635 : int val2 ;
14636 : int ecode2 = 0 ;
14637 : OGRGeometryShadow *result = 0 ;
14638 :
14639 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14640 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14641 : if (!SWIG_IsOK(res1)) {
14642 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetGeomFieldRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14643 : }
14644 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14645 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14646 : if (!SWIG_IsOK(ecode2)) {
14647 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetGeomFieldRef" "', argument " "2"" of type '" "int""'");
14648 : }
14649 : arg2 = static_cast< int >(val2);
14650 : {
14651 : const int bLocalUseExceptions = GetUseExceptions();
14652 : if ( bLocalUseExceptions ) {
14653 : pushErrorHandler();
14654 : }
14655 : {
14656 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14657 : result = (OGRGeometryShadow *)OGRFeatureShadow_GetGeomFieldRef__SWIG_0(arg1,arg2);
14658 : SWIG_PYTHON_THREAD_END_ALLOW;
14659 : }
14660 : if ( bLocalUseExceptions ) {
14661 : popErrorHandler();
14662 : }
14663 : #ifndef SED_HACKS
14664 : if ( bLocalUseExceptions ) {
14665 : CPLErr eclass = CPLGetLastErrorType();
14666 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14667 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14668 : }
14669 : }
14670 : #endif
14671 : }
14672 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
14673 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
14674 : return resultobj;
14675 : fail:
14676 : return NULL;
14677 : }
14678 :
14679 :
14680 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14681 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14682 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14683 : char *arg2 = (char *) 0 ;
14684 : void *argp1 = 0 ;
14685 : int res1 = 0 ;
14686 : int bToFree2 = 0 ;
14687 : OGRGeometryShadow *result = 0 ;
14688 :
14689 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14690 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14691 : if (!SWIG_IsOK(res1)) {
14692 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetGeomFieldRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14693 : }
14694 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14695 : {
14696 : /* %typemap(in) (const char *utf8_path) */
14697 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
14698 : {
14699 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
14700 : }
14701 : else
14702 : {
14703 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
14704 :
14705 : }
14706 : if (arg2 == NULL)
14707 : {
14708 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
14709 : SWIG_fail;
14710 : }
14711 : }
14712 : {
14713 : const int bLocalUseExceptions = GetUseExceptions();
14714 : if ( bLocalUseExceptions ) {
14715 : pushErrorHandler();
14716 : }
14717 : {
14718 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14719 : result = (OGRGeometryShadow *)OGRFeatureShadow_GetGeomFieldRef__SWIG_1(arg1,(char const *)arg2);
14720 : SWIG_PYTHON_THREAD_END_ALLOW;
14721 : }
14722 : if ( bLocalUseExceptions ) {
14723 : popErrorHandler();
14724 : }
14725 : #ifndef SED_HACKS
14726 : if ( bLocalUseExceptions ) {
14727 : CPLErr eclass = CPLGetLastErrorType();
14728 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14729 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14730 : }
14731 : }
14732 : #endif
14733 : }
14734 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
14735 : {
14736 : /* %typemap(freearg) (const char *utf8_path) */
14737 : GDALPythonFreeCStr(arg2, bToFree2);
14738 : }
14739 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
14740 : return resultobj;
14741 : fail:
14742 : {
14743 : /* %typemap(freearg) (const char *utf8_path) */
14744 : GDALPythonFreeCStr(arg2, bToFree2);
14745 : }
14746 : return NULL;
14747 : }
14748 :
14749 :
14750 361 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldRef(PyObject *self, PyObject *args) {
14751 361 : Py_ssize_t argc;
14752 361 : PyObject *argv[3] = {
14753 : 0
14754 : };
14755 :
14756 361 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetGeomFieldRef", 0, 2, argv))) SWIG_fail;
14757 361 : --argc;
14758 361 : if (argc == 2) {
14759 361 : int _v;
14760 361 : void *vptr = 0;
14761 361 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
14762 417 : _v = SWIG_CheckState(res);
14763 361 : if (_v) {
14764 361 : {
14765 361 : int res = SWIG_AsVal_int(argv[1], NULL);
14766 361 : _v = SWIG_CheckState(res);
14767 : }
14768 305 : if (_v) {
14769 305 : return _wrap_Feature_GetGeomFieldRef__SWIG_0(self, argc, argv);
14770 : }
14771 : }
14772 : }
14773 56 : if (argc == 2) {
14774 56 : int _v;
14775 56 : void *vptr = 0;
14776 56 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
14777 56 : _v = SWIG_CheckState(res);
14778 56 : if (_v) {
14779 56 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
14780 56 : _v = SWIG_CheckState(res);
14781 56 : if (_v) {
14782 56 : return _wrap_Feature_GetGeomFieldRef__SWIG_1(self, argc, argv);
14783 : }
14784 : }
14785 : }
14786 :
14787 0 : fail:
14788 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetGeomFieldRef'.\n"
14789 : " Possible C/C++ prototypes are:\n"
14790 : " OGRFeatureShadow::GetGeomFieldRef(int)\n"
14791 : " OGRFeatureShadow::GetGeomFieldRef(char const *)\n");
14792 : return 0;
14793 : }
14794 :
14795 :
14796 49 : SWIGINTERN PyObject *_wrap_Feature_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14797 49 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14798 49 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14799 49 : void *argp1 = 0 ;
14800 49 : int res1 = 0 ;
14801 49 : PyObject *swig_obj[1] ;
14802 49 : OGRFeatureShadow *result = 0 ;
14803 :
14804 49 : if (!args) SWIG_fail;
14805 49 : swig_obj[0] = args;
14806 49 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14807 49 : if (!SWIG_IsOK(res1)) {
14808 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_Clone" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14809 : }
14810 49 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14811 49 : {
14812 49 : const int bLocalUseExceptions = GetUseExceptions();
14813 49 : if ( bLocalUseExceptions ) {
14814 43 : pushErrorHandler();
14815 : }
14816 49 : {
14817 49 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14818 49 : result = (OGRFeatureShadow *)OGRFeatureShadow_Clone(arg1);
14819 49 : SWIG_PYTHON_THREAD_END_ALLOW;
14820 : }
14821 49 : if ( bLocalUseExceptions ) {
14822 43 : popErrorHandler();
14823 : }
14824 : #ifndef SED_HACKS
14825 : if ( bLocalUseExceptions ) {
14826 : CPLErr eclass = CPLGetLastErrorType();
14827 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14828 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14829 : }
14830 : }
14831 : #endif
14832 : }
14833 49 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_OWN | 0 );
14834 49 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
14835 : return resultobj;
14836 : fail:
14837 : return NULL;
14838 : }
14839 :
14840 :
14841 109 : SWIGINTERN PyObject *_wrap_Feature_Equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14842 109 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14843 109 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14844 109 : OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
14845 109 : void *argp1 = 0 ;
14846 109 : int res1 = 0 ;
14847 109 : void *argp2 = 0 ;
14848 109 : int res2 = 0 ;
14849 109 : PyObject *swig_obj[2] ;
14850 109 : bool result;
14851 :
14852 109 : if (!SWIG_Python_UnpackTuple(args, "Feature_Equal", 2, 2, swig_obj)) SWIG_fail;
14853 109 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14854 109 : if (!SWIG_IsOK(res1)) {
14855 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_Equal" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14856 : }
14857 109 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14858 109 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14859 109 : if (!SWIG_IsOK(res2)) {
14860 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_Equal" "', argument " "2"" of type '" "OGRFeatureShadow *""'");
14861 : }
14862 109 : arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
14863 109 : {
14864 109 : if (!arg2) {
14865 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
14866 : }
14867 : }
14868 109 : {
14869 109 : const int bLocalUseExceptions = GetUseExceptions();
14870 109 : if ( bLocalUseExceptions ) {
14871 97 : pushErrorHandler();
14872 : }
14873 109 : {
14874 109 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14875 109 : result = (bool)OGRFeatureShadow_Equal(arg1,arg2);
14876 109 : SWIG_PYTHON_THREAD_END_ALLOW;
14877 : }
14878 109 : if ( bLocalUseExceptions ) {
14879 97 : popErrorHandler();
14880 : }
14881 : #ifndef SED_HACKS
14882 : if ( bLocalUseExceptions ) {
14883 : CPLErr eclass = CPLGetLastErrorType();
14884 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14885 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14886 : }
14887 : }
14888 : #endif
14889 : }
14890 109 : resultobj = SWIG_From_bool(static_cast< bool >(result));
14891 109 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
14892 : return resultobj;
14893 : fail:
14894 : return NULL;
14895 : }
14896 :
14897 :
14898 109791 : SWIGINTERN PyObject *_wrap_Feature_GetFieldCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14899 109791 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14900 109791 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14901 109791 : void *argp1 = 0 ;
14902 109791 : int res1 = 0 ;
14903 109791 : PyObject *swig_obj[1] ;
14904 109791 : int result;
14905 :
14906 109791 : if (!args) SWIG_fail;
14907 109791 : swig_obj[0] = args;
14908 109791 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14909 109791 : if (!SWIG_IsOK(res1)) {
14910 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldCount" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14911 : }
14912 109791 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14913 109791 : {
14914 109791 : const int bLocalUseExceptions = GetUseExceptions();
14915 109791 : if ( bLocalUseExceptions ) {
14916 90707 : pushErrorHandler();
14917 : }
14918 109791 : {
14919 109791 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14920 109791 : result = (int)OGRFeatureShadow_GetFieldCount(arg1);
14921 109791 : SWIG_PYTHON_THREAD_END_ALLOW;
14922 : }
14923 109791 : if ( bLocalUseExceptions ) {
14924 90707 : popErrorHandler();
14925 : }
14926 : #ifndef SED_HACKS
14927 : if ( bLocalUseExceptions ) {
14928 : CPLErr eclass = CPLGetLastErrorType();
14929 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14930 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14931 : }
14932 : }
14933 : #endif
14934 : }
14935 109791 : resultobj = SWIG_From_int(static_cast< int >(result));
14936 109791 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
14937 : return resultobj;
14938 : fail:
14939 : return NULL;
14940 : }
14941 :
14942 :
14943 : SWIGINTERN PyObject *_wrap_Feature_GetFieldDefnRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14944 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14945 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14946 : int arg2 ;
14947 : void *argp1 = 0 ;
14948 : int res1 = 0 ;
14949 : int val2 ;
14950 : int ecode2 = 0 ;
14951 : OGRFieldDefnShadow *result = 0 ;
14952 :
14953 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14954 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
14955 : if (!SWIG_IsOK(res1)) {
14956 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldDefnRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
14957 : }
14958 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
14959 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14960 : if (!SWIG_IsOK(ecode2)) {
14961 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldDefnRef" "', argument " "2"" of type '" "int""'");
14962 : }
14963 : arg2 = static_cast< int >(val2);
14964 : {
14965 : const int bLocalUseExceptions = GetUseExceptions();
14966 : if ( bLocalUseExceptions ) {
14967 : pushErrorHandler();
14968 : }
14969 : {
14970 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14971 : result = (OGRFieldDefnShadow *)OGRFeatureShadow_GetFieldDefnRef__SWIG_0(arg1,arg2);
14972 : SWIG_PYTHON_THREAD_END_ALLOW;
14973 : }
14974 : if ( bLocalUseExceptions ) {
14975 : popErrorHandler();
14976 : }
14977 : #ifndef SED_HACKS
14978 : if ( bLocalUseExceptions ) {
14979 : CPLErr eclass = CPLGetLastErrorType();
14980 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14981 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14982 : }
14983 : }
14984 : #endif
14985 : }
14986 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
14987 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
14988 : return resultobj;
14989 : fail:
14990 : return NULL;
14991 : }
14992 :
14993 :
14994 : SWIGINTERN PyObject *_wrap_Feature_GetFieldDefnRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
14995 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14996 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
14997 : char *arg2 = (char *) 0 ;
14998 : void *argp1 = 0 ;
14999 : int res1 = 0 ;
15000 : int bToFree2 = 0 ;
15001 : OGRFieldDefnShadow *result = 0 ;
15002 :
15003 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15004 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15005 : if (!SWIG_IsOK(res1)) {
15006 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldDefnRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15007 : }
15008 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15009 : {
15010 : /* %typemap(in) (const char *utf8_path) */
15011 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
15012 : {
15013 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
15014 : }
15015 : else
15016 : {
15017 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
15018 :
15019 : }
15020 : if (arg2 == NULL)
15021 : {
15022 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15023 : SWIG_fail;
15024 : }
15025 : }
15026 : {
15027 : const int bLocalUseExceptions = GetUseExceptions();
15028 : if ( bLocalUseExceptions ) {
15029 : pushErrorHandler();
15030 : }
15031 : {
15032 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15033 : result = (OGRFieldDefnShadow *)OGRFeatureShadow_GetFieldDefnRef__SWIG_1(arg1,(char const *)arg2);
15034 : SWIG_PYTHON_THREAD_END_ALLOW;
15035 : }
15036 : if ( bLocalUseExceptions ) {
15037 : popErrorHandler();
15038 : }
15039 : #ifndef SED_HACKS
15040 : if ( bLocalUseExceptions ) {
15041 : CPLErr eclass = CPLGetLastErrorType();
15042 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15043 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15044 : }
15045 : }
15046 : #endif
15047 : }
15048 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
15049 : {
15050 : /* %typemap(freearg) (const char *utf8_path) */
15051 : GDALPythonFreeCStr(arg2, bToFree2);
15052 : }
15053 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
15054 : return resultobj;
15055 : fail:
15056 : {
15057 : /* %typemap(freearg) (const char *utf8_path) */
15058 : GDALPythonFreeCStr(arg2, bToFree2);
15059 : }
15060 : return NULL;
15061 : }
15062 :
15063 :
15064 86861 : SWIGINTERN PyObject *_wrap_Feature_GetFieldDefnRef(PyObject *self, PyObject *args) {
15065 86861 : Py_ssize_t argc;
15066 86861 : PyObject *argv[3] = {
15067 : 0
15068 : };
15069 :
15070 86861 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldDefnRef", 0, 2, argv))) SWIG_fail;
15071 86861 : --argc;
15072 86861 : if (argc == 2) {
15073 86861 : int _v;
15074 86861 : void *vptr = 0;
15075 86861 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15076 86861 : _v = SWIG_CheckState(res);
15077 86861 : if (_v) {
15078 86861 : {
15079 86861 : int res = SWIG_AsVal_int(argv[1], NULL);
15080 86861 : _v = SWIG_CheckState(res);
15081 : }
15082 86861 : if (_v) {
15083 86861 : return _wrap_Feature_GetFieldDefnRef__SWIG_0(self, argc, argv);
15084 : }
15085 : }
15086 : }
15087 0 : if (argc == 2) {
15088 0 : int _v;
15089 0 : void *vptr = 0;
15090 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15091 0 : _v = SWIG_CheckState(res);
15092 0 : if (_v) {
15093 0 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
15094 0 : _v = SWIG_CheckState(res);
15095 0 : if (_v) {
15096 0 : return _wrap_Feature_GetFieldDefnRef__SWIG_1(self, argc, argv);
15097 : }
15098 : }
15099 : }
15100 :
15101 0 : fail:
15102 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldDefnRef'.\n"
15103 : " Possible C/C++ prototypes are:\n"
15104 : " OGRFeatureShadow::GetFieldDefnRef(int)\n"
15105 : " OGRFeatureShadow::GetFieldDefnRef(char const *)\n");
15106 : return 0;
15107 : }
15108 :
15109 :
15110 121 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15111 121 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15112 121 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15113 121 : void *argp1 = 0 ;
15114 121 : int res1 = 0 ;
15115 121 : PyObject *swig_obj[1] ;
15116 121 : int result;
15117 :
15118 121 : if (!args) SWIG_fail;
15119 121 : swig_obj[0] = args;
15120 121 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15121 121 : if (!SWIG_IsOK(res1)) {
15122 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetGeomFieldCount" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15123 : }
15124 121 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15125 121 : {
15126 121 : const int bLocalUseExceptions = GetUseExceptions();
15127 121 : if ( bLocalUseExceptions ) {
15128 51 : pushErrorHandler();
15129 : }
15130 121 : {
15131 121 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15132 121 : result = (int)OGRFeatureShadow_GetGeomFieldCount(arg1);
15133 121 : SWIG_PYTHON_THREAD_END_ALLOW;
15134 : }
15135 121 : if ( bLocalUseExceptions ) {
15136 51 : popErrorHandler();
15137 : }
15138 : #ifndef SED_HACKS
15139 : if ( bLocalUseExceptions ) {
15140 : CPLErr eclass = CPLGetLastErrorType();
15141 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15142 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15143 : }
15144 : }
15145 : #endif
15146 : }
15147 121 : resultobj = SWIG_From_int(static_cast< int >(result));
15148 121 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
15149 : return resultobj;
15150 : fail:
15151 : return NULL;
15152 : }
15153 :
15154 :
15155 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldDefnRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15156 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15157 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15158 : int arg2 ;
15159 : void *argp1 = 0 ;
15160 : int res1 = 0 ;
15161 : int val2 ;
15162 : int ecode2 = 0 ;
15163 : OGRGeomFieldDefnShadow *result = 0 ;
15164 :
15165 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15166 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15167 : if (!SWIG_IsOK(res1)) {
15168 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetGeomFieldDefnRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15169 : }
15170 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15171 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15172 : if (!SWIG_IsOK(ecode2)) {
15173 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetGeomFieldDefnRef" "', argument " "2"" of type '" "int""'");
15174 : }
15175 : arg2 = static_cast< int >(val2);
15176 : {
15177 : const int bLocalUseExceptions = GetUseExceptions();
15178 : if ( bLocalUseExceptions ) {
15179 : pushErrorHandler();
15180 : }
15181 : {
15182 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15183 : result = (OGRGeomFieldDefnShadow *)OGRFeatureShadow_GetGeomFieldDefnRef__SWIG_0(arg1,arg2);
15184 : SWIG_PYTHON_THREAD_END_ALLOW;
15185 : }
15186 : if ( bLocalUseExceptions ) {
15187 : popErrorHandler();
15188 : }
15189 : #ifndef SED_HACKS
15190 : if ( bLocalUseExceptions ) {
15191 : CPLErr eclass = CPLGetLastErrorType();
15192 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15193 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15194 : }
15195 : }
15196 : #endif
15197 : }
15198 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
15199 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
15200 : return resultobj;
15201 : fail:
15202 : return NULL;
15203 : }
15204 :
15205 :
15206 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldDefnRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15207 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15208 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15209 : char *arg2 = (char *) 0 ;
15210 : void *argp1 = 0 ;
15211 : int res1 = 0 ;
15212 : int bToFree2 = 0 ;
15213 : OGRGeomFieldDefnShadow *result = 0 ;
15214 :
15215 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15216 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15217 : if (!SWIG_IsOK(res1)) {
15218 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetGeomFieldDefnRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15219 : }
15220 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15221 : {
15222 : /* %typemap(in) (const char *utf8_path) */
15223 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
15224 : {
15225 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
15226 : }
15227 : else
15228 : {
15229 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
15230 :
15231 : }
15232 : if (arg2 == NULL)
15233 : {
15234 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15235 : SWIG_fail;
15236 : }
15237 : }
15238 : {
15239 : const int bLocalUseExceptions = GetUseExceptions();
15240 : if ( bLocalUseExceptions ) {
15241 : pushErrorHandler();
15242 : }
15243 : {
15244 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15245 : result = (OGRGeomFieldDefnShadow *)OGRFeatureShadow_GetGeomFieldDefnRef__SWIG_1(arg1,(char const *)arg2);
15246 : SWIG_PYTHON_THREAD_END_ALLOW;
15247 : }
15248 : if ( bLocalUseExceptions ) {
15249 : popErrorHandler();
15250 : }
15251 : #ifndef SED_HACKS
15252 : if ( bLocalUseExceptions ) {
15253 : CPLErr eclass = CPLGetLastErrorType();
15254 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15255 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15256 : }
15257 : }
15258 : #endif
15259 : }
15260 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
15261 : {
15262 : /* %typemap(freearg) (const char *utf8_path) */
15263 : GDALPythonFreeCStr(arg2, bToFree2);
15264 : }
15265 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
15266 : return resultobj;
15267 : fail:
15268 : {
15269 : /* %typemap(freearg) (const char *utf8_path) */
15270 : GDALPythonFreeCStr(arg2, bToFree2);
15271 : }
15272 : return NULL;
15273 : }
15274 :
15275 :
15276 2 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldDefnRef(PyObject *self, PyObject *args) {
15277 2 : Py_ssize_t argc;
15278 2 : PyObject *argv[3] = {
15279 : 0
15280 : };
15281 :
15282 2 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetGeomFieldDefnRef", 0, 2, argv))) SWIG_fail;
15283 2 : --argc;
15284 2 : if (argc == 2) {
15285 2 : int _v;
15286 2 : void *vptr = 0;
15287 2 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15288 2 : _v = SWIG_CheckState(res);
15289 2 : if (_v) {
15290 2 : {
15291 2 : int res = SWIG_AsVal_int(argv[1], NULL);
15292 2 : _v = SWIG_CheckState(res);
15293 : }
15294 2 : if (_v) {
15295 2 : return _wrap_Feature_GetGeomFieldDefnRef__SWIG_0(self, argc, argv);
15296 : }
15297 : }
15298 : }
15299 0 : if (argc == 2) {
15300 0 : int _v;
15301 0 : void *vptr = 0;
15302 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15303 0 : _v = SWIG_CheckState(res);
15304 0 : if (_v) {
15305 0 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
15306 0 : _v = SWIG_CheckState(res);
15307 0 : if (_v) {
15308 0 : return _wrap_Feature_GetGeomFieldDefnRef__SWIG_1(self, argc, argv);
15309 : }
15310 : }
15311 : }
15312 :
15313 0 : fail:
15314 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetGeomFieldDefnRef'.\n"
15315 : " Possible C/C++ prototypes are:\n"
15316 : " OGRFeatureShadow::GetGeomFieldDefnRef(int)\n"
15317 : " OGRFeatureShadow::GetGeomFieldDefnRef(char const *)\n");
15318 : return 0;
15319 : }
15320 :
15321 :
15322 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15323 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15324 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15325 : int arg2 ;
15326 : void *argp1 = 0 ;
15327 : int res1 = 0 ;
15328 : int val2 ;
15329 : int ecode2 = 0 ;
15330 : char *result = 0 ;
15331 :
15332 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15333 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15334 : if (!SWIG_IsOK(res1)) {
15335 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15336 : }
15337 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15338 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15339 : if (!SWIG_IsOK(ecode2)) {
15340 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsString" "', argument " "2"" of type '" "int""'");
15341 : }
15342 : arg2 = static_cast< int >(val2);
15343 : {
15344 : const int bLocalUseExceptions = GetUseExceptions();
15345 : if ( bLocalUseExceptions ) {
15346 : pushErrorHandler();
15347 : }
15348 : {
15349 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15350 : result = (char *)OGRFeatureShadow_GetFieldAsString__SWIG_0(arg1,arg2);
15351 : SWIG_PYTHON_THREAD_END_ALLOW;
15352 : }
15353 : if ( bLocalUseExceptions ) {
15354 : popErrorHandler();
15355 : }
15356 : #ifndef SED_HACKS
15357 : if ( bLocalUseExceptions ) {
15358 : CPLErr eclass = CPLGetLastErrorType();
15359 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15360 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15361 : }
15362 : }
15363 : #endif
15364 : }
15365 : resultobj = SWIG_FromCharPtr((const char *)result);
15366 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
15367 : return resultobj;
15368 : fail:
15369 : return NULL;
15370 : }
15371 :
15372 :
15373 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15374 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15375 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15376 : char *arg2 = (char *) 0 ;
15377 : void *argp1 = 0 ;
15378 : int res1 = 0 ;
15379 : int bToFree2 = 0 ;
15380 : char *result = 0 ;
15381 :
15382 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15383 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15384 : if (!SWIG_IsOK(res1)) {
15385 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15386 : }
15387 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15388 : {
15389 : /* %typemap(in) (const char *utf8_path) */
15390 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
15391 : {
15392 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
15393 : }
15394 : else
15395 : {
15396 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
15397 :
15398 : }
15399 : if (arg2 == NULL)
15400 : {
15401 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15402 : SWIG_fail;
15403 : }
15404 : }
15405 : {
15406 : const int bLocalUseExceptions = GetUseExceptions();
15407 : if ( bLocalUseExceptions ) {
15408 : pushErrorHandler();
15409 : }
15410 : {
15411 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15412 : result = (char *)OGRFeatureShadow_GetFieldAsString__SWIG_1(arg1,(char const *)arg2);
15413 : SWIG_PYTHON_THREAD_END_ALLOW;
15414 : }
15415 : if ( bLocalUseExceptions ) {
15416 : popErrorHandler();
15417 : }
15418 : #ifndef SED_HACKS
15419 : if ( bLocalUseExceptions ) {
15420 : CPLErr eclass = CPLGetLastErrorType();
15421 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15422 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15423 : }
15424 : }
15425 : #endif
15426 : }
15427 : resultobj = SWIG_FromCharPtr((const char *)result);
15428 : {
15429 : /* %typemap(freearg) (const char *utf8_path) */
15430 : GDALPythonFreeCStr(arg2, bToFree2);
15431 : }
15432 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
15433 : return resultobj;
15434 : fail:
15435 : {
15436 : /* %typemap(freearg) (const char *utf8_path) */
15437 : GDALPythonFreeCStr(arg2, bToFree2);
15438 : }
15439 : return NULL;
15440 : }
15441 :
15442 :
15443 10595 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsString(PyObject *self, PyObject *args) {
15444 10595 : Py_ssize_t argc;
15445 10595 : PyObject *argv[3] = {
15446 : 0
15447 : };
15448 :
15449 10595 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsString", 0, 2, argv))) SWIG_fail;
15450 10595 : --argc;
15451 10595 : if (argc == 2) {
15452 10595 : int _v;
15453 10595 : void *vptr = 0;
15454 10595 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15455 11387 : _v = SWIG_CheckState(res);
15456 10595 : if (_v) {
15457 10595 : {
15458 10595 : int res = SWIG_AsVal_int(argv[1], NULL);
15459 10595 : _v = SWIG_CheckState(res);
15460 : }
15461 9803 : if (_v) {
15462 9803 : return _wrap_Feature_GetFieldAsString__SWIG_0(self, argc, argv);
15463 : }
15464 : }
15465 : }
15466 792 : if (argc == 2) {
15467 792 : int _v;
15468 792 : void *vptr = 0;
15469 792 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15470 792 : _v = SWIG_CheckState(res);
15471 792 : if (_v) {
15472 792 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
15473 792 : _v = SWIG_CheckState(res);
15474 792 : if (_v) {
15475 792 : return _wrap_Feature_GetFieldAsString__SWIG_1(self, argc, argv);
15476 : }
15477 : }
15478 : }
15479 :
15480 0 : fail:
15481 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsString'.\n"
15482 : " Possible C/C++ prototypes are:\n"
15483 : " OGRFeatureShadow::GetFieldAsString(int)\n"
15484 : " OGRFeatureShadow::GetFieldAsString(char const *)\n");
15485 : return 0;
15486 : }
15487 :
15488 :
15489 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsISO8601DateTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15490 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15491 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15492 : int arg2 ;
15493 : char **arg3 = (char **) 0 ;
15494 : void *argp1 = 0 ;
15495 : int res1 = 0 ;
15496 : int val2 ;
15497 : int ecode2 = 0 ;
15498 : char *result = 0 ;
15499 :
15500 : if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
15501 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15502 : if (!SWIG_IsOK(res1)) {
15503 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsISO8601DateTime" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15504 : }
15505 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15506 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15507 : if (!SWIG_IsOK(ecode2)) {
15508 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsISO8601DateTime" "', argument " "2"" of type '" "int""'");
15509 : }
15510 : arg2 = static_cast< int >(val2);
15511 : if (swig_obj[2]) {
15512 : {
15513 : /* %typemap(in) char **dict */
15514 : arg3 = NULL;
15515 : if ( PySequence_Check( swig_obj[2] ) ) {
15516 : int bErr = FALSE;
15517 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
15518 : if ( bErr )
15519 : {
15520 : SWIG_fail;
15521 : }
15522 : }
15523 : else if ( PyMapping_Check( swig_obj[2] ) ) {
15524 : int bErr = FALSE;
15525 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
15526 : if ( bErr )
15527 : {
15528 : SWIG_fail;
15529 : }
15530 : }
15531 : else {
15532 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
15533 : SWIG_fail;
15534 : }
15535 : }
15536 : }
15537 : {
15538 : const int bLocalUseExceptions = GetUseExceptions();
15539 : if ( bLocalUseExceptions ) {
15540 : pushErrorHandler();
15541 : }
15542 : {
15543 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15544 : result = (char *)OGRFeatureShadow_GetFieldAsISO8601DateTime__SWIG_0(arg1,arg2,arg3);
15545 : SWIG_PYTHON_THREAD_END_ALLOW;
15546 : }
15547 : if ( bLocalUseExceptions ) {
15548 : popErrorHandler();
15549 : }
15550 : #ifndef SED_HACKS
15551 : if ( bLocalUseExceptions ) {
15552 : CPLErr eclass = CPLGetLastErrorType();
15553 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15554 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15555 : }
15556 : }
15557 : #endif
15558 : }
15559 : resultobj = SWIG_FromCharPtr((const char *)result);
15560 : {
15561 : /* %typemap(freearg) char **dict */
15562 : CSLDestroy( arg3 );
15563 : }
15564 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
15565 : return resultobj;
15566 : fail:
15567 : {
15568 : /* %typemap(freearg) char **dict */
15569 : CSLDestroy( arg3 );
15570 : }
15571 : return NULL;
15572 : }
15573 :
15574 :
15575 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsISO8601DateTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15576 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15577 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15578 : char *arg2 = (char *) 0 ;
15579 : char **arg3 = (char **) 0 ;
15580 : void *argp1 = 0 ;
15581 : int res1 = 0 ;
15582 : int bToFree2 = 0 ;
15583 : char *result = 0 ;
15584 :
15585 : if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
15586 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15587 : if (!SWIG_IsOK(res1)) {
15588 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsISO8601DateTime" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15589 : }
15590 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15591 : {
15592 : /* %typemap(in) (const char *utf8_path) */
15593 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
15594 : {
15595 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
15596 : }
15597 : else
15598 : {
15599 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
15600 :
15601 : }
15602 : if (arg2 == NULL)
15603 : {
15604 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15605 : SWIG_fail;
15606 : }
15607 : }
15608 : if (swig_obj[2]) {
15609 : {
15610 : /* %typemap(in) char **dict */
15611 : arg3 = NULL;
15612 : if ( PySequence_Check( swig_obj[2] ) ) {
15613 : int bErr = FALSE;
15614 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
15615 : if ( bErr )
15616 : {
15617 : SWIG_fail;
15618 : }
15619 : }
15620 : else if ( PyMapping_Check( swig_obj[2] ) ) {
15621 : int bErr = FALSE;
15622 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
15623 : if ( bErr )
15624 : {
15625 : SWIG_fail;
15626 : }
15627 : }
15628 : else {
15629 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
15630 : SWIG_fail;
15631 : }
15632 : }
15633 : }
15634 : {
15635 : const int bLocalUseExceptions = GetUseExceptions();
15636 : if ( bLocalUseExceptions ) {
15637 : pushErrorHandler();
15638 : }
15639 : {
15640 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15641 : result = (char *)OGRFeatureShadow_GetFieldAsISO8601DateTime__SWIG_1(arg1,(char const *)arg2,arg3);
15642 : SWIG_PYTHON_THREAD_END_ALLOW;
15643 : }
15644 : if ( bLocalUseExceptions ) {
15645 : popErrorHandler();
15646 : }
15647 : #ifndef SED_HACKS
15648 : if ( bLocalUseExceptions ) {
15649 : CPLErr eclass = CPLGetLastErrorType();
15650 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15651 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15652 : }
15653 : }
15654 : #endif
15655 : }
15656 : resultobj = SWIG_FromCharPtr((const char *)result);
15657 : {
15658 : /* %typemap(freearg) (const char *utf8_path) */
15659 : GDALPythonFreeCStr(arg2, bToFree2);
15660 : }
15661 : {
15662 : /* %typemap(freearg) char **dict */
15663 : CSLDestroy( arg3 );
15664 : }
15665 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
15666 : return resultobj;
15667 : fail:
15668 : {
15669 : /* %typemap(freearg) (const char *utf8_path) */
15670 : GDALPythonFreeCStr(arg2, bToFree2);
15671 : }
15672 : {
15673 : /* %typemap(freearg) char **dict */
15674 : CSLDestroy( arg3 );
15675 : }
15676 : return NULL;
15677 : }
15678 :
15679 :
15680 8 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsISO8601DateTime(PyObject *self, PyObject *args) {
15681 8 : Py_ssize_t argc;
15682 8 : PyObject *argv[4] = {
15683 : 0
15684 : };
15685 :
15686 8 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsISO8601DateTime", 0, 3, argv))) SWIG_fail;
15687 8 : --argc;
15688 8 : if ((argc >= 2) && (argc <= 3)) {
15689 8 : int _v;
15690 8 : void *vptr = 0;
15691 8 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15692 14 : _v = SWIG_CheckState(res);
15693 8 : if (_v) {
15694 8 : {
15695 8 : int res = SWIG_AsVal_int(argv[1], NULL);
15696 8 : _v = SWIG_CheckState(res);
15697 : }
15698 2 : if (_v) {
15699 2 : if (argc <= 2) {
15700 2 : return _wrap_Feature_GetFieldAsISO8601DateTime__SWIG_0(self, argc, argv);
15701 : }
15702 0 : {
15703 : /* %typecheck(SWIG_TYPECHECK_POINTER) (char **dict) */
15704 : /* Note: we exclude explicitly strings, because they can be considered as a sequence of characters, */
15705 : /* which is not desirable since it makes it impossible to define bindings such as SetMetadata(string) and SetMetadata(array_of_string) */
15706 : /* (see #4816) */
15707 0 : _v = ((PyMapping_Check(argv[2]) || PySequence_Check(argv[2]) ) && !SWIG_CheckState(SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0)) ) ? 1 : 0;
15708 : }
15709 0 : if (_v) {
15710 0 : return _wrap_Feature_GetFieldAsISO8601DateTime__SWIG_0(self, argc, argv);
15711 : }
15712 : }
15713 : }
15714 : }
15715 6 : if ((argc >= 2) && (argc <= 3)) {
15716 6 : int _v;
15717 6 : void *vptr = 0;
15718 6 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15719 6 : _v = SWIG_CheckState(res);
15720 6 : if (_v) {
15721 6 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
15722 6 : _v = SWIG_CheckState(res);
15723 6 : if (_v) {
15724 6 : if (argc <= 2) {
15725 6 : return _wrap_Feature_GetFieldAsISO8601DateTime__SWIG_1(self, argc, argv);
15726 : }
15727 0 : {
15728 : /* %typecheck(SWIG_TYPECHECK_POINTER) (char **dict) */
15729 : /* Note: we exclude explicitly strings, because they can be considered as a sequence of characters, */
15730 : /* which is not desirable since it makes it impossible to define bindings such as SetMetadata(string) and SetMetadata(array_of_string) */
15731 : /* (see #4816) */
15732 0 : _v = ((PyMapping_Check(argv[2]) || PySequence_Check(argv[2]) ) && !SWIG_CheckState(SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0)) ) ? 1 : 0;
15733 : }
15734 0 : if (_v) {
15735 0 : return _wrap_Feature_GetFieldAsISO8601DateTime__SWIG_1(self, argc, argv);
15736 : }
15737 : }
15738 : }
15739 : }
15740 :
15741 0 : fail:
15742 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsISO8601DateTime'.\n"
15743 : " Possible C/C++ prototypes are:\n"
15744 : " OGRFeatureShadow::GetFieldAsISO8601DateTime(int,char **)\n"
15745 : " OGRFeatureShadow::GetFieldAsISO8601DateTime(char const *,char **)\n");
15746 : return 0;
15747 : }
15748 :
15749 :
15750 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsInteger__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15751 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15752 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15753 : int arg2 ;
15754 : void *argp1 = 0 ;
15755 : int res1 = 0 ;
15756 : int val2 ;
15757 : int ecode2 = 0 ;
15758 : int result;
15759 :
15760 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15761 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15762 : if (!SWIG_IsOK(res1)) {
15763 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsInteger" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15764 : }
15765 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15766 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15767 : if (!SWIG_IsOK(ecode2)) {
15768 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsInteger" "', argument " "2"" of type '" "int""'");
15769 : }
15770 : arg2 = static_cast< int >(val2);
15771 : {
15772 : const int bLocalUseExceptions = GetUseExceptions();
15773 : if ( bLocalUseExceptions ) {
15774 : pushErrorHandler();
15775 : }
15776 : {
15777 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15778 : result = (int)OGRFeatureShadow_GetFieldAsInteger__SWIG_0(arg1,arg2);
15779 : SWIG_PYTHON_THREAD_END_ALLOW;
15780 : }
15781 : if ( bLocalUseExceptions ) {
15782 : popErrorHandler();
15783 : }
15784 : #ifndef SED_HACKS
15785 : if ( bLocalUseExceptions ) {
15786 : CPLErr eclass = CPLGetLastErrorType();
15787 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15788 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15789 : }
15790 : }
15791 : #endif
15792 : }
15793 : resultobj = SWIG_From_int(static_cast< int >(result));
15794 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
15795 : return resultobj;
15796 : fail:
15797 : return NULL;
15798 : }
15799 :
15800 :
15801 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsInteger__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15802 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15803 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15804 : char *arg2 = (char *) 0 ;
15805 : void *argp1 = 0 ;
15806 : int res1 = 0 ;
15807 : int bToFree2 = 0 ;
15808 : int result;
15809 :
15810 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15811 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15812 : if (!SWIG_IsOK(res1)) {
15813 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsInteger" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15814 : }
15815 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15816 : {
15817 : /* %typemap(in) (const char *utf8_path) */
15818 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
15819 : {
15820 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
15821 : }
15822 : else
15823 : {
15824 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
15825 :
15826 : }
15827 : if (arg2 == NULL)
15828 : {
15829 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15830 : SWIG_fail;
15831 : }
15832 : }
15833 : {
15834 : const int bLocalUseExceptions = GetUseExceptions();
15835 : if ( bLocalUseExceptions ) {
15836 : pushErrorHandler();
15837 : }
15838 : {
15839 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15840 : result = (int)OGRFeatureShadow_GetFieldAsInteger__SWIG_1(arg1,(char const *)arg2);
15841 : SWIG_PYTHON_THREAD_END_ALLOW;
15842 : }
15843 : if ( bLocalUseExceptions ) {
15844 : popErrorHandler();
15845 : }
15846 : #ifndef SED_HACKS
15847 : if ( bLocalUseExceptions ) {
15848 : CPLErr eclass = CPLGetLastErrorType();
15849 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15850 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15851 : }
15852 : }
15853 : #endif
15854 : }
15855 : resultobj = SWIG_From_int(static_cast< int >(result));
15856 : {
15857 : /* %typemap(freearg) (const char *utf8_path) */
15858 : GDALPythonFreeCStr(arg2, bToFree2);
15859 : }
15860 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
15861 : return resultobj;
15862 : fail:
15863 : {
15864 : /* %typemap(freearg) (const char *utf8_path) */
15865 : GDALPythonFreeCStr(arg2, bToFree2);
15866 : }
15867 : return NULL;
15868 : }
15869 :
15870 :
15871 87752 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsInteger(PyObject *self, PyObject *args) {
15872 87752 : Py_ssize_t argc;
15873 87752 : PyObject *argv[3] = {
15874 : 0
15875 : };
15876 :
15877 87752 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsInteger", 0, 2, argv))) SWIG_fail;
15878 87752 : --argc;
15879 87752 : if (argc == 2) {
15880 87752 : int _v;
15881 87752 : void *vptr = 0;
15882 87752 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15883 87938 : _v = SWIG_CheckState(res);
15884 87752 : if (_v) {
15885 87752 : {
15886 87752 : int res = SWIG_AsVal_int(argv[1], NULL);
15887 87752 : _v = SWIG_CheckState(res);
15888 : }
15889 87566 : if (_v) {
15890 87566 : return _wrap_Feature_GetFieldAsInteger__SWIG_0(self, argc, argv);
15891 : }
15892 : }
15893 : }
15894 186 : if (argc == 2) {
15895 186 : int _v;
15896 186 : void *vptr = 0;
15897 186 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
15898 186 : _v = SWIG_CheckState(res);
15899 186 : if (_v) {
15900 186 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
15901 186 : _v = SWIG_CheckState(res);
15902 186 : if (_v) {
15903 186 : return _wrap_Feature_GetFieldAsInteger__SWIG_1(self, argc, argv);
15904 : }
15905 : }
15906 : }
15907 :
15908 0 : fail:
15909 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsInteger'.\n"
15910 : " Possible C/C++ prototypes are:\n"
15911 : " OGRFeatureShadow::GetFieldAsInteger(int)\n"
15912 : " OGRFeatureShadow::GetFieldAsInteger(char const *)\n");
15913 : return 0;
15914 : }
15915 :
15916 :
15917 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsInteger64__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15918 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15919 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15920 : int arg2 ;
15921 : void *argp1 = 0 ;
15922 : int res1 = 0 ;
15923 : int val2 ;
15924 : int ecode2 = 0 ;
15925 : GIntBig result;
15926 :
15927 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15928 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15929 : if (!SWIG_IsOK(res1)) {
15930 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsInteger64" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15931 : }
15932 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15933 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15934 : if (!SWIG_IsOK(ecode2)) {
15935 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsInteger64" "', argument " "2"" of type '" "int""'");
15936 : }
15937 : arg2 = static_cast< int >(val2);
15938 : {
15939 : const int bLocalUseExceptions = GetUseExceptions();
15940 : if ( bLocalUseExceptions ) {
15941 : pushErrorHandler();
15942 : }
15943 : {
15944 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15945 : result = OGRFeatureShadow_GetFieldAsInteger64__SWIG_0(arg1,arg2);
15946 : SWIG_PYTHON_THREAD_END_ALLOW;
15947 : }
15948 : if ( bLocalUseExceptions ) {
15949 : popErrorHandler();
15950 : }
15951 : #ifndef SED_HACKS
15952 : if ( bLocalUseExceptions ) {
15953 : CPLErr eclass = CPLGetLastErrorType();
15954 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15955 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15956 : }
15957 : }
15958 : #endif
15959 : }
15960 : {
15961 : resultobj = PyLong_FromLongLong(result);
15962 : }
15963 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
15964 : return resultobj;
15965 : fail:
15966 : return NULL;
15967 : }
15968 :
15969 :
15970 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsInteger64__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
15971 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15972 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
15973 : char *arg2 = (char *) 0 ;
15974 : void *argp1 = 0 ;
15975 : int res1 = 0 ;
15976 : int bToFree2 = 0 ;
15977 : GIntBig result;
15978 :
15979 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
15980 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
15981 : if (!SWIG_IsOK(res1)) {
15982 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsInteger64" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
15983 : }
15984 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
15985 : {
15986 : /* %typemap(in) (const char *utf8_path) */
15987 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
15988 : {
15989 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
15990 : }
15991 : else
15992 : {
15993 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
15994 :
15995 : }
15996 : if (arg2 == NULL)
15997 : {
15998 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15999 : SWIG_fail;
16000 : }
16001 : }
16002 : {
16003 : const int bLocalUseExceptions = GetUseExceptions();
16004 : if ( bLocalUseExceptions ) {
16005 : pushErrorHandler();
16006 : }
16007 : {
16008 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16009 : result = OGRFeatureShadow_GetFieldAsInteger64__SWIG_1(arg1,(char const *)arg2);
16010 : SWIG_PYTHON_THREAD_END_ALLOW;
16011 : }
16012 : if ( bLocalUseExceptions ) {
16013 : popErrorHandler();
16014 : }
16015 : #ifndef SED_HACKS
16016 : if ( bLocalUseExceptions ) {
16017 : CPLErr eclass = CPLGetLastErrorType();
16018 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16019 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16020 : }
16021 : }
16022 : #endif
16023 : }
16024 : {
16025 : resultobj = PyLong_FromLongLong(result);
16026 : }
16027 : {
16028 : /* %typemap(freearg) (const char *utf8_path) */
16029 : GDALPythonFreeCStr(arg2, bToFree2);
16030 : }
16031 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
16032 : return resultobj;
16033 : fail:
16034 : {
16035 : /* %typemap(freearg) (const char *utf8_path) */
16036 : GDALPythonFreeCStr(arg2, bToFree2);
16037 : }
16038 : return NULL;
16039 : }
16040 :
16041 :
16042 1431 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsInteger64(PyObject *self, PyObject *args) {
16043 1431 : Py_ssize_t argc;
16044 1431 : PyObject *argv[3] = {
16045 : 0
16046 : };
16047 :
16048 1431 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsInteger64", 0, 2, argv))) SWIG_fail;
16049 1431 : --argc;
16050 1431 : if (argc == 2) {
16051 1431 : int _v;
16052 1431 : void *vptr = 0;
16053 1431 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16054 1431 : _v = SWIG_CheckState(res);
16055 1431 : if (_v) {
16056 1431 : {
16057 1431 : int res = SWIG_AsVal_int(argv[1], NULL);
16058 1431 : _v = SWIG_CheckState(res);
16059 : }
16060 1431 : if (_v) {
16061 1431 : return _wrap_Feature_GetFieldAsInteger64__SWIG_0(self, argc, argv);
16062 : }
16063 : }
16064 : }
16065 0 : if (argc == 2) {
16066 0 : int _v;
16067 0 : void *vptr = 0;
16068 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16069 0 : _v = SWIG_CheckState(res);
16070 0 : if (_v) {
16071 0 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16072 0 : _v = SWIG_CheckState(res);
16073 0 : if (_v) {
16074 0 : return _wrap_Feature_GetFieldAsInteger64__SWIG_1(self, argc, argv);
16075 : }
16076 : }
16077 : }
16078 :
16079 0 : fail:
16080 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsInteger64'.\n"
16081 : " Possible C/C++ prototypes are:\n"
16082 : " OGRFeatureShadow::GetFieldAsInteger64(int)\n"
16083 : " OGRFeatureShadow::GetFieldAsInteger64(char const *)\n");
16084 : return 0;
16085 : }
16086 :
16087 :
16088 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDouble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16089 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16090 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16091 : int arg2 ;
16092 : void *argp1 = 0 ;
16093 : int res1 = 0 ;
16094 : int val2 ;
16095 : int ecode2 = 0 ;
16096 : double result;
16097 :
16098 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16099 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16100 : if (!SWIG_IsOK(res1)) {
16101 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsDouble" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16102 : }
16103 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16104 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
16105 : if (!SWIG_IsOK(ecode2)) {
16106 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsDouble" "', argument " "2"" of type '" "int""'");
16107 : }
16108 : arg2 = static_cast< int >(val2);
16109 : {
16110 : const int bLocalUseExceptions = GetUseExceptions();
16111 : if ( bLocalUseExceptions ) {
16112 : pushErrorHandler();
16113 : }
16114 : {
16115 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16116 : result = (double)OGRFeatureShadow_GetFieldAsDouble__SWIG_0(arg1,arg2);
16117 : SWIG_PYTHON_THREAD_END_ALLOW;
16118 : }
16119 : if ( bLocalUseExceptions ) {
16120 : popErrorHandler();
16121 : }
16122 : #ifndef SED_HACKS
16123 : if ( bLocalUseExceptions ) {
16124 : CPLErr eclass = CPLGetLastErrorType();
16125 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16126 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16127 : }
16128 : }
16129 : #endif
16130 : }
16131 : resultobj = SWIG_From_double(static_cast< double >(result));
16132 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
16133 : return resultobj;
16134 : fail:
16135 : return NULL;
16136 : }
16137 :
16138 :
16139 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDouble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16140 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16141 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16142 : char *arg2 = (char *) 0 ;
16143 : void *argp1 = 0 ;
16144 : int res1 = 0 ;
16145 : int bToFree2 = 0 ;
16146 : double result;
16147 :
16148 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16149 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16150 : if (!SWIG_IsOK(res1)) {
16151 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsDouble" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16152 : }
16153 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16154 : {
16155 : /* %typemap(in) (const char *utf8_path) */
16156 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
16157 : {
16158 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
16159 : }
16160 : else
16161 : {
16162 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
16163 :
16164 : }
16165 : if (arg2 == NULL)
16166 : {
16167 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
16168 : SWIG_fail;
16169 : }
16170 : }
16171 : {
16172 : const int bLocalUseExceptions = GetUseExceptions();
16173 : if ( bLocalUseExceptions ) {
16174 : pushErrorHandler();
16175 : }
16176 : {
16177 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16178 : result = (double)OGRFeatureShadow_GetFieldAsDouble__SWIG_1(arg1,(char const *)arg2);
16179 : SWIG_PYTHON_THREAD_END_ALLOW;
16180 : }
16181 : if ( bLocalUseExceptions ) {
16182 : popErrorHandler();
16183 : }
16184 : #ifndef SED_HACKS
16185 : if ( bLocalUseExceptions ) {
16186 : CPLErr eclass = CPLGetLastErrorType();
16187 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16188 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16189 : }
16190 : }
16191 : #endif
16192 : }
16193 : resultobj = SWIG_From_double(static_cast< double >(result));
16194 : {
16195 : /* %typemap(freearg) (const char *utf8_path) */
16196 : GDALPythonFreeCStr(arg2, bToFree2);
16197 : }
16198 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
16199 : return resultobj;
16200 : fail:
16201 : {
16202 : /* %typemap(freearg) (const char *utf8_path) */
16203 : GDALPythonFreeCStr(arg2, bToFree2);
16204 : }
16205 : return NULL;
16206 : }
16207 :
16208 :
16209 1912 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDouble(PyObject *self, PyObject *args) {
16210 1912 : Py_ssize_t argc;
16211 1912 : PyObject *argv[3] = {
16212 : 0
16213 : };
16214 :
16215 1912 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsDouble", 0, 2, argv))) SWIG_fail;
16216 1912 : --argc;
16217 1912 : if (argc == 2) {
16218 1912 : int _v;
16219 1912 : void *vptr = 0;
16220 1912 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16221 1934 : _v = SWIG_CheckState(res);
16222 1912 : if (_v) {
16223 1912 : {
16224 1912 : int res = SWIG_AsVal_int(argv[1], NULL);
16225 1912 : _v = SWIG_CheckState(res);
16226 : }
16227 1890 : if (_v) {
16228 1890 : return _wrap_Feature_GetFieldAsDouble__SWIG_0(self, argc, argv);
16229 : }
16230 : }
16231 : }
16232 22 : if (argc == 2) {
16233 22 : int _v;
16234 22 : void *vptr = 0;
16235 22 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16236 22 : _v = SWIG_CheckState(res);
16237 22 : if (_v) {
16238 22 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16239 22 : _v = SWIG_CheckState(res);
16240 22 : if (_v) {
16241 22 : return _wrap_Feature_GetFieldAsDouble__SWIG_1(self, argc, argv);
16242 : }
16243 : }
16244 : }
16245 :
16246 0 : fail:
16247 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsDouble'.\n"
16248 : " Possible C/C++ prototypes are:\n"
16249 : " OGRFeatureShadow::GetFieldAsDouble(int)\n"
16250 : " OGRFeatureShadow::GetFieldAsDouble(char const *)\n");
16251 : return 0;
16252 : }
16253 :
16254 :
16255 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDateTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16256 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16257 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16258 : int arg2 ;
16259 : int *arg3 = (int *) 0 ;
16260 : int *arg4 = (int *) 0 ;
16261 : int *arg5 = (int *) 0 ;
16262 : int *arg6 = (int *) 0 ;
16263 : int *arg7 = (int *) 0 ;
16264 : float *arg8 = (float *) 0 ;
16265 : int *arg9 = (int *) 0 ;
16266 : void *argp1 = 0 ;
16267 : int res1 = 0 ;
16268 : int val2 ;
16269 : int ecode2 = 0 ;
16270 : int temp3 ;
16271 : int res3 = SWIG_TMPOBJ ;
16272 : int temp4 ;
16273 : int res4 = SWIG_TMPOBJ ;
16274 : int temp5 ;
16275 : int res5 = SWIG_TMPOBJ ;
16276 : int temp6 ;
16277 : int res6 = SWIG_TMPOBJ ;
16278 : int temp7 ;
16279 : int res7 = SWIG_TMPOBJ ;
16280 : float temp8 ;
16281 : int res8 = SWIG_TMPOBJ ;
16282 : int temp9 ;
16283 : int res9 = SWIG_TMPOBJ ;
16284 :
16285 : arg3 = &temp3;
16286 : arg4 = &temp4;
16287 : arg5 = &temp5;
16288 : arg6 = &temp6;
16289 : arg7 = &temp7;
16290 : arg8 = &temp8;
16291 : arg9 = &temp9;
16292 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16293 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16294 : if (!SWIG_IsOK(res1)) {
16295 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsDateTime" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16296 : }
16297 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16298 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
16299 : if (!SWIG_IsOK(ecode2)) {
16300 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsDateTime" "', argument " "2"" of type '" "int""'");
16301 : }
16302 : arg2 = static_cast< int >(val2);
16303 : {
16304 : const int bLocalUseExceptions = GetUseExceptions();
16305 : if ( bLocalUseExceptions ) {
16306 : pushErrorHandler();
16307 : }
16308 : {
16309 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16310 : OGRFeatureShadow_GetFieldAsDateTime__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
16311 : SWIG_PYTHON_THREAD_END_ALLOW;
16312 : }
16313 : if ( bLocalUseExceptions ) {
16314 : popErrorHandler();
16315 : }
16316 : #ifndef SED_HACKS
16317 : if ( bLocalUseExceptions ) {
16318 : CPLErr eclass = CPLGetLastErrorType();
16319 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16320 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16321 : }
16322 : }
16323 : #endif
16324 : }
16325 : resultobj = SWIG_Py_Void();
16326 : if (ReturnSame(SWIG_IsTmpObj(res3))) {
16327 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
16328 : } else {
16329 : int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16330 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16331 : }
16332 : if (ReturnSame(SWIG_IsTmpObj(res4))) {
16333 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
16334 : } else {
16335 : int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16336 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
16337 : }
16338 : if (ReturnSame(SWIG_IsTmpObj(res5))) {
16339 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
16340 : } else {
16341 : int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16342 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
16343 : }
16344 : if (ReturnSame(SWIG_IsTmpObj(res6))) {
16345 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
16346 : } else {
16347 : int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16348 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
16349 : }
16350 : if (ReturnSame(SWIG_IsTmpObj(res7))) {
16351 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg7)));
16352 : } else {
16353 : int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16354 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
16355 : }
16356 : if (ReturnSame(SWIG_IsTmpObj(res8))) {
16357 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg8)));
16358 : } else {
16359 : int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16360 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_float, new_flags));
16361 : }
16362 : if (ReturnSame(SWIG_IsTmpObj(res9))) {
16363 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg9)));
16364 : } else {
16365 : int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16366 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_int, new_flags));
16367 : }
16368 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
16369 : return resultobj;
16370 : fail:
16371 : return NULL;
16372 : }
16373 :
16374 :
16375 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDateTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16376 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16377 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16378 : char *arg2 = (char *) 0 ;
16379 : int *arg3 = (int *) 0 ;
16380 : int *arg4 = (int *) 0 ;
16381 : int *arg5 = (int *) 0 ;
16382 : int *arg6 = (int *) 0 ;
16383 : int *arg7 = (int *) 0 ;
16384 : float *arg8 = (float *) 0 ;
16385 : int *arg9 = (int *) 0 ;
16386 : void *argp1 = 0 ;
16387 : int res1 = 0 ;
16388 : int bToFree2 = 0 ;
16389 : int temp3 ;
16390 : int res3 = SWIG_TMPOBJ ;
16391 : int temp4 ;
16392 : int res4 = SWIG_TMPOBJ ;
16393 : int temp5 ;
16394 : int res5 = SWIG_TMPOBJ ;
16395 : int temp6 ;
16396 : int res6 = SWIG_TMPOBJ ;
16397 : int temp7 ;
16398 : int res7 = SWIG_TMPOBJ ;
16399 : float temp8 ;
16400 : int res8 = SWIG_TMPOBJ ;
16401 : int temp9 ;
16402 : int res9 = SWIG_TMPOBJ ;
16403 :
16404 : arg3 = &temp3;
16405 : arg4 = &temp4;
16406 : arg5 = &temp5;
16407 : arg6 = &temp6;
16408 : arg7 = &temp7;
16409 : arg8 = &temp8;
16410 : arg9 = &temp9;
16411 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16412 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16413 : if (!SWIG_IsOK(res1)) {
16414 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsDateTime" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16415 : }
16416 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16417 : {
16418 : /* %typemap(in) (const char *utf8_path) */
16419 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
16420 : {
16421 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
16422 : }
16423 : else
16424 : {
16425 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
16426 :
16427 : }
16428 : if (arg2 == NULL)
16429 : {
16430 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
16431 : SWIG_fail;
16432 : }
16433 : }
16434 : {
16435 : const int bLocalUseExceptions = GetUseExceptions();
16436 : if ( bLocalUseExceptions ) {
16437 : pushErrorHandler();
16438 : }
16439 : {
16440 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16441 : OGRFeatureShadow_GetFieldAsDateTime__SWIG_1(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
16442 : SWIG_PYTHON_THREAD_END_ALLOW;
16443 : }
16444 : if ( bLocalUseExceptions ) {
16445 : popErrorHandler();
16446 : }
16447 : #ifndef SED_HACKS
16448 : if ( bLocalUseExceptions ) {
16449 : CPLErr eclass = CPLGetLastErrorType();
16450 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16451 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16452 : }
16453 : }
16454 : #endif
16455 : }
16456 : resultobj = SWIG_Py_Void();
16457 : if (ReturnSame(SWIG_IsTmpObj(res3))) {
16458 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
16459 : } else {
16460 : int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16461 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16462 : }
16463 : if (ReturnSame(SWIG_IsTmpObj(res4))) {
16464 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
16465 : } else {
16466 : int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16467 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
16468 : }
16469 : if (ReturnSame(SWIG_IsTmpObj(res5))) {
16470 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
16471 : } else {
16472 : int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16473 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
16474 : }
16475 : if (ReturnSame(SWIG_IsTmpObj(res6))) {
16476 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
16477 : } else {
16478 : int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16479 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
16480 : }
16481 : if (ReturnSame(SWIG_IsTmpObj(res7))) {
16482 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg7)));
16483 : } else {
16484 : int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16485 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
16486 : }
16487 : if (ReturnSame(SWIG_IsTmpObj(res8))) {
16488 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg8)));
16489 : } else {
16490 : int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16491 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_float, new_flags));
16492 : }
16493 : if (ReturnSame(SWIG_IsTmpObj(res9))) {
16494 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg9)));
16495 : } else {
16496 : int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16497 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_int, new_flags));
16498 : }
16499 : {
16500 : /* %typemap(freearg) (const char *utf8_path) */
16501 : GDALPythonFreeCStr(arg2, bToFree2);
16502 : }
16503 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
16504 : return resultobj;
16505 : fail:
16506 : {
16507 : /* %typemap(freearg) (const char *utf8_path) */
16508 : GDALPythonFreeCStr(arg2, bToFree2);
16509 : }
16510 : return NULL;
16511 : }
16512 :
16513 :
16514 87 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDateTime(PyObject *self, PyObject *args) {
16515 87 : Py_ssize_t argc;
16516 87 : PyObject *argv[3] = {
16517 : 0
16518 : };
16519 :
16520 87 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsDateTime", 0, 2, argv))) SWIG_fail;
16521 87 : --argc;
16522 87 : if (argc == 2) {
16523 87 : int _v;
16524 87 : void *vptr = 0;
16525 87 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16526 88 : _v = SWIG_CheckState(res);
16527 87 : if (_v) {
16528 87 : {
16529 87 : int res = SWIG_AsVal_int(argv[1], NULL);
16530 87 : _v = SWIG_CheckState(res);
16531 : }
16532 86 : if (_v) {
16533 86 : return _wrap_Feature_GetFieldAsDateTime__SWIG_0(self, argc, argv);
16534 : }
16535 : }
16536 : }
16537 1 : if (argc == 2) {
16538 1 : int _v;
16539 1 : void *vptr = 0;
16540 1 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16541 1 : _v = SWIG_CheckState(res);
16542 1 : if (_v) {
16543 1 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16544 1 : _v = SWIG_CheckState(res);
16545 1 : if (_v) {
16546 1 : return _wrap_Feature_GetFieldAsDateTime__SWIG_1(self, argc, argv);
16547 : }
16548 : }
16549 : }
16550 :
16551 0 : fail:
16552 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsDateTime'.\n"
16553 : " Possible C/C++ prototypes are:\n"
16554 : " OGRFeatureShadow::GetFieldAsDateTime(int,int *,int *,int *,int *,int *,float *,int *)\n"
16555 : " OGRFeatureShadow::GetFieldAsDateTime(char const *,int *,int *,int *,int *,int *,float *,int *)\n");
16556 : return 0;
16557 : }
16558 :
16559 :
16560 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsIntegerList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16561 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16562 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16563 : int arg2 ;
16564 : int *arg3 = (int *) 0 ;
16565 : int **arg4 = (int **) 0 ;
16566 : void *argp1 = 0 ;
16567 : int res1 = 0 ;
16568 : int val2 ;
16569 : int ecode2 = 0 ;
16570 : int nLen3 = 0 ;
16571 : int *pList3 = NULL ;
16572 :
16573 : {
16574 : /* %typemap(in,numinputs=0) (int *nLen3, const int **pList3) (int nLen3, int *pList3) */
16575 : arg3 = &nLen3;
16576 : arg4 = &pList3;
16577 : }
16578 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16579 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16580 : if (!SWIG_IsOK(res1)) {
16581 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsIntegerList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16582 : }
16583 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16584 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
16585 : if (!SWIG_IsOK(ecode2)) {
16586 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsIntegerList" "', argument " "2"" of type '" "int""'");
16587 : }
16588 : arg2 = static_cast< int >(val2);
16589 : {
16590 : const int bLocalUseExceptions = GetUseExceptions();
16591 : if ( bLocalUseExceptions ) {
16592 : pushErrorHandler();
16593 : }
16594 : {
16595 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16596 : OGRFeatureShadow_GetFieldAsIntegerList__SWIG_0(arg1,arg2,arg3,(int const **)arg4);
16597 : SWIG_PYTHON_THREAD_END_ALLOW;
16598 : }
16599 : if ( bLocalUseExceptions ) {
16600 : popErrorHandler();
16601 : }
16602 : #ifndef SED_HACKS
16603 : if ( bLocalUseExceptions ) {
16604 : CPLErr eclass = CPLGetLastErrorType();
16605 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16606 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16607 : }
16608 : }
16609 : #endif
16610 : }
16611 : resultobj = SWIG_Py_Void();
16612 : {
16613 : /* %typemap(argout) (int *nLen, const int **pList ) */
16614 : Py_DECREF(resultobj);
16615 : PyObject *out = PyList_New( *arg3 );
16616 : if( !out ) {
16617 : SWIG_fail;
16618 : }
16619 : for( int i=0; i<*arg3; i++ ) {
16620 : PyObject *val = PyInt_FromLong( (*arg4)[i] );
16621 : PyList_SetItem( out, i, val );
16622 : }
16623 : resultobj = out;
16624 : }
16625 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
16626 : return resultobj;
16627 : fail:
16628 : return NULL;
16629 : }
16630 :
16631 :
16632 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsIntegerList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16633 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16634 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16635 : char *arg2 = (char *) 0 ;
16636 : int *arg3 = (int *) 0 ;
16637 : int **arg4 = (int **) 0 ;
16638 : void *argp1 = 0 ;
16639 : int res1 = 0 ;
16640 : int bToFree2 = 0 ;
16641 : int nLen3 = 0 ;
16642 : int *pList3 = NULL ;
16643 :
16644 : {
16645 : /* %typemap(in,numinputs=0) (int *nLen3, const int **pList3) (int nLen3, int *pList3) */
16646 : arg3 = &nLen3;
16647 : arg4 = &pList3;
16648 : }
16649 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16650 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16651 : if (!SWIG_IsOK(res1)) {
16652 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsIntegerList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16653 : }
16654 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16655 : {
16656 : /* %typemap(in) (const char *utf8_path) */
16657 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
16658 : {
16659 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
16660 : }
16661 : else
16662 : {
16663 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
16664 :
16665 : }
16666 : if (arg2 == NULL)
16667 : {
16668 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
16669 : SWIG_fail;
16670 : }
16671 : }
16672 : {
16673 : const int bLocalUseExceptions = GetUseExceptions();
16674 : if ( bLocalUseExceptions ) {
16675 : pushErrorHandler();
16676 : }
16677 : {
16678 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16679 : OGRFeatureShadow_GetFieldAsIntegerList__SWIG_1(arg1,(char const *)arg2,arg3,(int const **)arg4);
16680 : SWIG_PYTHON_THREAD_END_ALLOW;
16681 : }
16682 : if ( bLocalUseExceptions ) {
16683 : popErrorHandler();
16684 : }
16685 : #ifndef SED_HACKS
16686 : if ( bLocalUseExceptions ) {
16687 : CPLErr eclass = CPLGetLastErrorType();
16688 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16689 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16690 : }
16691 : }
16692 : #endif
16693 : }
16694 : resultobj = SWIG_Py_Void();
16695 : {
16696 : /* %typemap(argout) (int *nLen, const int **pList ) */
16697 : Py_DECREF(resultobj);
16698 : PyObject *out = PyList_New( *arg3 );
16699 : if( !out ) {
16700 : SWIG_fail;
16701 : }
16702 : for( int i=0; i<*arg3; i++ ) {
16703 : PyObject *val = PyInt_FromLong( (*arg4)[i] );
16704 : PyList_SetItem( out, i, val );
16705 : }
16706 : resultobj = out;
16707 : }
16708 : {
16709 : /* %typemap(freearg) (const char *utf8_path) */
16710 : GDALPythonFreeCStr(arg2, bToFree2);
16711 : }
16712 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
16713 : return resultobj;
16714 : fail:
16715 : {
16716 : /* %typemap(freearg) (const char *utf8_path) */
16717 : GDALPythonFreeCStr(arg2, bToFree2);
16718 : }
16719 : return NULL;
16720 : }
16721 :
16722 :
16723 810 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsIntegerList(PyObject *self, PyObject *args) {
16724 810 : Py_ssize_t argc;
16725 810 : PyObject *argv[3] = {
16726 : 0
16727 : };
16728 :
16729 810 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsIntegerList", 0, 2, argv))) SWIG_fail;
16730 810 : --argc;
16731 810 : if (argc == 2) {
16732 810 : int _v;
16733 810 : void *vptr = 0;
16734 810 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16735 810 : _v = SWIG_CheckState(res);
16736 810 : if (_v) {
16737 810 : {
16738 810 : int res = SWIG_AsVal_int(argv[1], NULL);
16739 810 : _v = SWIG_CheckState(res);
16740 : }
16741 810 : if (_v) {
16742 810 : return _wrap_Feature_GetFieldAsIntegerList__SWIG_0(self, argc, argv);
16743 : }
16744 : }
16745 : }
16746 0 : if (argc == 2) {
16747 0 : int _v;
16748 0 : void *vptr = 0;
16749 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
16750 0 : _v = SWIG_CheckState(res);
16751 0 : if (_v) {
16752 0 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16753 0 : _v = SWIG_CheckState(res);
16754 0 : if (_v) {
16755 0 : return _wrap_Feature_GetFieldAsIntegerList__SWIG_1(self, argc, argv);
16756 : }
16757 : }
16758 : }
16759 :
16760 0 : fail:
16761 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsIntegerList'.\n"
16762 : " Possible C/C++ prototypes are:\n"
16763 : " OGRFeatureShadow::GetFieldAsIntegerList(int,int *,int const **)\n"
16764 : " OGRFeatureShadow::GetFieldAsIntegerList(char const *,int *,int const **)\n");
16765 : return 0;
16766 : }
16767 :
16768 :
16769 331 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsInteger64List(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16770 331 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16771 331 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16772 331 : int arg2 ;
16773 331 : int *arg3 = (int *) 0 ;
16774 331 : GIntBig **arg4 = (GIntBig **) 0 ;
16775 331 : void *argp1 = 0 ;
16776 331 : int res1 = 0 ;
16777 331 : int val2 ;
16778 331 : int ecode2 = 0 ;
16779 331 : int nLen3 = 0 ;
16780 331 : GIntBig *pList3 = NULL ;
16781 331 : PyObject *swig_obj[2] ;
16782 :
16783 331 : {
16784 : /* %typemap(in,numinputs=0) (int *nLen3, const GIntBig **pList3) (int nLen3, GIntBig *pList3) */
16785 331 : arg3 = &nLen3;
16786 331 : arg4 = &pList3;
16787 : }
16788 331 : if (!SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsInteger64List", 2, 2, swig_obj)) SWIG_fail;
16789 331 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16790 331 : if (!SWIG_IsOK(res1)) {
16791 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsInteger64List" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16792 : }
16793 331 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16794 331 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
16795 331 : if (!SWIG_IsOK(ecode2)) {
16796 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsInteger64List" "', argument " "2"" of type '" "int""'");
16797 : }
16798 331 : arg2 = static_cast< int >(val2);
16799 331 : {
16800 331 : const int bLocalUseExceptions = GetUseExceptions();
16801 331 : if ( bLocalUseExceptions ) {
16802 302 : pushErrorHandler();
16803 : }
16804 331 : {
16805 331 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16806 331 : OGRFeatureShadow_GetFieldAsInteger64List(arg1,arg2,arg3,(GIntBig const **)arg4);
16807 331 : SWIG_PYTHON_THREAD_END_ALLOW;
16808 : }
16809 331 : if ( bLocalUseExceptions ) {
16810 302 : popErrorHandler();
16811 : }
16812 : #ifndef SED_HACKS
16813 : if ( bLocalUseExceptions ) {
16814 : CPLErr eclass = CPLGetLastErrorType();
16815 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16816 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16817 : }
16818 : }
16819 : #endif
16820 : }
16821 331 : resultobj = SWIG_Py_Void();
16822 331 : {
16823 : /* %typemap(argout) (int *nLen, const GIntBig **pList ) */
16824 331 : Py_DECREF(resultobj);
16825 331 : PyObject *out = PyList_New( *arg3 );
16826 331 : if( !out ) {
16827 0 : SWIG_fail;
16828 : }
16829 830 : for( int i=0; i<*arg3; i++ ) {
16830 499 : char szTmp[32];
16831 499 : snprintf(szTmp, sizeof(szTmp), CPL_FRMT_GIB, (*arg4)[i]);
16832 499 : PyObject* val;
16833 499 : val = PyLong_FromString(szTmp, NULL, 10);
16834 499 : PyList_SetItem( out, i, val );
16835 : }
16836 331 : resultobj = out;
16837 : }
16838 331 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
16839 : return resultobj;
16840 : fail:
16841 : return NULL;
16842 : }
16843 :
16844 :
16845 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDoubleList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16846 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16847 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16848 : int arg2 ;
16849 : int *arg3 = (int *) 0 ;
16850 : double **arg4 = (double **) 0 ;
16851 : void *argp1 = 0 ;
16852 : int res1 = 0 ;
16853 : int val2 ;
16854 : int ecode2 = 0 ;
16855 : int nLen3 = 0 ;
16856 : double *pList3 = NULL ;
16857 :
16858 : {
16859 : /* %typemap(in,numinputs=0) (int *nLen3, const double **pList3) (int nLen3, double *pList3) */
16860 : arg3 = &nLen3;
16861 : arg4 = &pList3;
16862 : }
16863 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16864 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16865 : if (!SWIG_IsOK(res1)) {
16866 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsDoubleList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16867 : }
16868 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16869 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
16870 : if (!SWIG_IsOK(ecode2)) {
16871 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsDoubleList" "', argument " "2"" of type '" "int""'");
16872 : }
16873 : arg2 = static_cast< int >(val2);
16874 : {
16875 : const int bLocalUseExceptions = GetUseExceptions();
16876 : if ( bLocalUseExceptions ) {
16877 : pushErrorHandler();
16878 : }
16879 : {
16880 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16881 : OGRFeatureShadow_GetFieldAsDoubleList__SWIG_0(arg1,arg2,arg3,(double const **)arg4);
16882 : SWIG_PYTHON_THREAD_END_ALLOW;
16883 : }
16884 : if ( bLocalUseExceptions ) {
16885 : popErrorHandler();
16886 : }
16887 : #ifndef SED_HACKS
16888 : if ( bLocalUseExceptions ) {
16889 : CPLErr eclass = CPLGetLastErrorType();
16890 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16891 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16892 : }
16893 : }
16894 : #endif
16895 : }
16896 : resultobj = SWIG_Py_Void();
16897 : {
16898 : /* %typemap(argout) (int *nLen, const double **pList ) */
16899 : Py_DECREF(resultobj);
16900 : PyObject *out = PyList_New( *arg3 );
16901 : if( !out ) {
16902 : SWIG_fail;
16903 : }
16904 : for( int i=0; i<*arg3; i++ ) {
16905 : PyObject *val = PyFloat_FromDouble( (*arg4)[i] );
16906 : PyList_SetItem( out, i, val );
16907 : }
16908 : resultobj = out;
16909 : }
16910 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
16911 : return resultobj;
16912 : fail:
16913 : return NULL;
16914 : }
16915 :
16916 :
16917 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDoubleList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
16918 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16919 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
16920 : char *arg2 = (char *) 0 ;
16921 : int *arg3 = (int *) 0 ;
16922 : double **arg4 = (double **) 0 ;
16923 : void *argp1 = 0 ;
16924 : int res1 = 0 ;
16925 : int bToFree2 = 0 ;
16926 : int nLen3 = 0 ;
16927 : double *pList3 = NULL ;
16928 :
16929 : {
16930 : /* %typemap(in,numinputs=0) (int *nLen3, const double **pList3) (int nLen3, double *pList3) */
16931 : arg3 = &nLen3;
16932 : arg4 = &pList3;
16933 : }
16934 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16935 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
16936 : if (!SWIG_IsOK(res1)) {
16937 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsDoubleList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
16938 : }
16939 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
16940 : {
16941 : /* %typemap(in) (const char *utf8_path) */
16942 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
16943 : {
16944 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
16945 : }
16946 : else
16947 : {
16948 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
16949 :
16950 : }
16951 : if (arg2 == NULL)
16952 : {
16953 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
16954 : SWIG_fail;
16955 : }
16956 : }
16957 : {
16958 : const int bLocalUseExceptions = GetUseExceptions();
16959 : if ( bLocalUseExceptions ) {
16960 : pushErrorHandler();
16961 : }
16962 : {
16963 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16964 : OGRFeatureShadow_GetFieldAsDoubleList__SWIG_1(arg1,(char const *)arg2,arg3,(double const **)arg4);
16965 : SWIG_PYTHON_THREAD_END_ALLOW;
16966 : }
16967 : if ( bLocalUseExceptions ) {
16968 : popErrorHandler();
16969 : }
16970 : #ifndef SED_HACKS
16971 : if ( bLocalUseExceptions ) {
16972 : CPLErr eclass = CPLGetLastErrorType();
16973 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16974 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16975 : }
16976 : }
16977 : #endif
16978 : }
16979 : resultobj = SWIG_Py_Void();
16980 : {
16981 : /* %typemap(argout) (int *nLen, const double **pList ) */
16982 : Py_DECREF(resultobj);
16983 : PyObject *out = PyList_New( *arg3 );
16984 : if( !out ) {
16985 : SWIG_fail;
16986 : }
16987 : for( int i=0; i<*arg3; i++ ) {
16988 : PyObject *val = PyFloat_FromDouble( (*arg4)[i] );
16989 : PyList_SetItem( out, i, val );
16990 : }
16991 : resultobj = out;
16992 : }
16993 : {
16994 : /* %typemap(freearg) (const char *utf8_path) */
16995 : GDALPythonFreeCStr(arg2, bToFree2);
16996 : }
16997 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
16998 : return resultobj;
16999 : fail:
17000 : {
17001 : /* %typemap(freearg) (const char *utf8_path) */
17002 : GDALPythonFreeCStr(arg2, bToFree2);
17003 : }
17004 : return NULL;
17005 : }
17006 :
17007 :
17008 659 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsDoubleList(PyObject *self, PyObject *args) {
17009 659 : Py_ssize_t argc;
17010 659 : PyObject *argv[3] = {
17011 : 0
17012 : };
17013 :
17014 659 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsDoubleList", 0, 2, argv))) SWIG_fail;
17015 659 : --argc;
17016 659 : if (argc == 2) {
17017 659 : int _v;
17018 659 : void *vptr = 0;
17019 659 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17020 659 : _v = SWIG_CheckState(res);
17021 659 : if (_v) {
17022 659 : {
17023 659 : int res = SWIG_AsVal_int(argv[1], NULL);
17024 659 : _v = SWIG_CheckState(res);
17025 : }
17026 659 : if (_v) {
17027 659 : return _wrap_Feature_GetFieldAsDoubleList__SWIG_0(self, argc, argv);
17028 : }
17029 : }
17030 : }
17031 0 : if (argc == 2) {
17032 0 : int _v;
17033 0 : void *vptr = 0;
17034 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17035 0 : _v = SWIG_CheckState(res);
17036 0 : if (_v) {
17037 0 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
17038 0 : _v = SWIG_CheckState(res);
17039 0 : if (_v) {
17040 0 : return _wrap_Feature_GetFieldAsDoubleList__SWIG_1(self, argc, argv);
17041 : }
17042 : }
17043 : }
17044 :
17045 0 : fail:
17046 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsDoubleList'.\n"
17047 : " Possible C/C++ prototypes are:\n"
17048 : " OGRFeatureShadow::GetFieldAsDoubleList(int,int *,double const **)\n"
17049 : " OGRFeatureShadow::GetFieldAsDoubleList(char const *,int *,double const **)\n");
17050 : return 0;
17051 : }
17052 :
17053 :
17054 340 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsStringList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17055 340 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17056 340 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17057 340 : int arg2 ;
17058 340 : void *argp1 = 0 ;
17059 340 : int res1 = 0 ;
17060 340 : int val2 ;
17061 340 : int ecode2 = 0 ;
17062 340 : PyObject *swig_obj[2] ;
17063 340 : char **result = 0 ;
17064 :
17065 340 : if (!SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsStringList", 2, 2, swig_obj)) SWIG_fail;
17066 340 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17067 340 : if (!SWIG_IsOK(res1)) {
17068 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsStringList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17069 : }
17070 340 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17071 340 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
17072 340 : if (!SWIG_IsOK(ecode2)) {
17073 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsStringList" "', argument " "2"" of type '" "int""'");
17074 : }
17075 340 : arg2 = static_cast< int >(val2);
17076 340 : {
17077 340 : const int bLocalUseExceptions = GetUseExceptions();
17078 340 : if ( bLocalUseExceptions ) {
17079 279 : pushErrorHandler();
17080 : }
17081 340 : {
17082 340 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17083 340 : result = (char **)OGRFeatureShadow_GetFieldAsStringList(arg1,arg2);
17084 340 : SWIG_PYTHON_THREAD_END_ALLOW;
17085 : }
17086 340 : if ( bLocalUseExceptions ) {
17087 279 : popErrorHandler();
17088 : }
17089 : #ifndef SED_HACKS
17090 : if ( bLocalUseExceptions ) {
17091 : CPLErr eclass = CPLGetLastErrorType();
17092 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17093 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17094 : }
17095 : }
17096 : #endif
17097 : }
17098 340 : {
17099 : /* %typemap(out) char **options -> ( string ) */
17100 340 : bool bErr = false;
17101 340 : resultobj = CSLToList(result, &bErr);
17102 340 : if( bErr ) {
17103 0 : SWIG_fail;
17104 : }
17105 : }
17106 340 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
17107 : return resultobj;
17108 : fail:
17109 : return NULL;
17110 : }
17111 :
17112 :
17113 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsBinary__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17114 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17115 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17116 : int arg2 ;
17117 : int *arg3 = (int *) 0 ;
17118 : char **arg4 = (char **) 0 ;
17119 : void *argp1 = 0 ;
17120 : int res1 = 0 ;
17121 : int val2 ;
17122 : int ecode2 = 0 ;
17123 : int nLen3 = 0 ;
17124 : char *pBuf3 = 0 ;
17125 : OGRErr result;
17126 :
17127 : {
17128 : /* %typemap(in,numinputs=0) (int *nLen3, char **pBuf3 ) */
17129 : arg3 = &nLen3;
17130 : arg4 = &pBuf3;
17131 : }
17132 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17133 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17134 : if (!SWIG_IsOK(res1)) {
17135 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsBinary" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17136 : }
17137 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17138 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
17139 : if (!SWIG_IsOK(ecode2)) {
17140 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldAsBinary" "', argument " "2"" of type '" "int""'");
17141 : }
17142 : arg2 = static_cast< int >(val2);
17143 : {
17144 : const int bLocalUseExceptions = GetUseExceptions();
17145 : if ( bLocalUseExceptions ) {
17146 : pushErrorHandler();
17147 : }
17148 : {
17149 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17150 : result = (OGRErr)OGRFeatureShadow_GetFieldAsBinary__SWIG_0(arg1,arg2,arg3,arg4);
17151 : SWIG_PYTHON_THREAD_END_ALLOW;
17152 : }
17153 : if ( bLocalUseExceptions ) {
17154 : popErrorHandler();
17155 : }
17156 : #ifndef SED_HACKS
17157 : if ( bLocalUseExceptions ) {
17158 : CPLErr eclass = CPLGetLastErrorType();
17159 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17160 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17161 : }
17162 : }
17163 : #endif
17164 : }
17165 : {
17166 : /* %typemap(out) OGRErr */
17167 : if ( result != 0 && GetUseExceptions()) {
17168 : const char* pszMessage = CPLGetLastErrorMsg();
17169 : if( pszMessage[0] != '\0' )
17170 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
17171 : else
17172 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
17173 : SWIG_fail;
17174 : }
17175 : }
17176 : {
17177 : /* %typemap(argout) (int *nLen, char **pBuf ) */
17178 : Py_XDECREF(resultobj);
17179 : resultobj = PyByteArray_FromStringAndSize( *arg4, *arg3 );
17180 : }
17181 : {
17182 : /* %typemap(freearg) (int *nLen, char **pBuf ) */
17183 : VSIFree( *arg4 );
17184 : }
17185 : {
17186 : /* %typemap(ret) OGRErr */
17187 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
17188 : resultobj = PyInt_FromLong( result );
17189 : }
17190 : }
17191 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
17192 : return resultobj;
17193 : fail:
17194 : {
17195 : /* %typemap(freearg) (int *nLen, char **pBuf ) */
17196 : VSIFree( *arg4 );
17197 : }
17198 : return NULL;
17199 : }
17200 :
17201 :
17202 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsBinary__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17203 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17204 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17205 : char *arg2 = (char *) 0 ;
17206 : int *arg3 = (int *) 0 ;
17207 : char **arg4 = (char **) 0 ;
17208 : void *argp1 = 0 ;
17209 : int res1 = 0 ;
17210 : int bToFree2 = 0 ;
17211 : int nLen3 = 0 ;
17212 : char *pBuf3 = 0 ;
17213 : OGRErr result;
17214 :
17215 : {
17216 : /* %typemap(in,numinputs=0) (int *nLen3, char **pBuf3 ) */
17217 : arg3 = &nLen3;
17218 : arg4 = &pBuf3;
17219 : }
17220 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17221 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17222 : if (!SWIG_IsOK(res1)) {
17223 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldAsBinary" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17224 : }
17225 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17226 : {
17227 : /* %typemap(in) (const char *utf8_path) */
17228 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
17229 : {
17230 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
17231 : }
17232 : else
17233 : {
17234 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
17235 :
17236 : }
17237 : if (arg2 == NULL)
17238 : {
17239 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
17240 : SWIG_fail;
17241 : }
17242 : }
17243 : {
17244 : const int bLocalUseExceptions = GetUseExceptions();
17245 : if ( bLocalUseExceptions ) {
17246 : pushErrorHandler();
17247 : }
17248 : {
17249 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17250 : result = (OGRErr)OGRFeatureShadow_GetFieldAsBinary__SWIG_1(arg1,(char const *)arg2,arg3,arg4);
17251 : SWIG_PYTHON_THREAD_END_ALLOW;
17252 : }
17253 : if ( bLocalUseExceptions ) {
17254 : popErrorHandler();
17255 : }
17256 : #ifndef SED_HACKS
17257 : if ( bLocalUseExceptions ) {
17258 : CPLErr eclass = CPLGetLastErrorType();
17259 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17260 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17261 : }
17262 : }
17263 : #endif
17264 : }
17265 : {
17266 : /* %typemap(out) OGRErr */
17267 : if ( result != 0 && GetUseExceptions()) {
17268 : const char* pszMessage = CPLGetLastErrorMsg();
17269 : if( pszMessage[0] != '\0' )
17270 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
17271 : else
17272 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
17273 : SWIG_fail;
17274 : }
17275 : }
17276 : {
17277 : /* %typemap(argout) (int *nLen, char **pBuf ) */
17278 : Py_XDECREF(resultobj);
17279 : resultobj = PyByteArray_FromStringAndSize( *arg4, *arg3 );
17280 : }
17281 : {
17282 : /* %typemap(freearg) (const char *utf8_path) */
17283 : GDALPythonFreeCStr(arg2, bToFree2);
17284 : }
17285 : {
17286 : /* %typemap(freearg) (int *nLen, char **pBuf ) */
17287 : VSIFree( *arg4 );
17288 : }
17289 : {
17290 : /* %typemap(ret) OGRErr */
17291 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
17292 : resultobj = PyInt_FromLong( result );
17293 : }
17294 : }
17295 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
17296 : return resultobj;
17297 : fail:
17298 : {
17299 : /* %typemap(freearg) (const char *utf8_path) */
17300 : GDALPythonFreeCStr(arg2, bToFree2);
17301 : }
17302 : {
17303 : /* %typemap(freearg) (int *nLen, char **pBuf ) */
17304 : VSIFree( *arg4 );
17305 : }
17306 : return NULL;
17307 : }
17308 :
17309 :
17310 107 : SWIGINTERN PyObject *_wrap_Feature_GetFieldAsBinary(PyObject *self, PyObject *args) {
17311 107 : Py_ssize_t argc;
17312 107 : PyObject *argv[3] = {
17313 : 0
17314 : };
17315 :
17316 107 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldAsBinary", 0, 2, argv))) SWIG_fail;
17317 107 : --argc;
17318 107 : if (argc == 2) {
17319 107 : int _v;
17320 107 : void *vptr = 0;
17321 107 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17322 175 : _v = SWIG_CheckState(res);
17323 107 : if (_v) {
17324 107 : {
17325 107 : int res = SWIG_AsVal_int(argv[1], NULL);
17326 107 : _v = SWIG_CheckState(res);
17327 : }
17328 39 : if (_v) {
17329 39 : return _wrap_Feature_GetFieldAsBinary__SWIG_0(self, argc, argv);
17330 : }
17331 : }
17332 : }
17333 68 : if (argc == 2) {
17334 68 : int _v;
17335 68 : void *vptr = 0;
17336 68 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17337 68 : _v = SWIG_CheckState(res);
17338 68 : if (_v) {
17339 68 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
17340 68 : _v = SWIG_CheckState(res);
17341 68 : if (_v) {
17342 68 : return _wrap_Feature_GetFieldAsBinary__SWIG_1(self, argc, argv);
17343 : }
17344 : }
17345 : }
17346 :
17347 0 : fail:
17348 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldAsBinary'.\n"
17349 : " Possible C/C++ prototypes are:\n"
17350 : " OGRFeatureShadow::GetFieldAsBinary(int,int *,char **)\n"
17351 : " OGRFeatureShadow::GetFieldAsBinary(char const *,int *,char **)\n");
17352 : return 0;
17353 : }
17354 :
17355 :
17356 : SWIGINTERN PyObject *_wrap_Feature_IsFieldSet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17357 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17358 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17359 : int arg2 ;
17360 : void *argp1 = 0 ;
17361 : int res1 = 0 ;
17362 : int val2 ;
17363 : int ecode2 = 0 ;
17364 : bool result;
17365 :
17366 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17367 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17368 : if (!SWIG_IsOK(res1)) {
17369 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_IsFieldSet" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17370 : }
17371 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17372 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
17373 : if (!SWIG_IsOK(ecode2)) {
17374 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_IsFieldSet" "', argument " "2"" of type '" "int""'");
17375 : }
17376 : arg2 = static_cast< int >(val2);
17377 : {
17378 : const int bLocalUseExceptions = GetUseExceptions();
17379 : if ( bLocalUseExceptions ) {
17380 : pushErrorHandler();
17381 : }
17382 : {
17383 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17384 : result = (bool)OGRFeatureShadow_IsFieldSet__SWIG_0(arg1,arg2);
17385 : SWIG_PYTHON_THREAD_END_ALLOW;
17386 : }
17387 : if ( bLocalUseExceptions ) {
17388 : popErrorHandler();
17389 : }
17390 : #ifndef SED_HACKS
17391 : if ( bLocalUseExceptions ) {
17392 : CPLErr eclass = CPLGetLastErrorType();
17393 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17394 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17395 : }
17396 : }
17397 : #endif
17398 : }
17399 : resultobj = SWIG_From_bool(static_cast< bool >(result));
17400 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
17401 : return resultobj;
17402 : fail:
17403 : return NULL;
17404 : }
17405 :
17406 :
17407 : SWIGINTERN PyObject *_wrap_Feature_IsFieldSet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17408 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17409 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17410 : char *arg2 = (char *) 0 ;
17411 : void *argp1 = 0 ;
17412 : int res1 = 0 ;
17413 : int bToFree2 = 0 ;
17414 : bool result;
17415 :
17416 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17417 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17418 : if (!SWIG_IsOK(res1)) {
17419 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_IsFieldSet" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17420 : }
17421 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17422 : {
17423 : /* %typemap(in) (const char *utf8_path) */
17424 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
17425 : {
17426 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
17427 : }
17428 : else
17429 : {
17430 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
17431 :
17432 : }
17433 : if (arg2 == NULL)
17434 : {
17435 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
17436 : SWIG_fail;
17437 : }
17438 : }
17439 : {
17440 : const int bLocalUseExceptions = GetUseExceptions();
17441 : if ( bLocalUseExceptions ) {
17442 : pushErrorHandler();
17443 : }
17444 : {
17445 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17446 : result = (bool)OGRFeatureShadow_IsFieldSet__SWIG_1(arg1,(char const *)arg2);
17447 : SWIG_PYTHON_THREAD_END_ALLOW;
17448 : }
17449 : if ( bLocalUseExceptions ) {
17450 : popErrorHandler();
17451 : }
17452 : #ifndef SED_HACKS
17453 : if ( bLocalUseExceptions ) {
17454 : CPLErr eclass = CPLGetLastErrorType();
17455 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17456 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17457 : }
17458 : }
17459 : #endif
17460 : }
17461 : resultobj = SWIG_From_bool(static_cast< bool >(result));
17462 : {
17463 : /* %typemap(freearg) (const char *utf8_path) */
17464 : GDALPythonFreeCStr(arg2, bToFree2);
17465 : }
17466 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
17467 : return resultobj;
17468 : fail:
17469 : {
17470 : /* %typemap(freearg) (const char *utf8_path) */
17471 : GDALPythonFreeCStr(arg2, bToFree2);
17472 : }
17473 : return NULL;
17474 : }
17475 :
17476 :
17477 101742 : SWIGINTERN PyObject *_wrap_Feature_IsFieldSet(PyObject *self, PyObject *args) {
17478 101742 : Py_ssize_t argc;
17479 101742 : PyObject *argv[3] = {
17480 : 0
17481 : };
17482 :
17483 101742 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_IsFieldSet", 0, 2, argv))) SWIG_fail;
17484 101742 : --argc;
17485 101742 : if (argc == 2) {
17486 101742 : int _v;
17487 101742 : void *vptr = 0;
17488 101742 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17489 101956 : _v = SWIG_CheckState(res);
17490 101742 : if (_v) {
17491 101742 : {
17492 101742 : int res = SWIG_AsVal_int(argv[1], NULL);
17493 101742 : _v = SWIG_CheckState(res);
17494 : }
17495 101528 : if (_v) {
17496 101528 : return _wrap_Feature_IsFieldSet__SWIG_0(self, argc, argv);
17497 : }
17498 : }
17499 : }
17500 214 : if (argc == 2) {
17501 214 : int _v;
17502 214 : void *vptr = 0;
17503 214 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17504 214 : _v = SWIG_CheckState(res);
17505 214 : if (_v) {
17506 214 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
17507 214 : _v = SWIG_CheckState(res);
17508 214 : if (_v) {
17509 214 : return _wrap_Feature_IsFieldSet__SWIG_1(self, argc, argv);
17510 : }
17511 : }
17512 : }
17513 :
17514 0 : fail:
17515 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_IsFieldSet'.\n"
17516 : " Possible C/C++ prototypes are:\n"
17517 : " OGRFeatureShadow::IsFieldSet(int)\n"
17518 : " OGRFeatureShadow::IsFieldSet(char const *)\n");
17519 : return 0;
17520 : }
17521 :
17522 :
17523 : SWIGINTERN PyObject *_wrap_Feature_IsFieldNull__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17524 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17525 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17526 : int arg2 ;
17527 : void *argp1 = 0 ;
17528 : int res1 = 0 ;
17529 : int val2 ;
17530 : int ecode2 = 0 ;
17531 : bool result;
17532 :
17533 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17534 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17535 : if (!SWIG_IsOK(res1)) {
17536 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_IsFieldNull" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17537 : }
17538 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17539 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
17540 : if (!SWIG_IsOK(ecode2)) {
17541 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_IsFieldNull" "', argument " "2"" of type '" "int""'");
17542 : }
17543 : arg2 = static_cast< int >(val2);
17544 : {
17545 : const int bLocalUseExceptions = GetUseExceptions();
17546 : if ( bLocalUseExceptions ) {
17547 : pushErrorHandler();
17548 : }
17549 : {
17550 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17551 : result = (bool)OGRFeatureShadow_IsFieldNull__SWIG_0(arg1,arg2);
17552 : SWIG_PYTHON_THREAD_END_ALLOW;
17553 : }
17554 : if ( bLocalUseExceptions ) {
17555 : popErrorHandler();
17556 : }
17557 : #ifndef SED_HACKS
17558 : if ( bLocalUseExceptions ) {
17559 : CPLErr eclass = CPLGetLastErrorType();
17560 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17561 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17562 : }
17563 : }
17564 : #endif
17565 : }
17566 : resultobj = SWIG_From_bool(static_cast< bool >(result));
17567 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
17568 : return resultobj;
17569 : fail:
17570 : return NULL;
17571 : }
17572 :
17573 :
17574 : SWIGINTERN PyObject *_wrap_Feature_IsFieldNull__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17575 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17576 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17577 : char *arg2 = (char *) 0 ;
17578 : void *argp1 = 0 ;
17579 : int res1 = 0 ;
17580 : int bToFree2 = 0 ;
17581 : bool result;
17582 :
17583 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17584 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17585 : if (!SWIG_IsOK(res1)) {
17586 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_IsFieldNull" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17587 : }
17588 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17589 : {
17590 : /* %typemap(in) (const char *utf8_path) */
17591 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
17592 : {
17593 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
17594 : }
17595 : else
17596 : {
17597 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
17598 :
17599 : }
17600 : if (arg2 == NULL)
17601 : {
17602 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
17603 : SWIG_fail;
17604 : }
17605 : }
17606 : {
17607 : const int bLocalUseExceptions = GetUseExceptions();
17608 : if ( bLocalUseExceptions ) {
17609 : pushErrorHandler();
17610 : }
17611 : {
17612 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17613 : result = (bool)OGRFeatureShadow_IsFieldNull__SWIG_1(arg1,(char const *)arg2);
17614 : SWIG_PYTHON_THREAD_END_ALLOW;
17615 : }
17616 : if ( bLocalUseExceptions ) {
17617 : popErrorHandler();
17618 : }
17619 : #ifndef SED_HACKS
17620 : if ( bLocalUseExceptions ) {
17621 : CPLErr eclass = CPLGetLastErrorType();
17622 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17623 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17624 : }
17625 : }
17626 : #endif
17627 : }
17628 : resultobj = SWIG_From_bool(static_cast< bool >(result));
17629 : {
17630 : /* %typemap(freearg) (const char *utf8_path) */
17631 : GDALPythonFreeCStr(arg2, bToFree2);
17632 : }
17633 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
17634 : return resultobj;
17635 : fail:
17636 : {
17637 : /* %typemap(freearg) (const char *utf8_path) */
17638 : GDALPythonFreeCStr(arg2, bToFree2);
17639 : }
17640 : return NULL;
17641 : }
17642 :
17643 :
17644 100937 : SWIGINTERN PyObject *_wrap_Feature_IsFieldNull(PyObject *self, PyObject *args) {
17645 100937 : Py_ssize_t argc;
17646 100937 : PyObject *argv[3] = {
17647 : 0
17648 : };
17649 :
17650 100937 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_IsFieldNull", 0, 2, argv))) SWIG_fail;
17651 100937 : --argc;
17652 100937 : if (argc == 2) {
17653 100937 : int _v;
17654 100937 : void *vptr = 0;
17655 100937 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17656 100993 : _v = SWIG_CheckState(res);
17657 100937 : if (_v) {
17658 100937 : {
17659 100937 : int res = SWIG_AsVal_int(argv[1], NULL);
17660 100937 : _v = SWIG_CheckState(res);
17661 : }
17662 100881 : if (_v) {
17663 100881 : return _wrap_Feature_IsFieldNull__SWIG_0(self, argc, argv);
17664 : }
17665 : }
17666 : }
17667 56 : if (argc == 2) {
17668 56 : int _v;
17669 56 : void *vptr = 0;
17670 56 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17671 56 : _v = SWIG_CheckState(res);
17672 56 : if (_v) {
17673 56 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
17674 56 : _v = SWIG_CheckState(res);
17675 56 : if (_v) {
17676 56 : return _wrap_Feature_IsFieldNull__SWIG_1(self, argc, argv);
17677 : }
17678 : }
17679 : }
17680 :
17681 0 : fail:
17682 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_IsFieldNull'.\n"
17683 : " Possible C/C++ prototypes are:\n"
17684 : " OGRFeatureShadow::IsFieldNull(int)\n"
17685 : " OGRFeatureShadow::IsFieldNull(char const *)\n");
17686 : return 0;
17687 : }
17688 :
17689 :
17690 : SWIGINTERN PyObject *_wrap_Feature_IsFieldSetAndNotNull__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17691 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17692 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17693 : int arg2 ;
17694 : void *argp1 = 0 ;
17695 : int res1 = 0 ;
17696 : int val2 ;
17697 : int ecode2 = 0 ;
17698 : bool result;
17699 :
17700 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17701 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17702 : if (!SWIG_IsOK(res1)) {
17703 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_IsFieldSetAndNotNull" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17704 : }
17705 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17706 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
17707 : if (!SWIG_IsOK(ecode2)) {
17708 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_IsFieldSetAndNotNull" "', argument " "2"" of type '" "int""'");
17709 : }
17710 : arg2 = static_cast< int >(val2);
17711 : {
17712 : const int bLocalUseExceptions = GetUseExceptions();
17713 : if ( bLocalUseExceptions ) {
17714 : pushErrorHandler();
17715 : }
17716 : {
17717 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17718 : result = (bool)OGRFeatureShadow_IsFieldSetAndNotNull__SWIG_0(arg1,arg2);
17719 : SWIG_PYTHON_THREAD_END_ALLOW;
17720 : }
17721 : if ( bLocalUseExceptions ) {
17722 : popErrorHandler();
17723 : }
17724 : #ifndef SED_HACKS
17725 : if ( bLocalUseExceptions ) {
17726 : CPLErr eclass = CPLGetLastErrorType();
17727 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17728 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17729 : }
17730 : }
17731 : #endif
17732 : }
17733 : resultobj = SWIG_From_bool(static_cast< bool >(result));
17734 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
17735 : return resultobj;
17736 : fail:
17737 : return NULL;
17738 : }
17739 :
17740 :
17741 : SWIGINTERN PyObject *_wrap_Feature_IsFieldSetAndNotNull__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
17742 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17743 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17744 : char *arg2 = (char *) 0 ;
17745 : void *argp1 = 0 ;
17746 : int res1 = 0 ;
17747 : int bToFree2 = 0 ;
17748 : bool result;
17749 :
17750 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17751 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17752 : if (!SWIG_IsOK(res1)) {
17753 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_IsFieldSetAndNotNull" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17754 : }
17755 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17756 : {
17757 : /* %typemap(in) (const char *utf8_path) */
17758 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
17759 : {
17760 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
17761 : }
17762 : else
17763 : {
17764 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
17765 :
17766 : }
17767 : if (arg2 == NULL)
17768 : {
17769 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
17770 : SWIG_fail;
17771 : }
17772 : }
17773 : {
17774 : const int bLocalUseExceptions = GetUseExceptions();
17775 : if ( bLocalUseExceptions ) {
17776 : pushErrorHandler();
17777 : }
17778 : {
17779 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17780 : result = (bool)OGRFeatureShadow_IsFieldSetAndNotNull__SWIG_1(arg1,(char const *)arg2);
17781 : SWIG_PYTHON_THREAD_END_ALLOW;
17782 : }
17783 : if ( bLocalUseExceptions ) {
17784 : popErrorHandler();
17785 : }
17786 : #ifndef SED_HACKS
17787 : if ( bLocalUseExceptions ) {
17788 : CPLErr eclass = CPLGetLastErrorType();
17789 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17790 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17791 : }
17792 : }
17793 : #endif
17794 : }
17795 : resultobj = SWIG_From_bool(static_cast< bool >(result));
17796 : {
17797 : /* %typemap(freearg) (const char *utf8_path) */
17798 : GDALPythonFreeCStr(arg2, bToFree2);
17799 : }
17800 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
17801 : return resultobj;
17802 : fail:
17803 : {
17804 : /* %typemap(freearg) (const char *utf8_path) */
17805 : GDALPythonFreeCStr(arg2, bToFree2);
17806 : }
17807 : return NULL;
17808 : }
17809 :
17810 :
17811 827 : SWIGINTERN PyObject *_wrap_Feature_IsFieldSetAndNotNull(PyObject *self, PyObject *args) {
17812 827 : Py_ssize_t argc;
17813 827 : PyObject *argv[3] = {
17814 : 0
17815 : };
17816 :
17817 827 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_IsFieldSetAndNotNull", 0, 2, argv))) SWIG_fail;
17818 827 : --argc;
17819 827 : if (argc == 2) {
17820 827 : int _v;
17821 827 : void *vptr = 0;
17822 827 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17823 879 : _v = SWIG_CheckState(res);
17824 827 : if (_v) {
17825 827 : {
17826 827 : int res = SWIG_AsVal_int(argv[1], NULL);
17827 827 : _v = SWIG_CheckState(res);
17828 : }
17829 775 : if (_v) {
17830 775 : return _wrap_Feature_IsFieldSetAndNotNull__SWIG_0(self, argc, argv);
17831 : }
17832 : }
17833 : }
17834 52 : if (argc == 2) {
17835 52 : int _v;
17836 52 : void *vptr = 0;
17837 52 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
17838 52 : _v = SWIG_CheckState(res);
17839 52 : if (_v) {
17840 52 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
17841 52 : _v = SWIG_CheckState(res);
17842 52 : if (_v) {
17843 52 : return _wrap_Feature_IsFieldSetAndNotNull__SWIG_1(self, argc, argv);
17844 : }
17845 : }
17846 : }
17847 :
17848 0 : fail:
17849 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_IsFieldSetAndNotNull'.\n"
17850 : " Possible C/C++ prototypes are:\n"
17851 : " OGRFeatureShadow::IsFieldSetAndNotNull(int)\n"
17852 : " OGRFeatureShadow::IsFieldSetAndNotNull(char const *)\n");
17853 : return 0;
17854 : }
17855 :
17856 :
17857 302 : SWIGINTERN PyObject *_wrap_Feature_GetFieldIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17858 302 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17859 302 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17860 302 : char *arg2 = (char *) 0 ;
17861 302 : void *argp1 = 0 ;
17862 302 : int res1 = 0 ;
17863 302 : int bToFree2 = 0 ;
17864 302 : PyObject *swig_obj[2] ;
17865 302 : int result;
17866 :
17867 302 : if (!SWIG_Python_UnpackTuple(args, "Feature_GetFieldIndex", 2, 2, swig_obj)) SWIG_fail;
17868 302 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17869 302 : if (!SWIG_IsOK(res1)) {
17870 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldIndex" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17871 : }
17872 302 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17873 302 : {
17874 : /* %typemap(in) (const char *utf8_path) */
17875 302 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
17876 : {
17877 302 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
17878 : }
17879 : else
17880 : {
17881 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
17882 :
17883 : }
17884 302 : if (arg2 == NULL)
17885 : {
17886 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
17887 0 : SWIG_fail;
17888 : }
17889 : }
17890 302 : {
17891 302 : const int bLocalUseExceptions = GetUseExceptions();
17892 302 : if ( bLocalUseExceptions ) {
17893 72 : pushErrorHandler();
17894 : }
17895 302 : {
17896 302 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17897 302 : result = (int)OGRFeatureShadow_GetFieldIndex(arg1,(char const *)arg2);
17898 302 : SWIG_PYTHON_THREAD_END_ALLOW;
17899 : }
17900 302 : if ( bLocalUseExceptions ) {
17901 72 : popErrorHandler();
17902 : }
17903 : #ifndef SED_HACKS
17904 : if ( bLocalUseExceptions ) {
17905 : CPLErr eclass = CPLGetLastErrorType();
17906 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17907 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17908 : }
17909 : }
17910 : #endif
17911 : }
17912 302 : resultobj = SWIG_From_int(static_cast< int >(result));
17913 302 : {
17914 : /* %typemap(freearg) (const char *utf8_path) */
17915 302 : GDALPythonFreeCStr(arg2, bToFree2);
17916 : }
17917 302 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
17918 : return resultobj;
17919 0 : fail:
17920 0 : {
17921 : /* %typemap(freearg) (const char *utf8_path) */
17922 302 : GDALPythonFreeCStr(arg2, bToFree2);
17923 : }
17924 : return NULL;
17925 : }
17926 :
17927 :
17928 72 : SWIGINTERN PyObject *_wrap_Feature_GetGeomFieldIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17929 72 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17930 72 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
17931 72 : char *arg2 = (char *) 0 ;
17932 72 : void *argp1 = 0 ;
17933 72 : int res1 = 0 ;
17934 72 : int bToFree2 = 0 ;
17935 72 : PyObject *swig_obj[2] ;
17936 72 : int result;
17937 :
17938 72 : if (!SWIG_Python_UnpackTuple(args, "Feature_GetGeomFieldIndex", 2, 2, swig_obj)) SWIG_fail;
17939 72 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
17940 72 : if (!SWIG_IsOK(res1)) {
17941 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetGeomFieldIndex" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
17942 : }
17943 72 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
17944 72 : {
17945 : /* %typemap(in) (const char *utf8_path) */
17946 72 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
17947 : {
17948 72 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
17949 : }
17950 : else
17951 : {
17952 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
17953 :
17954 : }
17955 72 : if (arg2 == NULL)
17956 : {
17957 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
17958 0 : SWIG_fail;
17959 : }
17960 : }
17961 72 : {
17962 72 : const int bLocalUseExceptions = GetUseExceptions();
17963 72 : if ( bLocalUseExceptions ) {
17964 0 : pushErrorHandler();
17965 : }
17966 72 : {
17967 72 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17968 72 : result = (int)OGRFeatureShadow_GetGeomFieldIndex(arg1,(char const *)arg2);
17969 72 : SWIG_PYTHON_THREAD_END_ALLOW;
17970 : }
17971 72 : if ( bLocalUseExceptions ) {
17972 0 : popErrorHandler();
17973 : }
17974 : #ifndef SED_HACKS
17975 : if ( bLocalUseExceptions ) {
17976 : CPLErr eclass = CPLGetLastErrorType();
17977 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17978 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17979 : }
17980 : }
17981 : #endif
17982 : }
17983 72 : resultobj = SWIG_From_int(static_cast< int >(result));
17984 72 : {
17985 : /* %typemap(freearg) (const char *utf8_path) */
17986 72 : GDALPythonFreeCStr(arg2, bToFree2);
17987 : }
17988 72 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
17989 : return resultobj;
17990 0 : fail:
17991 0 : {
17992 : /* %typemap(freearg) (const char *utf8_path) */
17993 72 : GDALPythonFreeCStr(arg2, bToFree2);
17994 : }
17995 : return NULL;
17996 : }
17997 :
17998 :
17999 5216 : SWIGINTERN PyObject *_wrap_Feature_GetFID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18000 5216 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18001 5216 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18002 5216 : void *argp1 = 0 ;
18003 5216 : int res1 = 0 ;
18004 5216 : PyObject *swig_obj[1] ;
18005 5216 : GIntBig result;
18006 :
18007 5216 : if (!args) SWIG_fail;
18008 5216 : swig_obj[0] = args;
18009 5216 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18010 5216 : if (!SWIG_IsOK(res1)) {
18011 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFID" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18012 : }
18013 5216 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18014 5216 : {
18015 5216 : const int bLocalUseExceptions = GetUseExceptions();
18016 5216 : if ( bLocalUseExceptions ) {
18017 3486 : pushErrorHandler();
18018 : }
18019 5216 : {
18020 5216 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18021 5216 : result = OGRFeatureShadow_GetFID(arg1);
18022 5216 : SWIG_PYTHON_THREAD_END_ALLOW;
18023 : }
18024 5216 : if ( bLocalUseExceptions ) {
18025 3486 : popErrorHandler();
18026 : }
18027 : #ifndef SED_HACKS
18028 : if ( bLocalUseExceptions ) {
18029 : CPLErr eclass = CPLGetLastErrorType();
18030 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18031 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18032 : }
18033 : }
18034 : #endif
18035 : }
18036 5216 : {
18037 5216 : resultobj = PyLong_FromLongLong(result);
18038 : }
18039 5216 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
18040 : return resultobj;
18041 : fail:
18042 : return NULL;
18043 : }
18044 :
18045 :
18046 160519 : SWIGINTERN PyObject *_wrap_Feature_SetFID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18047 160519 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18048 160519 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18049 160519 : GIntBig arg2 ;
18050 160519 : void *argp1 = 0 ;
18051 160519 : int res1 = 0 ;
18052 160519 : PyObject *swig_obj[2] ;
18053 160519 : OGRErr result;
18054 :
18055 160519 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFID", 2, 2, swig_obj)) SWIG_fail;
18056 160519 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18057 160519 : if (!SWIG_IsOK(res1)) {
18058 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFID" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18059 : }
18060 160519 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18061 160519 : {
18062 160519 : arg2 = (GIntBig)PyLong_AsLongLong(swig_obj[1]);
18063 : }
18064 160519 : {
18065 160519 : const int bLocalUseExceptions = GetUseExceptions();
18066 160519 : if ( bLocalUseExceptions ) {
18067 160070 : pushErrorHandler();
18068 : }
18069 160519 : {
18070 160519 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18071 160519 : result = (OGRErr)OGRFeatureShadow_SetFID(arg1,arg2);
18072 160519 : SWIG_PYTHON_THREAD_END_ALLOW;
18073 : }
18074 160519 : if ( bLocalUseExceptions ) {
18075 160070 : popErrorHandler();
18076 : }
18077 : #ifndef SED_HACKS
18078 : if ( bLocalUseExceptions ) {
18079 : CPLErr eclass = CPLGetLastErrorType();
18080 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18081 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18082 : }
18083 : }
18084 : #endif
18085 : }
18086 160519 : {
18087 : /* %typemap(out) OGRErr */
18088 160519 : if ( result != 0 && GetUseExceptions()) {
18089 0 : const char* pszMessage = CPLGetLastErrorMsg();
18090 0 : if( pszMessage[0] != '\0' )
18091 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
18092 : else
18093 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
18094 0 : SWIG_fail;
18095 : }
18096 : }
18097 160519 : {
18098 : /* %typemap(ret) OGRErr */
18099 160519 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
18100 160519 : resultobj = PyInt_FromLong( result );
18101 : }
18102 : }
18103 160519 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
18104 : return resultobj;
18105 : fail:
18106 : return NULL;
18107 : }
18108 :
18109 :
18110 1 : SWIGINTERN PyObject *_wrap_Feature_DumpReadable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18111 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18112 1 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18113 1 : void *argp1 = 0 ;
18114 1 : int res1 = 0 ;
18115 1 : PyObject *swig_obj[1] ;
18116 :
18117 1 : if (!args) SWIG_fail;
18118 1 : swig_obj[0] = args;
18119 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18120 1 : if (!SWIG_IsOK(res1)) {
18121 2 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_DumpReadable" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18122 : }
18123 0 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18124 0 : {
18125 0 : const int bLocalUseExceptions = GetUseExceptions();
18126 0 : if ( bLocalUseExceptions ) {
18127 0 : pushErrorHandler();
18128 : }
18129 0 : {
18130 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18131 0 : OGRFeatureShadow_DumpReadable(arg1);
18132 0 : SWIG_PYTHON_THREAD_END_ALLOW;
18133 : }
18134 0 : if ( bLocalUseExceptions ) {
18135 0 : popErrorHandler();
18136 : }
18137 : #ifndef SED_HACKS
18138 : if ( bLocalUseExceptions ) {
18139 : CPLErr eclass = CPLGetLastErrorType();
18140 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18141 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18142 : }
18143 : }
18144 : #endif
18145 : }
18146 0 : resultobj = SWIG_Py_Void();
18147 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
18148 : return resultobj;
18149 : fail:
18150 : return NULL;
18151 : }
18152 :
18153 :
18154 52 : SWIGINTERN PyObject *_wrap_Feature_DumpReadableAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18155 52 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18156 52 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18157 52 : char **arg2 = (char **) NULL ;
18158 52 : void *argp1 = 0 ;
18159 52 : int res1 = 0 ;
18160 52 : PyObject *swig_obj[2] ;
18161 52 : retStringAndCPLFree *result = 0 ;
18162 :
18163 52 : if (!SWIG_Python_UnpackTuple(args, "Feature_DumpReadableAsString", 1, 2, swig_obj)) SWIG_fail;
18164 52 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18165 52 : if (!SWIG_IsOK(res1)) {
18166 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_DumpReadableAsString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18167 : }
18168 52 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18169 52 : if (swig_obj[1]) {
18170 3 : {
18171 : /* %typemap(in) char **dict */
18172 3 : arg2 = NULL;
18173 3 : if ( PySequence_Check( swig_obj[1] ) ) {
18174 0 : int bErr = FALSE;
18175 0 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
18176 0 : if ( bErr )
18177 : {
18178 0 : SWIG_fail;
18179 : }
18180 : }
18181 3 : else if ( PyMapping_Check( swig_obj[1] ) ) {
18182 3 : int bErr = FALSE;
18183 3 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
18184 3 : if ( bErr )
18185 : {
18186 0 : SWIG_fail;
18187 : }
18188 : }
18189 : else {
18190 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
18191 0 : SWIG_fail;
18192 : }
18193 : }
18194 : }
18195 52 : {
18196 52 : const int bLocalUseExceptions = GetUseExceptions();
18197 52 : if ( bLocalUseExceptions ) {
18198 52 : pushErrorHandler();
18199 : }
18200 52 : {
18201 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18202 52 : result = (retStringAndCPLFree *)OGRFeatureShadow_DumpReadableAsString(arg1,arg2);
18203 52 : SWIG_PYTHON_THREAD_END_ALLOW;
18204 : }
18205 52 : if ( bLocalUseExceptions ) {
18206 52 : popErrorHandler();
18207 : }
18208 : #ifndef SED_HACKS
18209 : if ( bLocalUseExceptions ) {
18210 : CPLErr eclass = CPLGetLastErrorType();
18211 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18212 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18213 : }
18214 : }
18215 : #endif
18216 : }
18217 52 : {
18218 : /* %typemap(out) (retStringAndCPLFree*) */
18219 52 : Py_XDECREF(resultobj);
18220 52 : if(result)
18221 : {
18222 52 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
18223 52 : CPLFree(result);
18224 : }
18225 : else
18226 : {
18227 0 : resultobj = Py_None;
18228 0 : Py_INCREF(resultobj);
18229 : }
18230 : }
18231 52 : {
18232 : /* %typemap(freearg) char **dict */
18233 52 : CSLDestroy( arg2 );
18234 : }
18235 52 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
18236 : return resultobj;
18237 0 : fail:
18238 0 : {
18239 : /* %typemap(freearg) char **dict */
18240 0 : CSLDestroy( arg2 );
18241 : }
18242 : return NULL;
18243 : }
18244 :
18245 :
18246 : SWIGINTERN PyObject *_wrap_Feature_UnsetField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18247 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18248 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18249 : int arg2 ;
18250 : void *argp1 = 0 ;
18251 : int res1 = 0 ;
18252 : int val2 ;
18253 : int ecode2 = 0 ;
18254 :
18255 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
18256 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18257 : if (!SWIG_IsOK(res1)) {
18258 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_UnsetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18259 : }
18260 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18261 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
18262 : if (!SWIG_IsOK(ecode2)) {
18263 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_UnsetField" "', argument " "2"" of type '" "int""'");
18264 : }
18265 : arg2 = static_cast< int >(val2);
18266 : {
18267 : const int bLocalUseExceptions = GetUseExceptions();
18268 : if ( bLocalUseExceptions ) {
18269 : pushErrorHandler();
18270 : }
18271 : {
18272 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18273 : OGRFeatureShadow_UnsetField__SWIG_0(arg1,arg2);
18274 : SWIG_PYTHON_THREAD_END_ALLOW;
18275 : }
18276 : if ( bLocalUseExceptions ) {
18277 : popErrorHandler();
18278 : }
18279 : #ifndef SED_HACKS
18280 : if ( bLocalUseExceptions ) {
18281 : CPLErr eclass = CPLGetLastErrorType();
18282 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18283 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18284 : }
18285 : }
18286 : #endif
18287 : }
18288 : resultobj = SWIG_Py_Void();
18289 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
18290 : return resultobj;
18291 : fail:
18292 : return NULL;
18293 : }
18294 :
18295 :
18296 : SWIGINTERN PyObject *_wrap_Feature_UnsetField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18297 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18298 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18299 : char *arg2 = (char *) 0 ;
18300 : void *argp1 = 0 ;
18301 : int res1 = 0 ;
18302 : int bToFree2 = 0 ;
18303 :
18304 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
18305 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18306 : if (!SWIG_IsOK(res1)) {
18307 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_UnsetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18308 : }
18309 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18310 : {
18311 : /* %typemap(in) (const char *utf8_path) */
18312 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
18313 : {
18314 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
18315 : }
18316 : else
18317 : {
18318 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
18319 :
18320 : }
18321 : if (arg2 == NULL)
18322 : {
18323 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
18324 : SWIG_fail;
18325 : }
18326 : }
18327 : {
18328 : const int bLocalUseExceptions = GetUseExceptions();
18329 : if ( bLocalUseExceptions ) {
18330 : pushErrorHandler();
18331 : }
18332 : {
18333 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18334 : OGRFeatureShadow_UnsetField__SWIG_1(arg1,(char const *)arg2);
18335 : SWIG_PYTHON_THREAD_END_ALLOW;
18336 : }
18337 : if ( bLocalUseExceptions ) {
18338 : popErrorHandler();
18339 : }
18340 : #ifndef SED_HACKS
18341 : if ( bLocalUseExceptions ) {
18342 : CPLErr eclass = CPLGetLastErrorType();
18343 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18344 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18345 : }
18346 : }
18347 : #endif
18348 : }
18349 : resultobj = SWIG_Py_Void();
18350 : {
18351 : /* %typemap(freearg) (const char *utf8_path) */
18352 : GDALPythonFreeCStr(arg2, bToFree2);
18353 : }
18354 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
18355 : return resultobj;
18356 : fail:
18357 : {
18358 : /* %typemap(freearg) (const char *utf8_path) */
18359 : GDALPythonFreeCStr(arg2, bToFree2);
18360 : }
18361 : return NULL;
18362 : }
18363 :
18364 :
18365 5 : SWIGINTERN PyObject *_wrap_Feature_UnsetField(PyObject *self, PyObject *args) {
18366 5 : Py_ssize_t argc;
18367 5 : PyObject *argv[3] = {
18368 : 0
18369 : };
18370 :
18371 5 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_UnsetField", 0, 2, argv))) SWIG_fail;
18372 5 : --argc;
18373 5 : if (argc == 2) {
18374 5 : int _v;
18375 5 : void *vptr = 0;
18376 5 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
18377 9 : _v = SWIG_CheckState(res);
18378 5 : if (_v) {
18379 5 : {
18380 5 : int res = SWIG_AsVal_int(argv[1], NULL);
18381 5 : _v = SWIG_CheckState(res);
18382 : }
18383 1 : if (_v) {
18384 1 : return _wrap_Feature_UnsetField__SWIG_0(self, argc, argv);
18385 : }
18386 : }
18387 : }
18388 4 : if (argc == 2) {
18389 4 : int _v;
18390 4 : void *vptr = 0;
18391 4 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
18392 4 : _v = SWIG_CheckState(res);
18393 4 : if (_v) {
18394 4 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
18395 4 : _v = SWIG_CheckState(res);
18396 4 : if (_v) {
18397 4 : return _wrap_Feature_UnsetField__SWIG_1(self, argc, argv);
18398 : }
18399 : }
18400 : }
18401 :
18402 0 : fail:
18403 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_UnsetField'.\n"
18404 : " Possible C/C++ prototypes are:\n"
18405 : " OGRFeatureShadow::UnsetField(int)\n"
18406 : " OGRFeatureShadow::UnsetField(char const *)\n");
18407 : return 0;
18408 : }
18409 :
18410 :
18411 : SWIGINTERN PyObject *_wrap_Feature_SetFieldNull__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18412 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18413 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18414 : int arg2 ;
18415 : void *argp1 = 0 ;
18416 : int res1 = 0 ;
18417 : int val2 ;
18418 : int ecode2 = 0 ;
18419 :
18420 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
18421 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18422 : if (!SWIG_IsOK(res1)) {
18423 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldNull" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18424 : }
18425 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18426 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
18427 : if (!SWIG_IsOK(ecode2)) {
18428 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldNull" "', argument " "2"" of type '" "int""'");
18429 : }
18430 : arg2 = static_cast< int >(val2);
18431 : {
18432 : const int bLocalUseExceptions = GetUseExceptions();
18433 : if ( bLocalUseExceptions ) {
18434 : pushErrorHandler();
18435 : }
18436 : {
18437 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18438 : OGRFeatureShadow_SetFieldNull__SWIG_0(arg1,arg2);
18439 : SWIG_PYTHON_THREAD_END_ALLOW;
18440 : }
18441 : if ( bLocalUseExceptions ) {
18442 : popErrorHandler();
18443 : }
18444 : #ifndef SED_HACKS
18445 : if ( bLocalUseExceptions ) {
18446 : CPLErr eclass = CPLGetLastErrorType();
18447 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18448 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18449 : }
18450 : }
18451 : #endif
18452 : }
18453 : resultobj = SWIG_Py_Void();
18454 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
18455 : return resultobj;
18456 : fail:
18457 : return NULL;
18458 : }
18459 :
18460 :
18461 : SWIGINTERN PyObject *_wrap_Feature_SetFieldNull__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18462 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18463 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18464 : char *arg2 = (char *) 0 ;
18465 : void *argp1 = 0 ;
18466 : int res1 = 0 ;
18467 : int bToFree2 = 0 ;
18468 :
18469 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
18470 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18471 : if (!SWIG_IsOK(res1)) {
18472 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldNull" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18473 : }
18474 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18475 : {
18476 : /* %typemap(in) (const char *utf8_path) */
18477 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
18478 : {
18479 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
18480 : }
18481 : else
18482 : {
18483 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
18484 :
18485 : }
18486 : if (arg2 == NULL)
18487 : {
18488 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
18489 : SWIG_fail;
18490 : }
18491 : }
18492 : {
18493 : const int bLocalUseExceptions = GetUseExceptions();
18494 : if ( bLocalUseExceptions ) {
18495 : pushErrorHandler();
18496 : }
18497 : {
18498 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18499 : OGRFeatureShadow_SetFieldNull__SWIG_1(arg1,(char const *)arg2);
18500 : SWIG_PYTHON_THREAD_END_ALLOW;
18501 : }
18502 : if ( bLocalUseExceptions ) {
18503 : popErrorHandler();
18504 : }
18505 : #ifndef SED_HACKS
18506 : if ( bLocalUseExceptions ) {
18507 : CPLErr eclass = CPLGetLastErrorType();
18508 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18509 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18510 : }
18511 : }
18512 : #endif
18513 : }
18514 : resultobj = SWIG_Py_Void();
18515 : {
18516 : /* %typemap(freearg) (const char *utf8_path) */
18517 : GDALPythonFreeCStr(arg2, bToFree2);
18518 : }
18519 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
18520 : return resultobj;
18521 : fail:
18522 : {
18523 : /* %typemap(freearg) (const char *utf8_path) */
18524 : GDALPythonFreeCStr(arg2, bToFree2);
18525 : }
18526 : return NULL;
18527 : }
18528 :
18529 :
18530 47 : SWIGINTERN PyObject *_wrap_Feature_SetFieldNull(PyObject *self, PyObject *args) {
18531 47 : Py_ssize_t argc;
18532 47 : PyObject *argv[3] = {
18533 : 0
18534 : };
18535 :
18536 47 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_SetFieldNull", 0, 2, argv))) SWIG_fail;
18537 47 : --argc;
18538 47 : if (argc == 2) {
18539 47 : int _v;
18540 47 : void *vptr = 0;
18541 47 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
18542 66 : _v = SWIG_CheckState(res);
18543 47 : if (_v) {
18544 47 : {
18545 47 : int res = SWIG_AsVal_int(argv[1], NULL);
18546 47 : _v = SWIG_CheckState(res);
18547 : }
18548 28 : if (_v) {
18549 28 : return _wrap_Feature_SetFieldNull__SWIG_0(self, argc, argv);
18550 : }
18551 : }
18552 : }
18553 19 : if (argc == 2) {
18554 19 : int _v;
18555 19 : void *vptr = 0;
18556 19 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
18557 19 : _v = SWIG_CheckState(res);
18558 19 : if (_v) {
18559 19 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
18560 19 : _v = SWIG_CheckState(res);
18561 19 : if (_v) {
18562 19 : return _wrap_Feature_SetFieldNull__SWIG_1(self, argc, argv);
18563 : }
18564 : }
18565 : }
18566 :
18567 0 : fail:
18568 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_SetFieldNull'.\n"
18569 : " Possible C/C++ prototypes are:\n"
18570 : " OGRFeatureShadow::SetFieldNull(int)\n"
18571 : " OGRFeatureShadow::SetFieldNull(char const *)\n");
18572 : return 0;
18573 : }
18574 :
18575 :
18576 : SWIGINTERN PyObject *_wrap_Feature_SetField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18577 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18578 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18579 : int arg2 ;
18580 : char *arg3 = (char *) 0 ;
18581 : void *argp1 = 0 ;
18582 : int res1 = 0 ;
18583 : int val2 ;
18584 : int ecode2 = 0 ;
18585 : PyObject *str3 = 0 ;
18586 : int bToFree3 = 0 ;
18587 :
18588 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
18589 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18590 : if (!SWIG_IsOK(res1)) {
18591 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18592 : }
18593 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18594 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
18595 : if (!SWIG_IsOK(ecode2)) {
18596 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetField" "', argument " "2"" of type '" "int""'");
18597 : }
18598 : arg2 = static_cast< int >(val2);
18599 : {
18600 : /* %typemap(in) (tostring argin) */
18601 : str3 = PyObject_Str( swig_obj[2] );
18602 : if ( str3 == 0 ) {
18603 : PyErr_SetString( PyExc_RuntimeError, "Unable to format argument as string");
18604 : SWIG_fail;
18605 : }
18606 :
18607 : arg3 = GDALPythonObjectToCStr(str3, &bToFree3);
18608 : }
18609 : {
18610 : const int bLocalUseExceptions = GetUseExceptions();
18611 : if ( bLocalUseExceptions ) {
18612 : pushErrorHandler();
18613 : }
18614 : {
18615 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18616 : OGRFeatureShadow_SetField__SWIG_0(arg1,arg2,(char const *)arg3);
18617 : SWIG_PYTHON_THREAD_END_ALLOW;
18618 : }
18619 : if ( bLocalUseExceptions ) {
18620 : popErrorHandler();
18621 : }
18622 : #ifndef SED_HACKS
18623 : if ( bLocalUseExceptions ) {
18624 : CPLErr eclass = CPLGetLastErrorType();
18625 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18626 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18627 : }
18628 : }
18629 : #endif
18630 : }
18631 : resultobj = SWIG_Py_Void();
18632 : {
18633 : /* %typemap(freearg) (tostring argin) */
18634 : if ( str3 != NULL)
18635 : {
18636 : Py_DECREF(str3);
18637 : }
18638 : GDALPythonFreeCStr(arg3, bToFree3);
18639 : }
18640 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
18641 : return resultobj;
18642 : fail:
18643 : {
18644 : /* %typemap(freearg) (tostring argin) */
18645 : if ( str3 != NULL)
18646 : {
18647 : Py_DECREF(str3);
18648 : }
18649 : GDALPythonFreeCStr(arg3, bToFree3);
18650 : }
18651 : return NULL;
18652 : }
18653 :
18654 :
18655 : SWIGINTERN PyObject *_wrap_Feature_SetField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18656 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18657 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18658 : char *arg2 = (char *) 0 ;
18659 : char *arg3 = (char *) 0 ;
18660 : void *argp1 = 0 ;
18661 : int res1 = 0 ;
18662 : int bToFree2 = 0 ;
18663 : PyObject *str3 = 0 ;
18664 : int bToFree3 = 0 ;
18665 :
18666 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
18667 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18668 : if (!SWIG_IsOK(res1)) {
18669 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18670 : }
18671 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18672 : {
18673 : /* %typemap(in) (const char *utf8_path) */
18674 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
18675 : {
18676 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
18677 : }
18678 : else
18679 : {
18680 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
18681 :
18682 : }
18683 : if (arg2 == NULL)
18684 : {
18685 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
18686 : SWIG_fail;
18687 : }
18688 : }
18689 : {
18690 : /* %typemap(in) (tostring argin) */
18691 : str3 = PyObject_Str( swig_obj[2] );
18692 : if ( str3 == 0 ) {
18693 : PyErr_SetString( PyExc_RuntimeError, "Unable to format argument as string");
18694 : SWIG_fail;
18695 : }
18696 :
18697 : arg3 = GDALPythonObjectToCStr(str3, &bToFree3);
18698 : }
18699 : {
18700 : const int bLocalUseExceptions = GetUseExceptions();
18701 : if ( bLocalUseExceptions ) {
18702 : pushErrorHandler();
18703 : }
18704 : {
18705 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18706 : OGRFeatureShadow_SetField__SWIG_1(arg1,(char const *)arg2,(char const *)arg3);
18707 : SWIG_PYTHON_THREAD_END_ALLOW;
18708 : }
18709 : if ( bLocalUseExceptions ) {
18710 : popErrorHandler();
18711 : }
18712 : #ifndef SED_HACKS
18713 : if ( bLocalUseExceptions ) {
18714 : CPLErr eclass = CPLGetLastErrorType();
18715 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18716 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18717 : }
18718 : }
18719 : #endif
18720 : }
18721 : resultobj = SWIG_Py_Void();
18722 : {
18723 : /* %typemap(freearg) (const char *utf8_path) */
18724 : GDALPythonFreeCStr(arg2, bToFree2);
18725 : }
18726 : {
18727 : /* %typemap(freearg) (tostring argin) */
18728 : if ( str3 != NULL)
18729 : {
18730 : Py_DECREF(str3);
18731 : }
18732 : GDALPythonFreeCStr(arg3, bToFree3);
18733 : }
18734 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
18735 : return resultobj;
18736 : fail:
18737 : {
18738 : /* %typemap(freearg) (const char *utf8_path) */
18739 : GDALPythonFreeCStr(arg2, bToFree2);
18740 : }
18741 : {
18742 : /* %typemap(freearg) (tostring argin) */
18743 : if ( str3 != NULL)
18744 : {
18745 : Py_DECREF(str3);
18746 : }
18747 : GDALPythonFreeCStr(arg3, bToFree3);
18748 : }
18749 : return NULL;
18750 : }
18751 :
18752 :
18753 86786 : SWIGINTERN PyObject *_wrap_Feature_SetFieldInteger64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18754 86786 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18755 86786 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18756 86786 : int arg2 ;
18757 86786 : GIntBig arg3 ;
18758 86786 : void *argp1 = 0 ;
18759 86786 : int res1 = 0 ;
18760 86786 : int val2 ;
18761 86786 : int ecode2 = 0 ;
18762 86786 : PyObject *swig_obj[3] ;
18763 :
18764 86786 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFieldInteger64", 3, 3, swig_obj)) SWIG_fail;
18765 86786 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18766 86786 : if (!SWIG_IsOK(res1)) {
18767 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldInteger64" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18768 : }
18769 86786 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18770 86786 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
18771 86786 : if (!SWIG_IsOK(ecode2)) {
18772 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldInteger64" "', argument " "2"" of type '" "int""'");
18773 : }
18774 86786 : arg2 = static_cast< int >(val2);
18775 86786 : {
18776 86786 : arg3 = (GIntBig)PyLong_AsLongLong(swig_obj[2]);
18777 : }
18778 86786 : {
18779 86786 : const int bLocalUseExceptions = GetUseExceptions();
18780 86786 : if ( bLocalUseExceptions ) {
18781 68437 : pushErrorHandler();
18782 : }
18783 86786 : {
18784 86786 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18785 86786 : OGRFeatureShadow_SetFieldInteger64(arg1,arg2,arg3);
18786 86786 : SWIG_PYTHON_THREAD_END_ALLOW;
18787 : }
18788 86786 : if ( bLocalUseExceptions ) {
18789 68437 : popErrorHandler();
18790 : }
18791 : #ifndef SED_HACKS
18792 : if ( bLocalUseExceptions ) {
18793 : CPLErr eclass = CPLGetLastErrorType();
18794 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18795 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18796 : }
18797 : }
18798 : #endif
18799 : }
18800 86786 : resultobj = SWIG_Py_Void();
18801 86786 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
18802 : return resultobj;
18803 : fail:
18804 : return NULL;
18805 : }
18806 :
18807 :
18808 : SWIGINTERN PyObject *_wrap_Feature_SetField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18809 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18810 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18811 : int arg2 ;
18812 : double arg3 ;
18813 : void *argp1 = 0 ;
18814 : int res1 = 0 ;
18815 : int val2 ;
18816 : int ecode2 = 0 ;
18817 : double val3 ;
18818 : int ecode3 = 0 ;
18819 :
18820 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
18821 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18822 : if (!SWIG_IsOK(res1)) {
18823 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18824 : }
18825 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18826 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
18827 : if (!SWIG_IsOK(ecode2)) {
18828 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetField" "', argument " "2"" of type '" "int""'");
18829 : }
18830 : arg2 = static_cast< int >(val2);
18831 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
18832 : if (!SWIG_IsOK(ecode3)) {
18833 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Feature_SetField" "', argument " "3"" of type '" "double""'");
18834 : }
18835 : arg3 = static_cast< double >(val3);
18836 : {
18837 : const int bLocalUseExceptions = GetUseExceptions();
18838 : if ( bLocalUseExceptions ) {
18839 : pushErrorHandler();
18840 : }
18841 : {
18842 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18843 : OGRFeatureShadow_SetField__SWIG_2(arg1,arg2,arg3);
18844 : SWIG_PYTHON_THREAD_END_ALLOW;
18845 : }
18846 : if ( bLocalUseExceptions ) {
18847 : popErrorHandler();
18848 : }
18849 : #ifndef SED_HACKS
18850 : if ( bLocalUseExceptions ) {
18851 : CPLErr eclass = CPLGetLastErrorType();
18852 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18853 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18854 : }
18855 : }
18856 : #endif
18857 : }
18858 : resultobj = SWIG_Py_Void();
18859 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
18860 : return resultobj;
18861 : fail:
18862 : return NULL;
18863 : }
18864 :
18865 :
18866 : SWIGINTERN PyObject *_wrap_Feature_SetField__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18867 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18868 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18869 : char *arg2 = (char *) 0 ;
18870 : double arg3 ;
18871 : void *argp1 = 0 ;
18872 : int res1 = 0 ;
18873 : int bToFree2 = 0 ;
18874 : double val3 ;
18875 : int ecode3 = 0 ;
18876 :
18877 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
18878 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18879 : if (!SWIG_IsOK(res1)) {
18880 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18881 : }
18882 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18883 : {
18884 : /* %typemap(in) (const char *utf8_path) */
18885 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
18886 : {
18887 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
18888 : }
18889 : else
18890 : {
18891 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
18892 :
18893 : }
18894 : if (arg2 == NULL)
18895 : {
18896 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
18897 : SWIG_fail;
18898 : }
18899 : }
18900 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
18901 : if (!SWIG_IsOK(ecode3)) {
18902 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Feature_SetField" "', argument " "3"" of type '" "double""'");
18903 : }
18904 : arg3 = static_cast< double >(val3);
18905 : {
18906 : const int bLocalUseExceptions = GetUseExceptions();
18907 : if ( bLocalUseExceptions ) {
18908 : pushErrorHandler();
18909 : }
18910 : {
18911 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18912 : OGRFeatureShadow_SetField__SWIG_3(arg1,(char const *)arg2,arg3);
18913 : SWIG_PYTHON_THREAD_END_ALLOW;
18914 : }
18915 : if ( bLocalUseExceptions ) {
18916 : popErrorHandler();
18917 : }
18918 : #ifndef SED_HACKS
18919 : if ( bLocalUseExceptions ) {
18920 : CPLErr eclass = CPLGetLastErrorType();
18921 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18922 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18923 : }
18924 : }
18925 : #endif
18926 : }
18927 : resultobj = SWIG_Py_Void();
18928 : {
18929 : /* %typemap(freearg) (const char *utf8_path) */
18930 : GDALPythonFreeCStr(arg2, bToFree2);
18931 : }
18932 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
18933 : return resultobj;
18934 : fail:
18935 : {
18936 : /* %typemap(freearg) (const char *utf8_path) */
18937 : GDALPythonFreeCStr(arg2, bToFree2);
18938 : }
18939 : return NULL;
18940 : }
18941 :
18942 :
18943 : SWIGINTERN PyObject *_wrap_Feature_SetField__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18944 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18945 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
18946 : int arg2 ;
18947 : int arg3 ;
18948 : int arg4 ;
18949 : int arg5 ;
18950 : int arg6 ;
18951 : int arg7 ;
18952 : float arg8 ;
18953 : int arg9 ;
18954 : void *argp1 = 0 ;
18955 : int res1 = 0 ;
18956 : int val2 ;
18957 : int ecode2 = 0 ;
18958 : int val3 ;
18959 : int ecode3 = 0 ;
18960 : int val4 ;
18961 : int ecode4 = 0 ;
18962 : int val5 ;
18963 : int ecode5 = 0 ;
18964 : int val6 ;
18965 : int ecode6 = 0 ;
18966 : int val7 ;
18967 : int ecode7 = 0 ;
18968 : float val8 ;
18969 : int ecode8 = 0 ;
18970 : int val9 ;
18971 : int ecode9 = 0 ;
18972 :
18973 : if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
18974 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
18975 : if (!SWIG_IsOK(res1)) {
18976 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
18977 : }
18978 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
18979 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
18980 : if (!SWIG_IsOK(ecode2)) {
18981 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetField" "', argument " "2"" of type '" "int""'");
18982 : }
18983 : arg2 = static_cast< int >(val2);
18984 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
18985 : if (!SWIG_IsOK(ecode3)) {
18986 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Feature_SetField" "', argument " "3"" of type '" "int""'");
18987 : }
18988 : arg3 = static_cast< int >(val3);
18989 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
18990 : if (!SWIG_IsOK(ecode4)) {
18991 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Feature_SetField" "', argument " "4"" of type '" "int""'");
18992 : }
18993 : arg4 = static_cast< int >(val4);
18994 : ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
18995 : if (!SWIG_IsOK(ecode5)) {
18996 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Feature_SetField" "', argument " "5"" of type '" "int""'");
18997 : }
18998 : arg5 = static_cast< int >(val5);
18999 : ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
19000 : if (!SWIG_IsOK(ecode6)) {
19001 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Feature_SetField" "', argument " "6"" of type '" "int""'");
19002 : }
19003 : arg6 = static_cast< int >(val6);
19004 : ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
19005 : if (!SWIG_IsOK(ecode7)) {
19006 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Feature_SetField" "', argument " "7"" of type '" "int""'");
19007 : }
19008 : arg7 = static_cast< int >(val7);
19009 : ecode8 = SWIG_AsVal_float(swig_obj[7], &val8);
19010 : if (!SWIG_IsOK(ecode8)) {
19011 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Feature_SetField" "', argument " "8"" of type '" "float""'");
19012 : }
19013 : arg8 = static_cast< float >(val8);
19014 : ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
19015 : if (!SWIG_IsOK(ecode9)) {
19016 : SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Feature_SetField" "', argument " "9"" of type '" "int""'");
19017 : }
19018 : arg9 = static_cast< int >(val9);
19019 : {
19020 : const int bLocalUseExceptions = GetUseExceptions();
19021 : if ( bLocalUseExceptions ) {
19022 : pushErrorHandler();
19023 : }
19024 : {
19025 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19026 : OGRFeatureShadow_SetField__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
19027 : SWIG_PYTHON_THREAD_END_ALLOW;
19028 : }
19029 : if ( bLocalUseExceptions ) {
19030 : popErrorHandler();
19031 : }
19032 : #ifndef SED_HACKS
19033 : if ( bLocalUseExceptions ) {
19034 : CPLErr eclass = CPLGetLastErrorType();
19035 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19036 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19037 : }
19038 : }
19039 : #endif
19040 : }
19041 : resultobj = SWIG_Py_Void();
19042 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
19043 : return resultobj;
19044 : fail:
19045 : return NULL;
19046 : }
19047 :
19048 :
19049 : SWIGINTERN PyObject *_wrap_Feature_SetField__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
19050 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19051 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19052 : char *arg2 = (char *) 0 ;
19053 : int arg3 ;
19054 : int arg4 ;
19055 : int arg5 ;
19056 : int arg6 ;
19057 : int arg7 ;
19058 : float arg8 ;
19059 : int arg9 ;
19060 : void *argp1 = 0 ;
19061 : int res1 = 0 ;
19062 : int bToFree2 = 0 ;
19063 : int val3 ;
19064 : int ecode3 = 0 ;
19065 : int val4 ;
19066 : int ecode4 = 0 ;
19067 : int val5 ;
19068 : int ecode5 = 0 ;
19069 : int val6 ;
19070 : int ecode6 = 0 ;
19071 : int val7 ;
19072 : int ecode7 = 0 ;
19073 : float val8 ;
19074 : int ecode8 = 0 ;
19075 : int val9 ;
19076 : int ecode9 = 0 ;
19077 :
19078 : if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
19079 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19080 : if (!SWIG_IsOK(res1)) {
19081 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19082 : }
19083 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19084 : {
19085 : /* %typemap(in) (const char *utf8_path) */
19086 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
19087 : {
19088 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
19089 : }
19090 : else
19091 : {
19092 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
19093 :
19094 : }
19095 : if (arg2 == NULL)
19096 : {
19097 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
19098 : SWIG_fail;
19099 : }
19100 : }
19101 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
19102 : if (!SWIG_IsOK(ecode3)) {
19103 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Feature_SetField" "', argument " "3"" of type '" "int""'");
19104 : }
19105 : arg3 = static_cast< int >(val3);
19106 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
19107 : if (!SWIG_IsOK(ecode4)) {
19108 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Feature_SetField" "', argument " "4"" of type '" "int""'");
19109 : }
19110 : arg4 = static_cast< int >(val4);
19111 : ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
19112 : if (!SWIG_IsOK(ecode5)) {
19113 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Feature_SetField" "', argument " "5"" of type '" "int""'");
19114 : }
19115 : arg5 = static_cast< int >(val5);
19116 : ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
19117 : if (!SWIG_IsOK(ecode6)) {
19118 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Feature_SetField" "', argument " "6"" of type '" "int""'");
19119 : }
19120 : arg6 = static_cast< int >(val6);
19121 : ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
19122 : if (!SWIG_IsOK(ecode7)) {
19123 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Feature_SetField" "', argument " "7"" of type '" "int""'");
19124 : }
19125 : arg7 = static_cast< int >(val7);
19126 : ecode8 = SWIG_AsVal_float(swig_obj[7], &val8);
19127 : if (!SWIG_IsOK(ecode8)) {
19128 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Feature_SetField" "', argument " "8"" of type '" "float""'");
19129 : }
19130 : arg8 = static_cast< float >(val8);
19131 : ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
19132 : if (!SWIG_IsOK(ecode9)) {
19133 : SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Feature_SetField" "', argument " "9"" of type '" "int""'");
19134 : }
19135 : arg9 = static_cast< int >(val9);
19136 : {
19137 : const int bLocalUseExceptions = GetUseExceptions();
19138 : if ( bLocalUseExceptions ) {
19139 : pushErrorHandler();
19140 : }
19141 : {
19142 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19143 : OGRFeatureShadow_SetField__SWIG_5(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
19144 : SWIG_PYTHON_THREAD_END_ALLOW;
19145 : }
19146 : if ( bLocalUseExceptions ) {
19147 : popErrorHandler();
19148 : }
19149 : #ifndef SED_HACKS
19150 : if ( bLocalUseExceptions ) {
19151 : CPLErr eclass = CPLGetLastErrorType();
19152 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19153 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19154 : }
19155 : }
19156 : #endif
19157 : }
19158 : resultobj = SWIG_Py_Void();
19159 : {
19160 : /* %typemap(freearg) (const char *utf8_path) */
19161 : GDALPythonFreeCStr(arg2, bToFree2);
19162 : }
19163 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
19164 : return resultobj;
19165 : fail:
19166 : {
19167 : /* %typemap(freearg) (const char *utf8_path) */
19168 : GDALPythonFreeCStr(arg2, bToFree2);
19169 : }
19170 : return NULL;
19171 : }
19172 :
19173 :
19174 2606 : SWIGINTERN PyObject *_wrap_Feature_SetField(PyObject *self, PyObject *args) {
19175 2606 : Py_ssize_t argc;
19176 2606 : PyObject *argv[10] = {
19177 : 0
19178 : };
19179 :
19180 2606 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_SetField", 0, 9, argv))) SWIG_fail;
19181 2606 : --argc;
19182 2606 : if (argc == 3) {
19183 2562 : int _v;
19184 2562 : void *vptr = 0;
19185 2562 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19186 4857 : _v = SWIG_CheckState(res);
19187 2562 : if (_v) {
19188 2562 : {
19189 2562 : int res = SWIG_AsVal_int(argv[1], NULL);
19190 2562 : _v = SWIG_CheckState(res);
19191 : }
19192 267 : if (_v) {
19193 267 : {
19194 267 : int res = SWIG_AsVal_double(argv[2], NULL);
19195 267 : _v = SWIG_CheckState(res);
19196 : }
19197 267 : if (_v) {
19198 267 : return _wrap_Feature_SetField__SWIG_2(self, argc, argv);
19199 : }
19200 : }
19201 : }
19202 : }
19203 2339 : if (argc == 3) {
19204 2295 : int _v;
19205 2295 : void *vptr = 0;
19206 2295 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19207 4590 : _v = SWIG_CheckState(res);
19208 2295 : if (_v) {
19209 2295 : {
19210 2295 : int res = SWIG_AsVal_int(argv[1], NULL);
19211 2295 : _v = SWIG_CheckState(res);
19212 : }
19213 0 : if (_v) {
19214 0 : int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
19215 0 : _v = SWIG_CheckState(res);
19216 0 : if (_v) {
19217 0 : return _wrap_Feature_SetField__SWIG_0(self, argc, argv);
19218 : }
19219 : }
19220 : }
19221 : }
19222 2339 : if (argc == 3) {
19223 2295 : int _v;
19224 2295 : void *vptr = 0;
19225 2295 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19226 2295 : _v = SWIG_CheckState(res);
19227 2295 : if (_v) {
19228 2295 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
19229 2295 : _v = SWIG_CheckState(res);
19230 2295 : if (_v) {
19231 2295 : {
19232 2295 : int res = SWIG_AsVal_double(argv[2], NULL);
19233 2295 : _v = SWIG_CheckState(res);
19234 : }
19235 2295 : if (_v) {
19236 2295 : return _wrap_Feature_SetField__SWIG_3(self, argc, argv);
19237 : }
19238 : }
19239 : }
19240 : }
19241 44 : if (argc == 3) {
19242 0 : int _v;
19243 0 : void *vptr = 0;
19244 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19245 0 : _v = SWIG_CheckState(res);
19246 0 : if (_v) {
19247 0 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
19248 0 : _v = SWIG_CheckState(res);
19249 0 : if (_v) {
19250 0 : int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
19251 0 : _v = SWIG_CheckState(res);
19252 0 : if (_v) {
19253 0 : return _wrap_Feature_SetField__SWIG_1(self, argc, argv);
19254 : }
19255 : }
19256 : }
19257 : }
19258 44 : if (argc == 9) {
19259 44 : int _v;
19260 44 : void *vptr = 0;
19261 44 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19262 64 : _v = SWIG_CheckState(res);
19263 44 : if (_v) {
19264 44 : {
19265 44 : int res = SWIG_AsVal_int(argv[1], NULL);
19266 44 : _v = SWIG_CheckState(res);
19267 : }
19268 24 : if (_v) {
19269 24 : {
19270 24 : int res = SWIG_AsVal_int(argv[2], NULL);
19271 24 : _v = SWIG_CheckState(res);
19272 : }
19273 24 : if (_v) {
19274 24 : {
19275 24 : int res = SWIG_AsVal_int(argv[3], NULL);
19276 24 : _v = SWIG_CheckState(res);
19277 : }
19278 24 : if (_v) {
19279 24 : {
19280 24 : int res = SWIG_AsVal_int(argv[4], NULL);
19281 24 : _v = SWIG_CheckState(res);
19282 : }
19283 24 : if (_v) {
19284 24 : {
19285 24 : int res = SWIG_AsVal_int(argv[5], NULL);
19286 24 : _v = SWIG_CheckState(res);
19287 : }
19288 24 : if (_v) {
19289 24 : {
19290 24 : int res = SWIG_AsVal_int(argv[6], NULL);
19291 24 : _v = SWIG_CheckState(res);
19292 : }
19293 24 : if (_v) {
19294 24 : {
19295 24 : int res = SWIG_AsVal_float(argv[7], NULL);
19296 24 : _v = SWIG_CheckState(res);
19297 : }
19298 24 : if (_v) {
19299 24 : {
19300 24 : int res = SWIG_AsVal_int(argv[8], NULL);
19301 24 : _v = SWIG_CheckState(res);
19302 : }
19303 24 : if (_v) {
19304 24 : return _wrap_Feature_SetField__SWIG_4(self, argc, argv);
19305 : }
19306 : }
19307 : }
19308 : }
19309 : }
19310 : }
19311 : }
19312 : }
19313 : }
19314 : }
19315 20 : if (argc == 9) {
19316 20 : int _v;
19317 20 : void *vptr = 0;
19318 20 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19319 20 : _v = SWIG_CheckState(res);
19320 20 : if (_v) {
19321 20 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
19322 20 : _v = SWIG_CheckState(res);
19323 20 : if (_v) {
19324 20 : {
19325 20 : int res = SWIG_AsVal_int(argv[2], NULL);
19326 20 : _v = SWIG_CheckState(res);
19327 : }
19328 20 : if (_v) {
19329 20 : {
19330 20 : int res = SWIG_AsVal_int(argv[3], NULL);
19331 20 : _v = SWIG_CheckState(res);
19332 : }
19333 20 : if (_v) {
19334 20 : {
19335 20 : int res = SWIG_AsVal_int(argv[4], NULL);
19336 20 : _v = SWIG_CheckState(res);
19337 : }
19338 20 : if (_v) {
19339 20 : {
19340 20 : int res = SWIG_AsVal_int(argv[5], NULL);
19341 20 : _v = SWIG_CheckState(res);
19342 : }
19343 20 : if (_v) {
19344 20 : {
19345 20 : int res = SWIG_AsVal_int(argv[6], NULL);
19346 20 : _v = SWIG_CheckState(res);
19347 : }
19348 20 : if (_v) {
19349 20 : {
19350 20 : int res = SWIG_AsVal_float(argv[7], NULL);
19351 20 : _v = SWIG_CheckState(res);
19352 : }
19353 20 : if (_v) {
19354 20 : {
19355 20 : int res = SWIG_AsVal_int(argv[8], NULL);
19356 20 : _v = SWIG_CheckState(res);
19357 : }
19358 20 : if (_v) {
19359 20 : return _wrap_Feature_SetField__SWIG_5(self, argc, argv);
19360 : }
19361 : }
19362 : }
19363 : }
19364 : }
19365 : }
19366 : }
19367 : }
19368 : }
19369 : }
19370 :
19371 0 : fail:
19372 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_SetField'.\n"
19373 : " Possible C/C++ prototypes are:\n"
19374 : " OGRFeatureShadow::SetField(int,char const *)\n"
19375 : " OGRFeatureShadow::SetField(char const *,char const *)\n"
19376 : " OGRFeatureShadow::SetField(int,double)\n"
19377 : " OGRFeatureShadow::SetField(char const *,double)\n"
19378 : " OGRFeatureShadow::SetField(int,int,int,int,int,int,float,int)\n"
19379 : " OGRFeatureShadow::SetField(char const *,int,int,int,int,int,float,int)\n");
19380 : return 0;
19381 : }
19382 :
19383 :
19384 9 : SWIGINTERN PyObject *_wrap_Feature_SetFieldIntegerList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19385 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19386 9 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19387 9 : int arg2 ;
19388 9 : int arg3 ;
19389 9 : int *arg4 = (int *) 0 ;
19390 9 : void *argp1 = 0 ;
19391 9 : int res1 = 0 ;
19392 9 : int val2 ;
19393 9 : int ecode2 = 0 ;
19394 9 : PyObject *swig_obj[3] ;
19395 :
19396 9 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFieldIntegerList", 3, 3, swig_obj)) SWIG_fail;
19397 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19398 9 : if (!SWIG_IsOK(res1)) {
19399 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldIntegerList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19400 : }
19401 9 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19402 9 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
19403 9 : if (!SWIG_IsOK(ecode2)) {
19404 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldIntegerList" "', argument " "2"" of type '" "int""'");
19405 : }
19406 9 : arg2 = static_cast< int >(val2);
19407 9 : {
19408 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
19409 9 : arg4 = CreateCIntListFromSequence(swig_obj[2], &arg3);
19410 9 : if( arg3 < 0 ) {
19411 0 : SWIG_fail;
19412 : }
19413 : }
19414 9 : {
19415 9 : const int bLocalUseExceptions = GetUseExceptions();
19416 9 : if ( bLocalUseExceptions ) {
19417 6 : pushErrorHandler();
19418 : }
19419 9 : {
19420 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19421 9 : OGRFeatureShadow_SetFieldIntegerList(arg1,arg2,arg3,arg4);
19422 9 : SWIG_PYTHON_THREAD_END_ALLOW;
19423 : }
19424 9 : if ( bLocalUseExceptions ) {
19425 6 : popErrorHandler();
19426 : }
19427 : #ifndef SED_HACKS
19428 : if ( bLocalUseExceptions ) {
19429 : CPLErr eclass = CPLGetLastErrorType();
19430 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19431 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19432 : }
19433 : }
19434 : #endif
19435 : }
19436 9 : resultobj = SWIG_Py_Void();
19437 9 : {
19438 : /* %typemap(freearg) (int nList, int* pList) */
19439 9 : free(arg4);
19440 : }
19441 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
19442 : return resultobj;
19443 0 : fail:
19444 0 : {
19445 : /* %typemap(freearg) (int nList, int* pList) */
19446 0 : free(arg4);
19447 : }
19448 0 : return NULL;
19449 : }
19450 :
19451 :
19452 122 : SWIGINTERN PyObject *_wrap_Feature_SetFieldInteger64List(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19453 122 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19454 122 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19455 122 : int arg2 ;
19456 122 : int arg3 ;
19457 122 : GIntBig *arg4 = (GIntBig *) 0 ;
19458 122 : void *argp1 = 0 ;
19459 122 : int res1 = 0 ;
19460 122 : int val2 ;
19461 122 : int ecode2 = 0 ;
19462 122 : PyObject *swig_obj[3] ;
19463 :
19464 122 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFieldInteger64List", 3, 3, swig_obj)) SWIG_fail;
19465 122 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19466 122 : if (!SWIG_IsOK(res1)) {
19467 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldInteger64List" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19468 : }
19469 122 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19470 122 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
19471 122 : if (!SWIG_IsOK(ecode2)) {
19472 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldInteger64List" "', argument " "2"" of type '" "int""'");
19473 : }
19474 122 : arg2 = static_cast< int >(val2);
19475 122 : {
19476 : /* %typemap(in,numinputs=1) (int nList, GIntBig* pList)*/
19477 122 : arg4 = CreateCGIntBigListFromSequence(swig_obj[2], &arg3);
19478 122 : if( arg3 < 0 ) {
19479 0 : SWIG_fail;
19480 : }
19481 : }
19482 122 : {
19483 122 : const int bLocalUseExceptions = GetUseExceptions();
19484 122 : if ( bLocalUseExceptions ) {
19485 114 : pushErrorHandler();
19486 : }
19487 122 : {
19488 122 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19489 122 : OGRFeatureShadow_SetFieldInteger64List(arg1,arg2,arg3,arg4);
19490 122 : SWIG_PYTHON_THREAD_END_ALLOW;
19491 : }
19492 122 : if ( bLocalUseExceptions ) {
19493 114 : popErrorHandler();
19494 : }
19495 : #ifndef SED_HACKS
19496 : if ( bLocalUseExceptions ) {
19497 : CPLErr eclass = CPLGetLastErrorType();
19498 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19499 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19500 : }
19501 : }
19502 : #endif
19503 : }
19504 122 : resultobj = SWIG_Py_Void();
19505 122 : {
19506 : /* %typemap(freearg) (int nList, GIntBig* pList) */
19507 122 : free(arg4);
19508 : }
19509 122 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
19510 : return resultobj;
19511 0 : fail:
19512 0 : {
19513 : /* %typemap(freearg) (int nList, GIntBig* pList) */
19514 0 : free(arg4);
19515 : }
19516 0 : return NULL;
19517 : }
19518 :
19519 :
19520 90 : SWIGINTERN PyObject *_wrap_Feature_SetFieldDoubleList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19521 90 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19522 90 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19523 90 : int arg2 ;
19524 90 : int arg3 ;
19525 90 : double *arg4 = (double *) 0 ;
19526 90 : void *argp1 = 0 ;
19527 90 : int res1 = 0 ;
19528 90 : int val2 ;
19529 90 : int ecode2 = 0 ;
19530 90 : PyObject *swig_obj[3] ;
19531 :
19532 90 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFieldDoubleList", 3, 3, swig_obj)) SWIG_fail;
19533 90 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19534 90 : if (!SWIG_IsOK(res1)) {
19535 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldDoubleList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19536 : }
19537 90 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19538 90 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
19539 90 : if (!SWIG_IsOK(ecode2)) {
19540 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldDoubleList" "', argument " "2"" of type '" "int""'");
19541 : }
19542 90 : arg2 = static_cast< int >(val2);
19543 90 : {
19544 : /* %typemap(in,numinputs=1) (int nList, double* pList)*/
19545 90 : arg4 = CreateCDoubleListFromSequence(swig_obj[2], &arg3);
19546 90 : if( arg3 < 0 ) {
19547 0 : SWIG_fail;
19548 : }
19549 : }
19550 90 : {
19551 90 : const int bLocalUseExceptions = GetUseExceptions();
19552 90 : if ( bLocalUseExceptions ) {
19553 74 : pushErrorHandler();
19554 : }
19555 90 : {
19556 90 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19557 90 : OGRFeatureShadow_SetFieldDoubleList(arg1,arg2,arg3,arg4);
19558 90 : SWIG_PYTHON_THREAD_END_ALLOW;
19559 : }
19560 90 : if ( bLocalUseExceptions ) {
19561 74 : popErrorHandler();
19562 : }
19563 : #ifndef SED_HACKS
19564 : if ( bLocalUseExceptions ) {
19565 : CPLErr eclass = CPLGetLastErrorType();
19566 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19567 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19568 : }
19569 : }
19570 : #endif
19571 : }
19572 90 : resultobj = SWIG_Py_Void();
19573 90 : {
19574 : /* %typemap(freearg) (int nList, double* pList) */
19575 90 : free(arg4);
19576 : }
19577 90 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
19578 : return resultobj;
19579 0 : fail:
19580 0 : {
19581 : /* %typemap(freearg) (int nList, double* pList) */
19582 0 : free(arg4);
19583 : }
19584 0 : return NULL;
19585 : }
19586 :
19587 :
19588 42 : SWIGINTERN PyObject *_wrap_Feature_SetFieldStringList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19589 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19590 42 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19591 42 : int arg2 ;
19592 42 : char **arg3 = (char **) 0 ;
19593 42 : void *argp1 = 0 ;
19594 42 : int res1 = 0 ;
19595 42 : int val2 ;
19596 42 : int ecode2 = 0 ;
19597 42 : PyObject *swig_obj[3] ;
19598 :
19599 42 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFieldStringList", 3, 3, swig_obj)) SWIG_fail;
19600 42 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19601 42 : if (!SWIG_IsOK(res1)) {
19602 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldStringList" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19603 : }
19604 42 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19605 42 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
19606 42 : if (!SWIG_IsOK(ecode2)) {
19607 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldStringList" "', argument " "2"" of type '" "int""'");
19608 : }
19609 42 : arg2 = static_cast< int >(val2);
19610 42 : {
19611 : /* %typemap(in) char **dict */
19612 42 : arg3 = NULL;
19613 42 : if ( PySequence_Check( swig_obj[2] ) ) {
19614 42 : int bErr = FALSE;
19615 42 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
19616 42 : if ( bErr )
19617 : {
19618 0 : SWIG_fail;
19619 : }
19620 : }
19621 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
19622 0 : int bErr = FALSE;
19623 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
19624 0 : if ( bErr )
19625 : {
19626 0 : SWIG_fail;
19627 : }
19628 : }
19629 : else {
19630 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
19631 0 : SWIG_fail;
19632 : }
19633 : }
19634 42 : {
19635 42 : const int bLocalUseExceptions = GetUseExceptions();
19636 42 : if ( bLocalUseExceptions ) {
19637 38 : pushErrorHandler();
19638 : }
19639 42 : {
19640 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19641 42 : OGRFeatureShadow_SetFieldStringList(arg1,arg2,arg3);
19642 42 : SWIG_PYTHON_THREAD_END_ALLOW;
19643 : }
19644 42 : if ( bLocalUseExceptions ) {
19645 38 : popErrorHandler();
19646 : }
19647 : #ifndef SED_HACKS
19648 : if ( bLocalUseExceptions ) {
19649 : CPLErr eclass = CPLGetLastErrorType();
19650 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19651 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19652 : }
19653 : }
19654 : #endif
19655 : }
19656 42 : resultobj = SWIG_Py_Void();
19657 42 : {
19658 : /* %typemap(freearg) char **dict */
19659 42 : CSLDestroy( arg3 );
19660 : }
19661 42 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
19662 : return resultobj;
19663 0 : fail:
19664 0 : {
19665 : /* %typemap(freearg) char **dict */
19666 0 : CSLDestroy( arg3 );
19667 : }
19668 : return NULL;
19669 : }
19670 :
19671 :
19672 1195 : SWIGINTERN PyObject *_wrap_Feature__SetFieldBinary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19673 1195 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19674 1195 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19675 1195 : int arg2 ;
19676 1195 : int arg3 ;
19677 1195 : char *arg4 = (char *) 0 ;
19678 1195 : void *argp1 = 0 ;
19679 1195 : int res1 = 0 ;
19680 1195 : int val2 ;
19681 1195 : int ecode2 = 0 ;
19682 1195 : int alloc3 = 0 ;
19683 1195 : bool viewIsValid3 = false ;
19684 1195 : Py_buffer view3 ;
19685 1195 : PyObject *swig_obj[3] ;
19686 :
19687 1195 : if (!SWIG_Python_UnpackTuple(args, "Feature__SetFieldBinary", 3, 3, swig_obj)) SWIG_fail;
19688 1195 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19689 1195 : if (!SWIG_IsOK(res1)) {
19690 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature__SetFieldBinary" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19691 : }
19692 1195 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19693 1195 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
19694 1195 : if (!SWIG_IsOK(ecode2)) {
19695 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature__SetFieldBinary" "', argument " "2"" of type '" "int""'");
19696 : }
19697 1195 : arg2 = static_cast< int >(val2);
19698 1195 : {
19699 : /* %typemap(in,numinputs=1) (int nLen, char *pBuf ) */
19700 1195 : char* ptr = NULL;
19701 1195 : if( !GetBufferAsCharPtrIntSize(swig_obj[2], &arg3, &ptr, &alloc3, &viewIsValid3, &view3) ) {
19702 0 : SWIG_fail;
19703 : }
19704 1195 : arg4 = (char *)ptr;
19705 : }
19706 1195 : {
19707 1195 : const int bLocalUseExceptions = GetUseExceptions();
19708 1195 : if ( bLocalUseExceptions ) {
19709 54 : pushErrorHandler();
19710 : }
19711 1195 : {
19712 1195 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19713 1195 : OGRFeatureShadow__SetFieldBinary(arg1,arg2,arg3,arg4);
19714 1195 : SWIG_PYTHON_THREAD_END_ALLOW;
19715 : }
19716 1195 : if ( bLocalUseExceptions ) {
19717 54 : popErrorHandler();
19718 : }
19719 : #ifndef SED_HACKS
19720 : if ( bLocalUseExceptions ) {
19721 : CPLErr eclass = CPLGetLastErrorType();
19722 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19723 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19724 : }
19725 : }
19726 : #endif
19727 : }
19728 1195 : resultobj = SWIG_Py_Void();
19729 1195 : {
19730 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
19731 1195 : if( viewIsValid3 ) {
19732 1195 : PyBuffer_Release(&view3);
19733 : }
19734 0 : else if (ReturnSame(alloc3) == SWIG_NEWOBJ ) {
19735 0 : delete[] arg4;
19736 : }
19737 : }
19738 1195 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
19739 : return resultobj;
19740 0 : fail:
19741 0 : {
19742 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
19743 0 : if( viewIsValid3 ) {
19744 0 : PyBuffer_Release(&view3);
19745 : }
19746 1195 : else if (ReturnSame(alloc3) == SWIG_NEWOBJ ) {
19747 : delete[] arg4;
19748 : }
19749 : }
19750 : return NULL;
19751 : }
19752 :
19753 :
19754 : SWIGINTERN PyObject *_wrap_Feature_SetFieldBinaryFromHexString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
19755 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19756 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19757 : int arg2 ;
19758 : char *arg3 = (char *) 0 ;
19759 : void *argp1 = 0 ;
19760 : int res1 = 0 ;
19761 : int val2 ;
19762 : int ecode2 = 0 ;
19763 : int res3 ;
19764 : char *buf3 = 0 ;
19765 : int alloc3 = 0 ;
19766 :
19767 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
19768 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19769 : if (!SWIG_IsOK(res1)) {
19770 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldBinaryFromHexString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19771 : }
19772 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19773 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
19774 : if (!SWIG_IsOK(ecode2)) {
19775 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldBinaryFromHexString" "', argument " "2"" of type '" "int""'");
19776 : }
19777 : arg2 = static_cast< int >(val2);
19778 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
19779 : if (!SWIG_IsOK(res3)) {
19780 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Feature_SetFieldBinaryFromHexString" "', argument " "3"" of type '" "char const *""'");
19781 : }
19782 : arg3 = reinterpret_cast< char * >(buf3);
19783 : {
19784 : const int bLocalUseExceptions = GetUseExceptions();
19785 : if ( bLocalUseExceptions ) {
19786 : pushErrorHandler();
19787 : }
19788 : {
19789 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19790 : OGRFeatureShadow_SetFieldBinaryFromHexString__SWIG_0(arg1,arg2,(char const *)arg3);
19791 : SWIG_PYTHON_THREAD_END_ALLOW;
19792 : }
19793 : if ( bLocalUseExceptions ) {
19794 : popErrorHandler();
19795 : }
19796 : #ifndef SED_HACKS
19797 : if ( bLocalUseExceptions ) {
19798 : CPLErr eclass = CPLGetLastErrorType();
19799 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19800 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19801 : }
19802 : }
19803 : #endif
19804 : }
19805 : resultobj = SWIG_Py_Void();
19806 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19807 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
19808 : return resultobj;
19809 : fail:
19810 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19811 : return NULL;
19812 : }
19813 :
19814 :
19815 : SWIGINTERN PyObject *_wrap_Feature_SetFieldBinaryFromHexString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
19816 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19817 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19818 : char *arg2 = (char *) 0 ;
19819 : char *arg3 = (char *) 0 ;
19820 : void *argp1 = 0 ;
19821 : int res1 = 0 ;
19822 : int bToFree2 = 0 ;
19823 : int res3 ;
19824 : char *buf3 = 0 ;
19825 : int alloc3 = 0 ;
19826 :
19827 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
19828 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19829 : if (!SWIG_IsOK(res1)) {
19830 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldBinaryFromHexString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19831 : }
19832 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19833 : {
19834 : /* %typemap(in) (const char *utf8_path) */
19835 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
19836 : {
19837 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
19838 : }
19839 : else
19840 : {
19841 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
19842 :
19843 : }
19844 : if (arg2 == NULL)
19845 : {
19846 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
19847 : SWIG_fail;
19848 : }
19849 : }
19850 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
19851 : if (!SWIG_IsOK(res3)) {
19852 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Feature_SetFieldBinaryFromHexString" "', argument " "3"" of type '" "char const *""'");
19853 : }
19854 : arg3 = reinterpret_cast< char * >(buf3);
19855 : {
19856 : const int bLocalUseExceptions = GetUseExceptions();
19857 : if ( bLocalUseExceptions ) {
19858 : pushErrorHandler();
19859 : }
19860 : {
19861 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19862 : OGRFeatureShadow_SetFieldBinaryFromHexString__SWIG_1(arg1,(char const *)arg2,(char const *)arg3);
19863 : SWIG_PYTHON_THREAD_END_ALLOW;
19864 : }
19865 : if ( bLocalUseExceptions ) {
19866 : popErrorHandler();
19867 : }
19868 : #ifndef SED_HACKS
19869 : if ( bLocalUseExceptions ) {
19870 : CPLErr eclass = CPLGetLastErrorType();
19871 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19872 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19873 : }
19874 : }
19875 : #endif
19876 : }
19877 : resultobj = SWIG_Py_Void();
19878 : {
19879 : /* %typemap(freearg) (const char *utf8_path) */
19880 : GDALPythonFreeCStr(arg2, bToFree2);
19881 : }
19882 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19883 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
19884 : return resultobj;
19885 : fail:
19886 : {
19887 : /* %typemap(freearg) (const char *utf8_path) */
19888 : GDALPythonFreeCStr(arg2, bToFree2);
19889 : }
19890 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19891 : return NULL;
19892 : }
19893 :
19894 :
19895 6 : SWIGINTERN PyObject *_wrap_Feature_SetFieldBinaryFromHexString(PyObject *self, PyObject *args) {
19896 6 : Py_ssize_t argc;
19897 6 : PyObject *argv[4] = {
19898 : 0
19899 : };
19900 :
19901 6 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_SetFieldBinaryFromHexString", 0, 3, argv))) SWIG_fail;
19902 6 : --argc;
19903 6 : if (argc == 3) {
19904 6 : int _v;
19905 6 : void *vptr = 0;
19906 6 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19907 8 : _v = SWIG_CheckState(res);
19908 6 : if (_v) {
19909 6 : {
19910 6 : int res = SWIG_AsVal_int(argv[1], NULL);
19911 6 : _v = SWIG_CheckState(res);
19912 : }
19913 4 : if (_v) {
19914 4 : int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
19915 4 : _v = SWIG_CheckState(res);
19916 4 : if (_v) {
19917 4 : return _wrap_Feature_SetFieldBinaryFromHexString__SWIG_0(self, argc, argv);
19918 : }
19919 : }
19920 : }
19921 : }
19922 2 : if (argc == 3) {
19923 2 : int _v;
19924 2 : void *vptr = 0;
19925 2 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
19926 2 : _v = SWIG_CheckState(res);
19927 2 : if (_v) {
19928 2 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
19929 2 : _v = SWIG_CheckState(res);
19930 2 : if (_v) {
19931 2 : int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
19932 2 : _v = SWIG_CheckState(res);
19933 2 : if (_v) {
19934 2 : return _wrap_Feature_SetFieldBinaryFromHexString__SWIG_1(self, argc, argv);
19935 : }
19936 : }
19937 : }
19938 : }
19939 :
19940 0 : fail:
19941 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_SetFieldBinaryFromHexString'.\n"
19942 : " Possible C/C++ prototypes are:\n"
19943 : " OGRFeatureShadow::SetFieldBinaryFromHexString(int,char const *)\n"
19944 : " OGRFeatureShadow::SetFieldBinaryFromHexString(char const *,char const *)\n");
19945 : return 0;
19946 : }
19947 :
19948 :
19949 1740 : SWIGINTERN PyObject *_wrap_Feature_SetFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19950 1740 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19951 1740 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
19952 1740 : OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
19953 1740 : int arg3 = (int) 1 ;
19954 1740 : void *argp1 = 0 ;
19955 1740 : int res1 = 0 ;
19956 1740 : void *argp2 = 0 ;
19957 1740 : int res2 = 0 ;
19958 1740 : int val3 ;
19959 1740 : int ecode3 = 0 ;
19960 1740 : PyObject * obj0 = 0 ;
19961 1740 : PyObject * obj1 = 0 ;
19962 1740 : PyObject * obj2 = 0 ;
19963 1740 : char * kwnames[] = {
19964 : (char *)"self", (char *)"other", (char *)"forgiving", NULL
19965 : };
19966 1740 : OGRErr result;
19967 :
19968 1740 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Feature_SetFrom", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
19969 1740 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19970 1740 : if (!SWIG_IsOK(res1)) {
19971 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFrom" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
19972 : }
19973 1740 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
19974 1740 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
19975 1740 : if (!SWIG_IsOK(res2)) {
19976 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_SetFrom" "', argument " "2"" of type '" "OGRFeatureShadow *""'");
19977 : }
19978 1740 : arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
19979 1740 : if (obj2) {
19980 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
19981 0 : if (!SWIG_IsOK(ecode3)) {
19982 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Feature_SetFrom" "', argument " "3"" of type '" "int""'");
19983 : }
19984 : arg3 = static_cast< int >(val3);
19985 : }
19986 1740 : {
19987 1740 : if (!arg2) {
19988 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
19989 : }
19990 : }
19991 1740 : {
19992 1740 : const int bLocalUseExceptions = GetUseExceptions();
19993 1740 : if ( bLocalUseExceptions ) {
19994 81 : pushErrorHandler();
19995 : }
19996 1740 : {
19997 1740 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19998 1740 : result = (OGRErr)OGRFeatureShadow_SetFrom(arg1,arg2,arg3);
19999 1740 : SWIG_PYTHON_THREAD_END_ALLOW;
20000 : }
20001 1740 : if ( bLocalUseExceptions ) {
20002 81 : popErrorHandler();
20003 : }
20004 : #ifndef SED_HACKS
20005 : if ( bLocalUseExceptions ) {
20006 : CPLErr eclass = CPLGetLastErrorType();
20007 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20008 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20009 : }
20010 : }
20011 : #endif
20012 : }
20013 1740 : {
20014 : /* %typemap(out) OGRErr */
20015 1740 : if ( result != 0 && GetUseExceptions()) {
20016 0 : const char* pszMessage = CPLGetLastErrorMsg();
20017 0 : if( pszMessage[0] != '\0' )
20018 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
20019 : else
20020 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
20021 0 : SWIG_fail;
20022 : }
20023 : }
20024 1740 : {
20025 : /* %typemap(ret) OGRErr */
20026 1740 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
20027 1740 : resultobj = PyInt_FromLong( result );
20028 : }
20029 : }
20030 1740 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20031 : return resultobj;
20032 : fail:
20033 : return NULL;
20034 : }
20035 :
20036 :
20037 0 : SWIGINTERN PyObject *_wrap_Feature_SetFromWithMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20038 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20039 0 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20040 0 : OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
20041 0 : int arg3 ;
20042 0 : int arg4 ;
20043 0 : int *arg5 = (int *) 0 ;
20044 0 : void *argp1 = 0 ;
20045 0 : int res1 = 0 ;
20046 0 : void *argp2 = 0 ;
20047 0 : int res2 = 0 ;
20048 0 : int val3 ;
20049 0 : int ecode3 = 0 ;
20050 0 : PyObject *swig_obj[4] ;
20051 0 : OGRErr result;
20052 :
20053 0 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFromWithMap", 4, 4, swig_obj)) SWIG_fail;
20054 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20055 0 : if (!SWIG_IsOK(res1)) {
20056 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFromWithMap" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20057 : }
20058 0 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20059 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20060 0 : if (!SWIG_IsOK(res2)) {
20061 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_SetFromWithMap" "', argument " "2"" of type '" "OGRFeatureShadow *""'");
20062 : }
20063 0 : arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
20064 0 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
20065 0 : if (!SWIG_IsOK(ecode3)) {
20066 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Feature_SetFromWithMap" "', argument " "3"" of type '" "int""'");
20067 : }
20068 0 : arg3 = static_cast< int >(val3);
20069 0 : {
20070 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
20071 0 : arg5 = CreateCIntListFromSequence(swig_obj[3], &arg4);
20072 0 : if( arg4 < 0 ) {
20073 0 : SWIG_fail;
20074 : }
20075 : }
20076 0 : {
20077 0 : if (!arg2) {
20078 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
20079 : }
20080 : }
20081 0 : {
20082 0 : const int bLocalUseExceptions = GetUseExceptions();
20083 0 : if ( bLocalUseExceptions ) {
20084 0 : pushErrorHandler();
20085 : }
20086 0 : {
20087 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20088 0 : result = (OGRErr)OGRFeatureShadow_SetFromWithMap(arg1,arg2,arg3,arg4,arg5);
20089 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20090 : }
20091 0 : if ( bLocalUseExceptions ) {
20092 0 : popErrorHandler();
20093 : }
20094 : #ifndef SED_HACKS
20095 : if ( bLocalUseExceptions ) {
20096 : CPLErr eclass = CPLGetLastErrorType();
20097 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20098 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20099 : }
20100 : }
20101 : #endif
20102 : }
20103 0 : {
20104 : /* %typemap(out) OGRErr */
20105 0 : if ( result != 0 && GetUseExceptions()) {
20106 0 : const char* pszMessage = CPLGetLastErrorMsg();
20107 0 : if( pszMessage[0] != '\0' )
20108 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
20109 : else
20110 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
20111 0 : SWIG_fail;
20112 : }
20113 : }
20114 0 : {
20115 : /* %typemap(freearg) (int nList, int* pList) */
20116 0 : free(arg5);
20117 : }
20118 0 : {
20119 : /* %typemap(ret) OGRErr */
20120 0 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
20121 0 : resultobj = PyInt_FromLong( result );
20122 : }
20123 : }
20124 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20125 : return resultobj;
20126 0 : fail:
20127 0 : {
20128 : /* %typemap(freearg) (int nList, int* pList) */
20129 0 : free(arg5);
20130 : }
20131 0 : return NULL;
20132 : }
20133 :
20134 :
20135 542 : SWIGINTERN PyObject *_wrap_Feature_GetStyleString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20136 542 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20137 542 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20138 542 : void *argp1 = 0 ;
20139 542 : int res1 = 0 ;
20140 542 : PyObject *swig_obj[1] ;
20141 542 : char *result = 0 ;
20142 :
20143 542 : if (!args) SWIG_fail;
20144 542 : swig_obj[0] = args;
20145 542 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20146 542 : if (!SWIG_IsOK(res1)) {
20147 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetStyleString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20148 : }
20149 542 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20150 542 : {
20151 542 : const int bLocalUseExceptions = GetUseExceptions();
20152 542 : if ( bLocalUseExceptions ) {
20153 37 : pushErrorHandler();
20154 : }
20155 542 : {
20156 542 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20157 542 : result = (char *)OGRFeatureShadow_GetStyleString(arg1);
20158 542 : SWIG_PYTHON_THREAD_END_ALLOW;
20159 : }
20160 542 : if ( bLocalUseExceptions ) {
20161 37 : popErrorHandler();
20162 : }
20163 : #ifndef SED_HACKS
20164 : if ( bLocalUseExceptions ) {
20165 : CPLErr eclass = CPLGetLastErrorType();
20166 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20167 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20168 : }
20169 : }
20170 : #endif
20171 : }
20172 542 : resultobj = SWIG_FromCharPtr((const char *)result);
20173 542 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20174 : return resultobj;
20175 : fail:
20176 : return NULL;
20177 : }
20178 :
20179 :
20180 104 : SWIGINTERN PyObject *_wrap_Feature_SetStyleString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20181 104 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20182 104 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20183 104 : char *arg2 = (char *) 0 ;
20184 104 : void *argp1 = 0 ;
20185 104 : int res1 = 0 ;
20186 104 : int res2 ;
20187 104 : char *buf2 = 0 ;
20188 104 : int alloc2 = 0 ;
20189 104 : PyObject *swig_obj[2] ;
20190 :
20191 104 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetStyleString", 2, 2, swig_obj)) SWIG_fail;
20192 104 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20193 104 : if (!SWIG_IsOK(res1)) {
20194 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetStyleString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20195 : }
20196 104 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20197 104 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
20198 104 : if (!SWIG_IsOK(res2)) {
20199 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_SetStyleString" "', argument " "2"" of type '" "char const *""'");
20200 : }
20201 104 : arg2 = reinterpret_cast< char * >(buf2);
20202 104 : {
20203 104 : const int bLocalUseExceptions = GetUseExceptions();
20204 104 : if ( bLocalUseExceptions ) {
20205 79 : pushErrorHandler();
20206 : }
20207 104 : {
20208 104 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20209 104 : OGRFeatureShadow_SetStyleString(arg1,(char const *)arg2);
20210 104 : SWIG_PYTHON_THREAD_END_ALLOW;
20211 : }
20212 104 : if ( bLocalUseExceptions ) {
20213 79 : popErrorHandler();
20214 : }
20215 : #ifndef SED_HACKS
20216 : if ( bLocalUseExceptions ) {
20217 : CPLErr eclass = CPLGetLastErrorType();
20218 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20219 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20220 : }
20221 : }
20222 : #endif
20223 : }
20224 104 : resultobj = SWIG_Py_Void();
20225 104 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20226 104 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20227 : return resultobj;
20228 0 : fail:
20229 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20230 : return NULL;
20231 : }
20232 :
20233 :
20234 : SWIGINTERN PyObject *_wrap_Feature_GetFieldType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
20235 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20236 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20237 : int arg2 ;
20238 : void *argp1 = 0 ;
20239 : int res1 = 0 ;
20240 : int val2 ;
20241 : int ecode2 = 0 ;
20242 : OGRFieldType result;
20243 :
20244 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
20245 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20246 : if (!SWIG_IsOK(res1)) {
20247 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldType" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20248 : }
20249 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20250 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20251 : if (!SWIG_IsOK(ecode2)) {
20252 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_GetFieldType" "', argument " "2"" of type '" "int""'");
20253 : }
20254 : arg2 = static_cast< int >(val2);
20255 : {
20256 : const int bLocalUseExceptions = GetUseExceptions();
20257 : if ( bLocalUseExceptions ) {
20258 : pushErrorHandler();
20259 : }
20260 : {
20261 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20262 : result = (OGRFieldType)OGRFeatureShadow_GetFieldType__SWIG_0(arg1,arg2);
20263 : SWIG_PYTHON_THREAD_END_ALLOW;
20264 : }
20265 : if ( bLocalUseExceptions ) {
20266 : popErrorHandler();
20267 : }
20268 : #ifndef SED_HACKS
20269 : if ( bLocalUseExceptions ) {
20270 : CPLErr eclass = CPLGetLastErrorType();
20271 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20272 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20273 : }
20274 : }
20275 : #endif
20276 : }
20277 : resultobj = SWIG_From_int(static_cast< int >(result));
20278 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20279 : return resultobj;
20280 : fail:
20281 : return NULL;
20282 : }
20283 :
20284 :
20285 : SWIGINTERN PyObject *_wrap_Feature_GetFieldType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
20286 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20287 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20288 : char *arg2 = (char *) 0 ;
20289 : void *argp1 = 0 ;
20290 : int res1 = 0 ;
20291 : int bToFree2 = 0 ;
20292 : OGRFieldType result;
20293 :
20294 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
20295 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20296 : if (!SWIG_IsOK(res1)) {
20297 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetFieldType" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20298 : }
20299 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20300 : {
20301 : /* %typemap(in) (const char *utf8_path) */
20302 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
20303 : {
20304 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
20305 : }
20306 : else
20307 : {
20308 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
20309 :
20310 : }
20311 : if (arg2 == NULL)
20312 : {
20313 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
20314 : SWIG_fail;
20315 : }
20316 : }
20317 : {
20318 : const int bLocalUseExceptions = GetUseExceptions();
20319 : if ( bLocalUseExceptions ) {
20320 : pushErrorHandler();
20321 : }
20322 : {
20323 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20324 : result = (OGRFieldType)OGRFeatureShadow_GetFieldType__SWIG_1(arg1,(char const *)arg2);
20325 : SWIG_PYTHON_THREAD_END_ALLOW;
20326 : }
20327 : if ( bLocalUseExceptions ) {
20328 : popErrorHandler();
20329 : }
20330 : #ifndef SED_HACKS
20331 : if ( bLocalUseExceptions ) {
20332 : CPLErr eclass = CPLGetLastErrorType();
20333 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20334 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20335 : }
20336 : }
20337 : #endif
20338 : }
20339 : resultobj = SWIG_From_int(static_cast< int >(result));
20340 : {
20341 : /* %typemap(freearg) (const char *utf8_path) */
20342 : GDALPythonFreeCStr(arg2, bToFree2);
20343 : }
20344 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20345 : return resultobj;
20346 : fail:
20347 : {
20348 : /* %typemap(freearg) (const char *utf8_path) */
20349 : GDALPythonFreeCStr(arg2, bToFree2);
20350 : }
20351 : return NULL;
20352 : }
20353 :
20354 :
20355 101263 : SWIGINTERN PyObject *_wrap_Feature_GetFieldType(PyObject *self, PyObject *args) {
20356 101263 : Py_ssize_t argc;
20357 101263 : PyObject *argv[3] = {
20358 : 0
20359 : };
20360 :
20361 101263 : if (!(argc = SWIG_Python_UnpackTuple(args, "Feature_GetFieldType", 0, 2, argv))) SWIG_fail;
20362 101263 : --argc;
20363 101263 : if (argc == 2) {
20364 101263 : int _v;
20365 101263 : void *vptr = 0;
20366 101263 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
20367 101263 : _v = SWIG_CheckState(res);
20368 101263 : if (_v) {
20369 101263 : {
20370 101263 : int res = SWIG_AsVal_int(argv[1], NULL);
20371 101263 : _v = SWIG_CheckState(res);
20372 : }
20373 101263 : if (_v) {
20374 101263 : return _wrap_Feature_GetFieldType__SWIG_0(self, argc, argv);
20375 : }
20376 : }
20377 : }
20378 0 : if (argc == 2) {
20379 0 : int _v;
20380 0 : void *vptr = 0;
20381 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
20382 0 : _v = SWIG_CheckState(res);
20383 0 : if (_v) {
20384 0 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
20385 0 : _v = SWIG_CheckState(res);
20386 0 : if (_v) {
20387 0 : return _wrap_Feature_GetFieldType__SWIG_1(self, argc, argv);
20388 : }
20389 : }
20390 : }
20391 :
20392 0 : fail:
20393 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Feature_GetFieldType'.\n"
20394 : " Possible C/C++ prototypes are:\n"
20395 : " OGRFeatureShadow::GetFieldType(int)\n"
20396 : " OGRFeatureShadow::GetFieldType(char const *)\n");
20397 : return 0;
20398 : }
20399 :
20400 :
20401 10 : SWIGINTERN PyObject *_wrap_Feature_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20402 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20403 10 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20404 10 : int arg2 = (int) OGR_F_VAL_ALL ;
20405 10 : int arg3 = (int) TRUE ;
20406 10 : void *argp1 = 0 ;
20407 10 : int res1 = 0 ;
20408 10 : int val2 ;
20409 10 : int ecode2 = 0 ;
20410 10 : int val3 ;
20411 10 : int ecode3 = 0 ;
20412 10 : PyObject *swig_obj[3] ;
20413 10 : int result;
20414 :
20415 10 : if (!SWIG_Python_UnpackTuple(args, "Feature_Validate", 1, 3, swig_obj)) SWIG_fail;
20416 10 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20417 10 : if (!SWIG_IsOK(res1)) {
20418 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_Validate" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20419 : }
20420 10 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20421 10 : if (swig_obj[1]) {
20422 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20423 0 : if (!SWIG_IsOK(ecode2)) {
20424 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_Validate" "', argument " "2"" of type '" "int""'");
20425 : }
20426 : arg2 = static_cast< int >(val2);
20427 : }
20428 10 : if (swig_obj[2]) {
20429 0 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
20430 0 : if (!SWIG_IsOK(ecode3)) {
20431 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Feature_Validate" "', argument " "3"" of type '" "int""'");
20432 : }
20433 : arg3 = static_cast< int >(val3);
20434 : }
20435 10 : {
20436 10 : const int bLocalUseExceptions = GetUseExceptions();
20437 10 : if ( bLocalUseExceptions ) {
20438 10 : pushErrorHandler();
20439 : }
20440 10 : {
20441 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20442 10 : result = (int)OGRFeatureShadow_Validate(arg1,arg2,arg3);
20443 10 : SWIG_PYTHON_THREAD_END_ALLOW;
20444 : }
20445 10 : if ( bLocalUseExceptions ) {
20446 10 : popErrorHandler();
20447 : }
20448 : #ifndef SED_HACKS
20449 : if ( bLocalUseExceptions ) {
20450 : CPLErr eclass = CPLGetLastErrorType();
20451 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20452 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20453 : }
20454 : }
20455 : #endif
20456 : }
20457 10 : resultobj = SWIG_From_int(static_cast< int >(result));
20458 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20459 : return resultobj;
20460 : fail:
20461 : return NULL;
20462 : }
20463 :
20464 :
20465 2 : SWIGINTERN PyObject *_wrap_Feature_FillUnsetWithDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20466 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20467 2 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20468 2 : int arg2 = (int) FALSE ;
20469 2 : char **arg3 = (char **) NULL ;
20470 2 : void *argp1 = 0 ;
20471 2 : int res1 = 0 ;
20472 2 : int val2 ;
20473 2 : int ecode2 = 0 ;
20474 2 : PyObject *swig_obj[3] ;
20475 :
20476 2 : if (!SWIG_Python_UnpackTuple(args, "Feature_FillUnsetWithDefault", 1, 3, swig_obj)) SWIG_fail;
20477 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20478 2 : if (!SWIG_IsOK(res1)) {
20479 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_FillUnsetWithDefault" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20480 : }
20481 2 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20482 2 : if (swig_obj[1]) {
20483 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20484 0 : if (!SWIG_IsOK(ecode2)) {
20485 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_FillUnsetWithDefault" "', argument " "2"" of type '" "int""'");
20486 : }
20487 : arg2 = static_cast< int >(val2);
20488 : }
20489 2 : if (swig_obj[2]) {
20490 0 : {
20491 : /* %typemap(in) char **dict */
20492 0 : arg3 = NULL;
20493 0 : if ( PySequence_Check( swig_obj[2] ) ) {
20494 0 : int bErr = FALSE;
20495 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
20496 0 : if ( bErr )
20497 : {
20498 0 : SWIG_fail;
20499 : }
20500 : }
20501 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
20502 0 : int bErr = FALSE;
20503 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
20504 0 : if ( bErr )
20505 : {
20506 0 : SWIG_fail;
20507 : }
20508 : }
20509 : else {
20510 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
20511 0 : SWIG_fail;
20512 : }
20513 : }
20514 : }
20515 2 : {
20516 2 : const int bLocalUseExceptions = GetUseExceptions();
20517 2 : if ( bLocalUseExceptions ) {
20518 2 : pushErrorHandler();
20519 : }
20520 2 : {
20521 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20522 2 : OGRFeatureShadow_FillUnsetWithDefault(arg1,arg2,arg3);
20523 2 : SWIG_PYTHON_THREAD_END_ALLOW;
20524 : }
20525 2 : if ( bLocalUseExceptions ) {
20526 2 : popErrorHandler();
20527 : }
20528 : #ifndef SED_HACKS
20529 : if ( bLocalUseExceptions ) {
20530 : CPLErr eclass = CPLGetLastErrorType();
20531 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20532 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20533 : }
20534 : }
20535 : #endif
20536 : }
20537 2 : resultobj = SWIG_Py_Void();
20538 2 : {
20539 : /* %typemap(freearg) char **dict */
20540 2 : CSLDestroy( arg3 );
20541 : }
20542 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20543 : return resultobj;
20544 0 : fail:
20545 0 : {
20546 : /* %typemap(freearg) char **dict */
20547 0 : CSLDestroy( arg3 );
20548 : }
20549 : return NULL;
20550 : }
20551 :
20552 :
20553 9 : SWIGINTERN PyObject *_wrap_Feature_GetNativeData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20554 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20555 9 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20556 9 : void *argp1 = 0 ;
20557 9 : int res1 = 0 ;
20558 9 : PyObject *swig_obj[1] ;
20559 9 : char *result = 0 ;
20560 :
20561 9 : if (!args) SWIG_fail;
20562 9 : swig_obj[0] = args;
20563 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20564 9 : if (!SWIG_IsOK(res1)) {
20565 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetNativeData" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20566 : }
20567 9 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20568 9 : {
20569 9 : const int bLocalUseExceptions = GetUseExceptions();
20570 9 : if ( bLocalUseExceptions ) {
20571 9 : pushErrorHandler();
20572 : }
20573 9 : {
20574 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20575 9 : result = (char *)OGRFeatureShadow_GetNativeData(arg1);
20576 9 : SWIG_PYTHON_THREAD_END_ALLOW;
20577 : }
20578 9 : if ( bLocalUseExceptions ) {
20579 9 : popErrorHandler();
20580 : }
20581 : #ifndef SED_HACKS
20582 : if ( bLocalUseExceptions ) {
20583 : CPLErr eclass = CPLGetLastErrorType();
20584 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20585 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20586 : }
20587 : }
20588 : #endif
20589 : }
20590 9 : resultobj = SWIG_FromCharPtr((const char *)result);
20591 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20592 : return resultobj;
20593 : fail:
20594 : return NULL;
20595 : }
20596 :
20597 :
20598 9 : SWIGINTERN PyObject *_wrap_Feature_GetNativeMediaType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20599 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20600 9 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20601 9 : void *argp1 = 0 ;
20602 9 : int res1 = 0 ;
20603 9 : PyObject *swig_obj[1] ;
20604 9 : char *result = 0 ;
20605 :
20606 9 : if (!args) SWIG_fail;
20607 9 : swig_obj[0] = args;
20608 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20609 9 : if (!SWIG_IsOK(res1)) {
20610 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_GetNativeMediaType" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20611 : }
20612 9 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20613 9 : {
20614 9 : const int bLocalUseExceptions = GetUseExceptions();
20615 9 : if ( bLocalUseExceptions ) {
20616 9 : pushErrorHandler();
20617 : }
20618 9 : {
20619 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20620 9 : result = (char *)OGRFeatureShadow_GetNativeMediaType(arg1);
20621 9 : SWIG_PYTHON_THREAD_END_ALLOW;
20622 : }
20623 9 : if ( bLocalUseExceptions ) {
20624 9 : popErrorHandler();
20625 : }
20626 : #ifndef SED_HACKS
20627 : if ( bLocalUseExceptions ) {
20628 : CPLErr eclass = CPLGetLastErrorType();
20629 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20630 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20631 : }
20632 : }
20633 : #endif
20634 : }
20635 9 : resultobj = SWIG_FromCharPtr((const char *)result);
20636 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20637 : return resultobj;
20638 : fail:
20639 : return NULL;
20640 : }
20641 :
20642 :
20643 4 : SWIGINTERN PyObject *_wrap_Feature_SetNativeData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20644 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20645 4 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20646 4 : char *arg2 = (char *) 0 ;
20647 4 : void *argp1 = 0 ;
20648 4 : int res1 = 0 ;
20649 4 : int res2 ;
20650 4 : char *buf2 = 0 ;
20651 4 : int alloc2 = 0 ;
20652 4 : PyObject *swig_obj[2] ;
20653 :
20654 4 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetNativeData", 2, 2, swig_obj)) SWIG_fail;
20655 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20656 4 : if (!SWIG_IsOK(res1)) {
20657 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetNativeData" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20658 : }
20659 4 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20660 4 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
20661 4 : if (!SWIG_IsOK(res2)) {
20662 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_SetNativeData" "', argument " "2"" of type '" "char const *""'");
20663 : }
20664 4 : arg2 = reinterpret_cast< char * >(buf2);
20665 4 : {
20666 4 : const int bLocalUseExceptions = GetUseExceptions();
20667 4 : if ( bLocalUseExceptions ) {
20668 4 : pushErrorHandler();
20669 : }
20670 4 : {
20671 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20672 4 : OGRFeatureShadow_SetNativeData(arg1,(char const *)arg2);
20673 4 : SWIG_PYTHON_THREAD_END_ALLOW;
20674 : }
20675 4 : if ( bLocalUseExceptions ) {
20676 4 : popErrorHandler();
20677 : }
20678 : #ifndef SED_HACKS
20679 : if ( bLocalUseExceptions ) {
20680 : CPLErr eclass = CPLGetLastErrorType();
20681 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20682 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20683 : }
20684 : }
20685 : #endif
20686 : }
20687 4 : resultobj = SWIG_Py_Void();
20688 4 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20689 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20690 : return resultobj;
20691 0 : fail:
20692 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20693 : return NULL;
20694 : }
20695 :
20696 :
20697 4 : SWIGINTERN PyObject *_wrap_Feature_SetNativeMediaType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20698 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20699 4 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20700 4 : char *arg2 = (char *) 0 ;
20701 4 : void *argp1 = 0 ;
20702 4 : int res1 = 0 ;
20703 4 : int res2 ;
20704 4 : char *buf2 = 0 ;
20705 4 : int alloc2 = 0 ;
20706 4 : PyObject *swig_obj[2] ;
20707 :
20708 4 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetNativeMediaType", 2, 2, swig_obj)) SWIG_fail;
20709 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20710 4 : if (!SWIG_IsOK(res1)) {
20711 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetNativeMediaType" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20712 : }
20713 4 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20714 4 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
20715 4 : if (!SWIG_IsOK(res2)) {
20716 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Feature_SetNativeMediaType" "', argument " "2"" of type '" "char const *""'");
20717 : }
20718 4 : arg2 = reinterpret_cast< char * >(buf2);
20719 4 : {
20720 4 : const int bLocalUseExceptions = GetUseExceptions();
20721 4 : if ( bLocalUseExceptions ) {
20722 4 : pushErrorHandler();
20723 : }
20724 4 : {
20725 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20726 4 : OGRFeatureShadow_SetNativeMediaType(arg1,(char const *)arg2);
20727 4 : SWIG_PYTHON_THREAD_END_ALLOW;
20728 : }
20729 4 : if ( bLocalUseExceptions ) {
20730 4 : popErrorHandler();
20731 : }
20732 : #ifndef SED_HACKS
20733 : if ( bLocalUseExceptions ) {
20734 : CPLErr eclass = CPLGetLastErrorType();
20735 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20736 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20737 : }
20738 : }
20739 : #endif
20740 : }
20741 4 : resultobj = SWIG_Py_Void();
20742 4 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20743 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20744 : return resultobj;
20745 0 : fail:
20746 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20747 : return NULL;
20748 : }
20749 :
20750 :
20751 12920 : SWIGINTERN PyObject *_wrap_Feature_SetFieldString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20752 12920 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20753 12920 : OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
20754 12920 : int arg2 ;
20755 12920 : char *arg3 = (char *) 0 ;
20756 12920 : void *argp1 = 0 ;
20757 12920 : int res1 = 0 ;
20758 12920 : int val2 ;
20759 12920 : int ecode2 = 0 ;
20760 12920 : int bToFree3 = 0 ;
20761 12920 : PyObject *swig_obj[3] ;
20762 :
20763 12920 : if (!SWIG_Python_UnpackTuple(args, "Feature_SetFieldString", 3, 3, swig_obj)) SWIG_fail;
20764 12920 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 | 0 );
20765 12920 : if (!SWIG_IsOK(res1)) {
20766 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Feature_SetFieldString" "', argument " "1"" of type '" "OGRFeatureShadow *""'");
20767 : }
20768 12920 : arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
20769 12920 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20770 12920 : if (!SWIG_IsOK(ecode2)) {
20771 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Feature_SetFieldString" "', argument " "2"" of type '" "int""'");
20772 : }
20773 12920 : arg2 = static_cast< int >(val2);
20774 12920 : {
20775 : /* %typemap(in) (const char *utf8_path) */
20776 12920 : if (PyUnicode_Check(swig_obj[2]) || PyBytes_Check(swig_obj[2]))
20777 : {
20778 12920 : arg3 = GDALPythonObjectToCStr( swig_obj[2], &bToFree3 );
20779 : }
20780 : else
20781 : {
20782 0 : arg3 = GDALPythonPathToCStr(swig_obj[2], &bToFree3);
20783 :
20784 : }
20785 12920 : if (arg3 == NULL)
20786 : {
20787 1 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
20788 1 : SWIG_fail;
20789 : }
20790 : }
20791 12919 : {
20792 12919 : const int bLocalUseExceptions = GetUseExceptions();
20793 12919 : if ( bLocalUseExceptions ) {
20794 1769 : pushErrorHandler();
20795 : }
20796 12919 : OGRFeatureShadow_SetFieldString(arg1,arg2,(char const *)arg3);
20797 12919 : if ( bLocalUseExceptions ) {
20798 1769 : popErrorHandler();
20799 : }
20800 : #ifndef SED_HACKS
20801 : if ( bLocalUseExceptions ) {
20802 : CPLErr eclass = CPLGetLastErrorType();
20803 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20804 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20805 : }
20806 : }
20807 : #endif
20808 : }
20809 12919 : resultobj = SWIG_Py_Void();
20810 12919 : {
20811 : /* %typemap(freearg) (const char *utf8_path) */
20812 12919 : GDALPythonFreeCStr(arg3, bToFree3);
20813 : }
20814 12919 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20815 : return resultobj;
20816 1 : fail:
20817 1 : {
20818 : /* %typemap(freearg) (const char *utf8_path) */
20819 1 : GDALPythonFreeCStr(arg3, bToFree3);
20820 : }
20821 : return NULL;
20822 : }
20823 :
20824 :
20825 275 : SWIGINTERN PyObject *Feature_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20826 275 : PyObject *obj;
20827 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
20828 275 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRFeatureShadow, SWIG_NewClientData(obj));
20829 275 : return SWIG_Py_Void();
20830 : }
20831 :
20832 121863 : SWIGINTERN PyObject *Feature_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20833 121863 : return SWIG_Python_InitShadowInstance(args);
20834 : }
20835 :
20836 125461 : SWIGINTERN PyObject *_wrap_delete_FeatureDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20837 125461 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20838 125461 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
20839 125461 : void *argp1 = 0 ;
20840 125461 : int res1 = 0 ;
20841 125461 : PyObject *swig_obj[1] ;
20842 :
20843 125461 : if (!args) SWIG_fail;
20844 125461 : swig_obj[0] = args;
20845 125461 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, SWIG_POINTER_DISOWN | 0 );
20846 125461 : if (!SWIG_IsOK(res1)) {
20847 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FeatureDefn" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
20848 : }
20849 125461 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
20850 125461 : {
20851 125461 : const int bLocalUseExceptions = GetUseExceptions();
20852 125461 : if ( bLocalUseExceptions ) {
20853 64436 : pushErrorHandler();
20854 : }
20855 125461 : {
20856 125461 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20857 125461 : delete_OGRFeatureDefnShadow(arg1);
20858 125461 : SWIG_PYTHON_THREAD_END_ALLOW;
20859 : }
20860 125461 : if ( bLocalUseExceptions ) {
20861 64436 : popErrorHandler();
20862 : }
20863 : #ifndef SED_HACKS
20864 : if ( bLocalUseExceptions ) {
20865 : CPLErr eclass = CPLGetLastErrorType();
20866 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20867 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20868 : }
20869 : }
20870 : #endif
20871 : }
20872 125461 : resultobj = SWIG_Py_Void();
20873 125461 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20874 : return resultobj;
20875 : fail:
20876 : return NULL;
20877 : }
20878 :
20879 :
20880 110 : SWIGINTERN PyObject *_wrap_new_FeatureDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20881 110 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20882 110 : char *arg1 = (char *) NULL ;
20883 110 : int res1 ;
20884 110 : char *buf1 = 0 ;
20885 110 : int alloc1 = 0 ;
20886 110 : PyObject * obj0 = 0 ;
20887 110 : char * kwnames[] = {
20888 : (char *)"name_null_ok", NULL
20889 : };
20890 110 : OGRFeatureDefnShadow *result = 0 ;
20891 :
20892 110 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_FeatureDefn", kwnames, &obj0)) SWIG_fail;
20893 110 : if (obj0) {
20894 84 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20895 84 : if (!SWIG_IsOK(res1)) {
20896 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FeatureDefn" "', argument " "1"" of type '" "char const *""'");
20897 : }
20898 84 : arg1 = reinterpret_cast< char * >(buf1);
20899 : }
20900 110 : {
20901 110 : const int bLocalUseExceptions = GetUseExceptions();
20902 110 : if ( bLocalUseExceptions ) {
20903 99 : pushErrorHandler();
20904 : }
20905 110 : {
20906 110 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20907 110 : result = (OGRFeatureDefnShadow *)new_OGRFeatureDefnShadow((char const *)arg1);
20908 110 : SWIG_PYTHON_THREAD_END_ALLOW;
20909 : }
20910 110 : if ( bLocalUseExceptions ) {
20911 99 : popErrorHandler();
20912 : }
20913 : #ifndef SED_HACKS
20914 : if ( bLocalUseExceptions ) {
20915 : CPLErr eclass = CPLGetLastErrorType();
20916 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20917 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20918 : }
20919 : }
20920 : #endif
20921 : }
20922 110 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureDefnShadow, SWIG_POINTER_NEW | 0 );
20923 110 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20924 110 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20925 : return resultobj;
20926 0 : fail:
20927 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20928 : return NULL;
20929 : }
20930 :
20931 :
20932 107 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20933 107 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20934 107 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
20935 107 : void *argp1 = 0 ;
20936 107 : int res1 = 0 ;
20937 107 : PyObject *swig_obj[1] ;
20938 107 : char *result = 0 ;
20939 :
20940 107 : if (!args) SWIG_fail;
20941 107 : swig_obj[0] = args;
20942 107 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
20943 107 : if (!SWIG_IsOK(res1)) {
20944 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetName" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
20945 : }
20946 107 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
20947 107 : {
20948 107 : const int bLocalUseExceptions = GetUseExceptions();
20949 107 : if ( bLocalUseExceptions ) {
20950 9 : pushErrorHandler();
20951 : }
20952 107 : {
20953 107 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20954 107 : result = (char *)OGRFeatureDefnShadow_GetName(arg1);
20955 107 : SWIG_PYTHON_THREAD_END_ALLOW;
20956 : }
20957 107 : if ( bLocalUseExceptions ) {
20958 9 : popErrorHandler();
20959 : }
20960 : #ifndef SED_HACKS
20961 : if ( bLocalUseExceptions ) {
20962 : CPLErr eclass = CPLGetLastErrorType();
20963 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20964 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20965 : }
20966 : }
20967 : #endif
20968 : }
20969 107 : resultobj = SWIG_FromCharPtr((const char *)result);
20970 107 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
20971 : return resultobj;
20972 : fail:
20973 : return NULL;
20974 : }
20975 :
20976 :
20977 48297 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetFieldCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20978 48297 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20979 48297 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
20980 48297 : void *argp1 = 0 ;
20981 48297 : int res1 = 0 ;
20982 48297 : PyObject *swig_obj[1] ;
20983 48297 : int result;
20984 :
20985 48297 : if (!args) SWIG_fail;
20986 48297 : swig_obj[0] = args;
20987 48297 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
20988 48297 : if (!SWIG_IsOK(res1)) {
20989 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetFieldCount" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
20990 : }
20991 48297 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
20992 48297 : {
20993 48297 : const int bLocalUseExceptions = GetUseExceptions();
20994 48297 : if ( bLocalUseExceptions ) {
20995 21889 : pushErrorHandler();
20996 : }
20997 48297 : {
20998 48297 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20999 48297 : result = (int)OGRFeatureDefnShadow_GetFieldCount(arg1);
21000 48297 : SWIG_PYTHON_THREAD_END_ALLOW;
21001 : }
21002 48297 : if ( bLocalUseExceptions ) {
21003 21889 : popErrorHandler();
21004 : }
21005 : #ifndef SED_HACKS
21006 : if ( bLocalUseExceptions ) {
21007 : CPLErr eclass = CPLGetLastErrorType();
21008 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21009 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21010 : }
21011 : }
21012 : #endif
21013 : }
21014 48297 : resultobj = SWIG_From_int(static_cast< int >(result));
21015 48297 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21016 : return resultobj;
21017 : fail:
21018 : return NULL;
21019 : }
21020 :
21021 :
21022 221588 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21023 221588 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21024 221588 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21025 221588 : int arg2 ;
21026 221588 : void *argp1 = 0 ;
21027 221588 : int res1 = 0 ;
21028 221588 : int val2 ;
21029 221588 : int ecode2 = 0 ;
21030 221588 : PyObject *swig_obj[2] ;
21031 221588 : OGRFieldDefnShadow *result = 0 ;
21032 :
21033 221588 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_GetFieldDefn", 2, 2, swig_obj)) SWIG_fail;
21034 221588 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21035 221588 : if (!SWIG_IsOK(res1)) {
21036 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetFieldDefn" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21037 : }
21038 221588 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21039 221588 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21040 221588 : if (!SWIG_IsOK(ecode2)) {
21041 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FeatureDefn_GetFieldDefn" "', argument " "2"" of type '" "int""'");
21042 : }
21043 221588 : arg2 = static_cast< int >(val2);
21044 221588 : {
21045 221588 : const int bLocalUseExceptions = GetUseExceptions();
21046 221588 : if ( bLocalUseExceptions ) {
21047 137511 : pushErrorHandler();
21048 : }
21049 221588 : {
21050 221588 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21051 221588 : result = (OGRFieldDefnShadow *)OGRFeatureDefnShadow_GetFieldDefn(arg1,arg2);
21052 221588 : SWIG_PYTHON_THREAD_END_ALLOW;
21053 : }
21054 221588 : if ( bLocalUseExceptions ) {
21055 137511 : popErrorHandler();
21056 : }
21057 : #ifndef SED_HACKS
21058 : if ( bLocalUseExceptions ) {
21059 : CPLErr eclass = CPLGetLastErrorType();
21060 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21061 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21062 : }
21063 : }
21064 : #endif
21065 : }
21066 221588 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
21067 221589 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21068 : return resultobj;
21069 : fail:
21070 : return NULL;
21071 : }
21072 :
21073 :
21074 1752 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetFieldIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21075 1752 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21076 1752 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21077 1752 : char *arg2 = (char *) 0 ;
21078 1752 : void *argp1 = 0 ;
21079 1752 : int res1 = 0 ;
21080 1752 : int bToFree2 = 0 ;
21081 1752 : PyObject *swig_obj[2] ;
21082 1752 : int result;
21083 :
21084 1752 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_GetFieldIndex", 2, 2, swig_obj)) SWIG_fail;
21085 1752 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21086 1752 : if (!SWIG_IsOK(res1)) {
21087 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetFieldIndex" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21088 : }
21089 1752 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21090 1752 : {
21091 : /* %typemap(in) (const char *utf8_path) */
21092 1752 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
21093 : {
21094 1752 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
21095 : }
21096 : else
21097 : {
21098 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
21099 :
21100 : }
21101 1752 : if (arg2 == NULL)
21102 : {
21103 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
21104 0 : SWIG_fail;
21105 : }
21106 : }
21107 1752 : {
21108 1752 : const int bLocalUseExceptions = GetUseExceptions();
21109 1752 : if ( bLocalUseExceptions ) {
21110 318 : pushErrorHandler();
21111 : }
21112 1752 : {
21113 1752 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21114 1752 : result = (int)OGRFeatureDefnShadow_GetFieldIndex(arg1,(char const *)arg2);
21115 1752 : SWIG_PYTHON_THREAD_END_ALLOW;
21116 : }
21117 1752 : if ( bLocalUseExceptions ) {
21118 318 : popErrorHandler();
21119 : }
21120 : #ifndef SED_HACKS
21121 : if ( bLocalUseExceptions ) {
21122 : CPLErr eclass = CPLGetLastErrorType();
21123 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21124 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21125 : }
21126 : }
21127 : #endif
21128 : }
21129 1752 : resultobj = SWIG_From_int(static_cast< int >(result));
21130 1752 : {
21131 : /* %typemap(freearg) (const char *utf8_path) */
21132 1752 : GDALPythonFreeCStr(arg2, bToFree2);
21133 : }
21134 1752 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21135 : return resultobj;
21136 0 : fail:
21137 0 : {
21138 : /* %typemap(freearg) (const char *utf8_path) */
21139 1752 : GDALPythonFreeCStr(arg2, bToFree2);
21140 : }
21141 : return NULL;
21142 : }
21143 :
21144 :
21145 397 : SWIGINTERN PyObject *_wrap_FeatureDefn_AddFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21146 397 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21147 397 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21148 397 : OGRFieldDefnShadow *arg2 = (OGRFieldDefnShadow *) 0 ;
21149 397 : void *argp1 = 0 ;
21150 397 : int res1 = 0 ;
21151 397 : void *argp2 = 0 ;
21152 397 : int res2 = 0 ;
21153 397 : PyObject *swig_obj[2] ;
21154 :
21155 397 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_AddFieldDefn", 2, 2, swig_obj)) SWIG_fail;
21156 397 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21157 397 : if (!SWIG_IsOK(res1)) {
21158 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_AddFieldDefn" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21159 : }
21160 397 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21161 397 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
21162 397 : if (!SWIG_IsOK(res2)) {
21163 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FeatureDefn_AddFieldDefn" "', argument " "2"" of type '" "OGRFieldDefnShadow *""'");
21164 : }
21165 397 : arg2 = reinterpret_cast< OGRFieldDefnShadow * >(argp2);
21166 397 : {
21167 397 : if (!arg2) {
21168 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21169 : }
21170 : }
21171 397 : {
21172 397 : const int bLocalUseExceptions = GetUseExceptions();
21173 397 : if ( bLocalUseExceptions ) {
21174 396 : pushErrorHandler();
21175 : }
21176 397 : {
21177 397 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21178 397 : OGRFeatureDefnShadow_AddFieldDefn(arg1,arg2);
21179 397 : SWIG_PYTHON_THREAD_END_ALLOW;
21180 : }
21181 397 : if ( bLocalUseExceptions ) {
21182 396 : popErrorHandler();
21183 : }
21184 : #ifndef SED_HACKS
21185 : if ( bLocalUseExceptions ) {
21186 : CPLErr eclass = CPLGetLastErrorType();
21187 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21188 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21189 : }
21190 : }
21191 : #endif
21192 : }
21193 397 : resultobj = SWIG_Py_Void();
21194 397 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21195 : return resultobj;
21196 : fail:
21197 : return NULL;
21198 : }
21199 :
21200 :
21201 293 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetGeomFieldCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21202 293 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21203 293 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21204 293 : void *argp1 = 0 ;
21205 293 : int res1 = 0 ;
21206 293 : PyObject *swig_obj[1] ;
21207 293 : int result;
21208 :
21209 293 : if (!args) SWIG_fail;
21210 293 : swig_obj[0] = args;
21211 293 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21212 293 : if (!SWIG_IsOK(res1)) {
21213 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetGeomFieldCount" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21214 : }
21215 293 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21216 293 : {
21217 293 : const int bLocalUseExceptions = GetUseExceptions();
21218 293 : if ( bLocalUseExceptions ) {
21219 210 : pushErrorHandler();
21220 : }
21221 293 : {
21222 293 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21223 293 : result = (int)OGRFeatureDefnShadow_GetGeomFieldCount(arg1);
21224 293 : SWIG_PYTHON_THREAD_END_ALLOW;
21225 : }
21226 293 : if ( bLocalUseExceptions ) {
21227 210 : popErrorHandler();
21228 : }
21229 : #ifndef SED_HACKS
21230 : if ( bLocalUseExceptions ) {
21231 : CPLErr eclass = CPLGetLastErrorType();
21232 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21233 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21234 : }
21235 : }
21236 : #endif
21237 : }
21238 293 : resultobj = SWIG_From_int(static_cast< int >(result));
21239 293 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21240 : return resultobj;
21241 : fail:
21242 : return NULL;
21243 : }
21244 :
21245 :
21246 578 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetGeomFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21247 578 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21248 578 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21249 578 : int arg2 ;
21250 578 : void *argp1 = 0 ;
21251 578 : int res1 = 0 ;
21252 578 : int val2 ;
21253 578 : int ecode2 = 0 ;
21254 578 : PyObject *swig_obj[2] ;
21255 578 : OGRGeomFieldDefnShadow *result = 0 ;
21256 :
21257 578 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_GetGeomFieldDefn", 2, 2, swig_obj)) SWIG_fail;
21258 578 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21259 578 : if (!SWIG_IsOK(res1)) {
21260 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetGeomFieldDefn" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21261 : }
21262 578 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21263 578 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21264 578 : if (!SWIG_IsOK(ecode2)) {
21265 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FeatureDefn_GetGeomFieldDefn" "', argument " "2"" of type '" "int""'");
21266 : }
21267 578 : arg2 = static_cast< int >(val2);
21268 578 : {
21269 578 : const int bLocalUseExceptions = GetUseExceptions();
21270 578 : if ( bLocalUseExceptions ) {
21271 252 : pushErrorHandler();
21272 : }
21273 578 : {
21274 578 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21275 578 : result = (OGRGeomFieldDefnShadow *)OGRFeatureDefnShadow_GetGeomFieldDefn(arg1,arg2);
21276 578 : SWIG_PYTHON_THREAD_END_ALLOW;
21277 : }
21278 578 : if ( bLocalUseExceptions ) {
21279 252 : popErrorHandler();
21280 : }
21281 : #ifndef SED_HACKS
21282 : if ( bLocalUseExceptions ) {
21283 : CPLErr eclass = CPLGetLastErrorType();
21284 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21285 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21286 : }
21287 : }
21288 : #endif
21289 : }
21290 578 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
21291 578 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21292 : return resultobj;
21293 : fail:
21294 : return NULL;
21295 : }
21296 :
21297 :
21298 37 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetGeomFieldIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21299 37 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21300 37 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21301 37 : char *arg2 = (char *) 0 ;
21302 37 : void *argp1 = 0 ;
21303 37 : int res1 = 0 ;
21304 37 : int bToFree2 = 0 ;
21305 37 : PyObject *swig_obj[2] ;
21306 37 : int result;
21307 :
21308 37 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_GetGeomFieldIndex", 2, 2, swig_obj)) SWIG_fail;
21309 37 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21310 37 : if (!SWIG_IsOK(res1)) {
21311 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetGeomFieldIndex" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21312 : }
21313 37 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21314 37 : {
21315 : /* %typemap(in) (const char *utf8_path) */
21316 37 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
21317 : {
21318 37 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
21319 : }
21320 : else
21321 : {
21322 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
21323 :
21324 : }
21325 37 : if (arg2 == NULL)
21326 : {
21327 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
21328 0 : SWIG_fail;
21329 : }
21330 : }
21331 37 : {
21332 37 : const int bLocalUseExceptions = GetUseExceptions();
21333 37 : if ( bLocalUseExceptions ) {
21334 0 : pushErrorHandler();
21335 : }
21336 37 : {
21337 37 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21338 37 : result = (int)OGRFeatureDefnShadow_GetGeomFieldIndex(arg1,(char const *)arg2);
21339 37 : SWIG_PYTHON_THREAD_END_ALLOW;
21340 : }
21341 37 : if ( bLocalUseExceptions ) {
21342 0 : popErrorHandler();
21343 : }
21344 : #ifndef SED_HACKS
21345 : if ( bLocalUseExceptions ) {
21346 : CPLErr eclass = CPLGetLastErrorType();
21347 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21348 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21349 : }
21350 : }
21351 : #endif
21352 : }
21353 37 : resultobj = SWIG_From_int(static_cast< int >(result));
21354 37 : {
21355 : /* %typemap(freearg) (const char *utf8_path) */
21356 37 : GDALPythonFreeCStr(arg2, bToFree2);
21357 : }
21358 37 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21359 : return resultobj;
21360 0 : fail:
21361 0 : {
21362 : /* %typemap(freearg) (const char *utf8_path) */
21363 37 : GDALPythonFreeCStr(arg2, bToFree2);
21364 : }
21365 : return NULL;
21366 : }
21367 :
21368 :
21369 11 : SWIGINTERN PyObject *_wrap_FeatureDefn_AddGeomFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21370 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21371 11 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21372 11 : OGRGeomFieldDefnShadow *arg2 = (OGRGeomFieldDefnShadow *) 0 ;
21373 11 : void *argp1 = 0 ;
21374 11 : int res1 = 0 ;
21375 11 : void *argp2 = 0 ;
21376 11 : int res2 = 0 ;
21377 11 : PyObject *swig_obj[2] ;
21378 :
21379 11 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_AddGeomFieldDefn", 2, 2, swig_obj)) SWIG_fail;
21380 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21381 11 : if (!SWIG_IsOK(res1)) {
21382 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_AddGeomFieldDefn" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21383 : }
21384 11 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21385 11 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
21386 11 : if (!SWIG_IsOK(res2)) {
21387 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FeatureDefn_AddGeomFieldDefn" "', argument " "2"" of type '" "OGRGeomFieldDefnShadow *""'");
21388 : }
21389 11 : arg2 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp2);
21390 11 : {
21391 11 : if (!arg2) {
21392 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21393 : }
21394 : }
21395 11 : {
21396 11 : const int bLocalUseExceptions = GetUseExceptions();
21397 11 : if ( bLocalUseExceptions ) {
21398 8 : pushErrorHandler();
21399 : }
21400 11 : {
21401 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21402 11 : OGRFeatureDefnShadow_AddGeomFieldDefn(arg1,arg2);
21403 11 : SWIG_PYTHON_THREAD_END_ALLOW;
21404 : }
21405 11 : if ( bLocalUseExceptions ) {
21406 8 : popErrorHandler();
21407 : }
21408 : #ifndef SED_HACKS
21409 : if ( bLocalUseExceptions ) {
21410 : CPLErr eclass = CPLGetLastErrorType();
21411 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21412 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21413 : }
21414 : }
21415 : #endif
21416 : }
21417 11 : resultobj = SWIG_Py_Void();
21418 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21419 : return resultobj;
21420 : fail:
21421 : return NULL;
21422 : }
21423 :
21424 :
21425 4 : SWIGINTERN PyObject *_wrap_FeatureDefn_DeleteGeomFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21426 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21427 4 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21428 4 : int arg2 ;
21429 4 : void *argp1 = 0 ;
21430 4 : int res1 = 0 ;
21431 4 : int val2 ;
21432 4 : int ecode2 = 0 ;
21433 4 : PyObject *swig_obj[2] ;
21434 4 : OGRErr result;
21435 :
21436 4 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_DeleteGeomFieldDefn", 2, 2, swig_obj)) SWIG_fail;
21437 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21438 4 : if (!SWIG_IsOK(res1)) {
21439 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_DeleteGeomFieldDefn" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21440 : }
21441 4 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21442 4 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21443 4 : if (!SWIG_IsOK(ecode2)) {
21444 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FeatureDefn_DeleteGeomFieldDefn" "', argument " "2"" of type '" "int""'");
21445 : }
21446 4 : arg2 = static_cast< int >(val2);
21447 4 : {
21448 4 : const int bLocalUseExceptions = GetUseExceptions();
21449 4 : if ( bLocalUseExceptions ) {
21450 0 : pushErrorHandler();
21451 : }
21452 4 : {
21453 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21454 4 : result = (OGRErr)OGRFeatureDefnShadow_DeleteGeomFieldDefn(arg1,arg2);
21455 4 : SWIG_PYTHON_THREAD_END_ALLOW;
21456 : }
21457 4 : if ( bLocalUseExceptions ) {
21458 0 : popErrorHandler();
21459 : }
21460 : #ifndef SED_HACKS
21461 : if ( bLocalUseExceptions ) {
21462 : CPLErr eclass = CPLGetLastErrorType();
21463 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21464 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21465 : }
21466 : }
21467 : #endif
21468 : }
21469 4 : {
21470 : /* %typemap(out) OGRErr */
21471 6 : if ( result != 0 && GetUseExceptions()) {
21472 0 : const char* pszMessage = CPLGetLastErrorMsg();
21473 0 : if( pszMessage[0] != '\0' )
21474 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
21475 : else
21476 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
21477 0 : SWIG_fail;
21478 : }
21479 : }
21480 4 : {
21481 : /* %typemap(ret) OGRErr */
21482 4 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
21483 4 : resultobj = PyInt_FromLong( result );
21484 : }
21485 : }
21486 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21487 : return resultobj;
21488 : fail:
21489 : return NULL;
21490 : }
21491 :
21492 :
21493 91 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetGeomType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21494 91 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21495 91 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21496 91 : void *argp1 = 0 ;
21497 91 : int res1 = 0 ;
21498 91 : PyObject *swig_obj[1] ;
21499 91 : OGRwkbGeometryType result;
21500 :
21501 91 : if (!args) SWIG_fail;
21502 91 : swig_obj[0] = args;
21503 91 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21504 91 : if (!SWIG_IsOK(res1)) {
21505 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetGeomType" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21506 : }
21507 91 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21508 91 : {
21509 91 : const int bLocalUseExceptions = GetUseExceptions();
21510 91 : if ( bLocalUseExceptions ) {
21511 28 : pushErrorHandler();
21512 : }
21513 91 : {
21514 91 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21515 91 : result = (OGRwkbGeometryType)OGRFeatureDefnShadow_GetGeomType(arg1);
21516 91 : SWIG_PYTHON_THREAD_END_ALLOW;
21517 : }
21518 91 : if ( bLocalUseExceptions ) {
21519 28 : popErrorHandler();
21520 : }
21521 : #ifndef SED_HACKS
21522 : if ( bLocalUseExceptions ) {
21523 : CPLErr eclass = CPLGetLastErrorType();
21524 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21525 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21526 : }
21527 : }
21528 : #endif
21529 : }
21530 91 : resultobj = SWIG_From_int(static_cast< int >(result));
21531 91 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21532 : return resultobj;
21533 : fail:
21534 : return NULL;
21535 : }
21536 :
21537 :
21538 12 : SWIGINTERN PyObject *_wrap_FeatureDefn_SetGeomType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21539 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21540 12 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21541 12 : OGRwkbGeometryType arg2 ;
21542 12 : void *argp1 = 0 ;
21543 12 : int res1 = 0 ;
21544 12 : int val2 ;
21545 12 : int ecode2 = 0 ;
21546 12 : PyObject *swig_obj[2] ;
21547 :
21548 12 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_SetGeomType", 2, 2, swig_obj)) SWIG_fail;
21549 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21550 12 : if (!SWIG_IsOK(res1)) {
21551 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_SetGeomType" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21552 : }
21553 12 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21554 12 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21555 12 : if (!SWIG_IsOK(ecode2)) {
21556 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FeatureDefn_SetGeomType" "', argument " "2"" of type '" "OGRwkbGeometryType""'");
21557 : }
21558 12 : arg2 = static_cast< OGRwkbGeometryType >(val2);
21559 12 : {
21560 12 : const int bLocalUseExceptions = GetUseExceptions();
21561 12 : if ( bLocalUseExceptions ) {
21562 4 : pushErrorHandler();
21563 : }
21564 12 : {
21565 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21566 12 : OGRFeatureDefnShadow_SetGeomType(arg1,arg2);
21567 12 : SWIG_PYTHON_THREAD_END_ALLOW;
21568 : }
21569 12 : if ( bLocalUseExceptions ) {
21570 4 : popErrorHandler();
21571 : }
21572 : #ifndef SED_HACKS
21573 : if ( bLocalUseExceptions ) {
21574 : CPLErr eclass = CPLGetLastErrorType();
21575 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21576 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21577 : }
21578 : }
21579 : #endif
21580 : }
21581 12 : resultobj = SWIG_Py_Void();
21582 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21583 : return resultobj;
21584 : fail:
21585 : return NULL;
21586 : }
21587 :
21588 :
21589 3 : SWIGINTERN PyObject *_wrap_FeatureDefn_GetReferenceCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21590 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21591 3 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21592 3 : void *argp1 = 0 ;
21593 3 : int res1 = 0 ;
21594 3 : PyObject *swig_obj[1] ;
21595 3 : int result;
21596 :
21597 3 : if (!args) SWIG_fail;
21598 3 : swig_obj[0] = args;
21599 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21600 3 : if (!SWIG_IsOK(res1)) {
21601 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_GetReferenceCount" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21602 : }
21603 3 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21604 3 : {
21605 3 : const int bLocalUseExceptions = GetUseExceptions();
21606 3 : if ( bLocalUseExceptions ) {
21607 3 : pushErrorHandler();
21608 : }
21609 3 : {
21610 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21611 3 : result = (int)OGRFeatureDefnShadow_GetReferenceCount(arg1);
21612 3 : SWIG_PYTHON_THREAD_END_ALLOW;
21613 : }
21614 3 : if ( bLocalUseExceptions ) {
21615 3 : popErrorHandler();
21616 : }
21617 : #ifndef SED_HACKS
21618 : if ( bLocalUseExceptions ) {
21619 : CPLErr eclass = CPLGetLastErrorType();
21620 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21621 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21622 : }
21623 : }
21624 : #endif
21625 : }
21626 3 : resultobj = SWIG_From_int(static_cast< int >(result));
21627 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21628 : return resultobj;
21629 : fail:
21630 : return NULL;
21631 : }
21632 :
21633 :
21634 6 : SWIGINTERN PyObject *_wrap_FeatureDefn_IsGeometryIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21635 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21636 6 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21637 6 : void *argp1 = 0 ;
21638 6 : int res1 = 0 ;
21639 6 : PyObject *swig_obj[1] ;
21640 6 : int result;
21641 :
21642 6 : if (!args) SWIG_fail;
21643 6 : swig_obj[0] = args;
21644 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21645 6 : if (!SWIG_IsOK(res1)) {
21646 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_IsGeometryIgnored" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21647 : }
21648 6 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21649 6 : {
21650 6 : const int bLocalUseExceptions = GetUseExceptions();
21651 6 : if ( bLocalUseExceptions ) {
21652 0 : pushErrorHandler();
21653 : }
21654 6 : {
21655 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21656 6 : result = (int)OGRFeatureDefnShadow_IsGeometryIgnored(arg1);
21657 6 : SWIG_PYTHON_THREAD_END_ALLOW;
21658 : }
21659 6 : if ( bLocalUseExceptions ) {
21660 0 : popErrorHandler();
21661 : }
21662 : #ifndef SED_HACKS
21663 : if ( bLocalUseExceptions ) {
21664 : CPLErr eclass = CPLGetLastErrorType();
21665 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21666 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21667 : }
21668 : }
21669 : #endif
21670 : }
21671 6 : resultobj = SWIG_From_int(static_cast< int >(result));
21672 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21673 : return resultobj;
21674 : fail:
21675 : return NULL;
21676 : }
21677 :
21678 :
21679 3 : SWIGINTERN PyObject *_wrap_FeatureDefn_SetGeometryIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21680 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21681 3 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21682 3 : int arg2 ;
21683 3 : void *argp1 = 0 ;
21684 3 : int res1 = 0 ;
21685 3 : int val2 ;
21686 3 : int ecode2 = 0 ;
21687 3 : PyObject *swig_obj[2] ;
21688 :
21689 3 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_SetGeometryIgnored", 2, 2, swig_obj)) SWIG_fail;
21690 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21691 3 : if (!SWIG_IsOK(res1)) {
21692 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_SetGeometryIgnored" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21693 : }
21694 3 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21695 3 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21696 3 : if (!SWIG_IsOK(ecode2)) {
21697 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FeatureDefn_SetGeometryIgnored" "', argument " "2"" of type '" "int""'");
21698 : }
21699 3 : arg2 = static_cast< int >(val2);
21700 3 : {
21701 3 : const int bLocalUseExceptions = GetUseExceptions();
21702 3 : if ( bLocalUseExceptions ) {
21703 0 : pushErrorHandler();
21704 : }
21705 3 : {
21706 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21707 3 : OGRFeatureDefnShadow_SetGeometryIgnored(arg1,arg2);
21708 3 : SWIG_PYTHON_THREAD_END_ALLOW;
21709 : }
21710 3 : if ( bLocalUseExceptions ) {
21711 0 : popErrorHandler();
21712 : }
21713 : #ifndef SED_HACKS
21714 : if ( bLocalUseExceptions ) {
21715 : CPLErr eclass = CPLGetLastErrorType();
21716 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21717 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21718 : }
21719 : }
21720 : #endif
21721 : }
21722 3 : resultobj = SWIG_Py_Void();
21723 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21724 : return resultobj;
21725 : fail:
21726 : return NULL;
21727 : }
21728 :
21729 :
21730 2 : SWIGINTERN PyObject *_wrap_FeatureDefn_IsStyleIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21731 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21732 2 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21733 2 : void *argp1 = 0 ;
21734 2 : int res1 = 0 ;
21735 2 : PyObject *swig_obj[1] ;
21736 2 : int result;
21737 :
21738 2 : if (!args) SWIG_fail;
21739 2 : swig_obj[0] = args;
21740 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21741 2 : if (!SWIG_IsOK(res1)) {
21742 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_IsStyleIgnored" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21743 : }
21744 2 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21745 2 : {
21746 2 : const int bLocalUseExceptions = GetUseExceptions();
21747 2 : if ( bLocalUseExceptions ) {
21748 0 : pushErrorHandler();
21749 : }
21750 2 : {
21751 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21752 2 : result = (int)OGRFeatureDefnShadow_IsStyleIgnored(arg1);
21753 2 : SWIG_PYTHON_THREAD_END_ALLOW;
21754 : }
21755 2 : if ( bLocalUseExceptions ) {
21756 0 : popErrorHandler();
21757 : }
21758 : #ifndef SED_HACKS
21759 : if ( bLocalUseExceptions ) {
21760 : CPLErr eclass = CPLGetLastErrorType();
21761 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21762 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21763 : }
21764 : }
21765 : #endif
21766 : }
21767 2 : resultobj = SWIG_From_int(static_cast< int >(result));
21768 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21769 : return resultobj;
21770 : fail:
21771 : return NULL;
21772 : }
21773 :
21774 :
21775 0 : SWIGINTERN PyObject *_wrap_FeatureDefn_SetStyleIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21776 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21777 0 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21778 0 : int arg2 ;
21779 0 : void *argp1 = 0 ;
21780 0 : int res1 = 0 ;
21781 0 : int val2 ;
21782 0 : int ecode2 = 0 ;
21783 0 : PyObject *swig_obj[2] ;
21784 :
21785 0 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_SetStyleIgnored", 2, 2, swig_obj)) SWIG_fail;
21786 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21787 0 : if (!SWIG_IsOK(res1)) {
21788 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_SetStyleIgnored" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21789 : }
21790 0 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21791 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21792 0 : if (!SWIG_IsOK(ecode2)) {
21793 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FeatureDefn_SetStyleIgnored" "', argument " "2"" of type '" "int""'");
21794 : }
21795 0 : arg2 = static_cast< int >(val2);
21796 0 : {
21797 0 : const int bLocalUseExceptions = GetUseExceptions();
21798 0 : if ( bLocalUseExceptions ) {
21799 0 : pushErrorHandler();
21800 : }
21801 0 : {
21802 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21803 0 : OGRFeatureDefnShadow_SetStyleIgnored(arg1,arg2);
21804 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21805 : }
21806 0 : if ( bLocalUseExceptions ) {
21807 0 : popErrorHandler();
21808 : }
21809 : #ifndef SED_HACKS
21810 : if ( bLocalUseExceptions ) {
21811 : CPLErr eclass = CPLGetLastErrorType();
21812 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21813 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21814 : }
21815 : }
21816 : #endif
21817 : }
21818 0 : resultobj = SWIG_Py_Void();
21819 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21820 : return resultobj;
21821 : fail:
21822 : return NULL;
21823 : }
21824 :
21825 :
21826 11 : SWIGINTERN PyObject *_wrap_FeatureDefn_IsSame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21827 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21828 11 : OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
21829 11 : OGRFeatureDefnShadow *arg2 = (OGRFeatureDefnShadow *) 0 ;
21830 11 : void *argp1 = 0 ;
21831 11 : int res1 = 0 ;
21832 11 : void *argp2 = 0 ;
21833 11 : int res2 = 0 ;
21834 11 : PyObject *swig_obj[2] ;
21835 11 : int result;
21836 :
21837 11 : if (!SWIG_Python_UnpackTuple(args, "FeatureDefn_IsSame", 2, 2, swig_obj)) SWIG_fail;
21838 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21839 11 : if (!SWIG_IsOK(res1)) {
21840 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FeatureDefn_IsSame" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'");
21841 : }
21842 11 : arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
21843 11 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFeatureDefnShadow, 0 | 0 );
21844 11 : if (!SWIG_IsOK(res2)) {
21845 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FeatureDefn_IsSame" "', argument " "2"" of type '" "OGRFeatureDefnShadow *""'");
21846 : }
21847 11 : arg2 = reinterpret_cast< OGRFeatureDefnShadow * >(argp2);
21848 11 : {
21849 11 : if (!arg2) {
21850 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21851 : }
21852 : }
21853 11 : {
21854 11 : const int bLocalUseExceptions = GetUseExceptions();
21855 11 : if ( bLocalUseExceptions ) {
21856 4 : pushErrorHandler();
21857 : }
21858 11 : {
21859 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21860 11 : result = (int)OGRFeatureDefnShadow_IsSame(arg1,arg2);
21861 11 : SWIG_PYTHON_THREAD_END_ALLOW;
21862 : }
21863 11 : if ( bLocalUseExceptions ) {
21864 4 : popErrorHandler();
21865 : }
21866 : #ifndef SED_HACKS
21867 : if ( bLocalUseExceptions ) {
21868 : CPLErr eclass = CPLGetLastErrorType();
21869 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21870 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21871 : }
21872 : }
21873 : #endif
21874 : }
21875 11 : resultobj = SWIG_From_int(static_cast< int >(result));
21876 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21877 : return resultobj;
21878 : fail:
21879 : return NULL;
21880 : }
21881 :
21882 :
21883 275 : SWIGINTERN PyObject *FeatureDefn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21884 275 : PyObject *obj;
21885 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
21886 275 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRFeatureDefnShadow, SWIG_NewClientData(obj));
21887 275 : return SWIG_Py_Void();
21888 : }
21889 :
21890 110 : SWIGINTERN PyObject *FeatureDefn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21891 110 : return SWIG_Python_InitShadowInstance(args);
21892 : }
21893 :
21894 77912 : SWIGINTERN PyObject *_wrap_delete_FieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21895 77912 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21896 77912 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
21897 77912 : void *argp1 = 0 ;
21898 77912 : int res1 = 0 ;
21899 77912 : PyObject *swig_obj[1] ;
21900 :
21901 77912 : if (!args) SWIG_fail;
21902 77912 : swig_obj[0] = args;
21903 77912 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, SWIG_POINTER_DISOWN | 0 );
21904 77912 : if (!SWIG_IsOK(res1)) {
21905 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FieldDefn" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
21906 : }
21907 77912 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
21908 77912 : {
21909 77912 : const int bLocalUseExceptions = GetUseExceptions();
21910 77912 : if ( bLocalUseExceptions ) {
21911 69581 : pushErrorHandler();
21912 : }
21913 77912 : {
21914 77912 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21915 77912 : delete_OGRFieldDefnShadow(arg1);
21916 77912 : SWIG_PYTHON_THREAD_END_ALLOW;
21917 : }
21918 77912 : if ( bLocalUseExceptions ) {
21919 69581 : popErrorHandler();
21920 : }
21921 : #ifndef SED_HACKS
21922 : if ( bLocalUseExceptions ) {
21923 : CPLErr eclass = CPLGetLastErrorType();
21924 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21925 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21926 : }
21927 : }
21928 : #endif
21929 : }
21930 77912 : resultobj = SWIG_Py_Void();
21931 77912 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21932 : return resultobj;
21933 : fail:
21934 : return NULL;
21935 : }
21936 :
21937 :
21938 77925 : SWIGINTERN PyObject *_wrap_new_FieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21939 77925 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21940 77925 : char *arg1 = (char *) "unnamed" ;
21941 77925 : OGRFieldType arg2 = (OGRFieldType) OFTString ;
21942 77925 : int res1 ;
21943 77925 : char *buf1 = 0 ;
21944 77925 : int alloc1 = 0 ;
21945 77925 : int val2 ;
21946 77925 : int ecode2 = 0 ;
21947 77925 : PyObject * obj0 = 0 ;
21948 77925 : PyObject * obj1 = 0 ;
21949 77925 : char * kwnames[] = {
21950 : (char *)"name_null_ok", (char *)"field_type", NULL
21951 : };
21952 77925 : OGRFieldDefnShadow *result = 0 ;
21953 :
21954 77925 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:new_FieldDefn", kwnames, &obj0, &obj1)) SWIG_fail;
21955 77925 : if (obj0) {
21956 77925 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
21957 77925 : if (!SWIG_IsOK(res1)) {
21958 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FieldDefn" "', argument " "1"" of type '" "char const *""'");
21959 : }
21960 77925 : arg1 = reinterpret_cast< char * >(buf1);
21961 : }
21962 77925 : if (obj1) {
21963 75293 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21964 75293 : if (!SWIG_IsOK(ecode2)) {
21965 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FieldDefn" "', argument " "2"" of type '" "OGRFieldType""'");
21966 : }
21967 75293 : arg2 = static_cast< OGRFieldType >(val2);
21968 : }
21969 77925 : {
21970 77925 : const int bLocalUseExceptions = GetUseExceptions();
21971 77925 : if ( bLocalUseExceptions ) {
21972 69594 : pushErrorHandler();
21973 : }
21974 77925 : {
21975 77925 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21976 77925 : result = (OGRFieldDefnShadow *)new_OGRFieldDefnShadow((char const *)arg1,arg2);
21977 77925 : SWIG_PYTHON_THREAD_END_ALLOW;
21978 : }
21979 77925 : if ( bLocalUseExceptions ) {
21980 69594 : popErrorHandler();
21981 : }
21982 : #ifndef SED_HACKS
21983 : if ( bLocalUseExceptions ) {
21984 : CPLErr eclass = CPLGetLastErrorType();
21985 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21986 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21987 : }
21988 : }
21989 : #endif
21990 : }
21991 77925 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDefnShadow, SWIG_POINTER_NEW | 0 );
21992 77925 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21993 77925 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
21994 : return resultobj;
21995 0 : fail:
21996 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21997 : return NULL;
21998 : }
21999 :
22000 :
22001 211880 : SWIGINTERN PyObject *_wrap_FieldDefn_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22002 211880 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22003 211880 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22004 211880 : void *argp1 = 0 ;
22005 211880 : int res1 = 0 ;
22006 211880 : PyObject *swig_obj[1] ;
22007 211880 : char *result = 0 ;
22008 :
22009 211880 : if (!args) SWIG_fail;
22010 211880 : swig_obj[0] = args;
22011 211880 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22012 211880 : if (!SWIG_IsOK(res1)) {
22013 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22014 : }
22015 211880 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22016 211880 : {
22017 211880 : const int bLocalUseExceptions = GetUseExceptions();
22018 211880 : if ( bLocalUseExceptions ) {
22019 131036 : pushErrorHandler();
22020 : }
22021 211880 : {
22022 211880 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22023 211880 : result = (char *)OGRFieldDefnShadow_GetName(arg1);
22024 211880 : SWIG_PYTHON_THREAD_END_ALLOW;
22025 : }
22026 211880 : if ( bLocalUseExceptions ) {
22027 131036 : popErrorHandler();
22028 : }
22029 : #ifndef SED_HACKS
22030 : if ( bLocalUseExceptions ) {
22031 : CPLErr eclass = CPLGetLastErrorType();
22032 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22033 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22034 : }
22035 : }
22036 : #endif
22037 : }
22038 211880 : resultobj = SWIG_FromCharPtr((const char *)result);
22039 211880 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22040 : return resultobj;
22041 : fail:
22042 : return NULL;
22043 : }
22044 :
22045 :
22046 1537 : SWIGINTERN PyObject *_wrap_FieldDefn_GetNameRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22047 1537 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22048 1537 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22049 1537 : void *argp1 = 0 ;
22050 1537 : int res1 = 0 ;
22051 1537 : PyObject *swig_obj[1] ;
22052 1537 : char *result = 0 ;
22053 :
22054 1537 : if (!args) SWIG_fail;
22055 1537 : swig_obj[0] = args;
22056 1537 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22057 1537 : if (!SWIG_IsOK(res1)) {
22058 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetNameRef" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22059 : }
22060 1537 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22061 1537 : {
22062 1537 : const int bLocalUseExceptions = GetUseExceptions();
22063 1537 : if ( bLocalUseExceptions ) {
22064 950 : pushErrorHandler();
22065 : }
22066 1537 : {
22067 1537 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22068 1537 : result = (char *)OGRFieldDefnShadow_GetNameRef(arg1);
22069 1537 : SWIG_PYTHON_THREAD_END_ALLOW;
22070 : }
22071 1537 : if ( bLocalUseExceptions ) {
22072 950 : popErrorHandler();
22073 : }
22074 : #ifndef SED_HACKS
22075 : if ( bLocalUseExceptions ) {
22076 : CPLErr eclass = CPLGetLastErrorType();
22077 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22078 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22079 : }
22080 : }
22081 : #endif
22082 : }
22083 1537 : resultobj = SWIG_FromCharPtr((const char *)result);
22084 1537 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22085 : return resultobj;
22086 : fail:
22087 : return NULL;
22088 : }
22089 :
22090 :
22091 2 : SWIGINTERN PyObject *_wrap_FieldDefn_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22092 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22093 2 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22094 2 : char *arg2 = (char *) 0 ;
22095 2 : void *argp1 = 0 ;
22096 2 : int res1 = 0 ;
22097 2 : int res2 ;
22098 2 : char *buf2 = 0 ;
22099 2 : int alloc2 = 0 ;
22100 2 : PyObject *swig_obj[2] ;
22101 :
22102 2 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetName", 2, 2, swig_obj)) SWIG_fail;
22103 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22104 2 : if (!SWIG_IsOK(res1)) {
22105 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22106 : }
22107 2 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22108 2 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
22109 2 : if (!SWIG_IsOK(res2)) {
22110 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldDefn_SetName" "', argument " "2"" of type '" "char const *""'");
22111 : }
22112 2 : arg2 = reinterpret_cast< char * >(buf2);
22113 2 : {
22114 2 : if (!arg2) {
22115 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
22116 : }
22117 : }
22118 2 : {
22119 2 : const int bLocalUseExceptions = GetUseExceptions();
22120 2 : if ( bLocalUseExceptions ) {
22121 0 : pushErrorHandler();
22122 : }
22123 2 : {
22124 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22125 2 : OGRFieldDefnShadow_SetName(arg1,(char const *)arg2);
22126 2 : SWIG_PYTHON_THREAD_END_ALLOW;
22127 : }
22128 2 : if ( bLocalUseExceptions ) {
22129 0 : popErrorHandler();
22130 : }
22131 : #ifndef SED_HACKS
22132 : if ( bLocalUseExceptions ) {
22133 : CPLErr eclass = CPLGetLastErrorType();
22134 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22135 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22136 : }
22137 : }
22138 : #endif
22139 : }
22140 2 : resultobj = SWIG_Py_Void();
22141 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22142 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22143 : return resultobj;
22144 0 : fail:
22145 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22146 : return NULL;
22147 : }
22148 :
22149 :
22150 51 : SWIGINTERN PyObject *_wrap_FieldDefn_GetAlternativeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22151 51 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22152 51 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22153 51 : void *argp1 = 0 ;
22154 51 : int res1 = 0 ;
22155 51 : PyObject *swig_obj[1] ;
22156 51 : char *result = 0 ;
22157 :
22158 51 : if (!args) SWIG_fail;
22159 51 : swig_obj[0] = args;
22160 51 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22161 51 : if (!SWIG_IsOK(res1)) {
22162 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetAlternativeName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22163 : }
22164 51 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22165 51 : {
22166 51 : const int bLocalUseExceptions = GetUseExceptions();
22167 51 : if ( bLocalUseExceptions ) {
22168 18 : pushErrorHandler();
22169 : }
22170 51 : {
22171 51 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22172 51 : result = (char *)OGRFieldDefnShadow_GetAlternativeName(arg1);
22173 51 : SWIG_PYTHON_THREAD_END_ALLOW;
22174 : }
22175 51 : if ( bLocalUseExceptions ) {
22176 18 : popErrorHandler();
22177 : }
22178 : #ifndef SED_HACKS
22179 : if ( bLocalUseExceptions ) {
22180 : CPLErr eclass = CPLGetLastErrorType();
22181 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22182 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22183 : }
22184 : }
22185 : #endif
22186 : }
22187 51 : resultobj = SWIG_FromCharPtr((const char *)result);
22188 51 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22189 : return resultobj;
22190 : fail:
22191 : return NULL;
22192 : }
22193 :
22194 :
22195 9 : SWIGINTERN PyObject *_wrap_FieldDefn_GetAlternativeNameRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22196 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22197 9 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22198 9 : void *argp1 = 0 ;
22199 9 : int res1 = 0 ;
22200 9 : PyObject *swig_obj[1] ;
22201 9 : char *result = 0 ;
22202 :
22203 9 : if (!args) SWIG_fail;
22204 9 : swig_obj[0] = args;
22205 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22206 9 : if (!SWIG_IsOK(res1)) {
22207 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetAlternativeNameRef" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22208 : }
22209 9 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22210 9 : {
22211 9 : const int bLocalUseExceptions = GetUseExceptions();
22212 9 : if ( bLocalUseExceptions ) {
22213 9 : pushErrorHandler();
22214 : }
22215 9 : {
22216 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22217 9 : result = (char *)OGRFieldDefnShadow_GetAlternativeNameRef(arg1);
22218 9 : SWIG_PYTHON_THREAD_END_ALLOW;
22219 : }
22220 9 : if ( bLocalUseExceptions ) {
22221 9 : popErrorHandler();
22222 : }
22223 : #ifndef SED_HACKS
22224 : if ( bLocalUseExceptions ) {
22225 : CPLErr eclass = CPLGetLastErrorType();
22226 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22227 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22228 : }
22229 : }
22230 : #endif
22231 : }
22232 9 : resultobj = SWIG_FromCharPtr((const char *)result);
22233 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22234 : return resultobj;
22235 : fail:
22236 : return NULL;
22237 : }
22238 :
22239 :
22240 19 : SWIGINTERN PyObject *_wrap_FieldDefn_SetAlternativeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22241 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22242 19 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22243 19 : char *arg2 = (char *) 0 ;
22244 19 : void *argp1 = 0 ;
22245 19 : int res1 = 0 ;
22246 19 : int res2 ;
22247 19 : char *buf2 = 0 ;
22248 19 : int alloc2 = 0 ;
22249 19 : PyObject *swig_obj[2] ;
22250 :
22251 19 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetAlternativeName", 2, 2, swig_obj)) SWIG_fail;
22252 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22253 19 : if (!SWIG_IsOK(res1)) {
22254 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetAlternativeName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22255 : }
22256 19 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22257 19 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
22258 19 : if (!SWIG_IsOK(res2)) {
22259 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldDefn_SetAlternativeName" "', argument " "2"" of type '" "char const *""'");
22260 : }
22261 19 : arg2 = reinterpret_cast< char * >(buf2);
22262 19 : {
22263 19 : const int bLocalUseExceptions = GetUseExceptions();
22264 19 : if ( bLocalUseExceptions ) {
22265 6 : pushErrorHandler();
22266 : }
22267 19 : {
22268 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22269 19 : OGRFieldDefnShadow_SetAlternativeName(arg1,(char const *)arg2);
22270 19 : SWIG_PYTHON_THREAD_END_ALLOW;
22271 : }
22272 19 : if ( bLocalUseExceptions ) {
22273 6 : popErrorHandler();
22274 : }
22275 : #ifndef SED_HACKS
22276 : if ( bLocalUseExceptions ) {
22277 : CPLErr eclass = CPLGetLastErrorType();
22278 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22279 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22280 : }
22281 : }
22282 : #endif
22283 : }
22284 19 : resultobj = SWIG_Py_Void();
22285 19 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22286 19 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22287 : return resultobj;
22288 0 : fail:
22289 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22290 : return NULL;
22291 : }
22292 :
22293 :
22294 3927 : SWIGINTERN PyObject *_wrap_FieldDefn_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22295 3927 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22296 3927 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22297 3927 : void *argp1 = 0 ;
22298 3927 : int res1 = 0 ;
22299 3927 : PyObject *swig_obj[1] ;
22300 3927 : OGRFieldType result;
22301 :
22302 3927 : if (!args) SWIG_fail;
22303 3927 : swig_obj[0] = args;
22304 3927 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22305 3927 : if (!SWIG_IsOK(res1)) {
22306 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetType" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22307 : }
22308 3927 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22309 3927 : {
22310 3927 : const int bLocalUseExceptions = GetUseExceptions();
22311 3927 : if ( bLocalUseExceptions ) {
22312 2726 : pushErrorHandler();
22313 : }
22314 3927 : {
22315 3927 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22316 3927 : result = (OGRFieldType)OGRFieldDefnShadow_GetType(arg1);
22317 3927 : SWIG_PYTHON_THREAD_END_ALLOW;
22318 : }
22319 3927 : if ( bLocalUseExceptions ) {
22320 2726 : popErrorHandler();
22321 : }
22322 : #ifndef SED_HACKS
22323 : if ( bLocalUseExceptions ) {
22324 : CPLErr eclass = CPLGetLastErrorType();
22325 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22326 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22327 : }
22328 : }
22329 : #endif
22330 : }
22331 3927 : resultobj = SWIG_From_int(static_cast< int >(result));
22332 3927 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22333 : return resultobj;
22334 : fail:
22335 : return NULL;
22336 : }
22337 :
22338 :
22339 0 : SWIGINTERN PyObject *_wrap_FieldDefn_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22340 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22341 0 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22342 0 : OGRFieldType arg2 ;
22343 0 : void *argp1 = 0 ;
22344 0 : int res1 = 0 ;
22345 0 : int val2 ;
22346 0 : int ecode2 = 0 ;
22347 0 : PyObject *swig_obj[2] ;
22348 :
22349 0 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetType", 2, 2, swig_obj)) SWIG_fail;
22350 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22351 0 : if (!SWIG_IsOK(res1)) {
22352 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetType" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22353 : }
22354 0 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22355 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22356 0 : if (!SWIG_IsOK(ecode2)) {
22357 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetType" "', argument " "2"" of type '" "OGRFieldType""'");
22358 : }
22359 0 : arg2 = static_cast< OGRFieldType >(val2);
22360 0 : {
22361 0 : const int bLocalUseExceptions = GetUseExceptions();
22362 0 : if ( bLocalUseExceptions ) {
22363 0 : pushErrorHandler();
22364 : }
22365 0 : {
22366 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22367 0 : OGRFieldDefnShadow_SetType(arg1,arg2);
22368 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22369 : }
22370 0 : if ( bLocalUseExceptions ) {
22371 0 : popErrorHandler();
22372 : }
22373 : #ifndef SED_HACKS
22374 : if ( bLocalUseExceptions ) {
22375 : CPLErr eclass = CPLGetLastErrorType();
22376 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22377 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22378 : }
22379 : }
22380 : #endif
22381 : }
22382 0 : resultobj = SWIG_Py_Void();
22383 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22384 : return resultobj;
22385 : fail:
22386 : return NULL;
22387 : }
22388 :
22389 :
22390 88502 : SWIGINTERN PyObject *_wrap_FieldDefn_GetSubType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22391 88502 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22392 88502 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22393 88502 : void *argp1 = 0 ;
22394 88502 : int res1 = 0 ;
22395 88502 : PyObject *swig_obj[1] ;
22396 88502 : OGRFieldSubType result;
22397 :
22398 88502 : if (!args) SWIG_fail;
22399 88502 : swig_obj[0] = args;
22400 88502 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22401 88502 : if (!SWIG_IsOK(res1)) {
22402 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetSubType" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22403 : }
22404 88502 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22405 88502 : {
22406 88502 : const int bLocalUseExceptions = GetUseExceptions();
22407 88502 : if ( bLocalUseExceptions ) {
22408 81774 : pushErrorHandler();
22409 : }
22410 88502 : {
22411 88502 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22412 88502 : result = (OGRFieldSubType)OGRFieldDefnShadow_GetSubType(arg1);
22413 88502 : SWIG_PYTHON_THREAD_END_ALLOW;
22414 : }
22415 88502 : if ( bLocalUseExceptions ) {
22416 81774 : popErrorHandler();
22417 : }
22418 : #ifndef SED_HACKS
22419 : if ( bLocalUseExceptions ) {
22420 : CPLErr eclass = CPLGetLastErrorType();
22421 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22422 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22423 : }
22424 : }
22425 : #endif
22426 : }
22427 88502 : resultobj = SWIG_From_int(static_cast< int >(result));
22428 88502 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22429 : return resultobj;
22430 : fail:
22431 : return NULL;
22432 : }
22433 :
22434 :
22435 555 : SWIGINTERN PyObject *_wrap_FieldDefn_SetSubType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22436 555 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22437 555 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22438 555 : OGRFieldSubType arg2 ;
22439 555 : void *argp1 = 0 ;
22440 555 : int res1 = 0 ;
22441 555 : int val2 ;
22442 555 : int ecode2 = 0 ;
22443 555 : PyObject *swig_obj[2] ;
22444 :
22445 555 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetSubType", 2, 2, swig_obj)) SWIG_fail;
22446 555 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22447 555 : if (!SWIG_IsOK(res1)) {
22448 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetSubType" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22449 : }
22450 555 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22451 555 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22452 555 : if (!SWIG_IsOK(ecode2)) {
22453 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetSubType" "', argument " "2"" of type '" "OGRFieldSubType""'");
22454 : }
22455 555 : arg2 = static_cast< OGRFieldSubType >(val2);
22456 555 : {
22457 555 : const int bLocalUseExceptions = GetUseExceptions();
22458 555 : if ( bLocalUseExceptions ) {
22459 150 : pushErrorHandler();
22460 : }
22461 555 : {
22462 555 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22463 555 : OGRFieldDefnShadow_SetSubType(arg1,arg2);
22464 555 : SWIG_PYTHON_THREAD_END_ALLOW;
22465 : }
22466 555 : if ( bLocalUseExceptions ) {
22467 150 : popErrorHandler();
22468 : }
22469 : #ifndef SED_HACKS
22470 : if ( bLocalUseExceptions ) {
22471 : CPLErr eclass = CPLGetLastErrorType();
22472 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22473 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22474 : }
22475 : }
22476 : #endif
22477 : }
22478 555 : resultobj = SWIG_Py_Void();
22479 555 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22480 : return resultobj;
22481 : fail:
22482 : return NULL;
22483 : }
22484 :
22485 :
22486 0 : SWIGINTERN PyObject *_wrap_FieldDefn_GetJustify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22487 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22488 0 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22489 0 : void *argp1 = 0 ;
22490 0 : int res1 = 0 ;
22491 0 : PyObject *swig_obj[1] ;
22492 0 : OGRJustification result;
22493 :
22494 0 : if (!args) SWIG_fail;
22495 0 : swig_obj[0] = args;
22496 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22497 0 : if (!SWIG_IsOK(res1)) {
22498 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetJustify" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22499 : }
22500 0 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22501 0 : {
22502 0 : const int bLocalUseExceptions = GetUseExceptions();
22503 0 : if ( bLocalUseExceptions ) {
22504 0 : pushErrorHandler();
22505 : }
22506 0 : {
22507 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22508 0 : result = (OGRJustification)OGRFieldDefnShadow_GetJustify(arg1);
22509 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22510 : }
22511 0 : if ( bLocalUseExceptions ) {
22512 0 : popErrorHandler();
22513 : }
22514 : #ifndef SED_HACKS
22515 : if ( bLocalUseExceptions ) {
22516 : CPLErr eclass = CPLGetLastErrorType();
22517 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22518 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22519 : }
22520 : }
22521 : #endif
22522 : }
22523 0 : resultobj = SWIG_From_int(static_cast< int >(result));
22524 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22525 : return resultobj;
22526 : fail:
22527 : return NULL;
22528 : }
22529 :
22530 :
22531 0 : SWIGINTERN PyObject *_wrap_FieldDefn_SetJustify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22532 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22533 0 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22534 0 : OGRJustification arg2 ;
22535 0 : void *argp1 = 0 ;
22536 0 : int res1 = 0 ;
22537 0 : int val2 ;
22538 0 : int ecode2 = 0 ;
22539 0 : PyObject *swig_obj[2] ;
22540 :
22541 0 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetJustify", 2, 2, swig_obj)) SWIG_fail;
22542 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22543 0 : if (!SWIG_IsOK(res1)) {
22544 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetJustify" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22545 : }
22546 0 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22547 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22548 0 : if (!SWIG_IsOK(ecode2)) {
22549 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetJustify" "', argument " "2"" of type '" "OGRJustification""'");
22550 : }
22551 0 : arg2 = static_cast< OGRJustification >(val2);
22552 0 : {
22553 0 : const int bLocalUseExceptions = GetUseExceptions();
22554 0 : if ( bLocalUseExceptions ) {
22555 0 : pushErrorHandler();
22556 : }
22557 0 : {
22558 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22559 0 : OGRFieldDefnShadow_SetJustify(arg1,arg2);
22560 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22561 : }
22562 0 : if ( bLocalUseExceptions ) {
22563 0 : popErrorHandler();
22564 : }
22565 : #ifndef SED_HACKS
22566 : if ( bLocalUseExceptions ) {
22567 : CPLErr eclass = CPLGetLastErrorType();
22568 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22569 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22570 : }
22571 : }
22572 : #endif
22573 : }
22574 0 : resultobj = SWIG_Py_Void();
22575 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22576 : return resultobj;
22577 : fail:
22578 : return NULL;
22579 : }
22580 :
22581 :
22582 2731 : SWIGINTERN PyObject *_wrap_FieldDefn_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22583 2731 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22584 2731 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22585 2731 : void *argp1 = 0 ;
22586 2731 : int res1 = 0 ;
22587 2731 : PyObject *swig_obj[1] ;
22588 2731 : int result;
22589 :
22590 2731 : if (!args) SWIG_fail;
22591 2731 : swig_obj[0] = args;
22592 2731 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22593 2731 : if (!SWIG_IsOK(res1)) {
22594 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetWidth" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22595 : }
22596 2731 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22597 2731 : {
22598 2731 : const int bLocalUseExceptions = GetUseExceptions();
22599 2731 : if ( bLocalUseExceptions ) {
22600 1491 : pushErrorHandler();
22601 : }
22602 2731 : {
22603 2731 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22604 2731 : result = (int)OGRFieldDefnShadow_GetWidth(arg1);
22605 2731 : SWIG_PYTHON_THREAD_END_ALLOW;
22606 : }
22607 2731 : if ( bLocalUseExceptions ) {
22608 1491 : popErrorHandler();
22609 : }
22610 : #ifndef SED_HACKS
22611 : if ( bLocalUseExceptions ) {
22612 : CPLErr eclass = CPLGetLastErrorType();
22613 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22614 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22615 : }
22616 : }
22617 : #endif
22618 : }
22619 2731 : resultobj = SWIG_From_int(static_cast< int >(result));
22620 2731 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22621 : return resultobj;
22622 : fail:
22623 : return NULL;
22624 : }
22625 :
22626 :
22627 321 : SWIGINTERN PyObject *_wrap_FieldDefn_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22628 321 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22629 321 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22630 321 : int arg2 ;
22631 321 : void *argp1 = 0 ;
22632 321 : int res1 = 0 ;
22633 321 : int val2 ;
22634 321 : int ecode2 = 0 ;
22635 321 : PyObject *swig_obj[2] ;
22636 :
22637 321 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetWidth", 2, 2, swig_obj)) SWIG_fail;
22638 321 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22639 321 : if (!SWIG_IsOK(res1)) {
22640 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetWidth" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22641 : }
22642 321 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22643 321 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22644 321 : if (!SWIG_IsOK(ecode2)) {
22645 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetWidth" "', argument " "2"" of type '" "int""'");
22646 : }
22647 321 : arg2 = static_cast< int >(val2);
22648 321 : {
22649 321 : const int bLocalUseExceptions = GetUseExceptions();
22650 321 : if ( bLocalUseExceptions ) {
22651 67 : pushErrorHandler();
22652 : }
22653 321 : {
22654 321 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22655 321 : OGRFieldDefnShadow_SetWidth(arg1,arg2);
22656 321 : SWIG_PYTHON_THREAD_END_ALLOW;
22657 : }
22658 321 : if ( bLocalUseExceptions ) {
22659 67 : popErrorHandler();
22660 : }
22661 : #ifndef SED_HACKS
22662 : if ( bLocalUseExceptions ) {
22663 : CPLErr eclass = CPLGetLastErrorType();
22664 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22665 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22666 : }
22667 : }
22668 : #endif
22669 : }
22670 321 : resultobj = SWIG_Py_Void();
22671 321 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22672 : return resultobj;
22673 : fail:
22674 : return NULL;
22675 : }
22676 :
22677 :
22678 1604 : SWIGINTERN PyObject *_wrap_FieldDefn_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22679 1604 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22680 1604 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22681 1604 : void *argp1 = 0 ;
22682 1604 : int res1 = 0 ;
22683 1604 : PyObject *swig_obj[1] ;
22684 1604 : int result;
22685 :
22686 1604 : if (!args) SWIG_fail;
22687 1604 : swig_obj[0] = args;
22688 1604 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22689 1604 : if (!SWIG_IsOK(res1)) {
22690 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetPrecision" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22691 : }
22692 1604 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22693 1604 : {
22694 1604 : const int bLocalUseExceptions = GetUseExceptions();
22695 1604 : if ( bLocalUseExceptions ) {
22696 1479 : pushErrorHandler();
22697 : }
22698 1604 : {
22699 1604 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22700 1604 : result = (int)OGRFieldDefnShadow_GetPrecision(arg1);
22701 1604 : SWIG_PYTHON_THREAD_END_ALLOW;
22702 : }
22703 1604 : if ( bLocalUseExceptions ) {
22704 1479 : popErrorHandler();
22705 : }
22706 : #ifndef SED_HACKS
22707 : if ( bLocalUseExceptions ) {
22708 : CPLErr eclass = CPLGetLastErrorType();
22709 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22710 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22711 : }
22712 : }
22713 : #endif
22714 : }
22715 1604 : resultobj = SWIG_From_int(static_cast< int >(result));
22716 1604 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22717 : return resultobj;
22718 : fail:
22719 : return NULL;
22720 : }
22721 :
22722 :
22723 24 : SWIGINTERN PyObject *_wrap_FieldDefn_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22724 24 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22725 24 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22726 24 : int arg2 ;
22727 24 : void *argp1 = 0 ;
22728 24 : int res1 = 0 ;
22729 24 : int val2 ;
22730 24 : int ecode2 = 0 ;
22731 24 : PyObject *swig_obj[2] ;
22732 :
22733 24 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetPrecision", 2, 2, swig_obj)) SWIG_fail;
22734 24 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22735 24 : if (!SWIG_IsOK(res1)) {
22736 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetPrecision" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22737 : }
22738 24 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22739 24 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22740 24 : if (!SWIG_IsOK(ecode2)) {
22741 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetPrecision" "', argument " "2"" of type '" "int""'");
22742 : }
22743 24 : arg2 = static_cast< int >(val2);
22744 24 : {
22745 24 : const int bLocalUseExceptions = GetUseExceptions();
22746 24 : if ( bLocalUseExceptions ) {
22747 13 : pushErrorHandler();
22748 : }
22749 24 : {
22750 24 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22751 24 : OGRFieldDefnShadow_SetPrecision(arg1,arg2);
22752 24 : SWIG_PYTHON_THREAD_END_ALLOW;
22753 : }
22754 24 : if ( bLocalUseExceptions ) {
22755 13 : popErrorHandler();
22756 : }
22757 : #ifndef SED_HACKS
22758 : if ( bLocalUseExceptions ) {
22759 : CPLErr eclass = CPLGetLastErrorType();
22760 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22761 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22762 : }
22763 : }
22764 : #endif
22765 : }
22766 24 : resultobj = SWIG_Py_Void();
22767 24 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22768 : return resultobj;
22769 : fail:
22770 : return NULL;
22771 : }
22772 :
22773 :
22774 0 : SWIGINTERN PyObject *_wrap_FieldDefn_GetTZFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22775 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22776 0 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22777 0 : void *argp1 = 0 ;
22778 0 : int res1 = 0 ;
22779 0 : PyObject *swig_obj[1] ;
22780 0 : int result;
22781 :
22782 0 : if (!args) SWIG_fail;
22783 0 : swig_obj[0] = args;
22784 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22785 0 : if (!SWIG_IsOK(res1)) {
22786 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetTZFlag" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22787 : }
22788 0 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22789 0 : {
22790 0 : const int bLocalUseExceptions = GetUseExceptions();
22791 0 : if ( bLocalUseExceptions ) {
22792 0 : pushErrorHandler();
22793 : }
22794 0 : {
22795 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22796 0 : result = (int)OGRFieldDefnShadow_GetTZFlag(arg1);
22797 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22798 : }
22799 0 : if ( bLocalUseExceptions ) {
22800 0 : popErrorHandler();
22801 : }
22802 : #ifndef SED_HACKS
22803 : if ( bLocalUseExceptions ) {
22804 : CPLErr eclass = CPLGetLastErrorType();
22805 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22806 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22807 : }
22808 : }
22809 : #endif
22810 : }
22811 0 : resultobj = SWIG_From_int(static_cast< int >(result));
22812 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22813 : return resultobj;
22814 : fail:
22815 : return NULL;
22816 : }
22817 :
22818 :
22819 6 : SWIGINTERN PyObject *_wrap_FieldDefn_SetTZFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22820 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22821 6 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22822 6 : int arg2 ;
22823 6 : void *argp1 = 0 ;
22824 6 : int res1 = 0 ;
22825 6 : int val2 ;
22826 6 : int ecode2 = 0 ;
22827 6 : PyObject *swig_obj[2] ;
22828 :
22829 6 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetTZFlag", 2, 2, swig_obj)) SWIG_fail;
22830 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22831 6 : if (!SWIG_IsOK(res1)) {
22832 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetTZFlag" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22833 : }
22834 6 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22835 6 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22836 6 : if (!SWIG_IsOK(ecode2)) {
22837 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetTZFlag" "', argument " "2"" of type '" "int""'");
22838 : }
22839 6 : arg2 = static_cast< int >(val2);
22840 6 : {
22841 6 : const int bLocalUseExceptions = GetUseExceptions();
22842 6 : if ( bLocalUseExceptions ) {
22843 6 : pushErrorHandler();
22844 : }
22845 6 : {
22846 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22847 6 : OGRFieldDefnShadow_SetTZFlag(arg1,arg2);
22848 6 : SWIG_PYTHON_THREAD_END_ALLOW;
22849 : }
22850 6 : if ( bLocalUseExceptions ) {
22851 6 : popErrorHandler();
22852 : }
22853 : #ifndef SED_HACKS
22854 : if ( bLocalUseExceptions ) {
22855 : CPLErr eclass = CPLGetLastErrorType();
22856 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22857 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22858 : }
22859 : }
22860 : #endif
22861 : }
22862 6 : resultobj = SWIG_Py_Void();
22863 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22864 : return resultobj;
22865 : fail:
22866 : return NULL;
22867 : }
22868 :
22869 :
22870 13 : SWIGINTERN PyObject *_wrap_FieldDefn_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22871 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22872 13 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22873 13 : void *argp1 = 0 ;
22874 13 : int res1 = 0 ;
22875 13 : PyObject *swig_obj[1] ;
22876 13 : char *result = 0 ;
22877 :
22878 13 : if (!args) SWIG_fail;
22879 13 : swig_obj[0] = args;
22880 13 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22881 13 : if (!SWIG_IsOK(res1)) {
22882 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetTypeName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22883 : }
22884 13 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22885 13 : {
22886 13 : const int bLocalUseExceptions = GetUseExceptions();
22887 13 : if ( bLocalUseExceptions ) {
22888 13 : pushErrorHandler();
22889 : }
22890 13 : {
22891 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22892 13 : result = (char *)OGRFieldDefnShadow_GetTypeName(arg1);
22893 13 : SWIG_PYTHON_THREAD_END_ALLOW;
22894 : }
22895 13 : if ( bLocalUseExceptions ) {
22896 13 : popErrorHandler();
22897 : }
22898 : #ifndef SED_HACKS
22899 : if ( bLocalUseExceptions ) {
22900 : CPLErr eclass = CPLGetLastErrorType();
22901 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22902 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22903 : }
22904 : }
22905 : #endif
22906 : }
22907 13 : resultobj = SWIG_FromCharPtr((const char *)result);
22908 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22909 : return resultobj;
22910 : fail:
22911 : return NULL;
22912 : }
22913 :
22914 :
22915 36 : SWIGINTERN PyObject *_wrap_FieldDefn_GetFieldTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22916 36 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22917 36 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22918 36 : OGRFieldType arg2 ;
22919 36 : void *argp1 = 0 ;
22920 36 : int res1 = 0 ;
22921 36 : int val2 ;
22922 36 : int ecode2 = 0 ;
22923 36 : PyObject *swig_obj[2] ;
22924 36 : char *result = 0 ;
22925 :
22926 36 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_GetFieldTypeName", 2, 2, swig_obj)) SWIG_fail;
22927 36 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22928 36 : if (!SWIG_IsOK(res1)) {
22929 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetFieldTypeName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22930 : }
22931 36 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22932 36 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22933 36 : if (!SWIG_IsOK(ecode2)) {
22934 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_GetFieldTypeName" "', argument " "2"" of type '" "OGRFieldType""'");
22935 : }
22936 36 : arg2 = static_cast< OGRFieldType >(val2);
22937 36 : {
22938 36 : const int bLocalUseExceptions = GetUseExceptions();
22939 36 : if ( bLocalUseExceptions ) {
22940 0 : pushErrorHandler();
22941 : }
22942 36 : {
22943 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22944 36 : result = (char *)OGRFieldDefnShadow_GetFieldTypeName(arg1,arg2);
22945 36 : SWIG_PYTHON_THREAD_END_ALLOW;
22946 : }
22947 36 : if ( bLocalUseExceptions ) {
22948 0 : popErrorHandler();
22949 : }
22950 : #ifndef SED_HACKS
22951 : if ( bLocalUseExceptions ) {
22952 : CPLErr eclass = CPLGetLastErrorType();
22953 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22954 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22955 : }
22956 : }
22957 : #endif
22958 : }
22959 36 : resultobj = SWIG_FromCharPtr((const char *)result);
22960 36 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
22961 : return resultobj;
22962 : fail:
22963 : return NULL;
22964 : }
22965 :
22966 :
22967 6 : SWIGINTERN PyObject *_wrap_FieldDefn_IsIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22968 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22969 6 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
22970 6 : void *argp1 = 0 ;
22971 6 : int res1 = 0 ;
22972 6 : PyObject *swig_obj[1] ;
22973 6 : int result;
22974 :
22975 6 : if (!args) SWIG_fail;
22976 6 : swig_obj[0] = args;
22977 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
22978 6 : if (!SWIG_IsOK(res1)) {
22979 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_IsIgnored" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
22980 : }
22981 6 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
22982 6 : {
22983 6 : const int bLocalUseExceptions = GetUseExceptions();
22984 6 : if ( bLocalUseExceptions ) {
22985 2 : pushErrorHandler();
22986 : }
22987 6 : {
22988 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22989 6 : result = (int)OGRFieldDefnShadow_IsIgnored(arg1);
22990 6 : SWIG_PYTHON_THREAD_END_ALLOW;
22991 : }
22992 6 : if ( bLocalUseExceptions ) {
22993 2 : popErrorHandler();
22994 : }
22995 : #ifndef SED_HACKS
22996 : if ( bLocalUseExceptions ) {
22997 : CPLErr eclass = CPLGetLastErrorType();
22998 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22999 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23000 : }
23001 : }
23002 : #endif
23003 : }
23004 6 : resultobj = SWIG_From_int(static_cast< int >(result));
23005 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23006 : return resultobj;
23007 : fail:
23008 : return NULL;
23009 : }
23010 :
23011 :
23012 0 : SWIGINTERN PyObject *_wrap_FieldDefn_SetIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23013 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23014 0 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23015 0 : int arg2 ;
23016 0 : void *argp1 = 0 ;
23017 0 : int res1 = 0 ;
23018 0 : int val2 ;
23019 0 : int ecode2 = 0 ;
23020 0 : PyObject *swig_obj[2] ;
23021 :
23022 0 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetIgnored", 2, 2, swig_obj)) SWIG_fail;
23023 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23024 0 : if (!SWIG_IsOK(res1)) {
23025 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetIgnored" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23026 : }
23027 0 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23028 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23029 0 : if (!SWIG_IsOK(ecode2)) {
23030 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetIgnored" "', argument " "2"" of type '" "int""'");
23031 : }
23032 0 : arg2 = static_cast< int >(val2);
23033 0 : {
23034 0 : const int bLocalUseExceptions = GetUseExceptions();
23035 0 : if ( bLocalUseExceptions ) {
23036 0 : pushErrorHandler();
23037 : }
23038 0 : {
23039 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23040 0 : OGRFieldDefnShadow_SetIgnored(arg1,arg2);
23041 0 : SWIG_PYTHON_THREAD_END_ALLOW;
23042 : }
23043 0 : if ( bLocalUseExceptions ) {
23044 0 : popErrorHandler();
23045 : }
23046 : #ifndef SED_HACKS
23047 : if ( bLocalUseExceptions ) {
23048 : CPLErr eclass = CPLGetLastErrorType();
23049 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23050 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23051 : }
23052 : }
23053 : #endif
23054 : }
23055 0 : resultobj = SWIG_Py_Void();
23056 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23057 : return resultobj;
23058 : fail:
23059 : return NULL;
23060 : }
23061 :
23062 :
23063 80 : SWIGINTERN PyObject *_wrap_FieldDefn_IsNullable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23064 80 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23065 80 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23066 80 : void *argp1 = 0 ;
23067 80 : int res1 = 0 ;
23068 80 : PyObject *swig_obj[1] ;
23069 80 : int result;
23070 :
23071 80 : if (!args) SWIG_fail;
23072 80 : swig_obj[0] = args;
23073 80 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23074 80 : if (!SWIG_IsOK(res1)) {
23075 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_IsNullable" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23076 : }
23077 80 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23078 80 : {
23079 80 : const int bLocalUseExceptions = GetUseExceptions();
23080 80 : if ( bLocalUseExceptions ) {
23081 45 : pushErrorHandler();
23082 : }
23083 80 : {
23084 80 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23085 80 : result = (int)OGRFieldDefnShadow_IsNullable(arg1);
23086 80 : SWIG_PYTHON_THREAD_END_ALLOW;
23087 : }
23088 80 : if ( bLocalUseExceptions ) {
23089 45 : popErrorHandler();
23090 : }
23091 : #ifndef SED_HACKS
23092 : if ( bLocalUseExceptions ) {
23093 : CPLErr eclass = CPLGetLastErrorType();
23094 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23095 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23096 : }
23097 : }
23098 : #endif
23099 : }
23100 80 : resultobj = SWIG_From_int(static_cast< int >(result));
23101 80 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23102 : return resultobj;
23103 : fail:
23104 : return NULL;
23105 : }
23106 :
23107 :
23108 190 : SWIGINTERN PyObject *_wrap_FieldDefn_SetNullable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23109 190 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23110 190 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23111 190 : int arg2 ;
23112 190 : void *argp1 = 0 ;
23113 190 : int res1 = 0 ;
23114 190 : int val2 ;
23115 190 : int ecode2 = 0 ;
23116 190 : PyObject *swig_obj[2] ;
23117 :
23118 190 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetNullable", 2, 2, swig_obj)) SWIG_fail;
23119 190 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23120 190 : if (!SWIG_IsOK(res1)) {
23121 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetNullable" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23122 : }
23123 190 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23124 190 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23125 190 : if (!SWIG_IsOK(ecode2)) {
23126 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetNullable" "', argument " "2"" of type '" "int""'");
23127 : }
23128 190 : arg2 = static_cast< int >(val2);
23129 190 : {
23130 190 : const int bLocalUseExceptions = GetUseExceptions();
23131 190 : if ( bLocalUseExceptions ) {
23132 119 : pushErrorHandler();
23133 : }
23134 190 : {
23135 190 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23136 190 : OGRFieldDefnShadow_SetNullable(arg1,arg2);
23137 190 : SWIG_PYTHON_THREAD_END_ALLOW;
23138 : }
23139 190 : if ( bLocalUseExceptions ) {
23140 119 : popErrorHandler();
23141 : }
23142 : #ifndef SED_HACKS
23143 : if ( bLocalUseExceptions ) {
23144 : CPLErr eclass = CPLGetLastErrorType();
23145 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23146 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23147 : }
23148 : }
23149 : #endif
23150 : }
23151 190 : resultobj = SWIG_Py_Void();
23152 190 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23153 : return resultobj;
23154 : fail:
23155 : return NULL;
23156 : }
23157 :
23158 :
23159 80 : SWIGINTERN PyObject *_wrap_FieldDefn_IsUnique(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23160 80 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23161 80 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23162 80 : void *argp1 = 0 ;
23163 80 : int res1 = 0 ;
23164 80 : PyObject *swig_obj[1] ;
23165 80 : int result;
23166 :
23167 80 : if (!args) SWIG_fail;
23168 80 : swig_obj[0] = args;
23169 80 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23170 80 : if (!SWIG_IsOK(res1)) {
23171 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_IsUnique" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23172 : }
23173 80 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23174 80 : {
23175 80 : const int bLocalUseExceptions = GetUseExceptions();
23176 80 : if ( bLocalUseExceptions ) {
23177 4 : pushErrorHandler();
23178 : }
23179 80 : {
23180 80 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23181 80 : result = (int)OGRFieldDefnShadow_IsUnique(arg1);
23182 80 : SWIG_PYTHON_THREAD_END_ALLOW;
23183 : }
23184 80 : if ( bLocalUseExceptions ) {
23185 4 : popErrorHandler();
23186 : }
23187 : #ifndef SED_HACKS
23188 : if ( bLocalUseExceptions ) {
23189 : CPLErr eclass = CPLGetLastErrorType();
23190 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23191 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23192 : }
23193 : }
23194 : #endif
23195 : }
23196 80 : resultobj = SWIG_From_int(static_cast< int >(result));
23197 80 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23198 : return resultobj;
23199 : fail:
23200 : return NULL;
23201 : }
23202 :
23203 :
23204 28 : SWIGINTERN PyObject *_wrap_FieldDefn_SetUnique(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23205 28 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23206 28 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23207 28 : int arg2 ;
23208 28 : void *argp1 = 0 ;
23209 28 : int res1 = 0 ;
23210 28 : int val2 ;
23211 28 : int ecode2 = 0 ;
23212 28 : PyObject *swig_obj[2] ;
23213 :
23214 28 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetUnique", 2, 2, swig_obj)) SWIG_fail;
23215 28 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23216 28 : if (!SWIG_IsOK(res1)) {
23217 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetUnique" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23218 : }
23219 28 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23220 28 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23221 28 : if (!SWIG_IsOK(ecode2)) {
23222 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDefn_SetUnique" "', argument " "2"" of type '" "int""'");
23223 : }
23224 28 : arg2 = static_cast< int >(val2);
23225 28 : {
23226 28 : const int bLocalUseExceptions = GetUseExceptions();
23227 28 : if ( bLocalUseExceptions ) {
23228 5 : pushErrorHandler();
23229 : }
23230 28 : {
23231 28 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23232 28 : OGRFieldDefnShadow_SetUnique(arg1,arg2);
23233 28 : SWIG_PYTHON_THREAD_END_ALLOW;
23234 : }
23235 28 : if ( bLocalUseExceptions ) {
23236 5 : popErrorHandler();
23237 : }
23238 : #ifndef SED_HACKS
23239 : if ( bLocalUseExceptions ) {
23240 : CPLErr eclass = CPLGetLastErrorType();
23241 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23242 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23243 : }
23244 : }
23245 : #endif
23246 : }
23247 28 : resultobj = SWIG_Py_Void();
23248 28 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23249 : return resultobj;
23250 : fail:
23251 : return NULL;
23252 : }
23253 :
23254 :
23255 141 : SWIGINTERN PyObject *_wrap_FieldDefn_GetDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23256 141 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23257 141 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23258 141 : void *argp1 = 0 ;
23259 141 : int res1 = 0 ;
23260 141 : PyObject *swig_obj[1] ;
23261 141 : char *result = 0 ;
23262 :
23263 141 : if (!args) SWIG_fail;
23264 141 : swig_obj[0] = args;
23265 141 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23266 141 : if (!SWIG_IsOK(res1)) {
23267 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetDefault" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23268 : }
23269 141 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23270 141 : {
23271 141 : const int bLocalUseExceptions = GetUseExceptions();
23272 141 : if ( bLocalUseExceptions ) {
23273 27 : pushErrorHandler();
23274 : }
23275 141 : {
23276 141 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23277 141 : result = (char *)OGRFieldDefnShadow_GetDefault(arg1);
23278 141 : SWIG_PYTHON_THREAD_END_ALLOW;
23279 : }
23280 141 : if ( bLocalUseExceptions ) {
23281 27 : popErrorHandler();
23282 : }
23283 : #ifndef SED_HACKS
23284 : if ( bLocalUseExceptions ) {
23285 : CPLErr eclass = CPLGetLastErrorType();
23286 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23287 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23288 : }
23289 : }
23290 : #endif
23291 : }
23292 141 : resultobj = SWIG_FromCharPtr((const char *)result);
23293 141 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23294 : return resultobj;
23295 : fail:
23296 : return NULL;
23297 : }
23298 :
23299 :
23300 154 : SWIGINTERN PyObject *_wrap_FieldDefn_SetDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23301 154 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23302 154 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23303 154 : char *arg2 = (char *) 0 ;
23304 154 : void *argp1 = 0 ;
23305 154 : int res1 = 0 ;
23306 154 : int res2 ;
23307 154 : char *buf2 = 0 ;
23308 154 : int alloc2 = 0 ;
23309 154 : PyObject *swig_obj[2] ;
23310 :
23311 154 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetDefault", 2, 2, swig_obj)) SWIG_fail;
23312 154 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23313 154 : if (!SWIG_IsOK(res1)) {
23314 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetDefault" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23315 : }
23316 154 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23317 154 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
23318 154 : if (!SWIG_IsOK(res2)) {
23319 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldDefn_SetDefault" "', argument " "2"" of type '" "char const *""'");
23320 : }
23321 154 : arg2 = reinterpret_cast< char * >(buf2);
23322 154 : {
23323 154 : const int bLocalUseExceptions = GetUseExceptions();
23324 154 : if ( bLocalUseExceptions ) {
23325 11 : pushErrorHandler();
23326 : }
23327 154 : {
23328 154 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23329 154 : OGRFieldDefnShadow_SetDefault(arg1,(char const *)arg2);
23330 154 : SWIG_PYTHON_THREAD_END_ALLOW;
23331 : }
23332 154 : if ( bLocalUseExceptions ) {
23333 11 : popErrorHandler();
23334 : }
23335 : #ifndef SED_HACKS
23336 : if ( bLocalUseExceptions ) {
23337 : CPLErr eclass = CPLGetLastErrorType();
23338 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23339 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23340 : }
23341 : }
23342 : #endif
23343 : }
23344 154 : resultobj = SWIG_Py_Void();
23345 154 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23346 154 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23347 : return resultobj;
23348 0 : fail:
23349 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23350 : return NULL;
23351 : }
23352 :
23353 :
23354 3 : SWIGINTERN PyObject *_wrap_FieldDefn_IsDefaultDriverSpecific(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23355 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23356 3 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23357 3 : void *argp1 = 0 ;
23358 3 : int res1 = 0 ;
23359 3 : PyObject *swig_obj[1] ;
23360 3 : int result;
23361 :
23362 3 : if (!args) SWIG_fail;
23363 3 : swig_obj[0] = args;
23364 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23365 3 : if (!SWIG_IsOK(res1)) {
23366 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_IsDefaultDriverSpecific" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23367 : }
23368 3 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23369 3 : {
23370 3 : const int bLocalUseExceptions = GetUseExceptions();
23371 3 : if ( bLocalUseExceptions ) {
23372 3 : pushErrorHandler();
23373 : }
23374 3 : {
23375 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23376 3 : result = (int)OGRFieldDefnShadow_IsDefaultDriverSpecific(arg1);
23377 3 : SWIG_PYTHON_THREAD_END_ALLOW;
23378 : }
23379 3 : if ( bLocalUseExceptions ) {
23380 3 : popErrorHandler();
23381 : }
23382 : #ifndef SED_HACKS
23383 : if ( bLocalUseExceptions ) {
23384 : CPLErr eclass = CPLGetLastErrorType();
23385 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23386 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23387 : }
23388 : }
23389 : #endif
23390 : }
23391 3 : resultobj = SWIG_From_int(static_cast< int >(result));
23392 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23393 : return resultobj;
23394 : fail:
23395 : return NULL;
23396 : }
23397 :
23398 :
23399 34 : SWIGINTERN PyObject *_wrap_FieldDefn_GetDomainName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23400 34 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23401 34 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23402 34 : void *argp1 = 0 ;
23403 34 : int res1 = 0 ;
23404 34 : PyObject *swig_obj[1] ;
23405 34 : char *result = 0 ;
23406 :
23407 34 : if (!args) SWIG_fail;
23408 34 : swig_obj[0] = args;
23409 34 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23410 34 : if (!SWIG_IsOK(res1)) {
23411 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetDomainName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23412 : }
23413 34 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23414 34 : {
23415 34 : const int bLocalUseExceptions = GetUseExceptions();
23416 34 : if ( bLocalUseExceptions ) {
23417 23 : pushErrorHandler();
23418 : }
23419 34 : {
23420 34 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23421 34 : result = (char *)OGRFieldDefnShadow_GetDomainName(arg1);
23422 34 : SWIG_PYTHON_THREAD_END_ALLOW;
23423 : }
23424 34 : if ( bLocalUseExceptions ) {
23425 23 : popErrorHandler();
23426 : }
23427 : #ifndef SED_HACKS
23428 : if ( bLocalUseExceptions ) {
23429 : CPLErr eclass = CPLGetLastErrorType();
23430 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23431 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23432 : }
23433 : }
23434 : #endif
23435 : }
23436 34 : resultobj = SWIG_FromCharPtr((const char *)result);
23437 34 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23438 : return resultobj;
23439 : fail:
23440 : return NULL;
23441 : }
23442 :
23443 :
23444 21 : SWIGINTERN PyObject *_wrap_FieldDefn_SetDomainName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23445 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23446 21 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23447 21 : char *arg2 = (char *) 0 ;
23448 21 : void *argp1 = 0 ;
23449 21 : int res1 = 0 ;
23450 21 : int res2 ;
23451 21 : char *buf2 = 0 ;
23452 21 : int alloc2 = 0 ;
23453 21 : PyObject *swig_obj[2] ;
23454 :
23455 21 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetDomainName", 2, 2, swig_obj)) SWIG_fail;
23456 21 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23457 21 : if (!SWIG_IsOK(res1)) {
23458 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetDomainName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23459 : }
23460 21 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23461 21 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
23462 21 : if (!SWIG_IsOK(res2)) {
23463 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldDefn_SetDomainName" "', argument " "2"" of type '" "char const *""'");
23464 : }
23465 21 : arg2 = reinterpret_cast< char * >(buf2);
23466 21 : {
23467 21 : if (!arg2) {
23468 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
23469 : }
23470 : }
23471 21 : {
23472 21 : const int bLocalUseExceptions = GetUseExceptions();
23473 21 : if ( bLocalUseExceptions ) {
23474 9 : pushErrorHandler();
23475 : }
23476 21 : {
23477 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23478 21 : OGRFieldDefnShadow_SetDomainName(arg1,(char const *)arg2);
23479 21 : SWIG_PYTHON_THREAD_END_ALLOW;
23480 : }
23481 21 : if ( bLocalUseExceptions ) {
23482 9 : popErrorHandler();
23483 : }
23484 : #ifndef SED_HACKS
23485 : if ( bLocalUseExceptions ) {
23486 : CPLErr eclass = CPLGetLastErrorType();
23487 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23488 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23489 : }
23490 : }
23491 : #endif
23492 : }
23493 21 : resultobj = SWIG_Py_Void();
23494 21 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23495 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23496 : return resultobj;
23497 0 : fail:
23498 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23499 : return NULL;
23500 : }
23501 :
23502 :
23503 58 : SWIGINTERN PyObject *_wrap_FieldDefn_GetComment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23504 58 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23505 58 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23506 58 : void *argp1 = 0 ;
23507 58 : int res1 = 0 ;
23508 58 : PyObject *swig_obj[1] ;
23509 58 : char *result = 0 ;
23510 :
23511 58 : if (!args) SWIG_fail;
23512 58 : swig_obj[0] = args;
23513 58 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23514 58 : if (!SWIG_IsOK(res1)) {
23515 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_GetComment" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23516 : }
23517 58 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23518 58 : {
23519 58 : const int bLocalUseExceptions = GetUseExceptions();
23520 58 : if ( bLocalUseExceptions ) {
23521 5 : pushErrorHandler();
23522 : }
23523 58 : {
23524 58 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23525 58 : result = (char *)OGRFieldDefnShadow_GetComment(arg1);
23526 58 : SWIG_PYTHON_THREAD_END_ALLOW;
23527 : }
23528 58 : if ( bLocalUseExceptions ) {
23529 5 : popErrorHandler();
23530 : }
23531 : #ifndef SED_HACKS
23532 : if ( bLocalUseExceptions ) {
23533 : CPLErr eclass = CPLGetLastErrorType();
23534 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23535 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23536 : }
23537 : }
23538 : #endif
23539 : }
23540 58 : resultobj = SWIG_FromCharPtr((const char *)result);
23541 58 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23542 : return resultobj;
23543 : fail:
23544 : return NULL;
23545 : }
23546 :
23547 :
23548 32 : SWIGINTERN PyObject *_wrap_FieldDefn_SetComment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23549 32 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23550 32 : OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
23551 32 : char *arg2 = (char *) 0 ;
23552 32 : void *argp1 = 0 ;
23553 32 : int res1 = 0 ;
23554 32 : int res2 ;
23555 32 : char *buf2 = 0 ;
23556 32 : int alloc2 = 0 ;
23557 32 : PyObject *swig_obj[2] ;
23558 :
23559 32 : if (!SWIG_Python_UnpackTuple(args, "FieldDefn_SetComment", 2, 2, swig_obj)) SWIG_fail;
23560 32 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 | 0 );
23561 32 : if (!SWIG_IsOK(res1)) {
23562 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDefn_SetComment" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'");
23563 : }
23564 32 : arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
23565 32 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
23566 32 : if (!SWIG_IsOK(res2)) {
23567 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldDefn_SetComment" "', argument " "2"" of type '" "char const *""'");
23568 : }
23569 32 : arg2 = reinterpret_cast< char * >(buf2);
23570 32 : {
23571 32 : const int bLocalUseExceptions = GetUseExceptions();
23572 32 : if ( bLocalUseExceptions ) {
23573 6 : pushErrorHandler();
23574 : }
23575 32 : {
23576 32 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23577 32 : OGRFieldDefnShadow_SetComment(arg1,(char const *)arg2);
23578 32 : SWIG_PYTHON_THREAD_END_ALLOW;
23579 : }
23580 32 : if ( bLocalUseExceptions ) {
23581 6 : popErrorHandler();
23582 : }
23583 : #ifndef SED_HACKS
23584 : if ( bLocalUseExceptions ) {
23585 : CPLErr eclass = CPLGetLastErrorType();
23586 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23587 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23588 : }
23589 : }
23590 : #endif
23591 : }
23592 32 : resultobj = SWIG_Py_Void();
23593 32 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23594 32 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23595 : return resultobj;
23596 0 : fail:
23597 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23598 : return NULL;
23599 : }
23600 :
23601 :
23602 275 : SWIGINTERN PyObject *FieldDefn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23603 275 : PyObject *obj;
23604 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
23605 275 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRFieldDefnShadow, SWIG_NewClientData(obj));
23606 275 : return SWIG_Py_Void();
23607 : }
23608 :
23609 77925 : SWIGINTERN PyObject *FieldDefn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23610 77925 : return SWIG_Python_InitShadowInstance(args);
23611 : }
23612 :
23613 171 : SWIGINTERN PyObject *_wrap_delete_GeomFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23614 171 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23615 171 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
23616 171 : void *argp1 = 0 ;
23617 171 : int res1 = 0 ;
23618 171 : PyObject *swig_obj[1] ;
23619 :
23620 171 : if (!args) SWIG_fail;
23621 171 : swig_obj[0] = args;
23622 171 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, SWIG_POINTER_DISOWN | 0 );
23623 171 : if (!SWIG_IsOK(res1)) {
23624 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeomFieldDefn" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
23625 : }
23626 171 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
23627 171 : {
23628 171 : const int bLocalUseExceptions = GetUseExceptions();
23629 171 : if ( bLocalUseExceptions ) {
23630 58 : pushErrorHandler();
23631 : }
23632 171 : {
23633 171 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23634 171 : delete_OGRGeomFieldDefnShadow(arg1);
23635 171 : SWIG_PYTHON_THREAD_END_ALLOW;
23636 : }
23637 171 : if ( bLocalUseExceptions ) {
23638 58 : popErrorHandler();
23639 : }
23640 : #ifndef SED_HACKS
23641 : if ( bLocalUseExceptions ) {
23642 : CPLErr eclass = CPLGetLastErrorType();
23643 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23644 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23645 : }
23646 : }
23647 : #endif
23648 : }
23649 171 : resultobj = SWIG_Py_Void();
23650 171 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23651 : return resultobj;
23652 : fail:
23653 : return NULL;
23654 : }
23655 :
23656 :
23657 171 : SWIGINTERN PyObject *_wrap_new_GeomFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23658 171 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23659 171 : char *arg1 = (char *) "" ;
23660 171 : OGRwkbGeometryType arg2 = (OGRwkbGeometryType) wkbUnknown ;
23661 171 : int res1 ;
23662 171 : char *buf1 = 0 ;
23663 171 : int alloc1 = 0 ;
23664 171 : int val2 ;
23665 171 : int ecode2 = 0 ;
23666 171 : PyObject * obj0 = 0 ;
23667 171 : PyObject * obj1 = 0 ;
23668 171 : char * kwnames[] = {
23669 : (char *)"name_null_ok", (char *)"field_type", NULL
23670 : };
23671 171 : OGRGeomFieldDefnShadow *result = 0 ;
23672 :
23673 171 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:new_GeomFieldDefn", kwnames, &obj0, &obj1)) SWIG_fail;
23674 171 : if (obj0) {
23675 168 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
23676 168 : if (!SWIG_IsOK(res1)) {
23677 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GeomFieldDefn" "', argument " "1"" of type '" "char const *""'");
23678 : }
23679 168 : arg1 = reinterpret_cast< char * >(buf1);
23680 : }
23681 171 : if (obj1) {
23682 155 : ecode2 = SWIG_AsVal_int(obj1, &val2);
23683 155 : if (!SWIG_IsOK(ecode2)) {
23684 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GeomFieldDefn" "', argument " "2"" of type '" "OGRwkbGeometryType""'");
23685 : }
23686 155 : arg2 = static_cast< OGRwkbGeometryType >(val2);
23687 : }
23688 171 : {
23689 171 : const int bLocalUseExceptions = GetUseExceptions();
23690 171 : if ( bLocalUseExceptions ) {
23691 58 : pushErrorHandler();
23692 : }
23693 171 : {
23694 171 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23695 171 : result = (OGRGeomFieldDefnShadow *)new_OGRGeomFieldDefnShadow((char const *)arg1,arg2);
23696 171 : SWIG_PYTHON_THREAD_END_ALLOW;
23697 : }
23698 171 : if ( bLocalUseExceptions ) {
23699 58 : popErrorHandler();
23700 : }
23701 : #ifndef SED_HACKS
23702 : if ( bLocalUseExceptions ) {
23703 : CPLErr eclass = CPLGetLastErrorType();
23704 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23705 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23706 : }
23707 : }
23708 : #endif
23709 : }
23710 171 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeomFieldDefnShadow, SWIG_POINTER_NEW | 0 );
23711 171 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23712 171 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23713 : return resultobj;
23714 0 : fail:
23715 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23716 : return NULL;
23717 : }
23718 :
23719 :
23720 228 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23721 228 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23722 228 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
23723 228 : void *argp1 = 0 ;
23724 228 : int res1 = 0 ;
23725 228 : PyObject *swig_obj[1] ;
23726 228 : char *result = 0 ;
23727 :
23728 228 : if (!args) SWIG_fail;
23729 228 : swig_obj[0] = args;
23730 228 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
23731 228 : if (!SWIG_IsOK(res1)) {
23732 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_GetName" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
23733 : }
23734 228 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
23735 228 : {
23736 228 : const int bLocalUseExceptions = GetUseExceptions();
23737 228 : if ( bLocalUseExceptions ) {
23738 182 : pushErrorHandler();
23739 : }
23740 228 : {
23741 228 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23742 228 : result = (char *)OGRGeomFieldDefnShadow_GetName(arg1);
23743 228 : SWIG_PYTHON_THREAD_END_ALLOW;
23744 : }
23745 228 : if ( bLocalUseExceptions ) {
23746 182 : popErrorHandler();
23747 : }
23748 : #ifndef SED_HACKS
23749 : if ( bLocalUseExceptions ) {
23750 : CPLErr eclass = CPLGetLastErrorType();
23751 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23752 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23753 : }
23754 : }
23755 : #endif
23756 : }
23757 228 : resultobj = SWIG_FromCharPtr((const char *)result);
23758 228 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23759 : return resultobj;
23760 : fail:
23761 : return NULL;
23762 : }
23763 :
23764 :
23765 82 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_GetNameRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23766 82 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23767 82 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
23768 82 : void *argp1 = 0 ;
23769 82 : int res1 = 0 ;
23770 82 : PyObject *swig_obj[1] ;
23771 82 : char *result = 0 ;
23772 :
23773 82 : if (!args) SWIG_fail;
23774 82 : swig_obj[0] = args;
23775 82 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
23776 82 : if (!SWIG_IsOK(res1)) {
23777 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_GetNameRef" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
23778 : }
23779 82 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
23780 82 : {
23781 82 : const int bLocalUseExceptions = GetUseExceptions();
23782 82 : if ( bLocalUseExceptions ) {
23783 0 : pushErrorHandler();
23784 : }
23785 82 : {
23786 82 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23787 82 : result = (char *)OGRGeomFieldDefnShadow_GetNameRef(arg1);
23788 82 : SWIG_PYTHON_THREAD_END_ALLOW;
23789 : }
23790 82 : if ( bLocalUseExceptions ) {
23791 0 : popErrorHandler();
23792 : }
23793 : #ifndef SED_HACKS
23794 : if ( bLocalUseExceptions ) {
23795 : CPLErr eclass = CPLGetLastErrorType();
23796 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23797 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23798 : }
23799 : }
23800 : #endif
23801 : }
23802 82 : resultobj = SWIG_FromCharPtr((const char *)result);
23803 82 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23804 : return resultobj;
23805 : fail:
23806 : return NULL;
23807 : }
23808 :
23809 :
23810 4 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23811 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23812 4 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
23813 4 : char *arg2 = (char *) 0 ;
23814 4 : void *argp1 = 0 ;
23815 4 : int res1 = 0 ;
23816 4 : int res2 ;
23817 4 : char *buf2 = 0 ;
23818 4 : int alloc2 = 0 ;
23819 4 : PyObject *swig_obj[2] ;
23820 :
23821 4 : if (!SWIG_Python_UnpackTuple(args, "GeomFieldDefn_SetName", 2, 2, swig_obj)) SWIG_fail;
23822 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
23823 4 : if (!SWIG_IsOK(res1)) {
23824 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_SetName" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
23825 : }
23826 4 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
23827 4 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
23828 4 : if (!SWIG_IsOK(res2)) {
23829 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomFieldDefn_SetName" "', argument " "2"" of type '" "char const *""'");
23830 : }
23831 4 : arg2 = reinterpret_cast< char * >(buf2);
23832 4 : {
23833 4 : if (!arg2) {
23834 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
23835 : }
23836 : }
23837 4 : {
23838 4 : const int bLocalUseExceptions = GetUseExceptions();
23839 4 : if ( bLocalUseExceptions ) {
23840 2 : pushErrorHandler();
23841 : }
23842 4 : {
23843 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23844 4 : OGRGeomFieldDefnShadow_SetName(arg1,(char const *)arg2);
23845 4 : SWIG_PYTHON_THREAD_END_ALLOW;
23846 : }
23847 4 : if ( bLocalUseExceptions ) {
23848 2 : popErrorHandler();
23849 : }
23850 : #ifndef SED_HACKS
23851 : if ( bLocalUseExceptions ) {
23852 : CPLErr eclass = CPLGetLastErrorType();
23853 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23854 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23855 : }
23856 : }
23857 : #endif
23858 : }
23859 4 : resultobj = SWIG_Py_Void();
23860 4 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23861 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23862 : return resultobj;
23863 0 : fail:
23864 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23865 : return NULL;
23866 : }
23867 :
23868 :
23869 85 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23870 85 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23871 85 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
23872 85 : void *argp1 = 0 ;
23873 85 : int res1 = 0 ;
23874 85 : PyObject *swig_obj[1] ;
23875 85 : OGRwkbGeometryType result;
23876 :
23877 85 : if (!args) SWIG_fail;
23878 85 : swig_obj[0] = args;
23879 85 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
23880 85 : if (!SWIG_IsOK(res1)) {
23881 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_GetType" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
23882 : }
23883 85 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
23884 85 : {
23885 85 : const int bLocalUseExceptions = GetUseExceptions();
23886 85 : if ( bLocalUseExceptions ) {
23887 17 : pushErrorHandler();
23888 : }
23889 85 : {
23890 85 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23891 85 : result = (OGRwkbGeometryType)OGRGeomFieldDefnShadow_GetType(arg1);
23892 85 : SWIG_PYTHON_THREAD_END_ALLOW;
23893 : }
23894 85 : if ( bLocalUseExceptions ) {
23895 17 : popErrorHandler();
23896 : }
23897 : #ifndef SED_HACKS
23898 : if ( bLocalUseExceptions ) {
23899 : CPLErr eclass = CPLGetLastErrorType();
23900 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23901 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23902 : }
23903 : }
23904 : #endif
23905 : }
23906 85 : resultobj = SWIG_From_int(static_cast< int >(result));
23907 85 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23908 : return resultobj;
23909 : fail:
23910 : return NULL;
23911 : }
23912 :
23913 :
23914 2 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23915 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23916 2 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
23917 2 : OGRwkbGeometryType arg2 ;
23918 2 : void *argp1 = 0 ;
23919 2 : int res1 = 0 ;
23920 2 : int val2 ;
23921 2 : int ecode2 = 0 ;
23922 2 : PyObject *swig_obj[2] ;
23923 :
23924 2 : if (!SWIG_Python_UnpackTuple(args, "GeomFieldDefn_SetType", 2, 2, swig_obj)) SWIG_fail;
23925 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
23926 2 : if (!SWIG_IsOK(res1)) {
23927 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_SetType" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
23928 : }
23929 2 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
23930 2 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23931 2 : if (!SWIG_IsOK(ecode2)) {
23932 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeomFieldDefn_SetType" "', argument " "2"" of type '" "OGRwkbGeometryType""'");
23933 : }
23934 2 : arg2 = static_cast< OGRwkbGeometryType >(val2);
23935 2 : {
23936 2 : const int bLocalUseExceptions = GetUseExceptions();
23937 2 : if ( bLocalUseExceptions ) {
23938 0 : pushErrorHandler();
23939 : }
23940 2 : {
23941 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23942 2 : OGRGeomFieldDefnShadow_SetType(arg1,arg2);
23943 2 : SWIG_PYTHON_THREAD_END_ALLOW;
23944 : }
23945 2 : if ( bLocalUseExceptions ) {
23946 0 : popErrorHandler();
23947 : }
23948 : #ifndef SED_HACKS
23949 : if ( bLocalUseExceptions ) {
23950 : CPLErr eclass = CPLGetLastErrorType();
23951 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23952 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23953 : }
23954 : }
23955 : #endif
23956 : }
23957 2 : resultobj = SWIG_Py_Void();
23958 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
23959 : return resultobj;
23960 : fail:
23961 : return NULL;
23962 : }
23963 :
23964 :
23965 81 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_GetSpatialRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23966 81 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23967 81 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
23968 81 : void *argp1 = 0 ;
23969 81 : int res1 = 0 ;
23970 81 : PyObject *swig_obj[1] ;
23971 81 : OSRSpatialReferenceShadow *result = 0 ;
23972 :
23973 81 : if (!args) SWIG_fail;
23974 81 : swig_obj[0] = args;
23975 81 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
23976 81 : if (!SWIG_IsOK(res1)) {
23977 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_GetSpatialRef" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
23978 : }
23979 81 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
23980 81 : {
23981 81 : const int bLocalUseExceptions = GetUseExceptions();
23982 81 : if ( bLocalUseExceptions ) {
23983 18 : pushErrorHandler();
23984 : }
23985 81 : {
23986 81 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23987 81 : result = (OSRSpatialReferenceShadow *)OGRGeomFieldDefnShadow_GetSpatialRef(arg1);
23988 81 : SWIG_PYTHON_THREAD_END_ALLOW;
23989 : }
23990 81 : if ( bLocalUseExceptions ) {
23991 18 : popErrorHandler();
23992 : }
23993 : #ifndef SED_HACKS
23994 : if ( bLocalUseExceptions ) {
23995 : CPLErr eclass = CPLGetLastErrorType();
23996 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23997 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23998 : }
23999 : }
24000 : #endif
24001 : }
24002 81 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_OWN | 0 );
24003 81 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24004 : return resultobj;
24005 : fail:
24006 : return NULL;
24007 : }
24008 :
24009 :
24010 48 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_SetSpatialRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24011 48 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24012 48 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24013 48 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
24014 48 : void *argp1 = 0 ;
24015 48 : int res1 = 0 ;
24016 48 : void *argp2 = 0 ;
24017 48 : int res2 = 0 ;
24018 48 : PyObject *swig_obj[2] ;
24019 :
24020 48 : if (!SWIG_Python_UnpackTuple(args, "GeomFieldDefn_SetSpatialRef", 2, 2, swig_obj)) SWIG_fail;
24021 48 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24022 48 : if (!SWIG_IsOK(res1)) {
24023 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_SetSpatialRef" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24024 : }
24025 48 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24026 48 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
24027 48 : if (!SWIG_IsOK(res2)) {
24028 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomFieldDefn_SetSpatialRef" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
24029 : }
24030 48 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
24031 48 : {
24032 48 : const int bLocalUseExceptions = GetUseExceptions();
24033 48 : if ( bLocalUseExceptions ) {
24034 5 : pushErrorHandler();
24035 : }
24036 48 : {
24037 48 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24038 48 : OGRGeomFieldDefnShadow_SetSpatialRef(arg1,arg2);
24039 48 : SWIG_PYTHON_THREAD_END_ALLOW;
24040 : }
24041 48 : if ( bLocalUseExceptions ) {
24042 5 : popErrorHandler();
24043 : }
24044 : #ifndef SED_HACKS
24045 : if ( bLocalUseExceptions ) {
24046 : CPLErr eclass = CPLGetLastErrorType();
24047 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24048 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24049 : }
24050 : }
24051 : #endif
24052 : }
24053 48 : resultobj = SWIG_Py_Void();
24054 48 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24055 : return resultobj;
24056 : fail:
24057 : return NULL;
24058 : }
24059 :
24060 :
24061 6 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_IsIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24062 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24063 6 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24064 6 : void *argp1 = 0 ;
24065 6 : int res1 = 0 ;
24066 6 : PyObject *swig_obj[1] ;
24067 6 : int result;
24068 :
24069 6 : if (!args) SWIG_fail;
24070 6 : swig_obj[0] = args;
24071 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24072 6 : if (!SWIG_IsOK(res1)) {
24073 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_IsIgnored" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24074 : }
24075 6 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24076 6 : {
24077 6 : const int bLocalUseExceptions = GetUseExceptions();
24078 6 : if ( bLocalUseExceptions ) {
24079 2 : pushErrorHandler();
24080 : }
24081 6 : {
24082 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24083 6 : result = (int)OGRGeomFieldDefnShadow_IsIgnored(arg1);
24084 6 : SWIG_PYTHON_THREAD_END_ALLOW;
24085 : }
24086 6 : if ( bLocalUseExceptions ) {
24087 2 : popErrorHandler();
24088 : }
24089 : #ifndef SED_HACKS
24090 : if ( bLocalUseExceptions ) {
24091 : CPLErr eclass = CPLGetLastErrorType();
24092 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24093 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24094 : }
24095 : }
24096 : #endif
24097 : }
24098 6 : resultobj = SWIG_From_int(static_cast< int >(result));
24099 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24100 : return resultobj;
24101 : fail:
24102 : return NULL;
24103 : }
24104 :
24105 :
24106 1 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_SetIgnored(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24107 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24108 1 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24109 1 : int arg2 ;
24110 1 : void *argp1 = 0 ;
24111 1 : int res1 = 0 ;
24112 1 : int val2 ;
24113 1 : int ecode2 = 0 ;
24114 1 : PyObject *swig_obj[2] ;
24115 :
24116 1 : if (!SWIG_Python_UnpackTuple(args, "GeomFieldDefn_SetIgnored", 2, 2, swig_obj)) SWIG_fail;
24117 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24118 1 : if (!SWIG_IsOK(res1)) {
24119 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_SetIgnored" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24120 : }
24121 1 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24122 1 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24123 1 : if (!SWIG_IsOK(ecode2)) {
24124 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeomFieldDefn_SetIgnored" "', argument " "2"" of type '" "int""'");
24125 : }
24126 1 : arg2 = static_cast< int >(val2);
24127 1 : {
24128 1 : const int bLocalUseExceptions = GetUseExceptions();
24129 1 : if ( bLocalUseExceptions ) {
24130 0 : pushErrorHandler();
24131 : }
24132 1 : {
24133 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24134 1 : OGRGeomFieldDefnShadow_SetIgnored(arg1,arg2);
24135 1 : SWIG_PYTHON_THREAD_END_ALLOW;
24136 : }
24137 1 : if ( bLocalUseExceptions ) {
24138 0 : popErrorHandler();
24139 : }
24140 : #ifndef SED_HACKS
24141 : if ( bLocalUseExceptions ) {
24142 : CPLErr eclass = CPLGetLastErrorType();
24143 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24144 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24145 : }
24146 : }
24147 : #endif
24148 : }
24149 1 : resultobj = SWIG_Py_Void();
24150 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24151 : return resultobj;
24152 : fail:
24153 : return NULL;
24154 : }
24155 :
24156 :
24157 85 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_IsNullable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24158 85 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24159 85 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24160 85 : void *argp1 = 0 ;
24161 85 : int res1 = 0 ;
24162 85 : PyObject *swig_obj[1] ;
24163 85 : int result;
24164 :
24165 85 : if (!args) SWIG_fail;
24166 85 : swig_obj[0] = args;
24167 85 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24168 85 : if (!SWIG_IsOK(res1)) {
24169 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_IsNullable" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24170 : }
24171 85 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24172 85 : {
24173 85 : const int bLocalUseExceptions = GetUseExceptions();
24174 85 : if ( bLocalUseExceptions ) {
24175 3 : pushErrorHandler();
24176 : }
24177 85 : {
24178 85 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24179 85 : result = (int)OGRGeomFieldDefnShadow_IsNullable(arg1);
24180 85 : SWIG_PYTHON_THREAD_END_ALLOW;
24181 : }
24182 85 : if ( bLocalUseExceptions ) {
24183 3 : popErrorHandler();
24184 : }
24185 : #ifndef SED_HACKS
24186 : if ( bLocalUseExceptions ) {
24187 : CPLErr eclass = CPLGetLastErrorType();
24188 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24189 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24190 : }
24191 : }
24192 : #endif
24193 : }
24194 85 : resultobj = SWIG_From_int(static_cast< int >(result));
24195 85 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24196 : return resultobj;
24197 : fail:
24198 : return NULL;
24199 : }
24200 :
24201 :
24202 23 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_SetNullable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24203 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24204 23 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24205 23 : int arg2 ;
24206 23 : void *argp1 = 0 ;
24207 23 : int res1 = 0 ;
24208 23 : int val2 ;
24209 23 : int ecode2 = 0 ;
24210 23 : PyObject *swig_obj[2] ;
24211 :
24212 23 : if (!SWIG_Python_UnpackTuple(args, "GeomFieldDefn_SetNullable", 2, 2, swig_obj)) SWIG_fail;
24213 23 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24214 23 : if (!SWIG_IsOK(res1)) {
24215 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_SetNullable" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24216 : }
24217 23 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24218 23 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24219 23 : if (!SWIG_IsOK(ecode2)) {
24220 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeomFieldDefn_SetNullable" "', argument " "2"" of type '" "int""'");
24221 : }
24222 23 : arg2 = static_cast< int >(val2);
24223 23 : {
24224 23 : const int bLocalUseExceptions = GetUseExceptions();
24225 23 : if ( bLocalUseExceptions ) {
24226 10 : pushErrorHandler();
24227 : }
24228 23 : {
24229 23 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24230 23 : OGRGeomFieldDefnShadow_SetNullable(arg1,arg2);
24231 23 : SWIG_PYTHON_THREAD_END_ALLOW;
24232 : }
24233 23 : if ( bLocalUseExceptions ) {
24234 10 : popErrorHandler();
24235 : }
24236 : #ifndef SED_HACKS
24237 : if ( bLocalUseExceptions ) {
24238 : CPLErr eclass = CPLGetLastErrorType();
24239 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24240 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24241 : }
24242 : }
24243 : #endif
24244 : }
24245 23 : resultobj = SWIG_Py_Void();
24246 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24247 : return resultobj;
24248 : fail:
24249 : return NULL;
24250 : }
24251 :
24252 :
24253 44 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_GetCoordinatePrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24254 44 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24255 44 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24256 44 : void *argp1 = 0 ;
24257 44 : int res1 = 0 ;
24258 44 : PyObject *swig_obj[1] ;
24259 44 : OGRGeomCoordinatePrecisionShadow *result = 0 ;
24260 :
24261 44 : if (!args) SWIG_fail;
24262 44 : swig_obj[0] = args;
24263 44 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24264 44 : if (!SWIG_IsOK(res1)) {
24265 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_GetCoordinatePrecision" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24266 : }
24267 44 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24268 44 : {
24269 44 : const int bLocalUseExceptions = GetUseExceptions();
24270 44 : if ( bLocalUseExceptions ) {
24271 35 : pushErrorHandler();
24272 : }
24273 44 : {
24274 44 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24275 44 : result = (OGRGeomCoordinatePrecisionShadow *)OGRGeomFieldDefnShadow_GetCoordinatePrecision(arg1);
24276 44 : SWIG_PYTHON_THREAD_END_ALLOW;
24277 : }
24278 44 : if ( bLocalUseExceptions ) {
24279 35 : popErrorHandler();
24280 : }
24281 : #ifndef SED_HACKS
24282 : if ( bLocalUseExceptions ) {
24283 : CPLErr eclass = CPLGetLastErrorType();
24284 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24285 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24286 : }
24287 : }
24288 : #endif
24289 : }
24290 44 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
24291 44 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24292 : return resultobj;
24293 : fail:
24294 : return NULL;
24295 : }
24296 :
24297 :
24298 19 : SWIGINTERN PyObject *_wrap_GeomFieldDefn_SetCoordinatePrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24299 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24300 19 : OGRGeomFieldDefnShadow *arg1 = (OGRGeomFieldDefnShadow *) 0 ;
24301 19 : OGRGeomCoordinatePrecisionShadow *arg2 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
24302 19 : void *argp1 = 0 ;
24303 19 : int res1 = 0 ;
24304 19 : void *argp2 = 0 ;
24305 19 : int res2 = 0 ;
24306 19 : PyObject *swig_obj[2] ;
24307 :
24308 19 : if (!SWIG_Python_UnpackTuple(args, "GeomFieldDefn_SetCoordinatePrecision", 2, 2, swig_obj)) SWIG_fail;
24309 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
24310 19 : if (!SWIG_IsOK(res1)) {
24311 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomFieldDefn_SetCoordinatePrecision" "', argument " "1"" of type '" "OGRGeomFieldDefnShadow *""'");
24312 : }
24313 19 : arg1 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp1);
24314 19 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
24315 19 : if (!SWIG_IsOK(res2)) {
24316 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomFieldDefn_SetCoordinatePrecision" "', argument " "2"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
24317 : }
24318 19 : arg2 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp2);
24319 19 : {
24320 19 : const int bLocalUseExceptions = GetUseExceptions();
24321 19 : if ( bLocalUseExceptions ) {
24322 13 : pushErrorHandler();
24323 : }
24324 19 : {
24325 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24326 19 : OGRGeomFieldDefnShadow_SetCoordinatePrecision(arg1,arg2);
24327 19 : SWIG_PYTHON_THREAD_END_ALLOW;
24328 : }
24329 19 : if ( bLocalUseExceptions ) {
24330 13 : popErrorHandler();
24331 : }
24332 : #ifndef SED_HACKS
24333 : if ( bLocalUseExceptions ) {
24334 : CPLErr eclass = CPLGetLastErrorType();
24335 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24336 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24337 : }
24338 : }
24339 : #endif
24340 : }
24341 19 : resultobj = SWIG_Py_Void();
24342 19 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24343 : return resultobj;
24344 : fail:
24345 : return NULL;
24346 : }
24347 :
24348 :
24349 275 : SWIGINTERN PyObject *GeomFieldDefn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24350 275 : PyObject *obj;
24351 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
24352 275 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRGeomFieldDefnShadow, SWIG_NewClientData(obj));
24353 275 : return SWIG_Py_Void();
24354 : }
24355 :
24356 171 : SWIGINTERN PyObject *GeomFieldDefn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24357 171 : return SWIG_Python_InitShadowInstance(args);
24358 : }
24359 :
24360 31028 : SWIGINTERN PyObject *_wrap_CreateGeometryFromWkb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24361 31028 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24362 31028 : size_t arg1 ;
24363 31028 : char *arg2 = (char *) 0 ;
24364 31028 : OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) NULL ;
24365 31028 : int alloc1 = 0 ;
24366 31028 : bool viewIsValid1 = false ;
24367 31028 : Py_buffer view1 ;
24368 31028 : void *argp3 = 0 ;
24369 31028 : int res3 = 0 ;
24370 31028 : PyObject * obj0 = 0 ;
24371 31028 : PyObject * obj1 = 0 ;
24372 31028 : char * kwnames[] = {
24373 : (char *)"len", (char *)"reference", NULL
24374 : };
24375 31028 : OGRGeometryShadow *result = 0 ;
24376 :
24377 31028 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:CreateGeometryFromWkb", kwnames, &obj0, &obj1)) SWIG_fail;
24378 31028 : {
24379 : /* %typemap(in,numinputs=1) (size_t nLen, char *pBuf ) */
24380 31028 : char* ptr = NULL;
24381 31028 : if( !GetBufferAsCharPtrSizetSize(obj0, &arg1, &ptr, &alloc1, &viewIsValid1, &view1) ) {
24382 0 : SWIG_fail;
24383 : }
24384 31028 : arg2 = (char *)ptr;
24385 : }
24386 31028 : if (obj1) {
24387 0 : res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
24388 0 : if (!SWIG_IsOK(res3)) {
24389 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CreateGeometryFromWkb" "', argument " "3"" of type '" "OSRSpatialReferenceShadow *""'");
24390 : }
24391 0 : arg3 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp3);
24392 : }
24393 31028 : {
24394 31028 : const int bLocalUseExceptions = GetUseExceptions();
24395 31028 : if ( bLocalUseExceptions ) {
24396 336 : pushErrorHandler();
24397 : }
24398 31028 : {
24399 31028 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24400 31028 : result = (OGRGeometryShadow *)CreateGeometryFromWkb(arg1,arg2,arg3);
24401 31028 : SWIG_PYTHON_THREAD_END_ALLOW;
24402 : }
24403 31028 : if ( bLocalUseExceptions ) {
24404 336 : popErrorHandler();
24405 : }
24406 : #ifndef SED_HACKS
24407 : if ( bLocalUseExceptions ) {
24408 : CPLErr eclass = CPLGetLastErrorType();
24409 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24410 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24411 : }
24412 : }
24413 : #endif
24414 : }
24415 31028 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24416 31028 : {
24417 : /* %typemap(freearg) (size_t *nLen, char *pBuf ) */
24418 31028 : if( viewIsValid1 ) {
24419 31021 : PyBuffer_Release(&view1);
24420 : }
24421 7 : else if (ReturnSame(alloc1) == SWIG_NEWOBJ ) {
24422 7 : delete[] arg2;
24423 : }
24424 : }
24425 31029 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24426 : return resultobj;
24427 0 : fail:
24428 0 : {
24429 : /* %typemap(freearg) (size_t *nLen, char *pBuf ) */
24430 0 : if( viewIsValid1 ) {
24431 0 : PyBuffer_Release(&view1);
24432 : }
24433 31028 : else if (ReturnSame(alloc1) == SWIG_NEWOBJ ) {
24434 0 : delete[] arg2;
24435 : }
24436 : }
24437 : return NULL;
24438 : }
24439 :
24440 :
24441 116412 : SWIGINTERN PyObject *_wrap_CreateGeometryFromWkt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24442 116412 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24443 116412 : char **arg1 = (char **) 0 ;
24444 116412 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) NULL ;
24445 116412 : char *val1 ;
24446 116412 : void *argp2 = 0 ;
24447 116412 : int res2 = 0 ;
24448 116412 : PyObject * obj0 = 0 ;
24449 116412 : PyObject * obj1 = 0 ;
24450 116412 : char * kwnames[] = {
24451 : (char *)"val", (char *)"reference", NULL
24452 : };
24453 116412 : OGRGeometryShadow *result = 0 ;
24454 :
24455 116412 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:CreateGeometryFromWkt", kwnames, &obj0, &obj1)) SWIG_fail;
24456 116412 : {
24457 : /* %typemap(in) (char **ignorechange) */
24458 116412 : if( !PyArg_Parse( obj0, "s", &val1 ) ) {
24459 0 : PyErr_SetString( PyExc_TypeError, "not a string" );
24460 0 : SWIG_fail;
24461 : }
24462 116412 : arg1 = &val1;
24463 : }
24464 116412 : if (obj1) {
24465 187 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
24466 187 : if (!SWIG_IsOK(res2)) {
24467 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateGeometryFromWkt" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
24468 : }
24469 187 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
24470 : }
24471 116412 : {
24472 116412 : const int bLocalUseExceptions = GetUseExceptions();
24473 116412 : if ( bLocalUseExceptions ) {
24474 59394 : pushErrorHandler();
24475 : }
24476 116412 : {
24477 116412 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24478 116412 : result = (OGRGeometryShadow *)CreateGeometryFromWkt(arg1,arg2);
24479 116412 : SWIG_PYTHON_THREAD_END_ALLOW;
24480 : }
24481 116412 : if ( bLocalUseExceptions ) {
24482 59394 : popErrorHandler();
24483 : }
24484 : #ifndef SED_HACKS
24485 : if ( bLocalUseExceptions ) {
24486 : CPLErr eclass = CPLGetLastErrorType();
24487 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24488 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24489 : }
24490 : }
24491 : #endif
24492 : }
24493 116412 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24494 116413 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24495 : return resultobj;
24496 : fail:
24497 : return NULL;
24498 : }
24499 :
24500 :
24501 280 : SWIGINTERN PyObject *_wrap_CreateGeometryFromGML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24502 280 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24503 280 : char *arg1 = (char *) 0 ;
24504 280 : int res1 ;
24505 280 : char *buf1 = 0 ;
24506 280 : int alloc1 = 0 ;
24507 280 : PyObject *swig_obj[1] ;
24508 280 : OGRGeometryShadow *result = 0 ;
24509 :
24510 280 : if (!args) SWIG_fail;
24511 280 : swig_obj[0] = args;
24512 280 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
24513 280 : if (!SWIG_IsOK(res1)) {
24514 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateGeometryFromGML" "', argument " "1"" of type '" "char const *""'");
24515 : }
24516 280 : arg1 = reinterpret_cast< char * >(buf1);
24517 280 : {
24518 280 : const int bLocalUseExceptions = GetUseExceptions();
24519 280 : if ( bLocalUseExceptions ) {
24520 134 : pushErrorHandler();
24521 : }
24522 280 : {
24523 280 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24524 280 : result = (OGRGeometryShadow *)CreateGeometryFromGML((char const *)arg1);
24525 280 : SWIG_PYTHON_THREAD_END_ALLOW;
24526 : }
24527 280 : if ( bLocalUseExceptions ) {
24528 134 : popErrorHandler();
24529 : }
24530 : #ifndef SED_HACKS
24531 : if ( bLocalUseExceptions ) {
24532 : CPLErr eclass = CPLGetLastErrorType();
24533 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24534 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24535 : }
24536 : }
24537 : #endif
24538 : }
24539 280 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24540 280 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24541 281 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24542 : return resultobj;
24543 0 : fail:
24544 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24545 : return NULL;
24546 : }
24547 :
24548 :
24549 42 : SWIGINTERN PyObject *_wrap_CreateGeometryFromJson(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24550 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24551 42 : char *arg1 = (char *) 0 ;
24552 42 : int res1 ;
24553 42 : char *buf1 = 0 ;
24554 42 : int alloc1 = 0 ;
24555 42 : PyObject *swig_obj[1] ;
24556 42 : OGRGeometryShadow *result = 0 ;
24557 :
24558 42 : if (!args) SWIG_fail;
24559 42 : swig_obj[0] = args;
24560 42 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
24561 42 : if (!SWIG_IsOK(res1)) {
24562 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateGeometryFromJson" "', argument " "1"" of type '" "char const *""'");
24563 : }
24564 42 : arg1 = reinterpret_cast< char * >(buf1);
24565 42 : {
24566 42 : const int bLocalUseExceptions = GetUseExceptions();
24567 42 : if ( bLocalUseExceptions ) {
24568 42 : pushErrorHandler();
24569 : }
24570 42 : {
24571 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24572 42 : result = (OGRGeometryShadow *)CreateGeometryFromJson((char const *)arg1);
24573 42 : SWIG_PYTHON_THREAD_END_ALLOW;
24574 : }
24575 42 : if ( bLocalUseExceptions ) {
24576 42 : popErrorHandler();
24577 : }
24578 : #ifndef SED_HACKS
24579 : if ( bLocalUseExceptions ) {
24580 : CPLErr eclass = CPLGetLastErrorType();
24581 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24582 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24583 : }
24584 : }
24585 : #endif
24586 : }
24587 42 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24588 42 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24589 42 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24590 : return resultobj;
24591 0 : fail:
24592 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24593 : return NULL;
24594 : }
24595 :
24596 :
24597 2 : SWIGINTERN PyObject *_wrap_CreateGeometryFromEsriJson(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24598 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24599 2 : char *arg1 = (char *) 0 ;
24600 2 : int res1 ;
24601 2 : char *buf1 = 0 ;
24602 2 : int alloc1 = 0 ;
24603 2 : PyObject *swig_obj[1] ;
24604 2 : OGRGeometryShadow *result = 0 ;
24605 :
24606 2 : if (!args) SWIG_fail;
24607 2 : swig_obj[0] = args;
24608 2 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
24609 2 : if (!SWIG_IsOK(res1)) {
24610 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateGeometryFromEsriJson" "', argument " "1"" of type '" "char const *""'");
24611 : }
24612 2 : arg1 = reinterpret_cast< char * >(buf1);
24613 2 : {
24614 2 : const int bLocalUseExceptions = GetUseExceptions();
24615 2 : if ( bLocalUseExceptions ) {
24616 2 : pushErrorHandler();
24617 : }
24618 2 : {
24619 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24620 2 : result = (OGRGeometryShadow *)CreateGeometryFromEsriJson((char const *)arg1);
24621 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24622 : }
24623 2 : if ( bLocalUseExceptions ) {
24624 2 : popErrorHandler();
24625 : }
24626 : #ifndef SED_HACKS
24627 : if ( bLocalUseExceptions ) {
24628 : CPLErr eclass = CPLGetLastErrorType();
24629 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24630 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24631 : }
24632 : }
24633 : #endif
24634 : }
24635 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24636 2 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24637 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24638 : return resultobj;
24639 0 : fail:
24640 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24641 : return NULL;
24642 : }
24643 :
24644 :
24645 5 : SWIGINTERN PyObject *_wrap_BuildPolygonFromEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24646 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24647 5 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
24648 5 : int arg2 = (int) 0 ;
24649 5 : int arg3 = (int) 0 ;
24650 5 : double arg4 = (double) 0 ;
24651 5 : void *argp1 = 0 ;
24652 5 : int res1 = 0 ;
24653 5 : int val2 ;
24654 5 : int ecode2 = 0 ;
24655 5 : int val3 ;
24656 5 : int ecode3 = 0 ;
24657 5 : double val4 ;
24658 5 : int ecode4 = 0 ;
24659 5 : PyObject * obj0 = 0 ;
24660 5 : PyObject * obj1 = 0 ;
24661 5 : PyObject * obj2 = 0 ;
24662 5 : PyObject * obj3 = 0 ;
24663 5 : char * kwnames[] = {
24664 : (char *)"hLineCollection", (char *)"bBestEffort", (char *)"bAutoClose", (char *)"dfTolerance", NULL
24665 : };
24666 5 : OGRGeometryShadow *result = 0 ;
24667 :
24668 5 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:BuildPolygonFromEdges", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
24669 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
24670 5 : if (!SWIG_IsOK(res1)) {
24671 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BuildPolygonFromEdges" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
24672 : }
24673 5 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
24674 5 : if (obj1) {
24675 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24676 0 : if (!SWIG_IsOK(ecode2)) {
24677 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BuildPolygonFromEdges" "', argument " "2"" of type '" "int""'");
24678 : }
24679 : arg2 = static_cast< int >(val2);
24680 : }
24681 5 : if (obj2) {
24682 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
24683 0 : if (!SWIG_IsOK(ecode3)) {
24684 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BuildPolygonFromEdges" "', argument " "3"" of type '" "int""'");
24685 : }
24686 : arg3 = static_cast< int >(val3);
24687 : }
24688 5 : if (obj3) {
24689 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
24690 0 : if (!SWIG_IsOK(ecode4)) {
24691 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BuildPolygonFromEdges" "', argument " "4"" of type '" "double""'");
24692 : }
24693 0 : arg4 = static_cast< double >(val4);
24694 : }
24695 5 : {
24696 5 : const int bLocalUseExceptions = GetUseExceptions();
24697 5 : if ( bLocalUseExceptions ) {
24698 0 : pushErrorHandler();
24699 : }
24700 5 : {
24701 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24702 5 : result = (OGRGeometryShadow *)BuildPolygonFromEdges(arg1,arg2,arg3,arg4);
24703 5 : SWIG_PYTHON_THREAD_END_ALLOW;
24704 : }
24705 5 : if ( bLocalUseExceptions ) {
24706 0 : popErrorHandler();
24707 : }
24708 : #ifndef SED_HACKS
24709 : if ( bLocalUseExceptions ) {
24710 : CPLErr eclass = CPLGetLastErrorType();
24711 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24712 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24713 : }
24714 : }
24715 : #endif
24716 : }
24717 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24718 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24719 : return resultobj;
24720 : fail:
24721 : return NULL;
24722 : }
24723 :
24724 :
24725 1 : SWIGINTERN PyObject *_wrap_ApproximateArcAngles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24726 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24727 1 : double arg1 ;
24728 1 : double arg2 ;
24729 1 : double arg3 ;
24730 1 : double arg4 ;
24731 1 : double arg5 ;
24732 1 : double arg6 ;
24733 1 : double arg7 ;
24734 1 : double arg8 ;
24735 1 : double arg9 ;
24736 1 : double val1 ;
24737 1 : int ecode1 = 0 ;
24738 1 : double val2 ;
24739 1 : int ecode2 = 0 ;
24740 1 : double val3 ;
24741 1 : int ecode3 = 0 ;
24742 1 : double val4 ;
24743 1 : int ecode4 = 0 ;
24744 1 : double val5 ;
24745 1 : int ecode5 = 0 ;
24746 1 : double val6 ;
24747 1 : int ecode6 = 0 ;
24748 1 : double val7 ;
24749 1 : int ecode7 = 0 ;
24750 1 : double val8 ;
24751 1 : int ecode8 = 0 ;
24752 1 : double val9 ;
24753 1 : int ecode9 = 0 ;
24754 1 : PyObject * obj0 = 0 ;
24755 1 : PyObject * obj1 = 0 ;
24756 1 : PyObject * obj2 = 0 ;
24757 1 : PyObject * obj3 = 0 ;
24758 1 : PyObject * obj4 = 0 ;
24759 1 : PyObject * obj5 = 0 ;
24760 1 : PyObject * obj6 = 0 ;
24761 1 : PyObject * obj7 = 0 ;
24762 1 : PyObject * obj8 = 0 ;
24763 1 : char * kwnames[] = {
24764 : (char *)"dfCenterX", (char *)"dfCenterY", (char *)"dfZ", (char *)"dfPrimaryRadius", (char *)"dfSecondaryAxis", (char *)"dfRotation", (char *)"dfStartAngle", (char *)"dfEndAngle", (char *)"dfMaxAngleStepSizeDegrees", NULL
24765 : };
24766 1 : OGRGeometryShadow *result = 0 ;
24767 :
24768 1 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOO:ApproximateArcAngles", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
24769 1 : ecode1 = SWIG_AsVal_double(obj0, &val1);
24770 1 : if (!SWIG_IsOK(ecode1)) {
24771 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ApproximateArcAngles" "', argument " "1"" of type '" "double""'");
24772 : }
24773 1 : arg1 = static_cast< double >(val1);
24774 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
24775 1 : if (!SWIG_IsOK(ecode2)) {
24776 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ApproximateArcAngles" "', argument " "2"" of type '" "double""'");
24777 : }
24778 1 : arg2 = static_cast< double >(val2);
24779 1 : ecode3 = SWIG_AsVal_double(obj2, &val3);
24780 1 : if (!SWIG_IsOK(ecode3)) {
24781 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ApproximateArcAngles" "', argument " "3"" of type '" "double""'");
24782 : }
24783 1 : arg3 = static_cast< double >(val3);
24784 1 : ecode4 = SWIG_AsVal_double(obj3, &val4);
24785 1 : if (!SWIG_IsOK(ecode4)) {
24786 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ApproximateArcAngles" "', argument " "4"" of type '" "double""'");
24787 : }
24788 1 : arg4 = static_cast< double >(val4);
24789 1 : ecode5 = SWIG_AsVal_double(obj4, &val5);
24790 1 : if (!SWIG_IsOK(ecode5)) {
24791 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ApproximateArcAngles" "', argument " "5"" of type '" "double""'");
24792 : }
24793 1 : arg5 = static_cast< double >(val5);
24794 1 : ecode6 = SWIG_AsVal_double(obj5, &val6);
24795 1 : if (!SWIG_IsOK(ecode6)) {
24796 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ApproximateArcAngles" "', argument " "6"" of type '" "double""'");
24797 : }
24798 1 : arg6 = static_cast< double >(val6);
24799 1 : ecode7 = SWIG_AsVal_double(obj6, &val7);
24800 1 : if (!SWIG_IsOK(ecode7)) {
24801 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ApproximateArcAngles" "', argument " "7"" of type '" "double""'");
24802 : }
24803 1 : arg7 = static_cast< double >(val7);
24804 1 : ecode8 = SWIG_AsVal_double(obj7, &val8);
24805 1 : if (!SWIG_IsOK(ecode8)) {
24806 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ApproximateArcAngles" "', argument " "8"" of type '" "double""'");
24807 : }
24808 1 : arg8 = static_cast< double >(val8);
24809 1 : ecode9 = SWIG_AsVal_double(obj8, &val9);
24810 1 : if (!SWIG_IsOK(ecode9)) {
24811 0 : SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ApproximateArcAngles" "', argument " "9"" of type '" "double""'");
24812 : }
24813 1 : arg9 = static_cast< double >(val9);
24814 1 : {
24815 1 : const int bLocalUseExceptions = GetUseExceptions();
24816 1 : if ( bLocalUseExceptions ) {
24817 1 : pushErrorHandler();
24818 : }
24819 1 : {
24820 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24821 1 : result = (OGRGeometryShadow *)ApproximateArcAngles(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
24822 1 : SWIG_PYTHON_THREAD_END_ALLOW;
24823 : }
24824 1 : if ( bLocalUseExceptions ) {
24825 1 : popErrorHandler();
24826 : }
24827 : #ifndef SED_HACKS
24828 : if ( bLocalUseExceptions ) {
24829 : CPLErr eclass = CPLGetLastErrorType();
24830 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24831 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24832 : }
24833 : }
24834 : #endif
24835 : }
24836 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24837 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24838 : return resultobj;
24839 : fail:
24840 : return NULL;
24841 : }
24842 :
24843 :
24844 46 : SWIGINTERN PyObject *_wrap_ForceToPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24845 46 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24846 46 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
24847 46 : void *argp1 = 0 ;
24848 46 : int res1 = 0 ;
24849 46 : PyObject *swig_obj[1] ;
24850 46 : OGRGeometryShadow *result = 0 ;
24851 :
24852 46 : if (!args) SWIG_fail;
24853 46 : swig_obj[0] = args;
24854 46 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
24855 46 : if (!SWIG_IsOK(res1)) {
24856 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForceToPolygon" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
24857 : }
24858 46 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
24859 46 : {
24860 46 : const int bLocalUseExceptions = GetUseExceptions();
24861 46 : if ( bLocalUseExceptions ) {
24862 4 : pushErrorHandler();
24863 : }
24864 46 : {
24865 46 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24866 46 : result = (OGRGeometryShadow *)ForceToPolygon(arg1);
24867 46 : SWIG_PYTHON_THREAD_END_ALLOW;
24868 : }
24869 46 : if ( bLocalUseExceptions ) {
24870 4 : popErrorHandler();
24871 : }
24872 : #ifndef SED_HACKS
24873 : if ( bLocalUseExceptions ) {
24874 : CPLErr eclass = CPLGetLastErrorType();
24875 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24876 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24877 : }
24878 : }
24879 : #endif
24880 : }
24881 46 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24882 46 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24883 : return resultobj;
24884 : fail:
24885 : return NULL;
24886 : }
24887 :
24888 :
24889 60 : SWIGINTERN PyObject *_wrap_ForceToLineString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24890 60 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24891 60 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
24892 60 : void *argp1 = 0 ;
24893 60 : int res1 = 0 ;
24894 60 : PyObject *swig_obj[1] ;
24895 60 : OGRGeometryShadow *result = 0 ;
24896 :
24897 60 : if (!args) SWIG_fail;
24898 60 : swig_obj[0] = args;
24899 60 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
24900 60 : if (!SWIG_IsOK(res1)) {
24901 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForceToLineString" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
24902 : }
24903 60 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
24904 60 : {
24905 60 : const int bLocalUseExceptions = GetUseExceptions();
24906 60 : if ( bLocalUseExceptions ) {
24907 16 : pushErrorHandler();
24908 : }
24909 60 : {
24910 60 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24911 60 : result = (OGRGeometryShadow *)ForceToLineString(arg1);
24912 60 : SWIG_PYTHON_THREAD_END_ALLOW;
24913 : }
24914 60 : if ( bLocalUseExceptions ) {
24915 16 : popErrorHandler();
24916 : }
24917 : #ifndef SED_HACKS
24918 : if ( bLocalUseExceptions ) {
24919 : CPLErr eclass = CPLGetLastErrorType();
24920 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24921 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24922 : }
24923 : }
24924 : #endif
24925 : }
24926 60 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24927 60 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24928 : return resultobj;
24929 : fail:
24930 : return NULL;
24931 : }
24932 :
24933 :
24934 47 : SWIGINTERN PyObject *_wrap_ForceToMultiPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24935 47 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24936 47 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
24937 47 : void *argp1 = 0 ;
24938 47 : int res1 = 0 ;
24939 47 : PyObject *swig_obj[1] ;
24940 47 : OGRGeometryShadow *result = 0 ;
24941 :
24942 47 : if (!args) SWIG_fail;
24943 47 : swig_obj[0] = args;
24944 47 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
24945 47 : if (!SWIG_IsOK(res1)) {
24946 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForceToMultiPolygon" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
24947 : }
24948 47 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
24949 47 : {
24950 47 : const int bLocalUseExceptions = GetUseExceptions();
24951 47 : if ( bLocalUseExceptions ) {
24952 4 : pushErrorHandler();
24953 : }
24954 47 : {
24955 47 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24956 47 : result = (OGRGeometryShadow *)ForceToMultiPolygon(arg1);
24957 47 : SWIG_PYTHON_THREAD_END_ALLOW;
24958 : }
24959 47 : if ( bLocalUseExceptions ) {
24960 4 : popErrorHandler();
24961 : }
24962 : #ifndef SED_HACKS
24963 : if ( bLocalUseExceptions ) {
24964 : CPLErr eclass = CPLGetLastErrorType();
24965 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24966 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24967 : }
24968 : }
24969 : #endif
24970 : }
24971 47 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
24972 47 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
24973 : return resultobj;
24974 : fail:
24975 : return NULL;
24976 : }
24977 :
24978 :
24979 42 : SWIGINTERN PyObject *_wrap_ForceToMultiPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24980 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24981 42 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
24982 42 : void *argp1 = 0 ;
24983 42 : int res1 = 0 ;
24984 42 : PyObject *swig_obj[1] ;
24985 42 : OGRGeometryShadow *result = 0 ;
24986 :
24987 42 : if (!args) SWIG_fail;
24988 42 : swig_obj[0] = args;
24989 42 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
24990 42 : if (!SWIG_IsOK(res1)) {
24991 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForceToMultiPoint" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
24992 : }
24993 42 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
24994 42 : {
24995 42 : const int bLocalUseExceptions = GetUseExceptions();
24996 42 : if ( bLocalUseExceptions ) {
24997 2 : pushErrorHandler();
24998 : }
24999 42 : {
25000 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25001 42 : result = (OGRGeometryShadow *)ForceToMultiPoint(arg1);
25002 42 : SWIG_PYTHON_THREAD_END_ALLOW;
25003 : }
25004 42 : if ( bLocalUseExceptions ) {
25005 2 : popErrorHandler();
25006 : }
25007 : #ifndef SED_HACKS
25008 : if ( bLocalUseExceptions ) {
25009 : CPLErr eclass = CPLGetLastErrorType();
25010 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25011 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25012 : }
25013 : }
25014 : #endif
25015 : }
25016 42 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
25017 42 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
25018 : return resultobj;
25019 : fail:
25020 : return NULL;
25021 : }
25022 :
25023 :
25024 50 : SWIGINTERN PyObject *_wrap_ForceToMultiLineString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25025 50 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25026 50 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25027 50 : void *argp1 = 0 ;
25028 50 : int res1 = 0 ;
25029 50 : PyObject *swig_obj[1] ;
25030 50 : OGRGeometryShadow *result = 0 ;
25031 :
25032 50 : if (!args) SWIG_fail;
25033 50 : swig_obj[0] = args;
25034 50 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25035 50 : if (!SWIG_IsOK(res1)) {
25036 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForceToMultiLineString" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25037 : }
25038 50 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25039 50 : {
25040 50 : const int bLocalUseExceptions = GetUseExceptions();
25041 50 : if ( bLocalUseExceptions ) {
25042 4 : pushErrorHandler();
25043 : }
25044 50 : {
25045 50 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25046 50 : result = (OGRGeometryShadow *)ForceToMultiLineString(arg1);
25047 50 : SWIG_PYTHON_THREAD_END_ALLOW;
25048 : }
25049 50 : if ( bLocalUseExceptions ) {
25050 4 : popErrorHandler();
25051 : }
25052 : #ifndef SED_HACKS
25053 : if ( bLocalUseExceptions ) {
25054 : CPLErr eclass = CPLGetLastErrorType();
25055 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25056 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25057 : }
25058 : }
25059 : #endif
25060 : }
25061 50 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
25062 50 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
25063 : return resultobj;
25064 : fail:
25065 : return NULL;
25066 : }
25067 :
25068 :
25069 831 : SWIGINTERN PyObject *_wrap_ForceTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25070 831 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25071 831 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25072 831 : OGRwkbGeometryType arg2 ;
25073 831 : char **arg3 = (char **) NULL ;
25074 831 : void *argp1 = 0 ;
25075 831 : int res1 = 0 ;
25076 831 : int val2 ;
25077 831 : int ecode2 = 0 ;
25078 831 : PyObject *swig_obj[3] ;
25079 831 : OGRGeometryShadow *result = 0 ;
25080 :
25081 831 : if (!SWIG_Python_UnpackTuple(args, "ForceTo", 2, 3, swig_obj)) SWIG_fail;
25082 831 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25083 831 : if (!SWIG_IsOK(res1)) {
25084 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForceTo" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25085 : }
25086 831 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25087 831 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25088 831 : if (!SWIG_IsOK(ecode2)) {
25089 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ForceTo" "', argument " "2"" of type '" "OGRwkbGeometryType""'");
25090 : }
25091 831 : arg2 = static_cast< OGRwkbGeometryType >(val2);
25092 831 : if (swig_obj[2]) {
25093 0 : {
25094 : /* %typemap(in) char **dict */
25095 0 : arg3 = NULL;
25096 0 : if ( PySequence_Check( swig_obj[2] ) ) {
25097 0 : int bErr = FALSE;
25098 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
25099 0 : if ( bErr )
25100 : {
25101 0 : SWIG_fail;
25102 : }
25103 : }
25104 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
25105 0 : int bErr = FALSE;
25106 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
25107 0 : if ( bErr )
25108 : {
25109 0 : SWIG_fail;
25110 : }
25111 : }
25112 : else {
25113 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
25114 0 : SWIG_fail;
25115 : }
25116 : }
25117 : }
25118 831 : {
25119 831 : const int bLocalUseExceptions = GetUseExceptions();
25120 831 : if ( bLocalUseExceptions ) {
25121 228 : pushErrorHandler();
25122 : }
25123 831 : {
25124 831 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25125 831 : result = (OGRGeometryShadow *)ForceTo(arg1,arg2,arg3);
25126 831 : SWIG_PYTHON_THREAD_END_ALLOW;
25127 : }
25128 831 : if ( bLocalUseExceptions ) {
25129 228 : popErrorHandler();
25130 : }
25131 : #ifndef SED_HACKS
25132 : if ( bLocalUseExceptions ) {
25133 : CPLErr eclass = CPLGetLastErrorType();
25134 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25135 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25136 : }
25137 : }
25138 : #endif
25139 : }
25140 831 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
25141 831 : {
25142 : /* %typemap(freearg) char **dict */
25143 831 : CSLDestroy( arg3 );
25144 : }
25145 831 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
25146 : return resultobj;
25147 0 : fail:
25148 0 : {
25149 : /* %typemap(freearg) char **dict */
25150 0 : CSLDestroy( arg3 );
25151 : }
25152 : return NULL;
25153 : }
25154 :
25155 :
25156 288706 : SWIGINTERN PyObject *_wrap_delete_Geometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25157 288706 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25158 288706 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25159 288706 : void *argp1 = 0 ;
25160 288706 : int res1 = 0 ;
25161 288706 : PyObject *swig_obj[1] ;
25162 :
25163 288706 : if (!args) SWIG_fail;
25164 288706 : swig_obj[0] = args;
25165 288706 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN | 0 );
25166 288706 : if (!SWIG_IsOK(res1)) {
25167 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Geometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25168 : }
25169 288706 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25170 288706 : {
25171 288706 : const int bLocalUseExceptions = GetUseExceptions();
25172 288706 : if ( bLocalUseExceptions ) {
25173 232239 : pushErrorHandler();
25174 : }
25175 288706 : {
25176 288706 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25177 288706 : delete_OGRGeometryShadow(arg1);
25178 288706 : SWIG_PYTHON_THREAD_END_ALLOW;
25179 : }
25180 288706 : if ( bLocalUseExceptions ) {
25181 232239 : popErrorHandler();
25182 : }
25183 : #ifndef SED_HACKS
25184 : if ( bLocalUseExceptions ) {
25185 : CPLErr eclass = CPLGetLastErrorType();
25186 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25187 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25188 : }
25189 : }
25190 : #endif
25191 : }
25192 288706 : resultobj = SWIG_Py_Void();
25193 288706 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
25194 : return resultobj;
25195 : fail:
25196 : return NULL;
25197 : }
25198 :
25199 :
25200 160958 : SWIGINTERN PyObject *_wrap_new_Geometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25201 160958 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25202 160958 : OGRwkbGeometryType arg1 = (OGRwkbGeometryType) wkbUnknown ;
25203 160958 : char *arg2 = (char *) 0 ;
25204 160958 : int arg3 = (int) 0 ;
25205 160958 : char *arg4 = (char *) 0 ;
25206 160958 : char *arg5 = (char *) 0 ;
25207 160958 : int val1 ;
25208 160958 : int ecode1 = 0 ;
25209 160958 : int res2 ;
25210 160958 : char *buf2 = 0 ;
25211 160958 : int alloc2 = 0 ;
25212 160958 : int alloc3 = 0 ;
25213 160958 : bool viewIsValid3 = false ;
25214 160958 : Py_buffer view3 ;
25215 160958 : int res5 ;
25216 160958 : char *buf5 = 0 ;
25217 160958 : int alloc5 = 0 ;
25218 160958 : PyObject * obj0 = 0 ;
25219 160958 : PyObject * obj1 = 0 ;
25220 160958 : PyObject * obj2 = 0 ;
25221 160958 : PyObject * obj3 = 0 ;
25222 160958 : char * kwnames[] = {
25223 : (char *)"type", (char *)"wkt", (char *)"wkb", (char *)"gml", NULL
25224 : };
25225 160958 : OGRGeometryShadow *result = 0 ;
25226 :
25227 160958 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO:new_Geometry", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
25228 160958 : if (obj0) {
25229 160795 : ecode1 = SWIG_AsVal_int(obj0, &val1);
25230 160795 : if (!SWIG_IsOK(ecode1)) {
25231 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Geometry" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
25232 : }
25233 160795 : arg1 = static_cast< OGRwkbGeometryType >(val1);
25234 : }
25235 160958 : if (obj1) {
25236 162 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
25237 162 : if (!SWIG_IsOK(res2)) {
25238 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Geometry" "', argument " "2"" of type '" "char *""'");
25239 : }
25240 162 : arg2 = reinterpret_cast< char * >(buf2);
25241 : }
25242 160958 : if (obj2) {
25243 0 : {
25244 : /* %typemap(in,numinputs=1) (int nLen, char *pBuf ) */
25245 0 : char* ptr = NULL;
25246 0 : if( !GetBufferAsCharPtrIntSize(obj2, &arg3, &ptr, &alloc3, &viewIsValid3, &view3) ) {
25247 0 : SWIG_fail;
25248 : }
25249 0 : arg4 = (char *)ptr;
25250 : }
25251 : }
25252 160958 : if (obj3) {
25253 0 : res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
25254 0 : if (!SWIG_IsOK(res5)) {
25255 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Geometry" "', argument " "5"" of type '" "char *""'");
25256 : }
25257 0 : arg5 = reinterpret_cast< char * >(buf5);
25258 : }
25259 160958 : {
25260 160958 : const int bLocalUseExceptions = GetUseExceptions();
25261 160958 : if ( bLocalUseExceptions ) {
25262 160714 : pushErrorHandler();
25263 : }
25264 160958 : {
25265 160958 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25266 160958 : result = (OGRGeometryShadow *)new_OGRGeometryShadow(arg1,arg2,arg3,arg4,arg5);
25267 160958 : SWIG_PYTHON_THREAD_END_ALLOW;
25268 : }
25269 160958 : if ( bLocalUseExceptions ) {
25270 160714 : popErrorHandler();
25271 : }
25272 : #ifndef SED_HACKS
25273 : if ( bLocalUseExceptions ) {
25274 : CPLErr eclass = CPLGetLastErrorType();
25275 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25276 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25277 : }
25278 : }
25279 : #endif
25280 : }
25281 160958 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_NEW | 0 );
25282 160958 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25283 160958 : {
25284 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
25285 160958 : if( viewIsValid3 ) {
25286 0 : PyBuffer_Release(&view3);
25287 : }
25288 160958 : else if (ReturnSame(alloc3) == SWIG_NEWOBJ ) {
25289 0 : delete[] arg4;
25290 : }
25291 : }
25292 160958 : if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25293 160958 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
25294 : return resultobj;
25295 0 : fail:
25296 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25297 0 : {
25298 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
25299 0 : if( viewIsValid3 ) {
25300 0 : PyBuffer_Release(&view3);
25301 : }
25302 0 : else if (ReturnSame(alloc3) == SWIG_NEWOBJ ) {
25303 0 : delete[] arg4;
25304 : }
25305 : }
25306 0 : if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25307 : return NULL;
25308 : }
25309 :
25310 :
25311 2403 : SWIGINTERN PyObject *_wrap_Geometry_ExportToWkt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25312 2403 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25313 2403 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25314 2403 : char **arg2 = (char **) 0 ;
25315 2403 : void *argp1 = 0 ;
25316 2403 : int res1 = 0 ;
25317 2403 : char *argout2 = 0 ;
25318 2403 : PyObject *swig_obj[1] ;
25319 2403 : OGRErr result;
25320 :
25321 2403 : {
25322 : /* %typemap(in,numinputs=0) (char **argout2) */
25323 2403 : arg2 = &argout2;
25324 : }
25325 2403 : if (!args) SWIG_fail;
25326 2403 : swig_obj[0] = args;
25327 2403 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25328 2403 : if (!SWIG_IsOK(res1)) {
25329 14 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ExportToWkt" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25330 : }
25331 2396 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25332 2396 : {
25333 2396 : const int bLocalUseExceptions = GetUseExceptions();
25334 2396 : if ( bLocalUseExceptions ) {
25335 506 : pushErrorHandler();
25336 : }
25337 2396 : {
25338 2396 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25339 2396 : result = (OGRErr)OGRGeometryShadow_ExportToWkt(arg1,arg2);
25340 2396 : SWIG_PYTHON_THREAD_END_ALLOW;
25341 : }
25342 2396 : if ( bLocalUseExceptions ) {
25343 506 : popErrorHandler();
25344 : }
25345 : #ifndef SED_HACKS
25346 : if ( bLocalUseExceptions ) {
25347 : CPLErr eclass = CPLGetLastErrorType();
25348 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25349 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25350 : }
25351 : }
25352 : #endif
25353 : }
25354 2396 : {
25355 : /* %typemap(out) OGRErr */
25356 2396 : if ( result != 0 && GetUseExceptions()) {
25357 0 : const char* pszMessage = CPLGetLastErrorMsg();
25358 0 : if( pszMessage[0] != '\0' )
25359 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
25360 : else
25361 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
25362 0 : SWIG_fail;
25363 : }
25364 : }
25365 2396 : {
25366 : /* %typemap(argout) (char **argout) */
25367 2396 : PyObject *o;
25368 2396 : if ( ReturnSame(arg2) != NULL && *arg2 != NULL ) {
25369 2396 : o = GDALPythonObjectFromCStr( *arg2 );
25370 : }
25371 : else {
25372 0 : o = Py_None;
25373 0 : Py_INCREF( o );
25374 : }
25375 : #if SWIG_VERSION >= 0x040300
25376 : resultobj = SWIG_Python_AppendOutput(resultobj,o,$isvoid);
25377 : #else
25378 2396 : resultobj = SWIG_Python_AppendOutput(resultobj,o);
25379 : #endif
25380 : }
25381 2396 : {
25382 : /* %typemap(freearg) (char **argout) */
25383 2396 : if ( *arg2 )
25384 2396 : CPLFree( *arg2 );
25385 : }
25386 2396 : {
25387 : /* %typemap(ret) OGRErr */
25388 4792 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
25389 0 : resultobj = PyInt_FromLong( result );
25390 : }
25391 : }
25392 2403 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
25393 : return resultobj;
25394 7 : fail:
25395 7 : {
25396 : /* %typemap(freearg) (char **argout) */
25397 7 : if ( *arg2 )
25398 0 : CPLFree( *arg2 );
25399 : }
25400 : return NULL;
25401 : }
25402 :
25403 :
25404 5407 : SWIGINTERN PyObject *_wrap_Geometry_ExportToIsoWkt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25405 5407 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25406 5407 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25407 5407 : char **arg2 = (char **) 0 ;
25408 5407 : void *argp1 = 0 ;
25409 5407 : int res1 = 0 ;
25410 5407 : char *argout2 = 0 ;
25411 5407 : PyObject *swig_obj[1] ;
25412 5407 : OGRErr result;
25413 :
25414 5407 : {
25415 : /* %typemap(in,numinputs=0) (char **argout2) */
25416 5407 : arg2 = &argout2;
25417 : }
25418 5407 : if (!args) SWIG_fail;
25419 5407 : swig_obj[0] = args;
25420 5407 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25421 5407 : if (!SWIG_IsOK(res1)) {
25422 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ExportToIsoWkt" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25423 : }
25424 5407 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25425 5407 : {
25426 5407 : const int bLocalUseExceptions = GetUseExceptions();
25427 5407 : if ( bLocalUseExceptions ) {
25428 604 : pushErrorHandler();
25429 : }
25430 5407 : {
25431 5407 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25432 5407 : result = (OGRErr)OGRGeometryShadow_ExportToIsoWkt(arg1,arg2);
25433 5407 : SWIG_PYTHON_THREAD_END_ALLOW;
25434 : }
25435 5407 : if ( bLocalUseExceptions ) {
25436 604 : popErrorHandler();
25437 : }
25438 : #ifndef SED_HACKS
25439 : if ( bLocalUseExceptions ) {
25440 : CPLErr eclass = CPLGetLastErrorType();
25441 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25442 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25443 : }
25444 : }
25445 : #endif
25446 : }
25447 5407 : {
25448 : /* %typemap(out) OGRErr */
25449 5407 : if ( result != 0 && GetUseExceptions()) {
25450 0 : const char* pszMessage = CPLGetLastErrorMsg();
25451 0 : if( pszMessage[0] != '\0' )
25452 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
25453 : else
25454 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
25455 0 : SWIG_fail;
25456 : }
25457 : }
25458 5407 : {
25459 : /* %typemap(argout) (char **argout) */
25460 5407 : PyObject *o;
25461 5407 : if ( ReturnSame(arg2) != NULL && *arg2 != NULL ) {
25462 5407 : o = GDALPythonObjectFromCStr( *arg2 );
25463 : }
25464 : else {
25465 0 : o = Py_None;
25466 0 : Py_INCREF( o );
25467 : }
25468 : #if SWIG_VERSION >= 0x040300
25469 : resultobj = SWIG_Python_AppendOutput(resultobj,o,$isvoid);
25470 : #else
25471 5407 : resultobj = SWIG_Python_AppendOutput(resultobj,o);
25472 : #endif
25473 : }
25474 5407 : {
25475 : /* %typemap(freearg) (char **argout) */
25476 5407 : if ( *arg2 )
25477 5407 : CPLFree( *arg2 );
25478 : }
25479 5407 : {
25480 : /* %typemap(ret) OGRErr */
25481 10814 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
25482 0 : resultobj = PyInt_FromLong( result );
25483 : }
25484 : }
25485 5407 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
25486 : return resultobj;
25487 0 : fail:
25488 0 : {
25489 : /* %typemap(freearg) (char **argout) */
25490 0 : if ( *arg2 )
25491 0 : CPLFree( *arg2 );
25492 : }
25493 : return NULL;
25494 : }
25495 :
25496 :
25497 103 : SWIGINTERN PyObject *_wrap_Geometry_ExportToWkb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25498 103 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25499 103 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25500 103 : size_t *arg2 = (size_t *) 0 ;
25501 103 : char **arg3 = (char **) 0 ;
25502 103 : OGRwkbByteOrder arg4 = (OGRwkbByteOrder) wkbNDR ;
25503 103 : void *argp1 = 0 ;
25504 103 : int res1 = 0 ;
25505 103 : size_t nLen2 = 0 ;
25506 103 : char *pBuf2 = 0 ;
25507 103 : int val4 ;
25508 103 : int ecode4 = 0 ;
25509 103 : PyObject * obj0 = 0 ;
25510 103 : PyObject * obj1 = 0 ;
25511 103 : char * kwnames[] = {
25512 : (char *)"self", (char *)"byte_order", NULL
25513 : };
25514 103 : OGRErr result;
25515 :
25516 103 : {
25517 : /* %typemap(in,numinputs=0) (size_t *nLen2, char **pBuf2 ) */
25518 103 : arg2 = &nLen2;
25519 103 : arg3 = &pBuf2;
25520 : }
25521 103 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_ExportToWkb", kwnames, &obj0, &obj1)) SWIG_fail;
25522 103 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25523 103 : if (!SWIG_IsOK(res1)) {
25524 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ExportToWkb" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25525 : }
25526 103 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25527 103 : if (obj1) {
25528 39 : ecode4 = SWIG_AsVal_int(obj1, &val4);
25529 39 : if (!SWIG_IsOK(ecode4)) {
25530 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_ExportToWkb" "', argument " "4"" of type '" "OGRwkbByteOrder""'");
25531 : }
25532 39 : arg4 = static_cast< OGRwkbByteOrder >(val4);
25533 : }
25534 103 : {
25535 103 : const int bLocalUseExceptions = GetUseExceptions();
25536 103 : if ( bLocalUseExceptions ) {
25537 17 : pushErrorHandler();
25538 : }
25539 103 : {
25540 103 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25541 103 : result = (OGRErr)OGRGeometryShadow_ExportToWkb(arg1,arg2,arg3,arg4);
25542 103 : SWIG_PYTHON_THREAD_END_ALLOW;
25543 : }
25544 103 : if ( bLocalUseExceptions ) {
25545 17 : popErrorHandler();
25546 : }
25547 : #ifndef SED_HACKS
25548 : if ( bLocalUseExceptions ) {
25549 : CPLErr eclass = CPLGetLastErrorType();
25550 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25551 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25552 : }
25553 : }
25554 : #endif
25555 : }
25556 103 : {
25557 : /* %typemap(out) OGRErr */
25558 103 : if ( result != 0 && GetUseExceptions()) {
25559 0 : const char* pszMessage = CPLGetLastErrorMsg();
25560 0 : if( pszMessage[0] != '\0' )
25561 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
25562 : else
25563 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
25564 0 : SWIG_fail;
25565 : }
25566 : }
25567 103 : {
25568 : /* %typemap(argout) (size_t *nLen, char **pBuf ) */
25569 103 : Py_XDECREF(resultobj);
25570 103 : if( *arg3 ) {
25571 103 : resultobj = PyByteArray_FromStringAndSize( *arg3, *arg2 );
25572 : }
25573 : else {
25574 0 : resultobj = Py_None;
25575 0 : Py_INCREF(Py_None);
25576 : }
25577 : }
25578 103 : {
25579 : /* %typemap(freearg) (size_t *nLen, char **pBuf ) */
25580 103 : VSIFree( *arg3 );
25581 : }
25582 103 : {
25583 : /* %typemap(ret) OGRErr */
25584 206 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
25585 0 : resultobj = PyInt_FromLong( result );
25586 : }
25587 : }
25588 103 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
25589 : return resultobj;
25590 0 : fail:
25591 0 : {
25592 : /* %typemap(freearg) (size_t *nLen, char **pBuf ) */
25593 0 : VSIFree( *arg3 );
25594 : }
25595 : return NULL;
25596 : }
25597 :
25598 :
25599 10570 : SWIGINTERN PyObject *_wrap_Geometry_ExportToIsoWkb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25600 10570 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25601 10570 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25602 10570 : size_t *arg2 = (size_t *) 0 ;
25603 10570 : char **arg3 = (char **) 0 ;
25604 10570 : OGRwkbByteOrder arg4 = (OGRwkbByteOrder) wkbNDR ;
25605 10570 : void *argp1 = 0 ;
25606 10570 : int res1 = 0 ;
25607 10570 : size_t nLen2 = 0 ;
25608 10570 : char *pBuf2 = 0 ;
25609 10570 : int val4 ;
25610 10570 : int ecode4 = 0 ;
25611 10570 : PyObject * obj0 = 0 ;
25612 10570 : PyObject * obj1 = 0 ;
25613 10570 : char * kwnames[] = {
25614 : (char *)"self", (char *)"byte_order", NULL
25615 : };
25616 10570 : OGRErr result;
25617 :
25618 10570 : {
25619 : /* %typemap(in,numinputs=0) (size_t *nLen2, char **pBuf2 ) */
25620 10570 : arg2 = &nLen2;
25621 10570 : arg3 = &pBuf2;
25622 : }
25623 10570 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_ExportToIsoWkb", kwnames, &obj0, &obj1)) SWIG_fail;
25624 10570 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25625 10570 : if (!SWIG_IsOK(res1)) {
25626 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ExportToIsoWkb" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25627 : }
25628 10570 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25629 10570 : if (obj1) {
25630 0 : ecode4 = SWIG_AsVal_int(obj1, &val4);
25631 0 : if (!SWIG_IsOK(ecode4)) {
25632 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_ExportToIsoWkb" "', argument " "4"" of type '" "OGRwkbByteOrder""'");
25633 : }
25634 0 : arg4 = static_cast< OGRwkbByteOrder >(val4);
25635 : }
25636 10570 : {
25637 10570 : const int bLocalUseExceptions = GetUseExceptions();
25638 10570 : if ( bLocalUseExceptions ) {
25639 1 : pushErrorHandler();
25640 : }
25641 10570 : {
25642 10570 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25643 10570 : result = (OGRErr)OGRGeometryShadow_ExportToIsoWkb(arg1,arg2,arg3,arg4);
25644 10570 : SWIG_PYTHON_THREAD_END_ALLOW;
25645 : }
25646 10570 : if ( bLocalUseExceptions ) {
25647 1 : popErrorHandler();
25648 : }
25649 : #ifndef SED_HACKS
25650 : if ( bLocalUseExceptions ) {
25651 : CPLErr eclass = CPLGetLastErrorType();
25652 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25653 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25654 : }
25655 : }
25656 : #endif
25657 : }
25658 10570 : {
25659 : /* %typemap(out) OGRErr */
25660 10570 : if ( result != 0 && GetUseExceptions()) {
25661 0 : const char* pszMessage = CPLGetLastErrorMsg();
25662 0 : if( pszMessage[0] != '\0' )
25663 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
25664 : else
25665 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
25666 0 : SWIG_fail;
25667 : }
25668 : }
25669 10570 : {
25670 : /* %typemap(argout) (size_t *nLen, char **pBuf ) */
25671 10570 : Py_XDECREF(resultobj);
25672 10570 : if( *arg3 ) {
25673 10570 : resultobj = PyByteArray_FromStringAndSize( *arg3, *arg2 );
25674 : }
25675 : else {
25676 0 : resultobj = Py_None;
25677 0 : Py_INCREF(Py_None);
25678 : }
25679 : }
25680 10570 : {
25681 : /* %typemap(freearg) (size_t *nLen, char **pBuf ) */
25682 10570 : VSIFree( *arg3 );
25683 : }
25684 10570 : {
25685 : /* %typemap(ret) OGRErr */
25686 21140 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
25687 0 : resultobj = PyInt_FromLong( result );
25688 : }
25689 : }
25690 10570 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
25691 : return resultobj;
25692 0 : fail:
25693 0 : {
25694 : /* %typemap(freearg) (size_t *nLen, char **pBuf ) */
25695 0 : VSIFree( *arg3 );
25696 : }
25697 : return NULL;
25698 : }
25699 :
25700 :
25701 66 : SWIGINTERN PyObject *_wrap_Geometry_ExportToGML(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25702 66 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25703 66 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25704 66 : char **arg2 = (char **) 0 ;
25705 66 : void *argp1 = 0 ;
25706 66 : int res1 = 0 ;
25707 66 : PyObject * obj0 = 0 ;
25708 66 : PyObject * obj1 = 0 ;
25709 66 : char * kwnames[] = {
25710 : (char *)"self", (char *)"options", NULL
25711 : };
25712 66 : retStringAndCPLFree *result = 0 ;
25713 :
25714 66 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_ExportToGML", kwnames, &obj0, &obj1)) SWIG_fail;
25715 66 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25716 66 : if (!SWIG_IsOK(res1)) {
25717 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ExportToGML" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25718 : }
25719 66 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25720 66 : if (obj1) {
25721 42 : {
25722 : /* %typemap(in) char **dict */
25723 42 : arg2 = NULL;
25724 42 : if ( PySequence_Check( obj1 ) ) {
25725 42 : int bErr = FALSE;
25726 42 : arg2 = CSLFromPySequence(obj1, &bErr);
25727 42 : if ( bErr )
25728 : {
25729 0 : SWIG_fail;
25730 : }
25731 : }
25732 0 : else if ( PyMapping_Check( obj1 ) ) {
25733 0 : int bErr = FALSE;
25734 0 : arg2 = CSLFromPyMapping(obj1, &bErr);
25735 0 : if ( bErr )
25736 : {
25737 0 : SWIG_fail;
25738 : }
25739 : }
25740 : else {
25741 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
25742 0 : SWIG_fail;
25743 : }
25744 : }
25745 : }
25746 66 : {
25747 66 : const int bLocalUseExceptions = GetUseExceptions();
25748 66 : if ( bLocalUseExceptions ) {
25749 66 : pushErrorHandler();
25750 : }
25751 66 : {
25752 66 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25753 66 : result = (retStringAndCPLFree *)OGRGeometryShadow_ExportToGML(arg1,arg2);
25754 66 : SWIG_PYTHON_THREAD_END_ALLOW;
25755 : }
25756 66 : if ( bLocalUseExceptions ) {
25757 66 : popErrorHandler();
25758 : }
25759 : #ifndef SED_HACKS
25760 : if ( bLocalUseExceptions ) {
25761 : CPLErr eclass = CPLGetLastErrorType();
25762 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25763 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25764 : }
25765 : }
25766 : #endif
25767 : }
25768 66 : {
25769 : /* %typemap(out) (retStringAndCPLFree*) */
25770 66 : Py_XDECREF(resultobj);
25771 66 : if(result)
25772 : {
25773 66 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
25774 66 : CPLFree(result);
25775 : }
25776 : else
25777 : {
25778 0 : resultobj = Py_None;
25779 0 : Py_INCREF(resultobj);
25780 : }
25781 : }
25782 66 : {
25783 : /* %typemap(freearg) char **dict */
25784 66 : CSLDestroy( arg2 );
25785 : }
25786 66 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
25787 : return resultobj;
25788 0 : fail:
25789 0 : {
25790 : /* %typemap(freearg) char **dict */
25791 0 : CSLDestroy( arg2 );
25792 : }
25793 : return NULL;
25794 : }
25795 :
25796 :
25797 0 : SWIGINTERN PyObject *_wrap_Geometry_ExportToKML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25798 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25799 0 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25800 0 : char *arg2 = (char *) NULL ;
25801 0 : void *argp1 = 0 ;
25802 0 : int res1 = 0 ;
25803 0 : int res2 ;
25804 0 : char *buf2 = 0 ;
25805 0 : int alloc2 = 0 ;
25806 0 : PyObject *swig_obj[2] ;
25807 0 : retStringAndCPLFree *result = 0 ;
25808 :
25809 0 : if (!SWIG_Python_UnpackTuple(args, "Geometry_ExportToKML", 1, 2, swig_obj)) SWIG_fail;
25810 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25811 0 : if (!SWIG_IsOK(res1)) {
25812 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ExportToKML" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25813 : }
25814 0 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25815 0 : if (swig_obj[1]) {
25816 0 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
25817 0 : if (!SWIG_IsOK(res2)) {
25818 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_ExportToKML" "', argument " "2"" of type '" "char const *""'");
25819 : }
25820 0 : arg2 = reinterpret_cast< char * >(buf2);
25821 : }
25822 0 : {
25823 0 : const int bLocalUseExceptions = GetUseExceptions();
25824 0 : if ( bLocalUseExceptions ) {
25825 0 : pushErrorHandler();
25826 : }
25827 0 : {
25828 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25829 0 : result = (retStringAndCPLFree *)OGRGeometryShadow_ExportToKML(arg1,(char const *)arg2);
25830 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25831 : }
25832 0 : if ( bLocalUseExceptions ) {
25833 0 : popErrorHandler();
25834 : }
25835 : #ifndef SED_HACKS
25836 : if ( bLocalUseExceptions ) {
25837 : CPLErr eclass = CPLGetLastErrorType();
25838 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25839 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25840 : }
25841 : }
25842 : #endif
25843 : }
25844 0 : {
25845 : /* %typemap(out) (retStringAndCPLFree*) */
25846 0 : Py_XDECREF(resultobj);
25847 0 : if(result)
25848 : {
25849 0 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
25850 0 : CPLFree(result);
25851 : }
25852 : else
25853 : {
25854 0 : resultobj = Py_None;
25855 0 : Py_INCREF(resultobj);
25856 : }
25857 : }
25858 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25859 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
25860 : return resultobj;
25861 0 : fail:
25862 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25863 : return NULL;
25864 : }
25865 :
25866 :
25867 88 : SWIGINTERN PyObject *_wrap_Geometry_ExportToJson(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25868 88 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25869 88 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25870 88 : char **arg2 = (char **) 0 ;
25871 88 : void *argp1 = 0 ;
25872 88 : int res1 = 0 ;
25873 88 : PyObject * obj0 = 0 ;
25874 88 : PyObject * obj1 = 0 ;
25875 88 : char * kwnames[] = {
25876 : (char *)"self", (char *)"options", NULL
25877 : };
25878 88 : retStringAndCPLFree *result = 0 ;
25879 :
25880 88 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_ExportToJson", kwnames, &obj0, &obj1)) SWIG_fail;
25881 88 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25882 88 : if (!SWIG_IsOK(res1)) {
25883 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ExportToJson" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25884 : }
25885 88 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25886 88 : if (obj1) {
25887 34 : {
25888 : /* %typemap(in) char **dict */
25889 34 : arg2 = NULL;
25890 34 : if ( PySequence_Check( obj1 ) ) {
25891 34 : int bErr = FALSE;
25892 34 : arg2 = CSLFromPySequence(obj1, &bErr);
25893 34 : if ( bErr )
25894 : {
25895 0 : SWIG_fail;
25896 : }
25897 : }
25898 0 : else if ( PyMapping_Check( obj1 ) ) {
25899 0 : int bErr = FALSE;
25900 0 : arg2 = CSLFromPyMapping(obj1, &bErr);
25901 0 : if ( bErr )
25902 : {
25903 0 : SWIG_fail;
25904 : }
25905 : }
25906 : else {
25907 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
25908 0 : SWIG_fail;
25909 : }
25910 : }
25911 : }
25912 88 : {
25913 88 : const int bLocalUseExceptions = GetUseExceptions();
25914 88 : if ( bLocalUseExceptions ) {
25915 71 : pushErrorHandler();
25916 : }
25917 88 : {
25918 88 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25919 88 : result = (retStringAndCPLFree *)OGRGeometryShadow_ExportToJson(arg1,arg2);
25920 88 : SWIG_PYTHON_THREAD_END_ALLOW;
25921 : }
25922 88 : if ( bLocalUseExceptions ) {
25923 71 : popErrorHandler();
25924 : }
25925 : #ifndef SED_HACKS
25926 : if ( bLocalUseExceptions ) {
25927 : CPLErr eclass = CPLGetLastErrorType();
25928 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25929 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25930 : }
25931 : }
25932 : #endif
25933 : }
25934 88 : {
25935 : /* %typemap(out) (retStringAndCPLFree*) */
25936 88 : Py_XDECREF(resultobj);
25937 88 : if(result)
25938 : {
25939 85 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
25940 85 : CPLFree(result);
25941 : }
25942 : else
25943 : {
25944 3 : resultobj = Py_None;
25945 3 : Py_INCREF(resultobj);
25946 : }
25947 : }
25948 88 : {
25949 : /* %typemap(freearg) char **dict */
25950 88 : CSLDestroy( arg2 );
25951 : }
25952 88 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
25953 : return resultobj;
25954 0 : fail:
25955 0 : {
25956 : /* %typemap(freearg) char **dict */
25957 0 : CSLDestroy( arg2 );
25958 : }
25959 : return NULL;
25960 : }
25961 :
25962 :
25963 254 : SWIGINTERN PyObject *_wrap_Geometry_AddPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25964 254 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25965 254 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
25966 254 : double arg2 ;
25967 254 : double arg3 ;
25968 254 : double arg4 = (double) 0 ;
25969 254 : void *argp1 = 0 ;
25970 254 : int res1 = 0 ;
25971 254 : double val2 ;
25972 254 : int ecode2 = 0 ;
25973 254 : double val3 ;
25974 254 : int ecode3 = 0 ;
25975 254 : double val4 ;
25976 254 : int ecode4 = 0 ;
25977 254 : PyObject * obj0 = 0 ;
25978 254 : PyObject * obj1 = 0 ;
25979 254 : PyObject * obj2 = 0 ;
25980 254 : PyObject * obj3 = 0 ;
25981 254 : char * kwnames[] = {
25982 : (char *)"self", (char *)"x", (char *)"y", (char *)"z", NULL
25983 : };
25984 :
25985 254 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Geometry_AddPoint", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
25986 254 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
25987 254 : if (!SWIG_IsOK(res1)) {
25988 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_AddPoint" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
25989 : }
25990 254 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
25991 254 : ecode2 = SWIG_AsVal_double(obj1, &val2);
25992 254 : if (!SWIG_IsOK(ecode2)) {
25993 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_AddPoint" "', argument " "2"" of type '" "double""'");
25994 : }
25995 254 : arg2 = static_cast< double >(val2);
25996 254 : ecode3 = SWIG_AsVal_double(obj2, &val3);
25997 254 : if (!SWIG_IsOK(ecode3)) {
25998 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_AddPoint" "', argument " "3"" of type '" "double""'");
25999 : }
26000 254 : arg3 = static_cast< double >(val3);
26001 254 : if (obj3) {
26002 153 : ecode4 = SWIG_AsVal_double(obj3, &val4);
26003 153 : if (!SWIG_IsOK(ecode4)) {
26004 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_AddPoint" "', argument " "4"" of type '" "double""'");
26005 : }
26006 153 : arg4 = static_cast< double >(val4);
26007 : }
26008 254 : {
26009 254 : const int bLocalUseExceptions = GetUseExceptions();
26010 254 : if ( bLocalUseExceptions ) {
26011 228 : pushErrorHandler();
26012 : }
26013 254 : {
26014 254 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26015 254 : OGRGeometryShadow_AddPoint(arg1,arg2,arg3,arg4);
26016 254 : SWIG_PYTHON_THREAD_END_ALLOW;
26017 : }
26018 254 : if ( bLocalUseExceptions ) {
26019 228 : popErrorHandler();
26020 : }
26021 : #ifndef SED_HACKS
26022 : if ( bLocalUseExceptions ) {
26023 : CPLErr eclass = CPLGetLastErrorType();
26024 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26025 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26026 : }
26027 : }
26028 : #endif
26029 : }
26030 254 : resultobj = SWIG_Py_Void();
26031 254 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26032 : return resultobj;
26033 : fail:
26034 : return NULL;
26035 : }
26036 :
26037 :
26038 0 : SWIGINTERN PyObject *_wrap_Geometry_AddPointM(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26039 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26040 0 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26041 0 : double arg2 ;
26042 0 : double arg3 ;
26043 0 : double arg4 ;
26044 0 : void *argp1 = 0 ;
26045 0 : int res1 = 0 ;
26046 0 : double val2 ;
26047 0 : int ecode2 = 0 ;
26048 0 : double val3 ;
26049 0 : int ecode3 = 0 ;
26050 0 : double val4 ;
26051 0 : int ecode4 = 0 ;
26052 0 : PyObject * obj0 = 0 ;
26053 0 : PyObject * obj1 = 0 ;
26054 0 : PyObject * obj2 = 0 ;
26055 0 : PyObject * obj3 = 0 ;
26056 0 : char * kwnames[] = {
26057 : (char *)"self", (char *)"x", (char *)"y", (char *)"m", NULL
26058 : };
26059 :
26060 0 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Geometry_AddPointM", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
26061 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26062 0 : if (!SWIG_IsOK(res1)) {
26063 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_AddPointM" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26064 : }
26065 0 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26066 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
26067 0 : if (!SWIG_IsOK(ecode2)) {
26068 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_AddPointM" "', argument " "2"" of type '" "double""'");
26069 : }
26070 0 : arg2 = static_cast< double >(val2);
26071 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
26072 0 : if (!SWIG_IsOK(ecode3)) {
26073 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_AddPointM" "', argument " "3"" of type '" "double""'");
26074 : }
26075 0 : arg3 = static_cast< double >(val3);
26076 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
26077 0 : if (!SWIG_IsOK(ecode4)) {
26078 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_AddPointM" "', argument " "4"" of type '" "double""'");
26079 : }
26080 0 : arg4 = static_cast< double >(val4);
26081 0 : {
26082 0 : const int bLocalUseExceptions = GetUseExceptions();
26083 0 : if ( bLocalUseExceptions ) {
26084 0 : pushErrorHandler();
26085 : }
26086 0 : {
26087 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26088 0 : OGRGeometryShadow_AddPointM(arg1,arg2,arg3,arg4);
26089 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26090 : }
26091 0 : if ( bLocalUseExceptions ) {
26092 0 : popErrorHandler();
26093 : }
26094 : #ifndef SED_HACKS
26095 : if ( bLocalUseExceptions ) {
26096 : CPLErr eclass = CPLGetLastErrorType();
26097 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26098 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26099 : }
26100 : }
26101 : #endif
26102 : }
26103 0 : resultobj = SWIG_Py_Void();
26104 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26105 : return resultobj;
26106 : fail:
26107 : return NULL;
26108 : }
26109 :
26110 :
26111 0 : SWIGINTERN PyObject *_wrap_Geometry_AddPointZM(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26112 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26113 0 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26114 0 : double arg2 ;
26115 0 : double arg3 ;
26116 0 : double arg4 ;
26117 0 : double arg5 ;
26118 0 : void *argp1 = 0 ;
26119 0 : int res1 = 0 ;
26120 0 : double val2 ;
26121 0 : int ecode2 = 0 ;
26122 0 : double val3 ;
26123 0 : int ecode3 = 0 ;
26124 0 : double val4 ;
26125 0 : int ecode4 = 0 ;
26126 0 : double val5 ;
26127 0 : int ecode5 = 0 ;
26128 0 : PyObject * obj0 = 0 ;
26129 0 : PyObject * obj1 = 0 ;
26130 0 : PyObject * obj2 = 0 ;
26131 0 : PyObject * obj3 = 0 ;
26132 0 : PyObject * obj4 = 0 ;
26133 0 : char * kwnames[] = {
26134 : (char *)"self", (char *)"x", (char *)"y", (char *)"z", (char *)"m", NULL
26135 : };
26136 :
26137 0 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:Geometry_AddPointZM", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
26138 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26139 0 : if (!SWIG_IsOK(res1)) {
26140 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_AddPointZM" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26141 : }
26142 0 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26143 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
26144 0 : if (!SWIG_IsOK(ecode2)) {
26145 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_AddPointZM" "', argument " "2"" of type '" "double""'");
26146 : }
26147 0 : arg2 = static_cast< double >(val2);
26148 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
26149 0 : if (!SWIG_IsOK(ecode3)) {
26150 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_AddPointZM" "', argument " "3"" of type '" "double""'");
26151 : }
26152 0 : arg3 = static_cast< double >(val3);
26153 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
26154 0 : if (!SWIG_IsOK(ecode4)) {
26155 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_AddPointZM" "', argument " "4"" of type '" "double""'");
26156 : }
26157 0 : arg4 = static_cast< double >(val4);
26158 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
26159 0 : if (!SWIG_IsOK(ecode5)) {
26160 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Geometry_AddPointZM" "', argument " "5"" of type '" "double""'");
26161 : }
26162 0 : arg5 = static_cast< double >(val5);
26163 0 : {
26164 0 : const int bLocalUseExceptions = GetUseExceptions();
26165 0 : if ( bLocalUseExceptions ) {
26166 0 : pushErrorHandler();
26167 : }
26168 0 : {
26169 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26170 0 : OGRGeometryShadow_AddPointZM(arg1,arg2,arg3,arg4,arg5);
26171 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26172 : }
26173 0 : if ( bLocalUseExceptions ) {
26174 0 : popErrorHandler();
26175 : }
26176 : #ifndef SED_HACKS
26177 : if ( bLocalUseExceptions ) {
26178 : CPLErr eclass = CPLGetLastErrorType();
26179 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26180 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26181 : }
26182 : }
26183 : #endif
26184 : }
26185 0 : resultobj = SWIG_Py_Void();
26186 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26187 : return resultobj;
26188 : fail:
26189 : return NULL;
26190 : }
26191 :
26192 :
26193 1259 : SWIGINTERN PyObject *_wrap_Geometry_AddPoint_2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26194 1259 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26195 1259 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26196 1259 : double arg2 ;
26197 1259 : double arg3 ;
26198 1259 : void *argp1 = 0 ;
26199 1259 : int res1 = 0 ;
26200 1259 : double val2 ;
26201 1259 : int ecode2 = 0 ;
26202 1259 : double val3 ;
26203 1259 : int ecode3 = 0 ;
26204 1259 : PyObject *swig_obj[3] ;
26205 :
26206 1259 : if (!SWIG_Python_UnpackTuple(args, "Geometry_AddPoint_2D", 3, 3, swig_obj)) SWIG_fail;
26207 1259 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26208 1259 : if (!SWIG_IsOK(res1)) {
26209 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_AddPoint_2D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26210 : }
26211 1259 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26212 1259 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
26213 1259 : if (!SWIG_IsOK(ecode2)) {
26214 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_AddPoint_2D" "', argument " "2"" of type '" "double""'");
26215 : }
26216 1259 : arg2 = static_cast< double >(val2);
26217 1259 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
26218 1259 : if (!SWIG_IsOK(ecode3)) {
26219 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_AddPoint_2D" "', argument " "3"" of type '" "double""'");
26220 : }
26221 1259 : arg3 = static_cast< double >(val3);
26222 1259 : {
26223 1259 : const int bLocalUseExceptions = GetUseExceptions();
26224 1259 : if ( bLocalUseExceptions ) {
26225 26 : pushErrorHandler();
26226 : }
26227 1259 : {
26228 1259 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26229 1259 : OGRGeometryShadow_AddPoint_2D(arg1,arg2,arg3);
26230 1259 : SWIG_PYTHON_THREAD_END_ALLOW;
26231 : }
26232 1259 : if ( bLocalUseExceptions ) {
26233 26 : popErrorHandler();
26234 : }
26235 : #ifndef SED_HACKS
26236 : if ( bLocalUseExceptions ) {
26237 : CPLErr eclass = CPLGetLastErrorType();
26238 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26239 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26240 : }
26241 : }
26242 : #endif
26243 : }
26244 1259 : resultobj = SWIG_Py_Void();
26245 1259 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26246 : return resultobj;
26247 : fail:
26248 : return NULL;
26249 : }
26250 :
26251 :
26252 9 : SWIGINTERN PyObject *_wrap_Geometry_AddGeometryDirectly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26253 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26254 9 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26255 9 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
26256 9 : void *argp1 = 0 ;
26257 9 : int res1 = 0 ;
26258 9 : int res2 = 0 ;
26259 9 : PyObject *swig_obj[2] ;
26260 9 : OGRErr result;
26261 :
26262 9 : if (!SWIG_Python_UnpackTuple(args, "Geometry_AddGeometryDirectly", 2, 2, swig_obj)) SWIG_fail;
26263 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26264 9 : if (!SWIG_IsOK(res1)) {
26265 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_AddGeometryDirectly" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26266 : }
26267 9 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26268 9 : res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN | 0 );
26269 9 : if (!SWIG_IsOK(res2)) {
26270 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_AddGeometryDirectly" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
26271 : }
26272 9 : {
26273 9 : if (!arg2) {
26274 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
26275 : }
26276 : }
26277 9 : {
26278 9 : const int bLocalUseExceptions = GetUseExceptions();
26279 9 : if ( bLocalUseExceptions ) {
26280 1 : pushErrorHandler();
26281 : }
26282 9 : {
26283 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26284 9 : result = (OGRErr)OGRGeometryShadow_AddGeometryDirectly(arg1,arg2);
26285 9 : SWIG_PYTHON_THREAD_END_ALLOW;
26286 : }
26287 9 : if ( bLocalUseExceptions ) {
26288 1 : popErrorHandler();
26289 : }
26290 : #ifndef SED_HACKS
26291 : if ( bLocalUseExceptions ) {
26292 : CPLErr eclass = CPLGetLastErrorType();
26293 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26294 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26295 : }
26296 : }
26297 : #endif
26298 : }
26299 9 : {
26300 : /* %typemap(out) OGRErr */
26301 12 : if ( result != 0 && GetUseExceptions()) {
26302 0 : const char* pszMessage = CPLGetLastErrorMsg();
26303 0 : if( pszMessage[0] != '\0' )
26304 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
26305 : else
26306 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
26307 0 : SWIG_fail;
26308 : }
26309 : }
26310 9 : {
26311 : /* %typemap(ret) OGRErr */
26312 9 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
26313 9 : resultobj = PyInt_FromLong( result );
26314 : }
26315 : }
26316 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26317 : return resultobj;
26318 : fail:
26319 : return NULL;
26320 : }
26321 :
26322 :
26323 106 : SWIGINTERN PyObject *_wrap_Geometry_AddGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26324 106 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26325 106 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26326 106 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
26327 106 : void *argp1 = 0 ;
26328 106 : int res1 = 0 ;
26329 106 : void *argp2 = 0 ;
26330 106 : int res2 = 0 ;
26331 106 : PyObject *swig_obj[2] ;
26332 106 : OGRErr result;
26333 :
26334 106 : if (!SWIG_Python_UnpackTuple(args, "Geometry_AddGeometry", 2, 2, swig_obj)) SWIG_fail;
26335 106 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26336 106 : if (!SWIG_IsOK(res1)) {
26337 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_AddGeometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26338 : }
26339 106 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26340 106 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26341 106 : if (!SWIG_IsOK(res2)) {
26342 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_AddGeometry" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
26343 : }
26344 106 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
26345 106 : {
26346 106 : if (!arg2) {
26347 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
26348 : }
26349 : }
26350 106 : {
26351 106 : const int bLocalUseExceptions = GetUseExceptions();
26352 106 : if ( bLocalUseExceptions ) {
26353 37 : pushErrorHandler();
26354 : }
26355 106 : {
26356 106 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26357 106 : result = (OGRErr)OGRGeometryShadow_AddGeometry(arg1,arg2);
26358 106 : SWIG_PYTHON_THREAD_END_ALLOW;
26359 : }
26360 106 : if ( bLocalUseExceptions ) {
26361 37 : popErrorHandler();
26362 : }
26363 : #ifndef SED_HACKS
26364 : if ( bLocalUseExceptions ) {
26365 : CPLErr eclass = CPLGetLastErrorType();
26366 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26367 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26368 : }
26369 : }
26370 : #endif
26371 : }
26372 106 : {
26373 : /* %typemap(out) OGRErr */
26374 110 : if ( result != 0 && GetUseExceptions()) {
26375 0 : const char* pszMessage = CPLGetLastErrorMsg();
26376 0 : if( pszMessage[0] != '\0' )
26377 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
26378 : else
26379 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
26380 0 : SWIG_fail;
26381 : }
26382 : }
26383 106 : {
26384 : /* %typemap(ret) OGRErr */
26385 106 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
26386 106 : resultobj = PyInt_FromLong( result );
26387 : }
26388 : }
26389 106 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26390 : return resultobj;
26391 : fail:
26392 : return NULL;
26393 : }
26394 :
26395 :
26396 87 : SWIGINTERN PyObject *_wrap_Geometry_RemoveGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26397 87 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26398 87 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26399 87 : int arg2 ;
26400 87 : void *argp1 = 0 ;
26401 87 : int res1 = 0 ;
26402 87 : int val2 ;
26403 87 : int ecode2 = 0 ;
26404 87 : PyObject *swig_obj[2] ;
26405 87 : OGRErr result;
26406 :
26407 87 : if (!SWIG_Python_UnpackTuple(args, "Geometry_RemoveGeometry", 2, 2, swig_obj)) SWIG_fail;
26408 87 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26409 87 : if (!SWIG_IsOK(res1)) {
26410 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_RemoveGeometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26411 : }
26412 87 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26413 87 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
26414 87 : if (!SWIG_IsOK(ecode2)) {
26415 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_RemoveGeometry" "', argument " "2"" of type '" "int""'");
26416 : }
26417 87 : arg2 = static_cast< int >(val2);
26418 87 : {
26419 87 : const int bLocalUseExceptions = GetUseExceptions();
26420 87 : if ( bLocalUseExceptions ) {
26421 70 : pushErrorHandler();
26422 : }
26423 87 : {
26424 87 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26425 87 : result = (OGRErr)OGRGeometryShadow_RemoveGeometry(arg1,arg2);
26426 87 : SWIG_PYTHON_THREAD_END_ALLOW;
26427 : }
26428 87 : if ( bLocalUseExceptions ) {
26429 70 : popErrorHandler();
26430 : }
26431 : #ifndef SED_HACKS
26432 : if ( bLocalUseExceptions ) {
26433 : CPLErr eclass = CPLGetLastErrorType();
26434 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26435 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26436 : }
26437 : }
26438 : #endif
26439 : }
26440 87 : {
26441 : /* %typemap(out) OGRErr */
26442 94 : if ( result != 0 && GetUseExceptions()) {
26443 0 : const char* pszMessage = CPLGetLastErrorMsg();
26444 0 : if( pszMessage[0] != '\0' )
26445 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
26446 : else
26447 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
26448 0 : SWIG_fail;
26449 : }
26450 : }
26451 87 : {
26452 : /* %typemap(ret) OGRErr */
26453 87 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
26454 87 : resultobj = PyInt_FromLong( result );
26455 : }
26456 : }
26457 87 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26458 : return resultobj;
26459 : fail:
26460 : return NULL;
26461 : }
26462 :
26463 :
26464 12445 : SWIGINTERN PyObject *_wrap_Geometry_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26465 12445 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26466 12445 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26467 12445 : void *argp1 = 0 ;
26468 12445 : int res1 = 0 ;
26469 12445 : PyObject *swig_obj[1] ;
26470 12445 : OGRGeometryShadow *result = 0 ;
26471 :
26472 12445 : if (!args) SWIG_fail;
26473 12445 : swig_obj[0] = args;
26474 12445 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26475 12445 : if (!SWIG_IsOK(res1)) {
26476 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Clone" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26477 : }
26478 12445 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26479 12445 : {
26480 12445 : const int bLocalUseExceptions = GetUseExceptions();
26481 12445 : if ( bLocalUseExceptions ) {
26482 12374 : pushErrorHandler();
26483 : }
26484 12445 : {
26485 12445 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26486 12445 : result = (OGRGeometryShadow *)OGRGeometryShadow_Clone(arg1);
26487 12445 : SWIG_PYTHON_THREAD_END_ALLOW;
26488 : }
26489 12445 : if ( bLocalUseExceptions ) {
26490 12374 : popErrorHandler();
26491 : }
26492 : #ifndef SED_HACKS
26493 : if ( bLocalUseExceptions ) {
26494 : CPLErr eclass = CPLGetLastErrorType();
26495 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26496 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26497 : }
26498 : }
26499 : #endif
26500 : }
26501 12445 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
26502 12445 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26503 : return resultobj;
26504 : fail:
26505 : return NULL;
26506 : }
26507 :
26508 :
26509 3884 : SWIGINTERN PyObject *_wrap_Geometry_GetGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26510 3884 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26511 3884 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26512 3884 : void *argp1 = 0 ;
26513 3884 : int res1 = 0 ;
26514 3884 : PyObject *swig_obj[1] ;
26515 3884 : OGRwkbGeometryType result;
26516 :
26517 3884 : if (!args) SWIG_fail;
26518 3884 : swig_obj[0] = args;
26519 3884 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26520 3884 : if (!SWIG_IsOK(res1)) {
26521 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetGeometryType" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26522 : }
26523 3884 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26524 3884 : {
26525 3884 : const int bLocalUseExceptions = GetUseExceptions();
26526 3884 : if ( bLocalUseExceptions ) {
26527 1398 : pushErrorHandler();
26528 : }
26529 3884 : {
26530 3884 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26531 3884 : result = (OGRwkbGeometryType)OGRGeometryShadow_GetGeometryType(arg1);
26532 3884 : SWIG_PYTHON_THREAD_END_ALLOW;
26533 : }
26534 3884 : if ( bLocalUseExceptions ) {
26535 1398 : popErrorHandler();
26536 : }
26537 : #ifndef SED_HACKS
26538 : if ( bLocalUseExceptions ) {
26539 : CPLErr eclass = CPLGetLastErrorType();
26540 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26541 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26542 : }
26543 : }
26544 : #endif
26545 : }
26546 3884 : resultobj = SWIG_From_int(static_cast< int >(result));
26547 3884 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26548 : return resultobj;
26549 : fail:
26550 : return NULL;
26551 : }
26552 :
26553 :
26554 16069 : SWIGINTERN PyObject *_wrap_Geometry_GetGeometryName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26555 16069 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26556 16069 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26557 16069 : void *argp1 = 0 ;
26558 16069 : int res1 = 0 ;
26559 16069 : PyObject *swig_obj[1] ;
26560 16069 : char *result = 0 ;
26561 :
26562 16069 : if (!args) SWIG_fail;
26563 16069 : swig_obj[0] = args;
26564 16069 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26565 16069 : if (!SWIG_IsOK(res1)) {
26566 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetGeometryName" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26567 : }
26568 16069 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26569 16069 : {
26570 16069 : const int bLocalUseExceptions = GetUseExceptions();
26571 16069 : if ( bLocalUseExceptions ) {
26572 3 : pushErrorHandler();
26573 : }
26574 16069 : {
26575 16069 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26576 16069 : result = (char *)OGRGeometryShadow_GetGeometryName(arg1);
26577 16069 : SWIG_PYTHON_THREAD_END_ALLOW;
26578 : }
26579 16069 : if ( bLocalUseExceptions ) {
26580 3 : popErrorHandler();
26581 : }
26582 : #ifndef SED_HACKS
26583 : if ( bLocalUseExceptions ) {
26584 : CPLErr eclass = CPLGetLastErrorType();
26585 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26586 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26587 : }
26588 : }
26589 : #endif
26590 : }
26591 16069 : resultobj = SWIG_FromCharPtr((const char *)result);
26592 16069 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26593 : return resultobj;
26594 : fail:
26595 : return NULL;
26596 : }
26597 :
26598 :
26599 28 : SWIGINTERN PyObject *_wrap_Geometry_Length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26600 28 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26601 28 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26602 28 : void *argp1 = 0 ;
26603 28 : int res1 = 0 ;
26604 28 : PyObject *swig_obj[1] ;
26605 28 : double result;
26606 :
26607 28 : if (!args) SWIG_fail;
26608 28 : swig_obj[0] = args;
26609 28 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26610 28 : if (!SWIG_IsOK(res1)) {
26611 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Length" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26612 : }
26613 28 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26614 28 : {
26615 28 : const int bLocalUseExceptions = GetUseExceptions();
26616 28 : if ( bLocalUseExceptions ) {
26617 7 : pushErrorHandler();
26618 : }
26619 28 : {
26620 28 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26621 28 : result = (double)OGRGeometryShadow_Length(arg1);
26622 28 : SWIG_PYTHON_THREAD_END_ALLOW;
26623 : }
26624 28 : if ( bLocalUseExceptions ) {
26625 7 : popErrorHandler();
26626 : }
26627 : #ifndef SED_HACKS
26628 : if ( bLocalUseExceptions ) {
26629 : CPLErr eclass = CPLGetLastErrorType();
26630 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26631 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26632 : }
26633 : }
26634 : #endif
26635 : }
26636 28 : resultobj = SWIG_From_double(static_cast< double >(result));
26637 28 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26638 : return resultobj;
26639 : fail:
26640 : return NULL;
26641 : }
26642 :
26643 :
26644 21 : SWIGINTERN PyObject *_wrap_Geometry_Area(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26645 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26646 21 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26647 21 : void *argp1 = 0 ;
26648 21 : int res1 = 0 ;
26649 21 : PyObject *swig_obj[1] ;
26650 21 : double result;
26651 :
26652 21 : if (!args) SWIG_fail;
26653 21 : swig_obj[0] = args;
26654 21 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26655 21 : if (!SWIG_IsOK(res1)) {
26656 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Area" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26657 : }
26658 21 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26659 21 : {
26660 21 : const int bLocalUseExceptions = GetUseExceptions();
26661 21 : if ( bLocalUseExceptions ) {
26662 3 : pushErrorHandler();
26663 : }
26664 21 : {
26665 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26666 21 : result = (double)OGRGeometryShadow_Area(arg1);
26667 21 : SWIG_PYTHON_THREAD_END_ALLOW;
26668 : }
26669 21 : if ( bLocalUseExceptions ) {
26670 3 : popErrorHandler();
26671 : }
26672 : #ifndef SED_HACKS
26673 : if ( bLocalUseExceptions ) {
26674 : CPLErr eclass = CPLGetLastErrorType();
26675 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26676 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26677 : }
26678 : }
26679 : #endif
26680 : }
26681 21 : resultobj = SWIG_From_double(static_cast< double >(result));
26682 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26683 : return resultobj;
26684 : fail:
26685 : return NULL;
26686 : }
26687 :
26688 :
26689 22 : SWIGINTERN PyObject *_wrap_Geometry_GeodesicLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26690 22 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26691 22 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26692 22 : void *argp1 = 0 ;
26693 22 : int res1 = 0 ;
26694 22 : PyObject *swig_obj[1] ;
26695 22 : double result;
26696 :
26697 22 : if (!args) SWIG_fail;
26698 22 : swig_obj[0] = args;
26699 22 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26700 22 : if (!SWIG_IsOK(res1)) {
26701 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GeodesicLength" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26702 : }
26703 22 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26704 22 : {
26705 22 : const int bLocalUseExceptions = GetUseExceptions();
26706 22 : if ( bLocalUseExceptions ) {
26707 22 : pushErrorHandler();
26708 : }
26709 22 : {
26710 22 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26711 22 : result = (double)OGRGeometryShadow_GeodesicLength(arg1);
26712 22 : SWIG_PYTHON_THREAD_END_ALLOW;
26713 : }
26714 22 : if ( bLocalUseExceptions ) {
26715 22 : popErrorHandler();
26716 : }
26717 : #ifndef SED_HACKS
26718 : if ( bLocalUseExceptions ) {
26719 : CPLErr eclass = CPLGetLastErrorType();
26720 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26721 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26722 : }
26723 : }
26724 : #endif
26725 : }
26726 22 : resultobj = SWIG_From_double(static_cast< double >(result));
26727 27 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26728 : return resultobj;
26729 : fail:
26730 : return NULL;
26731 : }
26732 :
26733 :
26734 24 : SWIGINTERN PyObject *_wrap_Geometry_GeodesicArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26735 24 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26736 24 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26737 24 : void *argp1 = 0 ;
26738 24 : int res1 = 0 ;
26739 24 : PyObject *swig_obj[1] ;
26740 24 : double result;
26741 :
26742 24 : if (!args) SWIG_fail;
26743 24 : swig_obj[0] = args;
26744 24 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26745 24 : if (!SWIG_IsOK(res1)) {
26746 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GeodesicArea" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26747 : }
26748 24 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26749 24 : {
26750 24 : const int bLocalUseExceptions = GetUseExceptions();
26751 24 : if ( bLocalUseExceptions ) {
26752 24 : pushErrorHandler();
26753 : }
26754 24 : {
26755 24 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26756 24 : result = (double)OGRGeometryShadow_GeodesicArea(arg1);
26757 24 : SWIG_PYTHON_THREAD_END_ALLOW;
26758 : }
26759 24 : if ( bLocalUseExceptions ) {
26760 24 : popErrorHandler();
26761 : }
26762 : #ifndef SED_HACKS
26763 : if ( bLocalUseExceptions ) {
26764 : CPLErr eclass = CPLGetLastErrorType();
26765 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26766 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26767 : }
26768 : }
26769 : #endif
26770 : }
26771 24 : resultobj = SWIG_From_double(static_cast< double >(result));
26772 32 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26773 : return resultobj;
26774 : fail:
26775 : return NULL;
26776 : }
26777 :
26778 :
26779 33 : SWIGINTERN PyObject *_wrap_Geometry_IsClockwise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26780 33 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26781 33 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26782 33 : void *argp1 = 0 ;
26783 33 : int res1 = 0 ;
26784 33 : PyObject *swig_obj[1] ;
26785 33 : bool result;
26786 :
26787 33 : if (!args) SWIG_fail;
26788 33 : swig_obj[0] = args;
26789 33 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26790 33 : if (!SWIG_IsOK(res1)) {
26791 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_IsClockwise" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26792 : }
26793 33 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26794 33 : {
26795 33 : const int bLocalUseExceptions = GetUseExceptions();
26796 33 : if ( bLocalUseExceptions ) {
26797 33 : pushErrorHandler();
26798 : }
26799 33 : {
26800 33 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26801 33 : result = (bool)OGRGeometryShadow_IsClockwise(arg1);
26802 33 : SWIG_PYTHON_THREAD_END_ALLOW;
26803 : }
26804 33 : if ( bLocalUseExceptions ) {
26805 33 : popErrorHandler();
26806 : }
26807 : #ifndef SED_HACKS
26808 : if ( bLocalUseExceptions ) {
26809 : CPLErr eclass = CPLGetLastErrorType();
26810 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26811 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26812 : }
26813 : }
26814 : #endif
26815 : }
26816 33 : resultobj = SWIG_From_bool(static_cast< bool >(result));
26817 34 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26818 : return resultobj;
26819 : fail:
26820 : return NULL;
26821 : }
26822 :
26823 :
26824 1386 : SWIGINTERN PyObject *_wrap_Geometry_GetArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26825 1386 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26826 1386 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26827 1386 : void *argp1 = 0 ;
26828 1386 : int res1 = 0 ;
26829 1386 : PyObject *swig_obj[1] ;
26830 1386 : double result;
26831 :
26832 1386 : if (!args) SWIG_fail;
26833 1386 : swig_obj[0] = args;
26834 1386 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26835 1386 : if (!SWIG_IsOK(res1)) {
26836 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetArea" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26837 : }
26838 1386 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26839 1386 : {
26840 1386 : const int bLocalUseExceptions = GetUseExceptions();
26841 1386 : if ( bLocalUseExceptions ) {
26842 1380 : pushErrorHandler();
26843 : }
26844 1386 : {
26845 1386 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26846 1386 : result = (double)OGRGeometryShadow_GetArea(arg1);
26847 1386 : SWIG_PYTHON_THREAD_END_ALLOW;
26848 : }
26849 1386 : if ( bLocalUseExceptions ) {
26850 1380 : popErrorHandler();
26851 : }
26852 : #ifndef SED_HACKS
26853 : if ( bLocalUseExceptions ) {
26854 : CPLErr eclass = CPLGetLastErrorType();
26855 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26856 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26857 : }
26858 : }
26859 : #endif
26860 : }
26861 1386 : resultobj = SWIG_From_double(static_cast< double >(result));
26862 1386 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26863 : return resultobj;
26864 : fail:
26865 : return NULL;
26866 : }
26867 :
26868 :
26869 12833 : SWIGINTERN PyObject *_wrap_Geometry_GetPointCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26870 12833 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26871 12833 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26872 12833 : void *argp1 = 0 ;
26873 12833 : int res1 = 0 ;
26874 12833 : PyObject *swig_obj[1] ;
26875 12833 : int result;
26876 :
26877 12833 : if (!args) SWIG_fail;
26878 12833 : swig_obj[0] = args;
26879 12833 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26880 12833 : if (!SWIG_IsOK(res1)) {
26881 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetPointCount" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26882 : }
26883 12833 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26884 12833 : {
26885 12833 : const int bLocalUseExceptions = GetUseExceptions();
26886 12833 : if ( bLocalUseExceptions ) {
26887 16 : pushErrorHandler();
26888 : }
26889 12833 : {
26890 12833 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26891 12833 : result = (int)OGRGeometryShadow_GetPointCount(arg1);
26892 12833 : SWIG_PYTHON_THREAD_END_ALLOW;
26893 : }
26894 12833 : if ( bLocalUseExceptions ) {
26895 16 : popErrorHandler();
26896 : }
26897 : #ifndef SED_HACKS
26898 : if ( bLocalUseExceptions ) {
26899 : CPLErr eclass = CPLGetLastErrorType();
26900 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26901 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26902 : }
26903 : }
26904 : #endif
26905 : }
26906 12833 : resultobj = SWIG_From_int(static_cast< int >(result));
26907 12833 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
26908 : return resultobj;
26909 : fail:
26910 : return NULL;
26911 : }
26912 :
26913 :
26914 11 : SWIGINTERN PyObject *_wrap_Geometry_GetPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26915 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26916 11 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
26917 11 : int *arg2 = (int *) 0 ;
26918 11 : double **arg3 = (double **) 0 ;
26919 11 : double **arg4 = (double **) 0 ;
26920 11 : int arg5 = (int) 0 ;
26921 11 : void *argp1 = 0 ;
26922 11 : int res1 = 0 ;
26923 11 : int nPoints2 = 0 ;
26924 11 : double *padfXY2 = NULL ;
26925 11 : double *padfZ2 = NULL ;
26926 11 : int val5 ;
26927 11 : int ecode5 = 0 ;
26928 11 : PyObject * obj0 = 0 ;
26929 11 : PyObject * obj1 = 0 ;
26930 11 : char * kwnames[] = {
26931 : (char *)"self", (char *)"nCoordDimension", NULL
26932 : };
26933 :
26934 11 : {
26935 : /* %typemap(in,numinputs=0) (int* pnCount, double** ppadfXY, double** ppadfZ) */
26936 11 : arg2 = &nPoints2;
26937 11 : arg3 = &padfXY2;
26938 11 : arg4 = &padfZ2;
26939 : }
26940 11 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_GetPoints", kwnames, &obj0, &obj1)) SWIG_fail;
26941 11 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26942 11 : if (!SWIG_IsOK(res1)) {
26943 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetPoints" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
26944 : }
26945 11 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
26946 11 : if (obj1) {
26947 4 : ecode5 = SWIG_AsVal_int(obj1, &val5);
26948 4 : if (!SWIG_IsOK(ecode5)) {
26949 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Geometry_GetPoints" "', argument " "5"" of type '" "int""'");
26950 : }
26951 : arg5 = static_cast< int >(val5);
26952 : }
26953 11 : {
26954 11 : const int bLocalUseExceptions = GetUseExceptions();
26955 11 : if ( bLocalUseExceptions ) {
26956 2 : pushErrorHandler();
26957 : }
26958 11 : {
26959 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26960 11 : OGRGeometryShadow_GetPoints(arg1,arg2,arg3,arg4,arg5);
26961 11 : SWIG_PYTHON_THREAD_END_ALLOW;
26962 : }
26963 11 : if ( bLocalUseExceptions ) {
26964 2 : popErrorHandler();
26965 : }
26966 : #ifndef SED_HACKS
26967 : if ( bLocalUseExceptions ) {
26968 : CPLErr eclass = CPLGetLastErrorType();
26969 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26970 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26971 : }
26972 : }
26973 : #endif
26974 : }
26975 11 : resultobj = SWIG_Py_Void();
26976 11 : {
26977 : /* %typemap(argout) (int* pnCount, double** ppadfXY, double** ppadfZ) */
26978 11 : Py_DECREF(resultobj);
26979 11 : int nPointCount = *(arg2);
26980 11 : if (nPointCount == 0)
26981 : {
26982 1 : Py_INCREF(Py_None);
26983 1 : resultobj = Py_None;
26984 : }
26985 : else
26986 : {
26987 10 : PyObject *xyz = PyList_New( nPointCount );
26988 10 : if( !xyz ) {
26989 0 : SWIG_fail;
26990 : }
26991 10 : int nDimensions = (*arg4 != NULL) ? 3 : 2;
26992 184 : for( int i=0; i< nPointCount; i++ ) {
26993 174 : PyObject *tuple = PyTuple_New( nDimensions );
26994 174 : PyTuple_SetItem( tuple, 0, PyFloat_FromDouble( (*arg3)[2*i] ) );
26995 174 : PyTuple_SetItem( tuple, 1, PyFloat_FromDouble( (*arg3)[2*i+1] ) );
26996 174 : if (nDimensions == 3)
26997 6 : PyTuple_SetItem( tuple, 2, PyFloat_FromDouble( (*arg4)[i] ) );
26998 174 : PyList_SetItem( xyz, i, tuple );
26999 : }
27000 : resultobj = xyz;
27001 : }
27002 : }
27003 11 : {
27004 : /* %typemap(freearg) (int* pnCount, double** ppadfXY, double** ppadfZ) */
27005 11 : VSIFree(*arg3);
27006 11 : VSIFree(*arg4);
27007 : }
27008 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27009 : return resultobj;
27010 0 : fail:
27011 0 : {
27012 : /* %typemap(freearg) (int* pnCount, double** ppadfXY, double** ppadfZ) */
27013 0 : VSIFree(*arg3);
27014 0 : VSIFree(*arg4);
27015 : }
27016 : return NULL;
27017 : }
27018 :
27019 :
27020 32096 : SWIGINTERN PyObject *_wrap_Geometry_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27021 32096 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27022 32096 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27023 32096 : int arg2 = (int) 0 ;
27024 32096 : void *argp1 = 0 ;
27025 32096 : int res1 = 0 ;
27026 32096 : int val2 ;
27027 32096 : int ecode2 = 0 ;
27028 32096 : PyObject * obj0 = 0 ;
27029 32096 : PyObject * obj1 = 0 ;
27030 32096 : char * kwnames[] = {
27031 : (char *)"self", (char *)"point", NULL
27032 : };
27033 32096 : double result;
27034 :
27035 32096 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_GetX", kwnames, &obj0, &obj1)) SWIG_fail;
27036 32096 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27037 32096 : if (!SWIG_IsOK(res1)) {
27038 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetX" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27039 : }
27040 32096 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27041 32096 : if (obj1) {
27042 30882 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27043 30882 : if (!SWIG_IsOK(ecode2)) {
27044 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetX" "', argument " "2"" of type '" "int""'");
27045 : }
27046 : arg2 = static_cast< int >(val2);
27047 : }
27048 32096 : {
27049 32096 : const int bLocalUseExceptions = GetUseExceptions();
27050 32096 : if ( bLocalUseExceptions ) {
27051 1410 : pushErrorHandler();
27052 : }
27053 32096 : {
27054 32096 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27055 32096 : result = (double)OGRGeometryShadow_GetX(arg1,arg2);
27056 32096 : SWIG_PYTHON_THREAD_END_ALLOW;
27057 : }
27058 32096 : if ( bLocalUseExceptions ) {
27059 1410 : popErrorHandler();
27060 : }
27061 : #ifndef SED_HACKS
27062 : if ( bLocalUseExceptions ) {
27063 : CPLErr eclass = CPLGetLastErrorType();
27064 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27065 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27066 : }
27067 : }
27068 : #endif
27069 : }
27070 32096 : resultobj = SWIG_From_double(static_cast< double >(result));
27071 32096 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27072 : return resultobj;
27073 : fail:
27074 : return NULL;
27075 : }
27076 :
27077 :
27078 30886 : SWIGINTERN PyObject *_wrap_Geometry_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27079 30886 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27080 30886 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27081 30886 : int arg2 = (int) 0 ;
27082 30886 : void *argp1 = 0 ;
27083 30886 : int res1 = 0 ;
27084 30886 : int val2 ;
27085 30886 : int ecode2 = 0 ;
27086 30886 : PyObject * obj0 = 0 ;
27087 30886 : PyObject * obj1 = 0 ;
27088 30886 : char * kwnames[] = {
27089 : (char *)"self", (char *)"point", NULL
27090 : };
27091 30886 : double result;
27092 :
27093 30886 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_GetY", kwnames, &obj0, &obj1)) SWIG_fail;
27094 30886 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27095 30886 : if (!SWIG_IsOK(res1)) {
27096 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetY" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27097 : }
27098 30886 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27099 30886 : if (obj1) {
27100 30873 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27101 30873 : if (!SWIG_IsOK(ecode2)) {
27102 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetY" "', argument " "2"" of type '" "int""'");
27103 : }
27104 : arg2 = static_cast< int >(val2);
27105 : }
27106 30886 : {
27107 30886 : const int bLocalUseExceptions = GetUseExceptions();
27108 30886 : if ( bLocalUseExceptions ) {
27109 202 : pushErrorHandler();
27110 : }
27111 30886 : {
27112 30886 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27113 30886 : result = (double)OGRGeometryShadow_GetY(arg1,arg2);
27114 30886 : SWIG_PYTHON_THREAD_END_ALLOW;
27115 : }
27116 30886 : if ( bLocalUseExceptions ) {
27117 202 : popErrorHandler();
27118 : }
27119 : #ifndef SED_HACKS
27120 : if ( bLocalUseExceptions ) {
27121 : CPLErr eclass = CPLGetLastErrorType();
27122 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27123 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27124 : }
27125 : }
27126 : #endif
27127 : }
27128 30886 : resultobj = SWIG_From_double(static_cast< double >(result));
27129 30886 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27130 : return resultobj;
27131 : fail:
27132 : return NULL;
27133 : }
27134 :
27135 :
27136 15324 : SWIGINTERN PyObject *_wrap_Geometry_GetZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27137 15324 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27138 15324 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27139 15324 : int arg2 = (int) 0 ;
27140 15324 : void *argp1 = 0 ;
27141 15324 : int res1 = 0 ;
27142 15324 : int val2 ;
27143 15324 : int ecode2 = 0 ;
27144 15324 : PyObject * obj0 = 0 ;
27145 15324 : PyObject * obj1 = 0 ;
27146 15324 : char * kwnames[] = {
27147 : (char *)"self", (char *)"point", NULL
27148 : };
27149 15324 : double result;
27150 :
27151 15324 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_GetZ", kwnames, &obj0, &obj1)) SWIG_fail;
27152 15324 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27153 15324 : if (!SWIG_IsOK(res1)) {
27154 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetZ" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27155 : }
27156 15324 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27157 15324 : if (obj1) {
27158 15313 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27159 15313 : if (!SWIG_IsOK(ecode2)) {
27160 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetZ" "', argument " "2"" of type '" "int""'");
27161 : }
27162 : arg2 = static_cast< int >(val2);
27163 : }
27164 15324 : {
27165 15324 : const int bLocalUseExceptions = GetUseExceptions();
27166 15324 : if ( bLocalUseExceptions ) {
27167 188 : pushErrorHandler();
27168 : }
27169 15324 : {
27170 15324 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27171 15324 : result = (double)OGRGeometryShadow_GetZ(arg1,arg2);
27172 15324 : SWIG_PYTHON_THREAD_END_ALLOW;
27173 : }
27174 15324 : if ( bLocalUseExceptions ) {
27175 188 : popErrorHandler();
27176 : }
27177 : #ifndef SED_HACKS
27178 : if ( bLocalUseExceptions ) {
27179 : CPLErr eclass = CPLGetLastErrorType();
27180 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27181 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27182 : }
27183 : }
27184 : #endif
27185 : }
27186 15324 : resultobj = SWIG_From_double(static_cast< double >(result));
27187 15324 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27188 : return resultobj;
27189 : fail:
27190 : return NULL;
27191 : }
27192 :
27193 :
27194 2266 : SWIGINTERN PyObject *_wrap_Geometry_GetM(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27195 2266 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27196 2266 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27197 2266 : int arg2 = (int) 0 ;
27198 2266 : void *argp1 = 0 ;
27199 2266 : int res1 = 0 ;
27200 2266 : int val2 ;
27201 2266 : int ecode2 = 0 ;
27202 2266 : PyObject * obj0 = 0 ;
27203 2266 : PyObject * obj1 = 0 ;
27204 2266 : char * kwnames[] = {
27205 : (char *)"self", (char *)"point", NULL
27206 : };
27207 2266 : double result;
27208 :
27209 2266 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_GetM", kwnames, &obj0, &obj1)) SWIG_fail;
27210 2266 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27211 2266 : if (!SWIG_IsOK(res1)) {
27212 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetM" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27213 : }
27214 2266 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27215 2266 : if (obj1) {
27216 2266 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27217 2266 : if (!SWIG_IsOK(ecode2)) {
27218 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetM" "', argument " "2"" of type '" "int""'");
27219 : }
27220 : arg2 = static_cast< int >(val2);
27221 : }
27222 2266 : {
27223 2266 : const int bLocalUseExceptions = GetUseExceptions();
27224 2266 : if ( bLocalUseExceptions ) {
27225 17 : pushErrorHandler();
27226 : }
27227 2266 : {
27228 2266 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27229 2266 : result = (double)OGRGeometryShadow_GetM(arg1,arg2);
27230 2266 : SWIG_PYTHON_THREAD_END_ALLOW;
27231 : }
27232 2266 : if ( bLocalUseExceptions ) {
27233 17 : popErrorHandler();
27234 : }
27235 : #ifndef SED_HACKS
27236 : if ( bLocalUseExceptions ) {
27237 : CPLErr eclass = CPLGetLastErrorType();
27238 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27239 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27240 : }
27241 : }
27242 : #endif
27243 : }
27244 2266 : resultobj = SWIG_From_double(static_cast< double >(result));
27245 2266 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27246 : return resultobj;
27247 : fail:
27248 : return NULL;
27249 : }
27250 :
27251 :
27252 217 : SWIGINTERN PyObject *_wrap_Geometry_GetPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27253 217 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27254 217 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27255 217 : int arg2 = (int) 0 ;
27256 217 : double *arg3 = (double *) (double *)NULL ;
27257 217 : void *argp1 = 0 ;
27258 217 : int res1 = 0 ;
27259 217 : int val2 ;
27260 217 : int ecode2 = 0 ;
27261 217 : double argout3[3] ;
27262 217 : PyObject *swig_obj[2] ;
27263 :
27264 217 : {
27265 : /* %typemap(in,numinputs=0) (double argout3[ANY]) */
27266 217 : memset(argout3, 0, sizeof(argout3));
27267 217 : arg3 = argout3;
27268 : }
27269 217 : if (!SWIG_Python_UnpackTuple(args, "Geometry_GetPoint", 1, 2, swig_obj)) SWIG_fail;
27270 217 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27271 217 : if (!SWIG_IsOK(res1)) {
27272 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetPoint" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27273 : }
27274 217 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27275 217 : if (swig_obj[1]) {
27276 202 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
27277 202 : if (!SWIG_IsOK(ecode2)) {
27278 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetPoint" "', argument " "2"" of type '" "int""'");
27279 : }
27280 : arg2 = static_cast< int >(val2);
27281 : }
27282 217 : {
27283 217 : const int bLocalUseExceptions = GetUseExceptions();
27284 217 : if ( bLocalUseExceptions ) {
27285 30 : pushErrorHandler();
27286 : }
27287 217 : {
27288 217 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27289 217 : OGRGeometryShadow_GetPoint(arg1,arg2,arg3);
27290 217 : SWIG_PYTHON_THREAD_END_ALLOW;
27291 : }
27292 217 : if ( bLocalUseExceptions ) {
27293 30 : popErrorHandler();
27294 : }
27295 : #ifndef SED_HACKS
27296 : if ( bLocalUseExceptions ) {
27297 : CPLErr eclass = CPLGetLastErrorType();
27298 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27299 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27300 : }
27301 : }
27302 : #endif
27303 : }
27304 217 : resultobj = SWIG_Py_Void();
27305 217 : {
27306 : /* %typemap(argout) (double argout[ANY]) */
27307 217 : PyObject *out = CreateTupleFromDoubleArray( arg3, 3 );
27308 : #if SWIG_VERSION >= 0x040300
27309 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
27310 : #else
27311 217 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
27312 : #endif
27313 : }
27314 219 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27315 : return resultobj;
27316 : fail:
27317 : return NULL;
27318 : }
27319 :
27320 :
27321 1 : SWIGINTERN PyObject *_wrap_Geometry_GetPointZM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27322 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27323 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27324 1 : int arg2 = (int) 0 ;
27325 1 : double *arg3 = (double *) (double *)NULL ;
27326 1 : void *argp1 = 0 ;
27327 1 : int res1 = 0 ;
27328 1 : int val2 ;
27329 1 : int ecode2 = 0 ;
27330 1 : double argout3[4] ;
27331 1 : PyObject *swig_obj[2] ;
27332 :
27333 1 : {
27334 : /* %typemap(in,numinputs=0) (double argout3[ANY]) */
27335 1 : memset(argout3, 0, sizeof(argout3));
27336 1 : arg3 = argout3;
27337 : }
27338 1 : if (!SWIG_Python_UnpackTuple(args, "Geometry_GetPointZM", 1, 2, swig_obj)) SWIG_fail;
27339 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27340 1 : if (!SWIG_IsOK(res1)) {
27341 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetPointZM" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27342 : }
27343 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27344 1 : if (swig_obj[1]) {
27345 1 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
27346 1 : if (!SWIG_IsOK(ecode2)) {
27347 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetPointZM" "', argument " "2"" of type '" "int""'");
27348 : }
27349 : arg2 = static_cast< int >(val2);
27350 : }
27351 1 : {
27352 1 : const int bLocalUseExceptions = GetUseExceptions();
27353 1 : if ( bLocalUseExceptions ) {
27354 0 : pushErrorHandler();
27355 : }
27356 1 : {
27357 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27358 1 : OGRGeometryShadow_GetPointZM(arg1,arg2,arg3);
27359 1 : SWIG_PYTHON_THREAD_END_ALLOW;
27360 : }
27361 1 : if ( bLocalUseExceptions ) {
27362 0 : popErrorHandler();
27363 : }
27364 : #ifndef SED_HACKS
27365 : if ( bLocalUseExceptions ) {
27366 : CPLErr eclass = CPLGetLastErrorType();
27367 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27368 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27369 : }
27370 : }
27371 : #endif
27372 : }
27373 1 : resultobj = SWIG_Py_Void();
27374 1 : {
27375 : /* %typemap(argout) (double argout[ANY]) */
27376 1 : PyObject *out = CreateTupleFromDoubleArray( arg3, 4 );
27377 : #if SWIG_VERSION >= 0x040300
27378 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
27379 : #else
27380 1 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
27381 : #endif
27382 : }
27383 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27384 : return resultobj;
27385 : fail:
27386 : return NULL;
27387 : }
27388 :
27389 :
27390 3 : SWIGINTERN PyObject *_wrap_Geometry_GetPoint_2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27391 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27392 3 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27393 3 : int arg2 = (int) 0 ;
27394 3 : double *arg3 = (double *) (double *)NULL ;
27395 3 : void *argp1 = 0 ;
27396 3 : int res1 = 0 ;
27397 3 : int val2 ;
27398 3 : int ecode2 = 0 ;
27399 3 : double argout3[2] ;
27400 3 : PyObject *swig_obj[2] ;
27401 :
27402 3 : {
27403 : /* %typemap(in,numinputs=0) (double argout3[ANY]) */
27404 3 : memset(argout3, 0, sizeof(argout3));
27405 3 : arg3 = argout3;
27406 : }
27407 3 : if (!SWIG_Python_UnpackTuple(args, "Geometry_GetPoint_2D", 1, 2, swig_obj)) SWIG_fail;
27408 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27409 3 : if (!SWIG_IsOK(res1)) {
27410 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetPoint_2D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27411 : }
27412 3 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27413 3 : if (swig_obj[1]) {
27414 3 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
27415 3 : if (!SWIG_IsOK(ecode2)) {
27416 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetPoint_2D" "', argument " "2"" of type '" "int""'");
27417 : }
27418 : arg2 = static_cast< int >(val2);
27419 : }
27420 3 : {
27421 3 : const int bLocalUseExceptions = GetUseExceptions();
27422 3 : if ( bLocalUseExceptions ) {
27423 2 : pushErrorHandler();
27424 : }
27425 3 : {
27426 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27427 3 : OGRGeometryShadow_GetPoint_2D(arg1,arg2,arg3);
27428 3 : SWIG_PYTHON_THREAD_END_ALLOW;
27429 : }
27430 3 : if ( bLocalUseExceptions ) {
27431 2 : popErrorHandler();
27432 : }
27433 : #ifndef SED_HACKS
27434 : if ( bLocalUseExceptions ) {
27435 : CPLErr eclass = CPLGetLastErrorType();
27436 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27437 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27438 : }
27439 : }
27440 : #endif
27441 : }
27442 3 : resultobj = SWIG_Py_Void();
27443 3 : {
27444 : /* %typemap(argout) (double argout[ANY]) */
27445 3 : PyObject *out = CreateTupleFromDoubleArray( arg3, 2 );
27446 : #if SWIG_VERSION >= 0x040300
27447 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
27448 : #else
27449 3 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
27450 : #endif
27451 : }
27452 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27453 : return resultobj;
27454 : fail:
27455 : return NULL;
27456 : }
27457 :
27458 :
27459 12119 : SWIGINTERN PyObject *_wrap_Geometry_GetGeometryCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27460 12119 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27461 12119 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27462 12119 : void *argp1 = 0 ;
27463 12119 : int res1 = 0 ;
27464 12119 : PyObject *swig_obj[1] ;
27465 12119 : int result;
27466 :
27467 12119 : if (!args) SWIG_fail;
27468 12119 : swig_obj[0] = args;
27469 12119 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27470 12119 : if (!SWIG_IsOK(res1)) {
27471 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetGeometryCount" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27472 : }
27473 12119 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27474 12119 : {
27475 12119 : const int bLocalUseExceptions = GetUseExceptions();
27476 12119 : if ( bLocalUseExceptions ) {
27477 438 : pushErrorHandler();
27478 : }
27479 12119 : {
27480 12119 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27481 12119 : result = (int)OGRGeometryShadow_GetGeometryCount(arg1);
27482 12119 : SWIG_PYTHON_THREAD_END_ALLOW;
27483 : }
27484 12119 : if ( bLocalUseExceptions ) {
27485 438 : popErrorHandler();
27486 : }
27487 : #ifndef SED_HACKS
27488 : if ( bLocalUseExceptions ) {
27489 : CPLErr eclass = CPLGetLastErrorType();
27490 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27491 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27492 : }
27493 : }
27494 : #endif
27495 : }
27496 12119 : resultobj = SWIG_From_int(static_cast< int >(result));
27497 12119 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27498 : return resultobj;
27499 : fail:
27500 : return NULL;
27501 : }
27502 :
27503 :
27504 168 : SWIGINTERN PyObject *_wrap_Geometry_SetPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27505 168 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27506 168 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27507 168 : int arg2 ;
27508 168 : double arg3 ;
27509 168 : double arg4 ;
27510 168 : double arg5 = (double) 0 ;
27511 168 : void *argp1 = 0 ;
27512 168 : int res1 = 0 ;
27513 168 : int val2 ;
27514 168 : int ecode2 = 0 ;
27515 168 : double val3 ;
27516 168 : int ecode3 = 0 ;
27517 168 : double val4 ;
27518 168 : int ecode4 = 0 ;
27519 168 : double val5 ;
27520 168 : int ecode5 = 0 ;
27521 168 : PyObject * obj0 = 0 ;
27522 168 : PyObject * obj1 = 0 ;
27523 168 : PyObject * obj2 = 0 ;
27524 168 : PyObject * obj3 = 0 ;
27525 168 : PyObject * obj4 = 0 ;
27526 168 : char * kwnames[] = {
27527 : (char *)"self", (char *)"point", (char *)"x", (char *)"y", (char *)"z", NULL
27528 : };
27529 :
27530 168 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:Geometry_SetPoint", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
27531 168 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27532 168 : if (!SWIG_IsOK(res1)) {
27533 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SetPoint" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27534 : }
27535 168 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27536 168 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27537 168 : if (!SWIG_IsOK(ecode2)) {
27538 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SetPoint" "', argument " "2"" of type '" "int""'");
27539 : }
27540 168 : arg2 = static_cast< int >(val2);
27541 168 : ecode3 = SWIG_AsVal_double(obj2, &val3);
27542 168 : if (!SWIG_IsOK(ecode3)) {
27543 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_SetPoint" "', argument " "3"" of type '" "double""'");
27544 : }
27545 168 : arg3 = static_cast< double >(val3);
27546 168 : ecode4 = SWIG_AsVal_double(obj3, &val4);
27547 168 : if (!SWIG_IsOK(ecode4)) {
27548 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_SetPoint" "', argument " "4"" of type '" "double""'");
27549 : }
27550 168 : arg4 = static_cast< double >(val4);
27551 168 : if (obj4) {
27552 162 : ecode5 = SWIG_AsVal_double(obj4, &val5);
27553 162 : if (!SWIG_IsOK(ecode5)) {
27554 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Geometry_SetPoint" "', argument " "5"" of type '" "double""'");
27555 : }
27556 162 : arg5 = static_cast< double >(val5);
27557 : }
27558 168 : {
27559 168 : const int bLocalUseExceptions = GetUseExceptions();
27560 168 : if ( bLocalUseExceptions ) {
27561 159 : pushErrorHandler();
27562 : }
27563 168 : {
27564 168 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27565 168 : OGRGeometryShadow_SetPoint(arg1,arg2,arg3,arg4,arg5);
27566 168 : SWIG_PYTHON_THREAD_END_ALLOW;
27567 : }
27568 168 : if ( bLocalUseExceptions ) {
27569 159 : popErrorHandler();
27570 : }
27571 : #ifndef SED_HACKS
27572 : if ( bLocalUseExceptions ) {
27573 : CPLErr eclass = CPLGetLastErrorType();
27574 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27575 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27576 : }
27577 : }
27578 : #endif
27579 : }
27580 168 : resultobj = SWIG_Py_Void();
27581 168 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27582 : return resultobj;
27583 : fail:
27584 : return NULL;
27585 : }
27586 :
27587 :
27588 0 : SWIGINTERN PyObject *_wrap_Geometry_SetPointM(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27589 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27590 0 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27591 0 : int arg2 ;
27592 0 : double arg3 ;
27593 0 : double arg4 ;
27594 0 : double arg5 ;
27595 0 : void *argp1 = 0 ;
27596 0 : int res1 = 0 ;
27597 0 : int val2 ;
27598 0 : int ecode2 = 0 ;
27599 0 : double val3 ;
27600 0 : int ecode3 = 0 ;
27601 0 : double val4 ;
27602 0 : int ecode4 = 0 ;
27603 0 : double val5 ;
27604 0 : int ecode5 = 0 ;
27605 0 : PyObject * obj0 = 0 ;
27606 0 : PyObject * obj1 = 0 ;
27607 0 : PyObject * obj2 = 0 ;
27608 0 : PyObject * obj3 = 0 ;
27609 0 : PyObject * obj4 = 0 ;
27610 0 : char * kwnames[] = {
27611 : (char *)"self", (char *)"point", (char *)"x", (char *)"y", (char *)"m", NULL
27612 : };
27613 :
27614 0 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:Geometry_SetPointM", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
27615 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27616 0 : if (!SWIG_IsOK(res1)) {
27617 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SetPointM" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27618 : }
27619 0 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27620 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27621 0 : if (!SWIG_IsOK(ecode2)) {
27622 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SetPointM" "', argument " "2"" of type '" "int""'");
27623 : }
27624 0 : arg2 = static_cast< int >(val2);
27625 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
27626 0 : if (!SWIG_IsOK(ecode3)) {
27627 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_SetPointM" "', argument " "3"" of type '" "double""'");
27628 : }
27629 0 : arg3 = static_cast< double >(val3);
27630 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
27631 0 : if (!SWIG_IsOK(ecode4)) {
27632 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_SetPointM" "', argument " "4"" of type '" "double""'");
27633 : }
27634 0 : arg4 = static_cast< double >(val4);
27635 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
27636 0 : if (!SWIG_IsOK(ecode5)) {
27637 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Geometry_SetPointM" "', argument " "5"" of type '" "double""'");
27638 : }
27639 0 : arg5 = static_cast< double >(val5);
27640 0 : {
27641 0 : const int bLocalUseExceptions = GetUseExceptions();
27642 0 : if ( bLocalUseExceptions ) {
27643 0 : pushErrorHandler();
27644 : }
27645 0 : {
27646 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27647 0 : OGRGeometryShadow_SetPointM(arg1,arg2,arg3,arg4,arg5);
27648 0 : SWIG_PYTHON_THREAD_END_ALLOW;
27649 : }
27650 0 : if ( bLocalUseExceptions ) {
27651 0 : popErrorHandler();
27652 : }
27653 : #ifndef SED_HACKS
27654 : if ( bLocalUseExceptions ) {
27655 : CPLErr eclass = CPLGetLastErrorType();
27656 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27657 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27658 : }
27659 : }
27660 : #endif
27661 : }
27662 0 : resultobj = SWIG_Py_Void();
27663 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27664 : return resultobj;
27665 : fail:
27666 : return NULL;
27667 : }
27668 :
27669 :
27670 0 : SWIGINTERN PyObject *_wrap_Geometry_SetPointZM(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27671 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27672 0 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27673 0 : int arg2 ;
27674 0 : double arg3 ;
27675 0 : double arg4 ;
27676 0 : double arg5 ;
27677 0 : double arg6 ;
27678 0 : void *argp1 = 0 ;
27679 0 : int res1 = 0 ;
27680 0 : int val2 ;
27681 0 : int ecode2 = 0 ;
27682 0 : double val3 ;
27683 0 : int ecode3 = 0 ;
27684 0 : double val4 ;
27685 0 : int ecode4 = 0 ;
27686 0 : double val5 ;
27687 0 : int ecode5 = 0 ;
27688 0 : double val6 ;
27689 0 : int ecode6 = 0 ;
27690 0 : PyObject * obj0 = 0 ;
27691 0 : PyObject * obj1 = 0 ;
27692 0 : PyObject * obj2 = 0 ;
27693 0 : PyObject * obj3 = 0 ;
27694 0 : PyObject * obj4 = 0 ;
27695 0 : PyObject * obj5 = 0 ;
27696 0 : char * kwnames[] = {
27697 : (char *)"self", (char *)"point", (char *)"x", (char *)"y", (char *)"z", (char *)"m", NULL
27698 : };
27699 :
27700 0 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:Geometry_SetPointZM", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
27701 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27702 0 : if (!SWIG_IsOK(res1)) {
27703 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SetPointZM" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27704 : }
27705 0 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27706 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27707 0 : if (!SWIG_IsOK(ecode2)) {
27708 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SetPointZM" "', argument " "2"" of type '" "int""'");
27709 : }
27710 0 : arg2 = static_cast< int >(val2);
27711 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
27712 0 : if (!SWIG_IsOK(ecode3)) {
27713 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_SetPointZM" "', argument " "3"" of type '" "double""'");
27714 : }
27715 0 : arg3 = static_cast< double >(val3);
27716 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
27717 0 : if (!SWIG_IsOK(ecode4)) {
27718 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_SetPointZM" "', argument " "4"" of type '" "double""'");
27719 : }
27720 0 : arg4 = static_cast< double >(val4);
27721 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
27722 0 : if (!SWIG_IsOK(ecode5)) {
27723 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Geometry_SetPointZM" "', argument " "5"" of type '" "double""'");
27724 : }
27725 0 : arg5 = static_cast< double >(val5);
27726 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
27727 0 : if (!SWIG_IsOK(ecode6)) {
27728 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Geometry_SetPointZM" "', argument " "6"" of type '" "double""'");
27729 : }
27730 0 : arg6 = static_cast< double >(val6);
27731 0 : {
27732 0 : const int bLocalUseExceptions = GetUseExceptions();
27733 0 : if ( bLocalUseExceptions ) {
27734 0 : pushErrorHandler();
27735 : }
27736 0 : {
27737 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27738 0 : OGRGeometryShadow_SetPointZM(arg1,arg2,arg3,arg4,arg5,arg6);
27739 0 : SWIG_PYTHON_THREAD_END_ALLOW;
27740 : }
27741 0 : if ( bLocalUseExceptions ) {
27742 0 : popErrorHandler();
27743 : }
27744 : #ifndef SED_HACKS
27745 : if ( bLocalUseExceptions ) {
27746 : CPLErr eclass = CPLGetLastErrorType();
27747 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27748 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27749 : }
27750 : }
27751 : #endif
27752 : }
27753 0 : resultobj = SWIG_Py_Void();
27754 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27755 : return resultobj;
27756 : fail:
27757 : return NULL;
27758 : }
27759 :
27760 :
27761 160062 : SWIGINTERN PyObject *_wrap_Geometry_SetPoint_2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27762 160062 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27763 160062 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27764 160062 : int arg2 ;
27765 160062 : double arg3 ;
27766 160062 : double arg4 ;
27767 160062 : void *argp1 = 0 ;
27768 160062 : int res1 = 0 ;
27769 160062 : int val2 ;
27770 160062 : int ecode2 = 0 ;
27771 160062 : double val3 ;
27772 160062 : int ecode3 = 0 ;
27773 160062 : double val4 ;
27774 160062 : int ecode4 = 0 ;
27775 160062 : PyObject * obj0 = 0 ;
27776 160062 : PyObject * obj1 = 0 ;
27777 160062 : PyObject * obj2 = 0 ;
27778 160062 : PyObject * obj3 = 0 ;
27779 160062 : char * kwnames[] = {
27780 : (char *)"self", (char *)"point", (char *)"x", (char *)"y", NULL
27781 : };
27782 :
27783 160062 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Geometry_SetPoint_2D", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
27784 160062 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27785 160062 : if (!SWIG_IsOK(res1)) {
27786 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SetPoint_2D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27787 : }
27788 160062 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27789 160062 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27790 160062 : if (!SWIG_IsOK(ecode2)) {
27791 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SetPoint_2D" "', argument " "2"" of type '" "int""'");
27792 : }
27793 160062 : arg2 = static_cast< int >(val2);
27794 160062 : ecode3 = SWIG_AsVal_double(obj2, &val3);
27795 160062 : if (!SWIG_IsOK(ecode3)) {
27796 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_SetPoint_2D" "', argument " "3"" of type '" "double""'");
27797 : }
27798 160062 : arg3 = static_cast< double >(val3);
27799 160062 : ecode4 = SWIG_AsVal_double(obj3, &val4);
27800 160062 : if (!SWIG_IsOK(ecode4)) {
27801 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Geometry_SetPoint_2D" "', argument " "4"" of type '" "double""'");
27802 : }
27803 160062 : arg4 = static_cast< double >(val4);
27804 160062 : {
27805 160062 : const int bLocalUseExceptions = GetUseExceptions();
27806 160062 : if ( bLocalUseExceptions ) {
27807 160003 : pushErrorHandler();
27808 : }
27809 160062 : {
27810 160062 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27811 160062 : OGRGeometryShadow_SetPoint_2D(arg1,arg2,arg3,arg4);
27812 160062 : SWIG_PYTHON_THREAD_END_ALLOW;
27813 : }
27814 160062 : if ( bLocalUseExceptions ) {
27815 160003 : popErrorHandler();
27816 : }
27817 : #ifndef SED_HACKS
27818 : if ( bLocalUseExceptions ) {
27819 : CPLErr eclass = CPLGetLastErrorType();
27820 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27821 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27822 : }
27823 : }
27824 : #endif
27825 : }
27826 160062 : resultobj = SWIG_Py_Void();
27827 160062 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27828 : return resultobj;
27829 : fail:
27830 : return NULL;
27831 : }
27832 :
27833 :
27834 2 : SWIGINTERN PyObject *_wrap_Geometry_SwapXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27835 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27836 2 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27837 2 : void *argp1 = 0 ;
27838 2 : int res1 = 0 ;
27839 2 : PyObject *swig_obj[1] ;
27840 :
27841 2 : if (!args) SWIG_fail;
27842 2 : swig_obj[0] = args;
27843 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27844 2 : if (!SWIG_IsOK(res1)) {
27845 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SwapXY" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27846 : }
27847 2 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27848 2 : {
27849 2 : const int bLocalUseExceptions = GetUseExceptions();
27850 2 : if ( bLocalUseExceptions ) {
27851 1 : pushErrorHandler();
27852 : }
27853 2 : {
27854 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27855 2 : OGRGeometryShadow_SwapXY(arg1);
27856 2 : SWIG_PYTHON_THREAD_END_ALLOW;
27857 : }
27858 2 : if ( bLocalUseExceptions ) {
27859 1 : popErrorHandler();
27860 : }
27861 : #ifndef SED_HACKS
27862 : if ( bLocalUseExceptions ) {
27863 : CPLErr eclass = CPLGetLastErrorType();
27864 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27865 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27866 : }
27867 : }
27868 : #endif
27869 : }
27870 2 : resultobj = SWIG_Py_Void();
27871 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27872 : return resultobj;
27873 : fail:
27874 : return NULL;
27875 : }
27876 :
27877 :
27878 2963 : SWIGINTERN PyObject *_wrap_Geometry_GetGeometryRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27879 2963 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27880 2963 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27881 2963 : int arg2 ;
27882 2963 : void *argp1 = 0 ;
27883 2963 : int res1 = 0 ;
27884 2963 : int val2 ;
27885 2963 : int ecode2 = 0 ;
27886 2963 : PyObject *swig_obj[2] ;
27887 2963 : OGRGeometryShadow *result = 0 ;
27888 :
27889 2963 : if (!SWIG_Python_UnpackTuple(args, "Geometry_GetGeometryRef", 2, 2, swig_obj)) SWIG_fail;
27890 2963 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27891 2963 : if (!SWIG_IsOK(res1)) {
27892 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetGeometryRef" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27893 : }
27894 2963 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27895 2963 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
27896 2963 : if (!SWIG_IsOK(ecode2)) {
27897 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetGeometryRef" "', argument " "2"" of type '" "int""'");
27898 : }
27899 2963 : arg2 = static_cast< int >(val2);
27900 2963 : {
27901 2963 : const int bLocalUseExceptions = GetUseExceptions();
27902 2963 : if ( bLocalUseExceptions ) {
27903 201 : pushErrorHandler();
27904 : }
27905 2963 : {
27906 2963 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27907 2963 : result = (OGRGeometryShadow *)OGRGeometryShadow_GetGeometryRef(arg1,arg2);
27908 2963 : SWIG_PYTHON_THREAD_END_ALLOW;
27909 : }
27910 2963 : if ( bLocalUseExceptions ) {
27911 201 : popErrorHandler();
27912 : }
27913 : #ifndef SED_HACKS
27914 : if ( bLocalUseExceptions ) {
27915 : CPLErr eclass = CPLGetLastErrorType();
27916 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27917 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27918 : }
27919 : }
27920 : #endif
27921 : }
27922 2963 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27923 2963 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27924 : return resultobj;
27925 : fail:
27926 : return NULL;
27927 : }
27928 :
27929 :
27930 1 : SWIGINTERN PyObject *_wrap_Geometry_Simplify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27931 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27932 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27933 1 : double arg2 ;
27934 1 : void *argp1 = 0 ;
27935 1 : int res1 = 0 ;
27936 1 : double val2 ;
27937 1 : int ecode2 = 0 ;
27938 1 : PyObject *swig_obj[2] ;
27939 1 : OGRGeometryShadow *result = 0 ;
27940 :
27941 1 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Simplify", 2, 2, swig_obj)) SWIG_fail;
27942 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27943 1 : if (!SWIG_IsOK(res1)) {
27944 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Simplify" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27945 : }
27946 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27947 1 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
27948 1 : if (!SWIG_IsOK(ecode2)) {
27949 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_Simplify" "', argument " "2"" of type '" "double""'");
27950 : }
27951 1 : arg2 = static_cast< double >(val2);
27952 1 : {
27953 1 : const int bLocalUseExceptions = GetUseExceptions();
27954 1 : if ( bLocalUseExceptions ) {
27955 1 : pushErrorHandler();
27956 : }
27957 1 : {
27958 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27959 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_Simplify(arg1,arg2);
27960 1 : SWIG_PYTHON_THREAD_END_ALLOW;
27961 : }
27962 1 : if ( bLocalUseExceptions ) {
27963 1 : popErrorHandler();
27964 : }
27965 : #ifndef SED_HACKS
27966 : if ( bLocalUseExceptions ) {
27967 : CPLErr eclass = CPLGetLastErrorType();
27968 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27969 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27970 : }
27971 : }
27972 : #endif
27973 : }
27974 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
27975 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
27976 : return resultobj;
27977 : fail:
27978 : return NULL;
27979 : }
27980 :
27981 :
27982 1 : SWIGINTERN PyObject *_wrap_Geometry_SimplifyPreserveTopology(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27983 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27984 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
27985 1 : double arg2 ;
27986 1 : void *argp1 = 0 ;
27987 1 : int res1 = 0 ;
27988 1 : double val2 ;
27989 1 : int ecode2 = 0 ;
27990 1 : PyObject *swig_obj[2] ;
27991 1 : OGRGeometryShadow *result = 0 ;
27992 :
27993 1 : if (!SWIG_Python_UnpackTuple(args, "Geometry_SimplifyPreserveTopology", 2, 2, swig_obj)) SWIG_fail;
27994 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
27995 1 : if (!SWIG_IsOK(res1)) {
27996 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SimplifyPreserveTopology" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
27997 : }
27998 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
27999 1 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
28000 1 : if (!SWIG_IsOK(ecode2)) {
28001 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SimplifyPreserveTopology" "', argument " "2"" of type '" "double""'");
28002 : }
28003 1 : arg2 = static_cast< double >(val2);
28004 1 : {
28005 1 : const int bLocalUseExceptions = GetUseExceptions();
28006 1 : if ( bLocalUseExceptions ) {
28007 1 : pushErrorHandler();
28008 : }
28009 1 : {
28010 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28011 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_SimplifyPreserveTopology(arg1,arg2);
28012 1 : SWIG_PYTHON_THREAD_END_ALLOW;
28013 : }
28014 1 : if ( bLocalUseExceptions ) {
28015 1 : popErrorHandler();
28016 : }
28017 : #ifndef SED_HACKS
28018 : if ( bLocalUseExceptions ) {
28019 : CPLErr eclass = CPLGetLastErrorType();
28020 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28021 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28022 : }
28023 : }
28024 : #endif
28025 : }
28026 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28027 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28028 : return resultobj;
28029 : fail:
28030 : return NULL;
28031 : }
28032 :
28033 :
28034 1 : SWIGINTERN PyObject *_wrap_Geometry_DelaunayTriangulation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28035 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28036 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28037 1 : double arg2 = (double) 0.0 ;
28038 1 : int arg3 = (int) FALSE ;
28039 1 : void *argp1 = 0 ;
28040 1 : int res1 = 0 ;
28041 1 : double val2 ;
28042 1 : int ecode2 = 0 ;
28043 1 : int val3 ;
28044 1 : int ecode3 = 0 ;
28045 1 : PyObject * obj0 = 0 ;
28046 1 : PyObject * obj1 = 0 ;
28047 1 : PyObject * obj2 = 0 ;
28048 1 : char * kwnames[] = {
28049 : (char *)"self", (char *)"dfTolerance", (char *)"bOnlyEdges", NULL
28050 : };
28051 1 : OGRGeometryShadow *result = 0 ;
28052 :
28053 1 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:Geometry_DelaunayTriangulation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
28054 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28055 1 : if (!SWIG_IsOK(res1)) {
28056 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_DelaunayTriangulation" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28057 : }
28058 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28059 1 : if (obj1) {
28060 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
28061 0 : if (!SWIG_IsOK(ecode2)) {
28062 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_DelaunayTriangulation" "', argument " "2"" of type '" "double""'");
28063 : }
28064 0 : arg2 = static_cast< double >(val2);
28065 : }
28066 1 : if (obj2) {
28067 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
28068 0 : if (!SWIG_IsOK(ecode3)) {
28069 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_DelaunayTriangulation" "', argument " "3"" of type '" "int""'");
28070 : }
28071 : arg3 = static_cast< int >(val3);
28072 : }
28073 1 : {
28074 1 : const int bLocalUseExceptions = GetUseExceptions();
28075 1 : if ( bLocalUseExceptions ) {
28076 1 : pushErrorHandler();
28077 : }
28078 1 : {
28079 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28080 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_DelaunayTriangulation(arg1,arg2,arg3);
28081 1 : SWIG_PYTHON_THREAD_END_ALLOW;
28082 : }
28083 1 : if ( bLocalUseExceptions ) {
28084 1 : popErrorHandler();
28085 : }
28086 : #ifndef SED_HACKS
28087 : if ( bLocalUseExceptions ) {
28088 : CPLErr eclass = CPLGetLastErrorType();
28089 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28090 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28091 : }
28092 : }
28093 : #endif
28094 : }
28095 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28096 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28097 : return resultobj;
28098 : fail:
28099 : return NULL;
28100 : }
28101 :
28102 :
28103 3 : SWIGINTERN PyObject *_wrap_Geometry_Polygonize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28104 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28105 3 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28106 3 : void *argp1 = 0 ;
28107 3 : int res1 = 0 ;
28108 3 : PyObject *swig_obj[1] ;
28109 3 : OGRGeometryShadow *result = 0 ;
28110 :
28111 3 : if (!args) SWIG_fail;
28112 3 : swig_obj[0] = args;
28113 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28114 3 : if (!SWIG_IsOK(res1)) {
28115 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Polygonize" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28116 : }
28117 3 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28118 3 : {
28119 3 : const int bLocalUseExceptions = GetUseExceptions();
28120 3 : if ( bLocalUseExceptions ) {
28121 3 : pushErrorHandler();
28122 : }
28123 3 : {
28124 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28125 3 : result = (OGRGeometryShadow *)OGRGeometryShadow_Polygonize(arg1);
28126 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28127 : }
28128 3 : if ( bLocalUseExceptions ) {
28129 3 : popErrorHandler();
28130 : }
28131 : #ifndef SED_HACKS
28132 : if ( bLocalUseExceptions ) {
28133 : CPLErr eclass = CPLGetLastErrorType();
28134 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28135 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28136 : }
28137 : }
28138 : #endif
28139 : }
28140 3 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28141 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28142 : return resultobj;
28143 : fail:
28144 : return NULL;
28145 : }
28146 :
28147 :
28148 1 : SWIGINTERN PyObject *_wrap_Geometry_Boundary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28149 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28150 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28151 1 : void *argp1 = 0 ;
28152 1 : int res1 = 0 ;
28153 1 : PyObject *swig_obj[1] ;
28154 1 : OGRGeometryShadow *result = 0 ;
28155 :
28156 1 : if (!args) SWIG_fail;
28157 1 : swig_obj[0] = args;
28158 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28159 1 : if (!SWIG_IsOK(res1)) {
28160 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Boundary" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28161 : }
28162 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28163 1 : {
28164 1 : const int bLocalUseExceptions = GetUseExceptions();
28165 1 : if ( bLocalUseExceptions ) {
28166 0 : pushErrorHandler();
28167 : }
28168 1 : {
28169 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28170 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_Boundary(arg1);
28171 1 : SWIG_PYTHON_THREAD_END_ALLOW;
28172 : }
28173 1 : if ( bLocalUseExceptions ) {
28174 0 : popErrorHandler();
28175 : }
28176 : #ifndef SED_HACKS
28177 : if ( bLocalUseExceptions ) {
28178 : CPLErr eclass = CPLGetLastErrorType();
28179 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28180 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28181 : }
28182 : }
28183 : #endif
28184 : }
28185 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28186 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28187 : return resultobj;
28188 : fail:
28189 : return NULL;
28190 : }
28191 :
28192 :
28193 5 : SWIGINTERN PyObject *_wrap_Geometry_GetBoundary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28194 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28195 5 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28196 5 : void *argp1 = 0 ;
28197 5 : int res1 = 0 ;
28198 5 : PyObject *swig_obj[1] ;
28199 5 : OGRGeometryShadow *result = 0 ;
28200 :
28201 5 : if (!args) SWIG_fail;
28202 5 : swig_obj[0] = args;
28203 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28204 5 : if (!SWIG_IsOK(res1)) {
28205 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetBoundary" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28206 : }
28207 5 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28208 5 : {
28209 5 : const int bLocalUseExceptions = GetUseExceptions();
28210 5 : if ( bLocalUseExceptions ) {
28211 0 : pushErrorHandler();
28212 : }
28213 5 : {
28214 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28215 5 : result = (OGRGeometryShadow *)OGRGeometryShadow_GetBoundary(arg1);
28216 5 : SWIG_PYTHON_THREAD_END_ALLOW;
28217 : }
28218 5 : if ( bLocalUseExceptions ) {
28219 0 : popErrorHandler();
28220 : }
28221 : #ifndef SED_HACKS
28222 : if ( bLocalUseExceptions ) {
28223 : CPLErr eclass = CPLGetLastErrorType();
28224 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28225 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28226 : }
28227 : }
28228 : #endif
28229 : }
28230 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28231 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28232 : return resultobj;
28233 : fail:
28234 : return NULL;
28235 : }
28236 :
28237 :
28238 1 : SWIGINTERN PyObject *_wrap_Geometry_ConvexHull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28239 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28240 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28241 1 : void *argp1 = 0 ;
28242 1 : int res1 = 0 ;
28243 1 : PyObject *swig_obj[1] ;
28244 1 : OGRGeometryShadow *result = 0 ;
28245 :
28246 1 : if (!args) SWIG_fail;
28247 1 : swig_obj[0] = args;
28248 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28249 1 : if (!SWIG_IsOK(res1)) {
28250 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ConvexHull" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28251 : }
28252 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28253 1 : {
28254 1 : const int bLocalUseExceptions = GetUseExceptions();
28255 1 : if ( bLocalUseExceptions ) {
28256 1 : pushErrorHandler();
28257 : }
28258 1 : {
28259 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28260 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_ConvexHull(arg1);
28261 1 : SWIG_PYTHON_THREAD_END_ALLOW;
28262 : }
28263 1 : if ( bLocalUseExceptions ) {
28264 1 : popErrorHandler();
28265 : }
28266 : #ifndef SED_HACKS
28267 : if ( bLocalUseExceptions ) {
28268 : CPLErr eclass = CPLGetLastErrorType();
28269 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28270 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28271 : }
28272 : }
28273 : #endif
28274 : }
28275 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28276 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28277 : return resultobj;
28278 : fail:
28279 : return NULL;
28280 : }
28281 :
28282 :
28283 2 : SWIGINTERN PyObject *_wrap_Geometry_ConcaveHull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28284 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28285 2 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28286 2 : double arg2 ;
28287 2 : bool arg3 ;
28288 2 : void *argp1 = 0 ;
28289 2 : int res1 = 0 ;
28290 2 : double val2 ;
28291 2 : int ecode2 = 0 ;
28292 2 : bool val3 ;
28293 2 : int ecode3 = 0 ;
28294 2 : PyObject *swig_obj[3] ;
28295 2 : OGRGeometryShadow *result = 0 ;
28296 :
28297 2 : if (!SWIG_Python_UnpackTuple(args, "Geometry_ConcaveHull", 3, 3, swig_obj)) SWIG_fail;
28298 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28299 2 : if (!SWIG_IsOK(res1)) {
28300 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_ConcaveHull" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28301 : }
28302 2 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28303 2 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
28304 2 : if (!SWIG_IsOK(ecode2)) {
28305 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_ConcaveHull" "', argument " "2"" of type '" "double""'");
28306 : }
28307 2 : arg2 = static_cast< double >(val2);
28308 2 : ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
28309 2 : if (!SWIG_IsOK(ecode3)) {
28310 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_ConcaveHull" "', argument " "3"" of type '" "bool""'");
28311 : }
28312 2 : arg3 = static_cast< bool >(val3);
28313 2 : {
28314 2 : const int bLocalUseExceptions = GetUseExceptions();
28315 2 : if ( bLocalUseExceptions ) {
28316 0 : pushErrorHandler();
28317 : }
28318 2 : {
28319 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28320 2 : result = (OGRGeometryShadow *)OGRGeometryShadow_ConcaveHull(arg1,arg2,arg3);
28321 2 : SWIG_PYTHON_THREAD_END_ALLOW;
28322 : }
28323 2 : 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 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28336 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28337 : return resultobj;
28338 : fail:
28339 : return NULL;
28340 : }
28341 :
28342 :
28343 11 : SWIGINTERN PyObject *_wrap_Geometry_MakeValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28344 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28345 11 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28346 11 : char **arg2 = (char **) NULL ;
28347 11 : void *argp1 = 0 ;
28348 11 : int res1 = 0 ;
28349 11 : PyObject *swig_obj[2] ;
28350 11 : OGRGeometryShadow *result = 0 ;
28351 :
28352 11 : if (!SWIG_Python_UnpackTuple(args, "Geometry_MakeValid", 1, 2, swig_obj)) SWIG_fail;
28353 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28354 11 : if (!SWIG_IsOK(res1)) {
28355 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_MakeValid" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28356 : }
28357 11 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28358 11 : if (swig_obj[1]) {
28359 5 : {
28360 : /* %typemap(in) char **dict */
28361 5 : arg2 = NULL;
28362 5 : if ( PySequence_Check( swig_obj[1] ) ) {
28363 5 : int bErr = FALSE;
28364 5 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
28365 5 : if ( bErr )
28366 : {
28367 0 : SWIG_fail;
28368 : }
28369 : }
28370 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
28371 0 : int bErr = FALSE;
28372 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
28373 0 : if ( bErr )
28374 : {
28375 0 : SWIG_fail;
28376 : }
28377 : }
28378 : else {
28379 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
28380 0 : SWIG_fail;
28381 : }
28382 : }
28383 : }
28384 11 : {
28385 11 : const int bLocalUseExceptions = GetUseExceptions();
28386 11 : if ( bLocalUseExceptions ) {
28387 0 : pushErrorHandler();
28388 : }
28389 11 : {
28390 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28391 11 : result = (OGRGeometryShadow *)OGRGeometryShadow_MakeValid(arg1,arg2);
28392 11 : SWIG_PYTHON_THREAD_END_ALLOW;
28393 : }
28394 11 : if ( bLocalUseExceptions ) {
28395 0 : popErrorHandler();
28396 : }
28397 : #ifndef SED_HACKS
28398 : if ( bLocalUseExceptions ) {
28399 : CPLErr eclass = CPLGetLastErrorType();
28400 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28401 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28402 : }
28403 : }
28404 : #endif
28405 : }
28406 11 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28407 11 : {
28408 : /* %typemap(freearg) char **dict */
28409 11 : CSLDestroy( arg2 );
28410 : }
28411 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28412 : return resultobj;
28413 0 : fail:
28414 0 : {
28415 : /* %typemap(freearg) char **dict */
28416 0 : CSLDestroy( arg2 );
28417 : }
28418 : return NULL;
28419 : }
28420 :
28421 :
28422 1 : SWIGINTERN PyObject *_wrap_Geometry_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28423 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28424 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28425 1 : double arg2 ;
28426 1 : int arg3 = (int) 0 ;
28427 1 : void *argp1 = 0 ;
28428 1 : int res1 = 0 ;
28429 1 : double val2 ;
28430 1 : int ecode2 = 0 ;
28431 1 : int val3 ;
28432 1 : int ecode3 = 0 ;
28433 1 : PyObject *swig_obj[3] ;
28434 1 : OGRGeometryShadow *result = 0 ;
28435 :
28436 1 : if (!SWIG_Python_UnpackTuple(args, "Geometry_SetPrecision", 2, 3, swig_obj)) SWIG_fail;
28437 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28438 1 : if (!SWIG_IsOK(res1)) {
28439 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SetPrecision" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28440 : }
28441 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28442 1 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
28443 1 : if (!SWIG_IsOK(ecode2)) {
28444 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SetPrecision" "', argument " "2"" of type '" "double""'");
28445 : }
28446 1 : arg2 = static_cast< double >(val2);
28447 1 : if (swig_obj[2]) {
28448 0 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
28449 0 : if (!SWIG_IsOK(ecode3)) {
28450 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_SetPrecision" "', argument " "3"" of type '" "int""'");
28451 : }
28452 : arg3 = static_cast< int >(val3);
28453 : }
28454 1 : {
28455 1 : const int bLocalUseExceptions = GetUseExceptions();
28456 1 : if ( bLocalUseExceptions ) {
28457 1 : pushErrorHandler();
28458 : }
28459 1 : {
28460 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28461 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_SetPrecision(arg1,arg2,arg3);
28462 1 : SWIG_PYTHON_THREAD_END_ALLOW;
28463 : }
28464 1 : if ( bLocalUseExceptions ) {
28465 1 : popErrorHandler();
28466 : }
28467 : #ifndef SED_HACKS
28468 : if ( bLocalUseExceptions ) {
28469 : CPLErr eclass = CPLGetLastErrorType();
28470 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28471 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28472 : }
28473 : }
28474 : #endif
28475 : }
28476 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28477 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28478 : return resultobj;
28479 : fail:
28480 : return NULL;
28481 : }
28482 :
28483 :
28484 1 : SWIGINTERN PyObject *_wrap_Geometry_Normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28485 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28486 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28487 1 : void *argp1 = 0 ;
28488 1 : int res1 = 0 ;
28489 1 : PyObject *swig_obj[1] ;
28490 1 : OGRGeometryShadow *result = 0 ;
28491 :
28492 1 : if (!args) SWIG_fail;
28493 1 : swig_obj[0] = args;
28494 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28495 1 : if (!SWIG_IsOK(res1)) {
28496 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Normalize" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28497 : }
28498 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28499 1 : {
28500 1 : const int bLocalUseExceptions = GetUseExceptions();
28501 1 : if ( bLocalUseExceptions ) {
28502 0 : pushErrorHandler();
28503 : }
28504 1 : {
28505 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28506 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_Normalize(arg1);
28507 1 : SWIG_PYTHON_THREAD_END_ALLOW;
28508 : }
28509 1 : if ( bLocalUseExceptions ) {
28510 0 : popErrorHandler();
28511 : }
28512 : #ifndef SED_HACKS
28513 : if ( bLocalUseExceptions ) {
28514 : CPLErr eclass = CPLGetLastErrorType();
28515 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28516 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28517 : }
28518 : }
28519 : #endif
28520 : }
28521 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28522 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28523 : return resultobj;
28524 : fail:
28525 : return NULL;
28526 : }
28527 :
28528 :
28529 18 : SWIGINTERN PyObject *_wrap_Geometry_RemoveLowerDimensionSubGeoms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28530 18 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28531 18 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28532 18 : void *argp1 = 0 ;
28533 18 : int res1 = 0 ;
28534 18 : PyObject *swig_obj[1] ;
28535 18 : OGRGeometryShadow *result = 0 ;
28536 :
28537 18 : if (!args) SWIG_fail;
28538 18 : swig_obj[0] = args;
28539 18 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28540 18 : if (!SWIG_IsOK(res1)) {
28541 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_RemoveLowerDimensionSubGeoms" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28542 : }
28543 18 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28544 18 : {
28545 18 : const int bLocalUseExceptions = GetUseExceptions();
28546 18 : if ( bLocalUseExceptions ) {
28547 0 : pushErrorHandler();
28548 : }
28549 18 : {
28550 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28551 18 : result = (OGRGeometryShadow *)OGRGeometryShadow_RemoveLowerDimensionSubGeoms(arg1);
28552 18 : SWIG_PYTHON_THREAD_END_ALLOW;
28553 : }
28554 18 : if ( bLocalUseExceptions ) {
28555 0 : popErrorHandler();
28556 : }
28557 : #ifndef SED_HACKS
28558 : if ( bLocalUseExceptions ) {
28559 : CPLErr eclass = CPLGetLastErrorType();
28560 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28561 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28562 : }
28563 : }
28564 : #endif
28565 : }
28566 18 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28567 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28568 : return resultobj;
28569 : fail:
28570 : return NULL;
28571 : }
28572 :
28573 :
28574 : SWIGINTERN PyObject *_wrap_Geometry_Buffer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
28575 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28576 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28577 : double arg2 ;
28578 : int arg3 = (int) 30 ;
28579 : void *argp1 = 0 ;
28580 : int res1 = 0 ;
28581 : double val2 ;
28582 : int ecode2 = 0 ;
28583 : int val3 ;
28584 : int ecode3 = 0 ;
28585 : OGRGeometryShadow *result = 0 ;
28586 :
28587 : if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
28588 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28589 : if (!SWIG_IsOK(res1)) {
28590 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Buffer" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28591 : }
28592 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28593 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
28594 : if (!SWIG_IsOK(ecode2)) {
28595 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_Buffer" "', argument " "2"" of type '" "double""'");
28596 : }
28597 : arg2 = static_cast< double >(val2);
28598 : if (swig_obj[2]) {
28599 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
28600 : if (!SWIG_IsOK(ecode3)) {
28601 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Geometry_Buffer" "', argument " "3"" of type '" "int""'");
28602 : }
28603 : arg3 = static_cast< int >(val3);
28604 : }
28605 : {
28606 : const int bLocalUseExceptions = GetUseExceptions();
28607 : if ( bLocalUseExceptions ) {
28608 : pushErrorHandler();
28609 : }
28610 : {
28611 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28612 : result = (OGRGeometryShadow *)OGRGeometryShadow_Buffer__SWIG_0(arg1,arg2,arg3);
28613 : SWIG_PYTHON_THREAD_END_ALLOW;
28614 : }
28615 : if ( bLocalUseExceptions ) {
28616 : popErrorHandler();
28617 : }
28618 : #ifndef SED_HACKS
28619 : if ( bLocalUseExceptions ) {
28620 : CPLErr eclass = CPLGetLastErrorType();
28621 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28622 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28623 : }
28624 : }
28625 : #endif
28626 : }
28627 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28628 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28629 : return resultobj;
28630 : fail:
28631 : return NULL;
28632 : }
28633 :
28634 :
28635 : SWIGINTERN PyObject *_wrap_Geometry_Buffer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
28636 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28637 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28638 : double arg2 ;
28639 : char **arg3 = (char **) 0 ;
28640 : void *argp1 = 0 ;
28641 : int res1 = 0 ;
28642 : double val2 ;
28643 : int ecode2 = 0 ;
28644 : OGRGeometryShadow *result = 0 ;
28645 :
28646 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
28647 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28648 : if (!SWIG_IsOK(res1)) {
28649 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Buffer" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28650 : }
28651 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28652 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
28653 : if (!SWIG_IsOK(ecode2)) {
28654 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_Buffer" "', argument " "2"" of type '" "double""'");
28655 : }
28656 : arg2 = static_cast< double >(val2);
28657 : {
28658 : /* %typemap(in) char **dict */
28659 : arg3 = NULL;
28660 : if ( PySequence_Check( swig_obj[2] ) ) {
28661 : int bErr = FALSE;
28662 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
28663 : if ( bErr )
28664 : {
28665 : SWIG_fail;
28666 : }
28667 : }
28668 : else if ( PyMapping_Check( swig_obj[2] ) ) {
28669 : int bErr = FALSE;
28670 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
28671 : if ( bErr )
28672 : {
28673 : SWIG_fail;
28674 : }
28675 : }
28676 : else {
28677 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
28678 : SWIG_fail;
28679 : }
28680 : }
28681 : {
28682 : const int bLocalUseExceptions = GetUseExceptions();
28683 : if ( bLocalUseExceptions ) {
28684 : pushErrorHandler();
28685 : }
28686 : {
28687 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28688 : result = (OGRGeometryShadow *)OGRGeometryShadow_Buffer__SWIG_1(arg1,arg2,arg3);
28689 : SWIG_PYTHON_THREAD_END_ALLOW;
28690 : }
28691 : if ( bLocalUseExceptions ) {
28692 : popErrorHandler();
28693 : }
28694 : #ifndef SED_HACKS
28695 : if ( bLocalUseExceptions ) {
28696 : CPLErr eclass = CPLGetLastErrorType();
28697 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28698 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28699 : }
28700 : }
28701 : #endif
28702 : }
28703 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28704 : {
28705 : /* %typemap(freearg) char **dict */
28706 : CSLDestroy( arg3 );
28707 : }
28708 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28709 : return resultobj;
28710 : fail:
28711 : {
28712 : /* %typemap(freearg) char **dict */
28713 : CSLDestroy( arg3 );
28714 : }
28715 : return NULL;
28716 : }
28717 :
28718 :
28719 16 : SWIGINTERN PyObject *_wrap_Geometry_Buffer(PyObject *self, PyObject *args) {
28720 16 : Py_ssize_t argc;
28721 16 : PyObject *argv[4] = {
28722 : 0
28723 : };
28724 :
28725 16 : if (!(argc = SWIG_Python_UnpackTuple(args, "Geometry_Buffer", 0, 3, argv))) SWIG_fail;
28726 16 : --argc;
28727 16 : if ((argc >= 2) && (argc <= 3)) {
28728 16 : int _v;
28729 16 : void *vptr = 0;
28730 16 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
28731 28 : _v = SWIG_CheckState(res);
28732 16 : if (_v) {
28733 16 : {
28734 16 : int res = SWIG_AsVal_double(argv[1], NULL);
28735 16 : _v = SWIG_CheckState(res);
28736 : }
28737 16 : if (_v) {
28738 16 : if (argc <= 2) {
28739 4 : return _wrap_Geometry_Buffer__SWIG_0(self, argc, argv);
28740 : }
28741 14 : {
28742 14 : int res = SWIG_AsVal_int(argv[2], NULL);
28743 14 : _v = SWIG_CheckState(res);
28744 : }
28745 2 : if (_v) {
28746 2 : return _wrap_Geometry_Buffer__SWIG_0(self, argc, argv);
28747 : }
28748 : }
28749 : }
28750 : }
28751 12 : if (argc == 3) {
28752 12 : int _v;
28753 12 : void *vptr = 0;
28754 12 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
28755 12 : _v = SWIG_CheckState(res);
28756 12 : if (_v) {
28757 12 : {
28758 12 : int res = SWIG_AsVal_double(argv[1], NULL);
28759 12 : _v = SWIG_CheckState(res);
28760 : }
28761 12 : if (_v) {
28762 12 : {
28763 : /* %typecheck(SWIG_TYPECHECK_POINTER) (char **dict) */
28764 : /* Note: we exclude explicitly strings, because they can be considered as a sequence of characters, */
28765 : /* which is not desirable since it makes it impossible to define bindings such as SetMetadata(string) and SetMetadata(array_of_string) */
28766 : /* (see #4816) */
28767 12 : _v = ((PyMapping_Check(argv[2]) || PySequence_Check(argv[2]) ) && !SWIG_CheckState(SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0)) ) ? 1 : 0;
28768 : }
28769 12 : if (_v) {
28770 12 : return _wrap_Geometry_Buffer__SWIG_1(self, argc, argv);
28771 : }
28772 : }
28773 : }
28774 : }
28775 :
28776 0 : fail:
28777 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Geometry_Buffer'.\n"
28778 : " Possible C/C++ prototypes are:\n"
28779 : " OGRGeometryShadow::Buffer(double,int)\n"
28780 : " OGRGeometryShadow::Buffer(double,char **)\n");
28781 : return 0;
28782 : }
28783 :
28784 :
28785 11 : SWIGINTERN PyObject *_wrap_Geometry_Intersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28786 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28787 11 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28788 11 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
28789 11 : void *argp1 = 0 ;
28790 11 : int res1 = 0 ;
28791 11 : void *argp2 = 0 ;
28792 11 : int res2 = 0 ;
28793 11 : PyObject *swig_obj[2] ;
28794 11 : OGRGeometryShadow *result = 0 ;
28795 :
28796 11 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Intersection", 2, 2, swig_obj)) SWIG_fail;
28797 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28798 11 : if (!SWIG_IsOK(res1)) {
28799 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Intersection" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28800 : }
28801 11 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28802 11 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28803 11 : if (!SWIG_IsOK(res2)) {
28804 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Intersection" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
28805 : }
28806 11 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
28807 11 : {
28808 11 : if (!arg2) {
28809 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
28810 : }
28811 : }
28812 11 : {
28813 11 : const int bLocalUseExceptions = GetUseExceptions();
28814 11 : if ( bLocalUseExceptions ) {
28815 1 : pushErrorHandler();
28816 : }
28817 11 : {
28818 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28819 11 : result = (OGRGeometryShadow *)OGRGeometryShadow_Intersection(arg1,arg2);
28820 11 : SWIG_PYTHON_THREAD_END_ALLOW;
28821 : }
28822 11 : if ( bLocalUseExceptions ) {
28823 1 : popErrorHandler();
28824 : }
28825 : #ifndef SED_HACKS
28826 : if ( bLocalUseExceptions ) {
28827 : CPLErr eclass = CPLGetLastErrorType();
28828 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28829 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28830 : }
28831 : }
28832 : #endif
28833 : }
28834 11 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28835 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28836 : return resultobj;
28837 : fail:
28838 : return NULL;
28839 : }
28840 :
28841 :
28842 7 : SWIGINTERN PyObject *_wrap_Geometry_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28843 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28844 7 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28845 7 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
28846 7 : void *argp1 = 0 ;
28847 7 : int res1 = 0 ;
28848 7 : void *argp2 = 0 ;
28849 7 : int res2 = 0 ;
28850 7 : PyObject *swig_obj[2] ;
28851 7 : OGRGeometryShadow *result = 0 ;
28852 :
28853 7 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Union", 2, 2, swig_obj)) SWIG_fail;
28854 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28855 7 : if (!SWIG_IsOK(res1)) {
28856 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Union" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28857 : }
28858 7 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28859 7 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28860 7 : if (!SWIG_IsOK(res2)) {
28861 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Union" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
28862 : }
28863 7 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
28864 7 : {
28865 7 : if (!arg2) {
28866 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
28867 : }
28868 : }
28869 7 : {
28870 7 : const int bLocalUseExceptions = GetUseExceptions();
28871 7 : if ( bLocalUseExceptions ) {
28872 1 : pushErrorHandler();
28873 : }
28874 7 : {
28875 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28876 7 : result = (OGRGeometryShadow *)OGRGeometryShadow_Union(arg1,arg2);
28877 7 : SWIG_PYTHON_THREAD_END_ALLOW;
28878 : }
28879 7 : if ( bLocalUseExceptions ) {
28880 1 : popErrorHandler();
28881 : }
28882 : #ifndef SED_HACKS
28883 : if ( bLocalUseExceptions ) {
28884 : CPLErr eclass = CPLGetLastErrorType();
28885 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28886 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28887 : }
28888 : }
28889 : #endif
28890 : }
28891 7 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28892 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28893 : return resultobj;
28894 : fail:
28895 : return NULL;
28896 : }
28897 :
28898 :
28899 2 : SWIGINTERN PyObject *_wrap_Geometry_UnionCascaded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28900 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28901 2 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28902 2 : void *argp1 = 0 ;
28903 2 : int res1 = 0 ;
28904 2 : PyObject *swig_obj[1] ;
28905 2 : OGRGeometryShadow *result = 0 ;
28906 :
28907 2 : if (!args) SWIG_fail;
28908 2 : swig_obj[0] = args;
28909 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28910 2 : if (!SWIG_IsOK(res1)) {
28911 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_UnionCascaded" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28912 : }
28913 2 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28914 2 : {
28915 2 : const int bLocalUseExceptions = GetUseExceptions();
28916 2 : if ( bLocalUseExceptions ) {
28917 2 : pushErrorHandler();
28918 : }
28919 2 : {
28920 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28921 2 : result = (OGRGeometryShadow *)OGRGeometryShadow_UnionCascaded(arg1);
28922 2 : SWIG_PYTHON_THREAD_END_ALLOW;
28923 : }
28924 2 : if ( bLocalUseExceptions ) {
28925 2 : popErrorHandler();
28926 : }
28927 : #ifndef SED_HACKS
28928 : if ( bLocalUseExceptions ) {
28929 : CPLErr eclass = CPLGetLastErrorType();
28930 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28931 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28932 : }
28933 : }
28934 : #endif
28935 : }
28936 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28937 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28938 : return resultobj;
28939 : fail:
28940 : return NULL;
28941 : }
28942 :
28943 :
28944 2 : SWIGINTERN PyObject *_wrap_Geometry_UnaryUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28945 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28946 2 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28947 2 : void *argp1 = 0 ;
28948 2 : int res1 = 0 ;
28949 2 : PyObject *swig_obj[1] ;
28950 2 : OGRGeometryShadow *result = 0 ;
28951 :
28952 2 : if (!args) SWIG_fail;
28953 2 : swig_obj[0] = args;
28954 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
28955 2 : if (!SWIG_IsOK(res1)) {
28956 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_UnaryUnion" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
28957 : }
28958 2 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
28959 2 : {
28960 2 : const int bLocalUseExceptions = GetUseExceptions();
28961 2 : if ( bLocalUseExceptions ) {
28962 2 : pushErrorHandler();
28963 : }
28964 2 : {
28965 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28966 2 : result = (OGRGeometryShadow *)OGRGeometryShadow_UnaryUnion(arg1);
28967 2 : SWIG_PYTHON_THREAD_END_ALLOW;
28968 : }
28969 2 : if ( bLocalUseExceptions ) {
28970 2 : popErrorHandler();
28971 : }
28972 : #ifndef SED_HACKS
28973 : if ( bLocalUseExceptions ) {
28974 : CPLErr eclass = CPLGetLastErrorType();
28975 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28976 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28977 : }
28978 : }
28979 : #endif
28980 : }
28981 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
28982 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
28983 : return resultobj;
28984 : fail:
28985 : return NULL;
28986 : }
28987 :
28988 :
28989 5 : SWIGINTERN PyObject *_wrap_Geometry_Difference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28990 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28991 5 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
28992 5 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
28993 5 : void *argp1 = 0 ;
28994 5 : int res1 = 0 ;
28995 5 : void *argp2 = 0 ;
28996 5 : int res2 = 0 ;
28997 5 : PyObject *swig_obj[2] ;
28998 5 : OGRGeometryShadow *result = 0 ;
28999 :
29000 5 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Difference", 2, 2, swig_obj)) SWIG_fail;
29001 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29002 5 : if (!SWIG_IsOK(res1)) {
29003 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Difference" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29004 : }
29005 5 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29006 5 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29007 5 : if (!SWIG_IsOK(res2)) {
29008 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Difference" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29009 : }
29010 5 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29011 5 : {
29012 5 : if (!arg2) {
29013 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29014 : }
29015 : }
29016 5 : {
29017 5 : const int bLocalUseExceptions = GetUseExceptions();
29018 5 : if ( bLocalUseExceptions ) {
29019 1 : pushErrorHandler();
29020 : }
29021 5 : {
29022 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29023 5 : result = (OGRGeometryShadow *)OGRGeometryShadow_Difference(arg1,arg2);
29024 5 : SWIG_PYTHON_THREAD_END_ALLOW;
29025 : }
29026 5 : if ( bLocalUseExceptions ) {
29027 1 : popErrorHandler();
29028 : }
29029 : #ifndef SED_HACKS
29030 : if ( bLocalUseExceptions ) {
29031 : CPLErr eclass = CPLGetLastErrorType();
29032 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29033 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29034 : }
29035 : }
29036 : #endif
29037 : }
29038 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
29039 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29040 : return resultobj;
29041 : fail:
29042 : return NULL;
29043 : }
29044 :
29045 :
29046 5 : SWIGINTERN PyObject *_wrap_Geometry_SymDifference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29047 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29048 5 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29049 5 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29050 5 : void *argp1 = 0 ;
29051 5 : int res1 = 0 ;
29052 5 : void *argp2 = 0 ;
29053 5 : int res2 = 0 ;
29054 5 : PyObject *swig_obj[2] ;
29055 5 : OGRGeometryShadow *result = 0 ;
29056 :
29057 5 : if (!SWIG_Python_UnpackTuple(args, "Geometry_SymDifference", 2, 2, swig_obj)) SWIG_fail;
29058 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29059 5 : if (!SWIG_IsOK(res1)) {
29060 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SymDifference" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29061 : }
29062 5 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29063 5 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29064 5 : if (!SWIG_IsOK(res2)) {
29065 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_SymDifference" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29066 : }
29067 5 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29068 5 : {
29069 5 : if (!arg2) {
29070 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29071 : }
29072 : }
29073 5 : {
29074 5 : const int bLocalUseExceptions = GetUseExceptions();
29075 5 : if ( bLocalUseExceptions ) {
29076 1 : pushErrorHandler();
29077 : }
29078 5 : {
29079 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29080 5 : result = (OGRGeometryShadow *)OGRGeometryShadow_SymDifference(arg1,arg2);
29081 5 : SWIG_PYTHON_THREAD_END_ALLOW;
29082 : }
29083 5 : if ( bLocalUseExceptions ) {
29084 1 : popErrorHandler();
29085 : }
29086 : #ifndef SED_HACKS
29087 : if ( bLocalUseExceptions ) {
29088 : CPLErr eclass = CPLGetLastErrorType();
29089 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29090 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29091 : }
29092 : }
29093 : #endif
29094 : }
29095 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
29096 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29097 : return resultobj;
29098 : fail:
29099 : return NULL;
29100 : }
29101 :
29102 :
29103 1 : SWIGINTERN PyObject *_wrap_Geometry_SymmetricDifference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29104 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29105 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29106 1 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29107 1 : void *argp1 = 0 ;
29108 1 : int res1 = 0 ;
29109 1 : void *argp2 = 0 ;
29110 1 : int res2 = 0 ;
29111 1 : PyObject *swig_obj[2] ;
29112 1 : OGRGeometryShadow *result = 0 ;
29113 :
29114 1 : if (!SWIG_Python_UnpackTuple(args, "Geometry_SymmetricDifference", 2, 2, swig_obj)) SWIG_fail;
29115 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29116 1 : if (!SWIG_IsOK(res1)) {
29117 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SymmetricDifference" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29118 : }
29119 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29120 1 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29121 1 : if (!SWIG_IsOK(res2)) {
29122 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_SymmetricDifference" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29123 : }
29124 1 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29125 1 : {
29126 1 : if (!arg2) {
29127 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29128 : }
29129 : }
29130 1 : {
29131 1 : const int bLocalUseExceptions = GetUseExceptions();
29132 1 : if ( bLocalUseExceptions ) {
29133 1 : pushErrorHandler();
29134 : }
29135 1 : {
29136 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29137 1 : result = (OGRGeometryShadow *)OGRGeometryShadow_SymmetricDifference(arg1,arg2);
29138 1 : SWIG_PYTHON_THREAD_END_ALLOW;
29139 : }
29140 1 : if ( bLocalUseExceptions ) {
29141 1 : popErrorHandler();
29142 : }
29143 : #ifndef SED_HACKS
29144 : if ( bLocalUseExceptions ) {
29145 : CPLErr eclass = CPLGetLastErrorType();
29146 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29147 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29148 : }
29149 : }
29150 : #endif
29151 : }
29152 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
29153 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29154 : return resultobj;
29155 : fail:
29156 : return NULL;
29157 : }
29158 :
29159 :
29160 1 : SWIGINTERN PyObject *_wrap_Geometry_Distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29161 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29162 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29163 1 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29164 1 : void *argp1 = 0 ;
29165 1 : int res1 = 0 ;
29166 1 : void *argp2 = 0 ;
29167 1 : int res2 = 0 ;
29168 1 : PyObject *swig_obj[2] ;
29169 1 : double result;
29170 :
29171 1 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Distance", 2, 2, swig_obj)) SWIG_fail;
29172 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29173 1 : if (!SWIG_IsOK(res1)) {
29174 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Distance" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29175 : }
29176 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29177 1 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29178 1 : if (!SWIG_IsOK(res2)) {
29179 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Distance" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29180 : }
29181 1 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29182 1 : {
29183 1 : if (!arg2) {
29184 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29185 : }
29186 : }
29187 1 : {
29188 1 : const int bLocalUseExceptions = GetUseExceptions();
29189 1 : if ( bLocalUseExceptions ) {
29190 1 : pushErrorHandler();
29191 : }
29192 1 : {
29193 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29194 1 : result = (double)OGRGeometryShadow_Distance(arg1,arg2);
29195 1 : SWIG_PYTHON_THREAD_END_ALLOW;
29196 : }
29197 1 : if ( bLocalUseExceptions ) {
29198 1 : popErrorHandler();
29199 : }
29200 : #ifndef SED_HACKS
29201 : if ( bLocalUseExceptions ) {
29202 : CPLErr eclass = CPLGetLastErrorType();
29203 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29204 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29205 : }
29206 : }
29207 : #endif
29208 : }
29209 1 : resultobj = SWIG_From_double(static_cast< double >(result));
29210 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29211 : return resultobj;
29212 : fail:
29213 : return NULL;
29214 : }
29215 :
29216 :
29217 1 : SWIGINTERN PyObject *_wrap_Geometry_Distance3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29218 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29219 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29220 1 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29221 1 : void *argp1 = 0 ;
29222 1 : int res1 = 0 ;
29223 1 : void *argp2 = 0 ;
29224 1 : int res2 = 0 ;
29225 1 : PyObject *swig_obj[2] ;
29226 1 : double result;
29227 :
29228 1 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Distance3D", 2, 2, swig_obj)) SWIG_fail;
29229 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29230 1 : if (!SWIG_IsOK(res1)) {
29231 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Distance3D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29232 : }
29233 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29234 1 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29235 1 : if (!SWIG_IsOK(res2)) {
29236 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Distance3D" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29237 : }
29238 1 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29239 1 : {
29240 1 : if (!arg2) {
29241 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29242 : }
29243 : }
29244 1 : {
29245 1 : const int bLocalUseExceptions = GetUseExceptions();
29246 1 : if ( bLocalUseExceptions ) {
29247 0 : pushErrorHandler();
29248 : }
29249 1 : {
29250 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29251 1 : result = (double)OGRGeometryShadow_Distance3D(arg1,arg2);
29252 1 : SWIG_PYTHON_THREAD_END_ALLOW;
29253 : }
29254 1 : if ( bLocalUseExceptions ) {
29255 0 : popErrorHandler();
29256 : }
29257 : #ifndef SED_HACKS
29258 : if ( bLocalUseExceptions ) {
29259 : CPLErr eclass = CPLGetLastErrorType();
29260 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29261 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29262 : }
29263 : }
29264 : #endif
29265 : }
29266 1 : resultobj = SWIG_From_double(static_cast< double >(result));
29267 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29268 : return resultobj;
29269 : fail:
29270 : return NULL;
29271 : }
29272 :
29273 :
29274 4 : SWIGINTERN PyObject *_wrap_Geometry_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29275 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29276 4 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29277 4 : void *argp1 = 0 ;
29278 4 : int res1 = 0 ;
29279 4 : PyObject *swig_obj[1] ;
29280 :
29281 4 : if (!args) SWIG_fail;
29282 4 : swig_obj[0] = args;
29283 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29284 4 : if (!SWIG_IsOK(res1)) {
29285 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Empty" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29286 : }
29287 4 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29288 4 : {
29289 4 : const int bLocalUseExceptions = GetUseExceptions();
29290 4 : if ( bLocalUseExceptions ) {
29291 0 : pushErrorHandler();
29292 : }
29293 4 : {
29294 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29295 4 : OGRGeometryShadow_Empty(arg1);
29296 4 : SWIG_PYTHON_THREAD_END_ALLOW;
29297 : }
29298 4 : if ( bLocalUseExceptions ) {
29299 0 : popErrorHandler();
29300 : }
29301 : #ifndef SED_HACKS
29302 : if ( bLocalUseExceptions ) {
29303 : CPLErr eclass = CPLGetLastErrorType();
29304 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29305 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29306 : }
29307 : }
29308 : #endif
29309 : }
29310 4 : resultobj = SWIG_Py_Void();
29311 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29312 : return resultobj;
29313 : fail:
29314 : return NULL;
29315 : }
29316 :
29317 :
29318 2126 : SWIGINTERN PyObject *_wrap_Geometry_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29319 2126 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29320 2126 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29321 2126 : void *argp1 = 0 ;
29322 2126 : int res1 = 0 ;
29323 2126 : PyObject *swig_obj[1] ;
29324 2126 : bool result;
29325 :
29326 2126 : if (!args) SWIG_fail;
29327 2126 : swig_obj[0] = args;
29328 2126 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29329 2126 : if (!SWIG_IsOK(res1)) {
29330 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_IsEmpty" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29331 : }
29332 2126 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29333 2126 : {
29334 2126 : const int bLocalUseExceptions = GetUseExceptions();
29335 2126 : if ( bLocalUseExceptions ) {
29336 1011 : pushErrorHandler();
29337 : }
29338 2126 : {
29339 2126 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29340 2126 : result = (bool)OGRGeometryShadow_IsEmpty(arg1);
29341 2126 : SWIG_PYTHON_THREAD_END_ALLOW;
29342 : }
29343 2126 : if ( bLocalUseExceptions ) {
29344 1011 : popErrorHandler();
29345 : }
29346 : #ifndef SED_HACKS
29347 : if ( bLocalUseExceptions ) {
29348 : CPLErr eclass = CPLGetLastErrorType();
29349 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29350 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29351 : }
29352 : }
29353 : #endif
29354 : }
29355 2126 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29356 2126 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29357 : return resultobj;
29358 : fail:
29359 : return NULL;
29360 : }
29361 :
29362 :
29363 19 : SWIGINTERN PyObject *_wrap_Geometry_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29364 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29365 19 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29366 19 : void *argp1 = 0 ;
29367 19 : int res1 = 0 ;
29368 19 : PyObject *swig_obj[1] ;
29369 19 : bool result;
29370 :
29371 19 : if (!args) SWIG_fail;
29372 19 : swig_obj[0] = args;
29373 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29374 19 : if (!SWIG_IsOK(res1)) {
29375 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_IsValid" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29376 : }
29377 19 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29378 19 : {
29379 19 : const int bLocalUseExceptions = GetUseExceptions();
29380 19 : if ( bLocalUseExceptions ) {
29381 14 : pushErrorHandler();
29382 : }
29383 19 : {
29384 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29385 19 : result = (bool)OGRGeometryShadow_IsValid(arg1);
29386 19 : SWIG_PYTHON_THREAD_END_ALLOW;
29387 : }
29388 19 : if ( bLocalUseExceptions ) {
29389 14 : popErrorHandler();
29390 : }
29391 : #ifndef SED_HACKS
29392 : if ( bLocalUseExceptions ) {
29393 : CPLErr eclass = CPLGetLastErrorType();
29394 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29395 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29396 : }
29397 : }
29398 : #endif
29399 : }
29400 19 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29401 19 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29402 : return resultobj;
29403 : fail:
29404 : return NULL;
29405 : }
29406 :
29407 :
29408 5 : SWIGINTERN PyObject *_wrap_Geometry_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29409 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29410 5 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29411 5 : void *argp1 = 0 ;
29412 5 : int res1 = 0 ;
29413 5 : PyObject *swig_obj[1] ;
29414 5 : bool result;
29415 :
29416 5 : if (!args) SWIG_fail;
29417 5 : swig_obj[0] = args;
29418 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29419 5 : if (!SWIG_IsOK(res1)) {
29420 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_IsSimple" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29421 : }
29422 5 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29423 5 : {
29424 5 : const int bLocalUseExceptions = GetUseExceptions();
29425 5 : if ( bLocalUseExceptions ) {
29426 2 : pushErrorHandler();
29427 : }
29428 5 : {
29429 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29430 5 : result = (bool)OGRGeometryShadow_IsSimple(arg1);
29431 5 : SWIG_PYTHON_THREAD_END_ALLOW;
29432 : }
29433 5 : if ( bLocalUseExceptions ) {
29434 2 : popErrorHandler();
29435 : }
29436 : #ifndef SED_HACKS
29437 : if ( bLocalUseExceptions ) {
29438 : CPLErr eclass = CPLGetLastErrorType();
29439 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29440 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29441 : }
29442 : }
29443 : #endif
29444 : }
29445 5 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29446 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29447 : return resultobj;
29448 : fail:
29449 : return NULL;
29450 : }
29451 :
29452 :
29453 1 : SWIGINTERN PyObject *_wrap_Geometry_IsRing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29454 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29455 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29456 1 : void *argp1 = 0 ;
29457 1 : int res1 = 0 ;
29458 1 : PyObject *swig_obj[1] ;
29459 1 : bool result;
29460 :
29461 1 : if (!args) SWIG_fail;
29462 1 : swig_obj[0] = args;
29463 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29464 1 : if (!SWIG_IsOK(res1)) {
29465 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_IsRing" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29466 : }
29467 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29468 1 : {
29469 1 : const int bLocalUseExceptions = GetUseExceptions();
29470 1 : if ( bLocalUseExceptions ) {
29471 1 : pushErrorHandler();
29472 : }
29473 1 : {
29474 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29475 1 : result = (bool)OGRGeometryShadow_IsRing(arg1);
29476 1 : SWIG_PYTHON_THREAD_END_ALLOW;
29477 : }
29478 1 : if ( bLocalUseExceptions ) {
29479 1 : popErrorHandler();
29480 : }
29481 : #ifndef SED_HACKS
29482 : if ( bLocalUseExceptions ) {
29483 : CPLErr eclass = CPLGetLastErrorType();
29484 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29485 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29486 : }
29487 : }
29488 : #endif
29489 : }
29490 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29491 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29492 : return resultobj;
29493 : fail:
29494 : return NULL;
29495 : }
29496 :
29497 :
29498 7 : SWIGINTERN PyObject *_wrap_Geometry_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29499 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29500 7 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29501 7 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29502 7 : void *argp1 = 0 ;
29503 7 : int res1 = 0 ;
29504 7 : void *argp2 = 0 ;
29505 7 : int res2 = 0 ;
29506 7 : PyObject *swig_obj[2] ;
29507 7 : bool result;
29508 :
29509 7 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Intersects", 2, 2, swig_obj)) SWIG_fail;
29510 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29511 7 : if (!SWIG_IsOK(res1)) {
29512 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Intersects" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29513 : }
29514 7 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29515 7 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29516 7 : if (!SWIG_IsOK(res2)) {
29517 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Intersects" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29518 : }
29519 7 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29520 7 : {
29521 7 : if (!arg2) {
29522 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29523 : }
29524 : }
29525 7 : {
29526 7 : const int bLocalUseExceptions = GetUseExceptions();
29527 7 : if ( bLocalUseExceptions ) {
29528 0 : pushErrorHandler();
29529 : }
29530 7 : {
29531 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29532 7 : result = (bool)OGRGeometryShadow_Intersects(arg1,arg2);
29533 7 : SWIG_PYTHON_THREAD_END_ALLOW;
29534 : }
29535 7 : if ( bLocalUseExceptions ) {
29536 0 : popErrorHandler();
29537 : }
29538 : #ifndef SED_HACKS
29539 : if ( bLocalUseExceptions ) {
29540 : CPLErr eclass = CPLGetLastErrorType();
29541 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29542 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29543 : }
29544 : }
29545 : #endif
29546 : }
29547 7 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29548 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29549 : return resultobj;
29550 : fail:
29551 : return NULL;
29552 : }
29553 :
29554 :
29555 2 : SWIGINTERN PyObject *_wrap_Geometry_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29556 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29557 2 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29558 2 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29559 2 : void *argp1 = 0 ;
29560 2 : int res1 = 0 ;
29561 2 : void *argp2 = 0 ;
29562 2 : int res2 = 0 ;
29563 2 : PyObject *swig_obj[2] ;
29564 2 : bool result;
29565 :
29566 2 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Intersect", 2, 2, swig_obj)) SWIG_fail;
29567 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29568 2 : if (!SWIG_IsOK(res1)) {
29569 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Intersect" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29570 : }
29571 2 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29572 2 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29573 2 : if (!SWIG_IsOK(res2)) {
29574 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Intersect" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29575 : }
29576 2 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29577 2 : {
29578 2 : if (!arg2) {
29579 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29580 : }
29581 : }
29582 2 : {
29583 2 : const int bLocalUseExceptions = GetUseExceptions();
29584 2 : if ( bLocalUseExceptions ) {
29585 2 : pushErrorHandler();
29586 : }
29587 2 : {
29588 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29589 2 : result = (bool)OGRGeometryShadow_Intersect(arg1,arg2);
29590 2 : SWIG_PYTHON_THREAD_END_ALLOW;
29591 : }
29592 2 : if ( bLocalUseExceptions ) {
29593 2 : popErrorHandler();
29594 : }
29595 : #ifndef SED_HACKS
29596 : if ( bLocalUseExceptions ) {
29597 : CPLErr eclass = CPLGetLastErrorType();
29598 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29599 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29600 : }
29601 : }
29602 : #endif
29603 : }
29604 2 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29605 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29606 : return resultobj;
29607 : fail:
29608 : return NULL;
29609 : }
29610 :
29611 :
29612 28071 : SWIGINTERN PyObject *_wrap_Geometry_Equals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29613 28071 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29614 28071 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29615 28071 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29616 28071 : void *argp1 = 0 ;
29617 28071 : int res1 = 0 ;
29618 28071 : void *argp2 = 0 ;
29619 28071 : int res2 = 0 ;
29620 28071 : PyObject *swig_obj[2] ;
29621 28071 : bool result;
29622 :
29623 28071 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Equals", 2, 2, swig_obj)) SWIG_fail;
29624 28071 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29625 28071 : if (!SWIG_IsOK(res1)) {
29626 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Equals" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29627 : }
29628 28071 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29629 28071 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29630 28071 : if (!SWIG_IsOK(res2)) {
29631 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Equals" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29632 : }
29633 28071 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29634 28071 : {
29635 28071 : if (!arg2) {
29636 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29637 : }
29638 : }
29639 28071 : {
29640 28071 : const int bLocalUseExceptions = GetUseExceptions();
29641 28071 : if ( bLocalUseExceptions ) {
29642 14424 : pushErrorHandler();
29643 : }
29644 28071 : {
29645 28071 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29646 28071 : result = (bool)OGRGeometryShadow_Equals(arg1,arg2);
29647 28071 : SWIG_PYTHON_THREAD_END_ALLOW;
29648 : }
29649 28071 : if ( bLocalUseExceptions ) {
29650 14424 : popErrorHandler();
29651 : }
29652 : #ifndef SED_HACKS
29653 : if ( bLocalUseExceptions ) {
29654 : CPLErr eclass = CPLGetLastErrorType();
29655 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29656 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29657 : }
29658 : }
29659 : #endif
29660 : }
29661 28071 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29662 28071 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29663 : return resultobj;
29664 : fail:
29665 : return NULL;
29666 : }
29667 :
29668 :
29669 170 : SWIGINTERN PyObject *_wrap_Geometry_Equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29670 170 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29671 170 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29672 170 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29673 170 : void *argp1 = 0 ;
29674 170 : int res1 = 0 ;
29675 170 : void *argp2 = 0 ;
29676 170 : int res2 = 0 ;
29677 170 : PyObject *swig_obj[2] ;
29678 170 : bool result;
29679 :
29680 170 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Equal", 2, 2, swig_obj)) SWIG_fail;
29681 170 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29682 170 : if (!SWIG_IsOK(res1)) {
29683 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Equal" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29684 : }
29685 170 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29686 170 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29687 170 : if (!SWIG_IsOK(res2)) {
29688 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Equal" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29689 : }
29690 170 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29691 170 : {
29692 170 : if (!arg2) {
29693 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29694 : }
29695 : }
29696 170 : {
29697 170 : const int bLocalUseExceptions = GetUseExceptions();
29698 170 : if ( bLocalUseExceptions ) {
29699 0 : pushErrorHandler();
29700 : }
29701 170 : {
29702 170 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29703 170 : result = (bool)OGRGeometryShadow_Equal(arg1,arg2);
29704 170 : SWIG_PYTHON_THREAD_END_ALLOW;
29705 : }
29706 170 : if ( bLocalUseExceptions ) {
29707 0 : popErrorHandler();
29708 : }
29709 : #ifndef SED_HACKS
29710 : if ( bLocalUseExceptions ) {
29711 : CPLErr eclass = CPLGetLastErrorType();
29712 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29713 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29714 : }
29715 : }
29716 : #endif
29717 : }
29718 170 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29719 170 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29720 : return resultobj;
29721 : fail:
29722 : return NULL;
29723 : }
29724 :
29725 :
29726 6 : SWIGINTERN PyObject *_wrap_Geometry_Disjoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29727 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29728 6 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29729 6 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29730 6 : void *argp1 = 0 ;
29731 6 : int res1 = 0 ;
29732 6 : void *argp2 = 0 ;
29733 6 : int res2 = 0 ;
29734 6 : PyObject *swig_obj[2] ;
29735 6 : bool result;
29736 :
29737 6 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Disjoint", 2, 2, swig_obj)) SWIG_fail;
29738 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29739 6 : if (!SWIG_IsOK(res1)) {
29740 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Disjoint" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29741 : }
29742 6 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29743 6 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29744 6 : if (!SWIG_IsOK(res2)) {
29745 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Disjoint" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29746 : }
29747 6 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29748 6 : {
29749 6 : if (!arg2) {
29750 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29751 : }
29752 : }
29753 6 : {
29754 6 : const int bLocalUseExceptions = GetUseExceptions();
29755 6 : if ( bLocalUseExceptions ) {
29756 2 : pushErrorHandler();
29757 : }
29758 6 : {
29759 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29760 6 : result = (bool)OGRGeometryShadow_Disjoint(arg1,arg2);
29761 6 : SWIG_PYTHON_THREAD_END_ALLOW;
29762 : }
29763 6 : if ( bLocalUseExceptions ) {
29764 2 : popErrorHandler();
29765 : }
29766 : #ifndef SED_HACKS
29767 : if ( bLocalUseExceptions ) {
29768 : CPLErr eclass = CPLGetLastErrorType();
29769 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29770 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29771 : }
29772 : }
29773 : #endif
29774 : }
29775 6 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29776 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29777 : return resultobj;
29778 : fail:
29779 : return NULL;
29780 : }
29781 :
29782 :
29783 6 : SWIGINTERN PyObject *_wrap_Geometry_Touches(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29784 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29785 6 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29786 6 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29787 6 : void *argp1 = 0 ;
29788 6 : int res1 = 0 ;
29789 6 : void *argp2 = 0 ;
29790 6 : int res2 = 0 ;
29791 6 : PyObject *swig_obj[2] ;
29792 6 : bool result;
29793 :
29794 6 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Touches", 2, 2, swig_obj)) SWIG_fail;
29795 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29796 6 : if (!SWIG_IsOK(res1)) {
29797 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Touches" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29798 : }
29799 6 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29800 6 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29801 6 : if (!SWIG_IsOK(res2)) {
29802 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Touches" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29803 : }
29804 6 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29805 6 : {
29806 6 : if (!arg2) {
29807 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29808 : }
29809 : }
29810 6 : {
29811 6 : const int bLocalUseExceptions = GetUseExceptions();
29812 6 : if ( bLocalUseExceptions ) {
29813 2 : pushErrorHandler();
29814 : }
29815 6 : {
29816 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29817 6 : result = (bool)OGRGeometryShadow_Touches(arg1,arg2);
29818 6 : SWIG_PYTHON_THREAD_END_ALLOW;
29819 : }
29820 6 : if ( bLocalUseExceptions ) {
29821 2 : popErrorHandler();
29822 : }
29823 : #ifndef SED_HACKS
29824 : if ( bLocalUseExceptions ) {
29825 : CPLErr eclass = CPLGetLastErrorType();
29826 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29827 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29828 : }
29829 : }
29830 : #endif
29831 : }
29832 6 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29833 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29834 : return resultobj;
29835 : fail:
29836 : return NULL;
29837 : }
29838 :
29839 :
29840 6 : SWIGINTERN PyObject *_wrap_Geometry_Crosses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29841 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29842 6 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29843 6 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29844 6 : void *argp1 = 0 ;
29845 6 : int res1 = 0 ;
29846 6 : void *argp2 = 0 ;
29847 6 : int res2 = 0 ;
29848 6 : PyObject *swig_obj[2] ;
29849 6 : bool result;
29850 :
29851 6 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Crosses", 2, 2, swig_obj)) SWIG_fail;
29852 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29853 6 : if (!SWIG_IsOK(res1)) {
29854 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Crosses" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29855 : }
29856 6 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29857 6 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29858 6 : if (!SWIG_IsOK(res2)) {
29859 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Crosses" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29860 : }
29861 6 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29862 6 : {
29863 6 : if (!arg2) {
29864 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29865 : }
29866 : }
29867 6 : {
29868 6 : const int bLocalUseExceptions = GetUseExceptions();
29869 6 : if ( bLocalUseExceptions ) {
29870 2 : pushErrorHandler();
29871 : }
29872 6 : {
29873 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29874 6 : result = (bool)OGRGeometryShadow_Crosses(arg1,arg2);
29875 6 : SWIG_PYTHON_THREAD_END_ALLOW;
29876 : }
29877 6 : if ( bLocalUseExceptions ) {
29878 2 : popErrorHandler();
29879 : }
29880 : #ifndef SED_HACKS
29881 : if ( bLocalUseExceptions ) {
29882 : CPLErr eclass = CPLGetLastErrorType();
29883 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29884 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29885 : }
29886 : }
29887 : #endif
29888 : }
29889 6 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29890 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29891 : return resultobj;
29892 : fail:
29893 : return NULL;
29894 : }
29895 :
29896 :
29897 6165 : SWIGINTERN PyObject *_wrap_Geometry_Within(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29898 6165 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29899 6165 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29900 6165 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29901 6165 : void *argp1 = 0 ;
29902 6165 : int res1 = 0 ;
29903 6165 : void *argp2 = 0 ;
29904 6165 : int res2 = 0 ;
29905 6165 : PyObject *swig_obj[2] ;
29906 6165 : bool result;
29907 :
29908 6165 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Within", 2, 2, swig_obj)) SWIG_fail;
29909 6165 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29910 6165 : if (!SWIG_IsOK(res1)) {
29911 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Within" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29912 : }
29913 6165 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29914 6165 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29915 6165 : if (!SWIG_IsOK(res2)) {
29916 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Within" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29917 : }
29918 6165 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29919 6165 : {
29920 6165 : if (!arg2) {
29921 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29922 : }
29923 : }
29924 6165 : {
29925 6165 : const int bLocalUseExceptions = GetUseExceptions();
29926 6165 : if ( bLocalUseExceptions ) {
29927 3 : pushErrorHandler();
29928 : }
29929 6165 : {
29930 6165 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29931 6165 : result = (bool)OGRGeometryShadow_Within(arg1,arg2);
29932 6165 : SWIG_PYTHON_THREAD_END_ALLOW;
29933 : }
29934 6165 : if ( bLocalUseExceptions ) {
29935 3 : popErrorHandler();
29936 : }
29937 : #ifndef SED_HACKS
29938 : if ( bLocalUseExceptions ) {
29939 : CPLErr eclass = CPLGetLastErrorType();
29940 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29941 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29942 : }
29943 : }
29944 : #endif
29945 : }
29946 6165 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29947 6165 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
29948 : return resultobj;
29949 : fail:
29950 : return NULL;
29951 : }
29952 :
29953 :
29954 9 : SWIGINTERN PyObject *_wrap_Geometry_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29955 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29956 9 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
29957 9 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
29958 9 : void *argp1 = 0 ;
29959 9 : int res1 = 0 ;
29960 9 : void *argp2 = 0 ;
29961 9 : int res2 = 0 ;
29962 9 : PyObject *swig_obj[2] ;
29963 9 : bool result;
29964 :
29965 9 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Contains", 2, 2, swig_obj)) SWIG_fail;
29966 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29967 9 : if (!SWIG_IsOK(res1)) {
29968 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Contains" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
29969 : }
29970 9 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
29971 9 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
29972 9 : if (!SWIG_IsOK(res2)) {
29973 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Contains" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
29974 : }
29975 9 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
29976 9 : {
29977 9 : if (!arg2) {
29978 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
29979 : }
29980 : }
29981 9 : {
29982 9 : const int bLocalUseExceptions = GetUseExceptions();
29983 9 : if ( bLocalUseExceptions ) {
29984 2 : pushErrorHandler();
29985 : }
29986 9 : {
29987 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29988 9 : result = (bool)OGRGeometryShadow_Contains(arg1,arg2);
29989 9 : SWIG_PYTHON_THREAD_END_ALLOW;
29990 : }
29991 9 : if ( bLocalUseExceptions ) {
29992 2 : popErrorHandler();
29993 : }
29994 : #ifndef SED_HACKS
29995 : if ( bLocalUseExceptions ) {
29996 : CPLErr eclass = CPLGetLastErrorType();
29997 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29998 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29999 : }
30000 : }
30001 : #endif
30002 : }
30003 9 : resultobj = SWIG_From_bool(static_cast< bool >(result));
30004 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30005 : return resultobj;
30006 : fail:
30007 : return NULL;
30008 : }
30009 :
30010 :
30011 6 : SWIGINTERN PyObject *_wrap_Geometry_Overlaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30012 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30013 6 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30014 6 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
30015 6 : void *argp1 = 0 ;
30016 6 : int res1 = 0 ;
30017 6 : void *argp2 = 0 ;
30018 6 : int res2 = 0 ;
30019 6 : PyObject *swig_obj[2] ;
30020 6 : bool result;
30021 :
30022 6 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Overlaps", 2, 2, swig_obj)) SWIG_fail;
30023 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30024 6 : if (!SWIG_IsOK(res1)) {
30025 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Overlaps" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30026 : }
30027 6 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30028 6 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30029 6 : if (!SWIG_IsOK(res2)) {
30030 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Overlaps" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
30031 : }
30032 6 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
30033 6 : {
30034 6 : if (!arg2) {
30035 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
30036 : }
30037 : }
30038 6 : {
30039 6 : const int bLocalUseExceptions = GetUseExceptions();
30040 6 : if ( bLocalUseExceptions ) {
30041 2 : pushErrorHandler();
30042 : }
30043 6 : {
30044 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30045 6 : result = (bool)OGRGeometryShadow_Overlaps(arg1,arg2);
30046 6 : SWIG_PYTHON_THREAD_END_ALLOW;
30047 : }
30048 6 : if ( bLocalUseExceptions ) {
30049 2 : popErrorHandler();
30050 : }
30051 : #ifndef SED_HACKS
30052 : if ( bLocalUseExceptions ) {
30053 : CPLErr eclass = CPLGetLastErrorType();
30054 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30055 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30056 : }
30057 : }
30058 : #endif
30059 : }
30060 6 : resultobj = SWIG_From_bool(static_cast< bool >(result));
30061 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30062 : return resultobj;
30063 : fail:
30064 : return NULL;
30065 : }
30066 :
30067 :
30068 9 : SWIGINTERN PyObject *_wrap_Geometry_TransformTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30069 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30070 9 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30071 9 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
30072 9 : void *argp1 = 0 ;
30073 9 : int res1 = 0 ;
30074 9 : void *argp2 = 0 ;
30075 9 : int res2 = 0 ;
30076 9 : PyObject *swig_obj[2] ;
30077 9 : OGRErr result;
30078 :
30079 9 : if (!SWIG_Python_UnpackTuple(args, "Geometry_TransformTo", 2, 2, swig_obj)) SWIG_fail;
30080 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30081 9 : if (!SWIG_IsOK(res1)) {
30082 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_TransformTo" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30083 : }
30084 9 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30085 9 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
30086 9 : if (!SWIG_IsOK(res2)) {
30087 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_TransformTo" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
30088 : }
30089 9 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
30090 9 : {
30091 9 : if (!arg2) {
30092 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
30093 : }
30094 : }
30095 9 : {
30096 9 : const int bLocalUseExceptions = GetUseExceptions();
30097 9 : if ( bLocalUseExceptions ) {
30098 2 : pushErrorHandler();
30099 : }
30100 9 : {
30101 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30102 9 : result = (OGRErr)OGRGeometryShadow_TransformTo(arg1,arg2);
30103 9 : SWIG_PYTHON_THREAD_END_ALLOW;
30104 : }
30105 9 : if ( bLocalUseExceptions ) {
30106 2 : popErrorHandler();
30107 : }
30108 : #ifndef SED_HACKS
30109 : if ( bLocalUseExceptions ) {
30110 : CPLErr eclass = CPLGetLastErrorType();
30111 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30112 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30113 : }
30114 : }
30115 : #endif
30116 : }
30117 9 : {
30118 : /* %typemap(out) OGRErr */
30119 10 : if ( result != 0 && GetUseExceptions()) {
30120 0 : const char* pszMessage = CPLGetLastErrorMsg();
30121 0 : if( pszMessage[0] != '\0' )
30122 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
30123 : else
30124 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
30125 0 : SWIG_fail;
30126 : }
30127 : }
30128 9 : {
30129 : /* %typemap(ret) OGRErr */
30130 9 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
30131 9 : resultobj = PyInt_FromLong( result );
30132 : }
30133 : }
30134 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30135 : return resultobj;
30136 : fail:
30137 : return NULL;
30138 : }
30139 :
30140 :
30141 : SWIGINTERN PyObject *_wrap_Geometry_Transform__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
30142 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30143 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30144 : OSRCoordinateTransformationShadow *arg2 = (OSRCoordinateTransformationShadow *) 0 ;
30145 : void *argp1 = 0 ;
30146 : int res1 = 0 ;
30147 : void *argp2 = 0 ;
30148 : int res2 = 0 ;
30149 : OGRErr result;
30150 :
30151 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30152 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30153 : if (!SWIG_IsOK(res1)) {
30154 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Transform" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30155 : }
30156 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30157 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OSRCoordinateTransformationShadow, 0 | 0 );
30158 : if (!SWIG_IsOK(res2)) {
30159 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Transform" "', argument " "2"" of type '" "OSRCoordinateTransformationShadow *""'");
30160 : }
30161 : arg2 = reinterpret_cast< OSRCoordinateTransformationShadow * >(argp2);
30162 : {
30163 : if (!arg2) {
30164 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
30165 : }
30166 : }
30167 : {
30168 : const int bLocalUseExceptions = GetUseExceptions();
30169 : if ( bLocalUseExceptions ) {
30170 : pushErrorHandler();
30171 : }
30172 : {
30173 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30174 : result = (OGRErr)OGRGeometryShadow_Transform__SWIG_0(arg1,arg2);
30175 : SWIG_PYTHON_THREAD_END_ALLOW;
30176 : }
30177 : if ( bLocalUseExceptions ) {
30178 : popErrorHandler();
30179 : }
30180 : #ifndef SED_HACKS
30181 : if ( bLocalUseExceptions ) {
30182 : CPLErr eclass = CPLGetLastErrorType();
30183 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30184 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30185 : }
30186 : }
30187 : #endif
30188 : }
30189 : {
30190 : /* %typemap(out) OGRErr */
30191 : if ( result != 0 && GetUseExceptions()) {
30192 : const char* pszMessage = CPLGetLastErrorMsg();
30193 : if( pszMessage[0] != '\0' )
30194 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
30195 : else
30196 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
30197 : SWIG_fail;
30198 : }
30199 : }
30200 : {
30201 : /* %typemap(ret) OGRErr */
30202 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
30203 : resultobj = PyInt_FromLong( result );
30204 : }
30205 : }
30206 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30207 : return resultobj;
30208 : fail:
30209 : return NULL;
30210 : }
30211 :
30212 :
30213 48 : SWIGINTERN PyObject *_wrap_Geometry_GetSpatialReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30214 48 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30215 48 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30216 48 : void *argp1 = 0 ;
30217 48 : int res1 = 0 ;
30218 48 : PyObject *swig_obj[1] ;
30219 48 : OSRSpatialReferenceShadow *result = 0 ;
30220 :
30221 48 : if (!args) SWIG_fail;
30222 48 : swig_obj[0] = args;
30223 48 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30224 48 : if (!SWIG_IsOK(res1)) {
30225 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetSpatialReference" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30226 : }
30227 48 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30228 48 : {
30229 48 : const int bLocalUseExceptions = GetUseExceptions();
30230 48 : if ( bLocalUseExceptions ) {
30231 25 : pushErrorHandler();
30232 : }
30233 48 : {
30234 48 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30235 48 : result = (OSRSpatialReferenceShadow *)OGRGeometryShadow_GetSpatialReference(arg1);
30236 48 : SWIG_PYTHON_THREAD_END_ALLOW;
30237 : }
30238 48 : if ( bLocalUseExceptions ) {
30239 25 : popErrorHandler();
30240 : }
30241 : #ifndef SED_HACKS
30242 : if ( bLocalUseExceptions ) {
30243 : CPLErr eclass = CPLGetLastErrorType();
30244 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30245 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30246 : }
30247 : }
30248 : #endif
30249 : }
30250 48 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_OWN | 0 );
30251 48 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30252 : return resultobj;
30253 : fail:
30254 : return NULL;
30255 : }
30256 :
30257 :
30258 71 : SWIGINTERN PyObject *_wrap_Geometry_AssignSpatialReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30259 71 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30260 71 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30261 71 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
30262 71 : void *argp1 = 0 ;
30263 71 : int res1 = 0 ;
30264 71 : void *argp2 = 0 ;
30265 71 : int res2 = 0 ;
30266 71 : PyObject *swig_obj[2] ;
30267 :
30268 71 : if (!SWIG_Python_UnpackTuple(args, "Geometry_AssignSpatialReference", 2, 2, swig_obj)) SWIG_fail;
30269 71 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30270 71 : if (!SWIG_IsOK(res1)) {
30271 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_AssignSpatialReference" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30272 : }
30273 71 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30274 71 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
30275 71 : if (!SWIG_IsOK(res2)) {
30276 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_AssignSpatialReference" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
30277 : }
30278 71 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
30279 71 : {
30280 71 : const int bLocalUseExceptions = GetUseExceptions();
30281 71 : if ( bLocalUseExceptions ) {
30282 60 : pushErrorHandler();
30283 : }
30284 71 : {
30285 71 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30286 71 : OGRGeometryShadow_AssignSpatialReference(arg1,arg2);
30287 71 : SWIG_PYTHON_THREAD_END_ALLOW;
30288 : }
30289 71 : if ( bLocalUseExceptions ) {
30290 60 : popErrorHandler();
30291 : }
30292 : #ifndef SED_HACKS
30293 : if ( bLocalUseExceptions ) {
30294 : CPLErr eclass = CPLGetLastErrorType();
30295 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30296 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30297 : }
30298 : }
30299 : #endif
30300 : }
30301 71 : resultobj = SWIG_Py_Void();
30302 71 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30303 : return resultobj;
30304 : fail:
30305 : return NULL;
30306 : }
30307 :
30308 :
30309 6 : SWIGINTERN PyObject *_wrap_Geometry_CloseRings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30310 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30311 6 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30312 6 : void *argp1 = 0 ;
30313 6 : int res1 = 0 ;
30314 6 : PyObject *swig_obj[1] ;
30315 :
30316 6 : if (!args) SWIG_fail;
30317 6 : swig_obj[0] = args;
30318 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30319 6 : if (!SWIG_IsOK(res1)) {
30320 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_CloseRings" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30321 : }
30322 6 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30323 6 : {
30324 6 : const int bLocalUseExceptions = GetUseExceptions();
30325 6 : if ( bLocalUseExceptions ) {
30326 0 : pushErrorHandler();
30327 : }
30328 6 : {
30329 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30330 6 : OGRGeometryShadow_CloseRings(arg1);
30331 6 : SWIG_PYTHON_THREAD_END_ALLOW;
30332 : }
30333 6 : if ( bLocalUseExceptions ) {
30334 0 : popErrorHandler();
30335 : }
30336 : #ifndef SED_HACKS
30337 : if ( bLocalUseExceptions ) {
30338 : CPLErr eclass = CPLGetLastErrorType();
30339 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30340 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30341 : }
30342 : }
30343 : #endif
30344 : }
30345 6 : resultobj = SWIG_Py_Void();
30346 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30347 : return resultobj;
30348 : fail:
30349 : return NULL;
30350 : }
30351 :
30352 :
30353 31 : SWIGINTERN PyObject *_wrap_Geometry_FlattenTo2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30354 31 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30355 31 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30356 31 : void *argp1 = 0 ;
30357 31 : int res1 = 0 ;
30358 31 : PyObject *swig_obj[1] ;
30359 :
30360 31 : if (!args) SWIG_fail;
30361 31 : swig_obj[0] = args;
30362 31 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30363 31 : if (!SWIG_IsOK(res1)) {
30364 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_FlattenTo2D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30365 : }
30366 31 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30367 31 : {
30368 31 : const int bLocalUseExceptions = GetUseExceptions();
30369 31 : if ( bLocalUseExceptions ) {
30370 0 : pushErrorHandler();
30371 : }
30372 31 : {
30373 31 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30374 31 : OGRGeometryShadow_FlattenTo2D(arg1);
30375 31 : SWIG_PYTHON_THREAD_END_ALLOW;
30376 : }
30377 31 : if ( bLocalUseExceptions ) {
30378 0 : popErrorHandler();
30379 : }
30380 : #ifndef SED_HACKS
30381 : if ( bLocalUseExceptions ) {
30382 : CPLErr eclass = CPLGetLastErrorType();
30383 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30384 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30385 : }
30386 : }
30387 : #endif
30388 : }
30389 31 : resultobj = SWIG_Py_Void();
30390 31 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30391 : return resultobj;
30392 : fail:
30393 : return NULL;
30394 : }
30395 :
30396 :
30397 21 : SWIGINTERN PyObject *_wrap_Geometry_Segmentize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30398 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30399 21 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30400 21 : double arg2 ;
30401 21 : void *argp1 = 0 ;
30402 21 : int res1 = 0 ;
30403 21 : double val2 ;
30404 21 : int ecode2 = 0 ;
30405 21 : PyObject *swig_obj[2] ;
30406 :
30407 21 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Segmentize", 2, 2, swig_obj)) SWIG_fail;
30408 21 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30409 21 : if (!SWIG_IsOK(res1)) {
30410 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Segmentize" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30411 : }
30412 21 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30413 21 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
30414 21 : if (!SWIG_IsOK(ecode2)) {
30415 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_Segmentize" "', argument " "2"" of type '" "double""'");
30416 : }
30417 21 : arg2 = static_cast< double >(val2);
30418 21 : {
30419 21 : const int bLocalUseExceptions = GetUseExceptions();
30420 21 : if ( bLocalUseExceptions ) {
30421 0 : pushErrorHandler();
30422 : }
30423 21 : {
30424 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30425 21 : OGRGeometryShadow_Segmentize(arg1,arg2);
30426 21 : SWIG_PYTHON_THREAD_END_ALLOW;
30427 : }
30428 21 : if ( bLocalUseExceptions ) {
30429 0 : popErrorHandler();
30430 : }
30431 : #ifndef SED_HACKS
30432 : if ( bLocalUseExceptions ) {
30433 : CPLErr eclass = CPLGetLastErrorType();
30434 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30435 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30436 : }
30437 : }
30438 : #endif
30439 : }
30440 21 : resultobj = SWIG_Py_Void();
30441 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30442 : return resultobj;
30443 : fail:
30444 : return NULL;
30445 : }
30446 :
30447 :
30448 13139 : SWIGINTERN PyObject *_wrap_Geometry_GetEnvelope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30449 13139 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30450 13139 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30451 13139 : double *arg2 ;
30452 13139 : void *argp1 = 0 ;
30453 13139 : int res1 = 0 ;
30454 13139 : double argout2[4] ;
30455 13139 : PyObject *swig_obj[1] ;
30456 :
30457 13139 : {
30458 : /* %typemap(in,numinputs=0) (double argout2[ANY]) */
30459 13139 : memset(argout2, 0, sizeof(argout2));
30460 13139 : arg2 = argout2;
30461 : }
30462 13139 : if (!args) SWIG_fail;
30463 13139 : swig_obj[0] = args;
30464 13139 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30465 13139 : if (!SWIG_IsOK(res1)) {
30466 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetEnvelope" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30467 : }
30468 13139 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30469 13139 : {
30470 13139 : const int bLocalUseExceptions = GetUseExceptions();
30471 13139 : if ( bLocalUseExceptions ) {
30472 13084 : pushErrorHandler();
30473 : }
30474 13139 : {
30475 13139 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30476 13139 : OGRGeometryShadow_GetEnvelope(arg1,arg2);
30477 13139 : SWIG_PYTHON_THREAD_END_ALLOW;
30478 : }
30479 13139 : if ( bLocalUseExceptions ) {
30480 13084 : popErrorHandler();
30481 : }
30482 : #ifndef SED_HACKS
30483 : if ( bLocalUseExceptions ) {
30484 : CPLErr eclass = CPLGetLastErrorType();
30485 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30486 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30487 : }
30488 : }
30489 : #endif
30490 : }
30491 13139 : resultobj = SWIG_Py_Void();
30492 13139 : {
30493 : /* %typemap(argout) (double argout[ANY]) */
30494 13139 : PyObject *out = CreateTupleFromDoubleArray( arg2, 4 );
30495 : #if SWIG_VERSION >= 0x040300
30496 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
30497 : #else
30498 13139 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
30499 : #endif
30500 : }
30501 13139 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30502 : return resultobj;
30503 : fail:
30504 : return NULL;
30505 : }
30506 :
30507 :
30508 10 : SWIGINTERN PyObject *_wrap_Geometry_GetEnvelope3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30509 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30510 10 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30511 10 : double *arg2 ;
30512 10 : void *argp1 = 0 ;
30513 10 : int res1 = 0 ;
30514 10 : double argout2[6] ;
30515 10 : PyObject *swig_obj[1] ;
30516 :
30517 10 : {
30518 : /* %typemap(in,numinputs=0) (double argout2[ANY]) */
30519 10 : memset(argout2, 0, sizeof(argout2));
30520 10 : arg2 = argout2;
30521 : }
30522 10 : if (!args) SWIG_fail;
30523 10 : swig_obj[0] = args;
30524 10 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30525 10 : if (!SWIG_IsOK(res1)) {
30526 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetEnvelope3D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30527 : }
30528 10 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30529 10 : {
30530 10 : const int bLocalUseExceptions = GetUseExceptions();
30531 10 : if ( bLocalUseExceptions ) {
30532 0 : pushErrorHandler();
30533 : }
30534 10 : {
30535 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30536 10 : OGRGeometryShadow_GetEnvelope3D(arg1,arg2);
30537 10 : SWIG_PYTHON_THREAD_END_ALLOW;
30538 : }
30539 10 : if ( bLocalUseExceptions ) {
30540 0 : popErrorHandler();
30541 : }
30542 : #ifndef SED_HACKS
30543 : if ( bLocalUseExceptions ) {
30544 : CPLErr eclass = CPLGetLastErrorType();
30545 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30546 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30547 : }
30548 : }
30549 : #endif
30550 : }
30551 10 : resultobj = SWIG_Py_Void();
30552 10 : {
30553 : /* %typemap(argout) (double argout[ANY]) */
30554 10 : PyObject *out = CreateTupleFromDoubleArray( arg2, 6 );
30555 : #if SWIG_VERSION >= 0x040300
30556 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
30557 : #else
30558 10 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
30559 : #endif
30560 : }
30561 10 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30562 : return resultobj;
30563 : fail:
30564 : return NULL;
30565 : }
30566 :
30567 :
30568 5 : SWIGINTERN PyObject *_wrap_Geometry_Centroid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30569 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30570 5 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30571 5 : void *argp1 = 0 ;
30572 5 : int res1 = 0 ;
30573 5 : PyObject *swig_obj[1] ;
30574 5 : OGRGeometryShadow *result = 0 ;
30575 :
30576 5 : if (!args) SWIG_fail;
30577 5 : swig_obj[0] = args;
30578 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30579 5 : if (!SWIG_IsOK(res1)) {
30580 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Centroid" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30581 : }
30582 5 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30583 5 : {
30584 5 : const int bLocalUseExceptions = GetUseExceptions();
30585 5 : if ( bLocalUseExceptions ) {
30586 5 : pushErrorHandler();
30587 : }
30588 5 : {
30589 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30590 5 : result = (OGRGeometryShadow *)OGRGeometryShadow_Centroid(arg1);
30591 5 : SWIG_PYTHON_THREAD_END_ALLOW;
30592 : }
30593 5 : if ( bLocalUseExceptions ) {
30594 5 : popErrorHandler();
30595 : }
30596 : #ifndef SED_HACKS
30597 : if ( bLocalUseExceptions ) {
30598 : CPLErr eclass = CPLGetLastErrorType();
30599 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30600 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30601 : }
30602 : }
30603 : #endif
30604 : }
30605 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
30606 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30607 : return resultobj;
30608 : fail:
30609 : return NULL;
30610 : }
30611 :
30612 :
30613 4 : SWIGINTERN PyObject *_wrap_Geometry_PointOnSurface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30614 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30615 4 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30616 4 : void *argp1 = 0 ;
30617 4 : int res1 = 0 ;
30618 4 : PyObject *swig_obj[1] ;
30619 4 : OGRGeometryShadow *result = 0 ;
30620 :
30621 4 : if (!args) SWIG_fail;
30622 4 : swig_obj[0] = args;
30623 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30624 4 : if (!SWIG_IsOK(res1)) {
30625 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_PointOnSurface" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30626 : }
30627 4 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30628 4 : {
30629 4 : const int bLocalUseExceptions = GetUseExceptions();
30630 4 : if ( bLocalUseExceptions ) {
30631 1 : pushErrorHandler();
30632 : }
30633 4 : {
30634 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30635 4 : result = (OGRGeometryShadow *)OGRGeometryShadow_PointOnSurface(arg1);
30636 4 : SWIG_PYTHON_THREAD_END_ALLOW;
30637 : }
30638 4 : if ( bLocalUseExceptions ) {
30639 1 : popErrorHandler();
30640 : }
30641 : #ifndef SED_HACKS
30642 : if ( bLocalUseExceptions ) {
30643 : CPLErr eclass = CPLGetLastErrorType();
30644 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30645 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30646 : }
30647 : }
30648 : #endif
30649 : }
30650 4 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
30651 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30652 : return resultobj;
30653 : fail:
30654 : return NULL;
30655 : }
30656 :
30657 :
30658 2 : SWIGINTERN PyObject *_wrap_Geometry_WkbSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30659 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30660 2 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30661 2 : void *argp1 = 0 ;
30662 2 : int res1 = 0 ;
30663 2 : PyObject *swig_obj[1] ;
30664 2 : size_t result;
30665 :
30666 2 : if (!args) SWIG_fail;
30667 2 : swig_obj[0] = args;
30668 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30669 2 : if (!SWIG_IsOK(res1)) {
30670 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_WkbSize" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30671 : }
30672 2 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30673 2 : {
30674 2 : const int bLocalUseExceptions = GetUseExceptions();
30675 2 : if ( bLocalUseExceptions ) {
30676 0 : pushErrorHandler();
30677 : }
30678 2 : {
30679 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30680 2 : result = OGRGeometryShadow_WkbSize(arg1);
30681 2 : SWIG_PYTHON_THREAD_END_ALLOW;
30682 : }
30683 2 : if ( bLocalUseExceptions ) {
30684 0 : popErrorHandler();
30685 : }
30686 : #ifndef SED_HACKS
30687 : if ( bLocalUseExceptions ) {
30688 : CPLErr eclass = CPLGetLastErrorType();
30689 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30690 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30691 : }
30692 : }
30693 : #endif
30694 : }
30695 2 : resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30696 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30697 : return resultobj;
30698 : fail:
30699 : return NULL;
30700 : }
30701 :
30702 :
30703 77 : SWIGINTERN PyObject *_wrap_Geometry_GetCoordinateDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30704 77 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30705 77 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30706 77 : void *argp1 = 0 ;
30707 77 : int res1 = 0 ;
30708 77 : PyObject *swig_obj[1] ;
30709 77 : int result;
30710 :
30711 77 : if (!args) SWIG_fail;
30712 77 : swig_obj[0] = args;
30713 77 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30714 77 : if (!SWIG_IsOK(res1)) {
30715 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetCoordinateDimension" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30716 : }
30717 77 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30718 77 : {
30719 77 : const int bLocalUseExceptions = GetUseExceptions();
30720 77 : if ( bLocalUseExceptions ) {
30721 15 : pushErrorHandler();
30722 : }
30723 77 : {
30724 77 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30725 77 : result = (int)OGRGeometryShadow_GetCoordinateDimension(arg1);
30726 77 : SWIG_PYTHON_THREAD_END_ALLOW;
30727 : }
30728 77 : if ( bLocalUseExceptions ) {
30729 15 : popErrorHandler();
30730 : }
30731 : #ifndef SED_HACKS
30732 : if ( bLocalUseExceptions ) {
30733 : CPLErr eclass = CPLGetLastErrorType();
30734 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30735 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30736 : }
30737 : }
30738 : #endif
30739 : }
30740 77 : resultobj = SWIG_From_int(static_cast< int >(result));
30741 77 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30742 : return resultobj;
30743 : fail:
30744 : return NULL;
30745 : }
30746 :
30747 :
30748 4 : SWIGINTERN PyObject *_wrap_Geometry_CoordinateDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30749 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30750 4 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30751 4 : void *argp1 = 0 ;
30752 4 : int res1 = 0 ;
30753 4 : PyObject *swig_obj[1] ;
30754 4 : int result;
30755 :
30756 4 : if (!args) SWIG_fail;
30757 4 : swig_obj[0] = args;
30758 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30759 4 : if (!SWIG_IsOK(res1)) {
30760 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_CoordinateDimension" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30761 : }
30762 4 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30763 4 : {
30764 4 : const int bLocalUseExceptions = GetUseExceptions();
30765 4 : if ( bLocalUseExceptions ) {
30766 0 : pushErrorHandler();
30767 : }
30768 4 : {
30769 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30770 4 : result = (int)OGRGeometryShadow_CoordinateDimension(arg1);
30771 4 : SWIG_PYTHON_THREAD_END_ALLOW;
30772 : }
30773 4 : if ( bLocalUseExceptions ) {
30774 0 : popErrorHandler();
30775 : }
30776 : #ifndef SED_HACKS
30777 : if ( bLocalUseExceptions ) {
30778 : CPLErr eclass = CPLGetLastErrorType();
30779 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30780 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30781 : }
30782 : }
30783 : #endif
30784 : }
30785 4 : resultobj = SWIG_From_int(static_cast< int >(result));
30786 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30787 : return resultobj;
30788 : fail:
30789 : return NULL;
30790 : }
30791 :
30792 :
30793 34456 : SWIGINTERN PyObject *_wrap_Geometry_Is3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30794 34456 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30795 34456 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30796 34456 : void *argp1 = 0 ;
30797 34456 : int res1 = 0 ;
30798 34456 : PyObject *swig_obj[1] ;
30799 34456 : int result;
30800 :
30801 34456 : if (!args) SWIG_fail;
30802 34456 : swig_obj[0] = args;
30803 34456 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30804 34456 : if (!SWIG_IsOK(res1)) {
30805 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Is3D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30806 : }
30807 34456 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30808 34456 : {
30809 34456 : const int bLocalUseExceptions = GetUseExceptions();
30810 34456 : if ( bLocalUseExceptions ) {
30811 0 : pushErrorHandler();
30812 : }
30813 34456 : {
30814 34456 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30815 34456 : result = (int)OGRGeometryShadow_Is3D(arg1);
30816 34456 : SWIG_PYTHON_THREAD_END_ALLOW;
30817 : }
30818 34456 : if ( bLocalUseExceptions ) {
30819 0 : popErrorHandler();
30820 : }
30821 : #ifndef SED_HACKS
30822 : if ( bLocalUseExceptions ) {
30823 : CPLErr eclass = CPLGetLastErrorType();
30824 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30825 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30826 : }
30827 : }
30828 : #endif
30829 : }
30830 34456 : resultobj = SWIG_From_int(static_cast< int >(result));
30831 34456 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30832 : return resultobj;
30833 : fail:
30834 : return NULL;
30835 : }
30836 :
30837 :
30838 37547 : SWIGINTERN PyObject *_wrap_Geometry_IsMeasured(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30839 37547 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30840 37547 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30841 37547 : void *argp1 = 0 ;
30842 37547 : int res1 = 0 ;
30843 37547 : PyObject *swig_obj[1] ;
30844 37547 : int result;
30845 :
30846 37547 : if (!args) SWIG_fail;
30847 37547 : swig_obj[0] = args;
30848 37547 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30849 37547 : if (!SWIG_IsOK(res1)) {
30850 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_IsMeasured" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30851 : }
30852 37547 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30853 37547 : {
30854 37547 : const int bLocalUseExceptions = GetUseExceptions();
30855 37547 : if ( bLocalUseExceptions ) {
30856 0 : pushErrorHandler();
30857 : }
30858 37547 : {
30859 37547 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30860 37547 : result = (int)OGRGeometryShadow_IsMeasured(arg1);
30861 37547 : SWIG_PYTHON_THREAD_END_ALLOW;
30862 : }
30863 37547 : if ( bLocalUseExceptions ) {
30864 0 : popErrorHandler();
30865 : }
30866 : #ifndef SED_HACKS
30867 : if ( bLocalUseExceptions ) {
30868 : CPLErr eclass = CPLGetLastErrorType();
30869 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30870 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30871 : }
30872 : }
30873 : #endif
30874 : }
30875 37547 : resultobj = SWIG_From_int(static_cast< int >(result));
30876 37547 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30877 : return resultobj;
30878 : fail:
30879 : return NULL;
30880 : }
30881 :
30882 :
30883 56 : SWIGINTERN PyObject *_wrap_Geometry_SetCoordinateDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30884 56 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30885 56 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30886 56 : int arg2 ;
30887 56 : void *argp1 = 0 ;
30888 56 : int res1 = 0 ;
30889 56 : int val2 ;
30890 56 : int ecode2 = 0 ;
30891 56 : PyObject *swig_obj[2] ;
30892 :
30893 56 : if (!SWIG_Python_UnpackTuple(args, "Geometry_SetCoordinateDimension", 2, 2, swig_obj)) SWIG_fail;
30894 56 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30895 56 : if (!SWIG_IsOK(res1)) {
30896 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SetCoordinateDimension" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30897 : }
30898 56 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30899 56 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30900 56 : if (!SWIG_IsOK(ecode2)) {
30901 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SetCoordinateDimension" "', argument " "2"" of type '" "int""'");
30902 : }
30903 56 : arg2 = static_cast< int >(val2);
30904 56 : {
30905 56 : const int bLocalUseExceptions = GetUseExceptions();
30906 56 : if ( bLocalUseExceptions ) {
30907 0 : pushErrorHandler();
30908 : }
30909 56 : {
30910 56 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30911 56 : OGRGeometryShadow_SetCoordinateDimension(arg1,arg2);
30912 56 : SWIG_PYTHON_THREAD_END_ALLOW;
30913 : }
30914 56 : if ( bLocalUseExceptions ) {
30915 0 : popErrorHandler();
30916 : }
30917 : #ifndef SED_HACKS
30918 : if ( bLocalUseExceptions ) {
30919 : CPLErr eclass = CPLGetLastErrorType();
30920 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30921 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30922 : }
30923 : }
30924 : #endif
30925 : }
30926 56 : resultobj = SWIG_Py_Void();
30927 56 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30928 : return resultobj;
30929 : fail:
30930 : return NULL;
30931 : }
30932 :
30933 :
30934 154 : SWIGINTERN PyObject *_wrap_Geometry_Set3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30935 154 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30936 154 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30937 154 : int arg2 ;
30938 154 : void *argp1 = 0 ;
30939 154 : int res1 = 0 ;
30940 154 : int val2 ;
30941 154 : int ecode2 = 0 ;
30942 154 : PyObject *swig_obj[2] ;
30943 :
30944 154 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Set3D", 2, 2, swig_obj)) SWIG_fail;
30945 154 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30946 154 : if (!SWIG_IsOK(res1)) {
30947 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Set3D" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30948 : }
30949 154 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
30950 154 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30951 154 : if (!SWIG_IsOK(ecode2)) {
30952 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_Set3D" "', argument " "2"" of type '" "int""'");
30953 : }
30954 154 : arg2 = static_cast< int >(val2);
30955 154 : {
30956 154 : const int bLocalUseExceptions = GetUseExceptions();
30957 154 : if ( bLocalUseExceptions ) {
30958 42 : pushErrorHandler();
30959 : }
30960 154 : {
30961 154 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30962 154 : OGRGeometryShadow_Set3D(arg1,arg2);
30963 154 : SWIG_PYTHON_THREAD_END_ALLOW;
30964 : }
30965 154 : if ( bLocalUseExceptions ) {
30966 42 : popErrorHandler();
30967 : }
30968 : #ifndef SED_HACKS
30969 : if ( bLocalUseExceptions ) {
30970 : CPLErr eclass = CPLGetLastErrorType();
30971 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30972 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30973 : }
30974 : }
30975 : #endif
30976 : }
30977 154 : resultobj = SWIG_Py_Void();
30978 154 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
30979 : return resultobj;
30980 : fail:
30981 : return NULL;
30982 : }
30983 :
30984 :
30985 154 : SWIGINTERN PyObject *_wrap_Geometry_SetMeasured(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30986 154 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30987 154 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
30988 154 : int arg2 ;
30989 154 : void *argp1 = 0 ;
30990 154 : int res1 = 0 ;
30991 154 : int val2 ;
30992 154 : int ecode2 = 0 ;
30993 154 : PyObject *swig_obj[2] ;
30994 :
30995 154 : if (!SWIG_Python_UnpackTuple(args, "Geometry_SetMeasured", 2, 2, swig_obj)) SWIG_fail;
30996 154 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
30997 154 : if (!SWIG_IsOK(res1)) {
30998 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_SetMeasured" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
30999 : }
31000 154 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31001 154 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31002 154 : if (!SWIG_IsOK(ecode2)) {
31003 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_SetMeasured" "', argument " "2"" of type '" "int""'");
31004 : }
31005 154 : arg2 = static_cast< int >(val2);
31006 154 : {
31007 154 : const int bLocalUseExceptions = GetUseExceptions();
31008 154 : if ( bLocalUseExceptions ) {
31009 42 : pushErrorHandler();
31010 : }
31011 154 : {
31012 154 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31013 154 : OGRGeometryShadow_SetMeasured(arg1,arg2);
31014 154 : SWIG_PYTHON_THREAD_END_ALLOW;
31015 : }
31016 154 : if ( bLocalUseExceptions ) {
31017 42 : popErrorHandler();
31018 : }
31019 : #ifndef SED_HACKS
31020 : if ( bLocalUseExceptions ) {
31021 : CPLErr eclass = CPLGetLastErrorType();
31022 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31023 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31024 : }
31025 : }
31026 : #endif
31027 : }
31028 154 : resultobj = SWIG_Py_Void();
31029 154 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31030 : return resultobj;
31031 : fail:
31032 : return NULL;
31033 : }
31034 :
31035 :
31036 21 : SWIGINTERN PyObject *_wrap_Geometry_GetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31037 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31038 21 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31039 21 : void *argp1 = 0 ;
31040 21 : int res1 = 0 ;
31041 21 : PyObject *swig_obj[1] ;
31042 21 : int result;
31043 :
31044 21 : if (!args) SWIG_fail;
31045 21 : swig_obj[0] = args;
31046 21 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31047 21 : if (!SWIG_IsOK(res1)) {
31048 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetDimension" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31049 : }
31050 21 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31051 21 : {
31052 21 : const int bLocalUseExceptions = GetUseExceptions();
31053 21 : if ( bLocalUseExceptions ) {
31054 0 : pushErrorHandler();
31055 : }
31056 21 : {
31057 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31058 21 : result = (int)OGRGeometryShadow_GetDimension(arg1);
31059 21 : SWIG_PYTHON_THREAD_END_ALLOW;
31060 : }
31061 21 : if ( bLocalUseExceptions ) {
31062 0 : popErrorHandler();
31063 : }
31064 : #ifndef SED_HACKS
31065 : if ( bLocalUseExceptions ) {
31066 : CPLErr eclass = CPLGetLastErrorType();
31067 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31068 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31069 : }
31070 : }
31071 : #endif
31072 : }
31073 21 : resultobj = SWIG_From_int(static_cast< int >(result));
31074 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31075 : return resultobj;
31076 : fail:
31077 : return NULL;
31078 : }
31079 :
31080 :
31081 29 : SWIGINTERN PyObject *_wrap_Geometry_HasCurveGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31082 29 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31083 29 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31084 29 : int arg2 = (int) FALSE ;
31085 29 : void *argp1 = 0 ;
31086 29 : int res1 = 0 ;
31087 29 : int val2 ;
31088 29 : int ecode2 = 0 ;
31089 29 : PyObject *swig_obj[2] ;
31090 29 : int result;
31091 :
31092 29 : if (!SWIG_Python_UnpackTuple(args, "Geometry_HasCurveGeometry", 1, 2, swig_obj)) SWIG_fail;
31093 29 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31094 29 : if (!SWIG_IsOK(res1)) {
31095 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_HasCurveGeometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31096 : }
31097 29 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31098 29 : if (swig_obj[1]) {
31099 12 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31100 12 : if (!SWIG_IsOK(ecode2)) {
31101 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_HasCurveGeometry" "', argument " "2"" of type '" "int""'");
31102 : }
31103 : arg2 = static_cast< int >(val2);
31104 : }
31105 29 : {
31106 29 : const int bLocalUseExceptions = GetUseExceptions();
31107 29 : if ( bLocalUseExceptions ) {
31108 0 : pushErrorHandler();
31109 : }
31110 29 : {
31111 29 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31112 29 : result = (int)OGRGeometryShadow_HasCurveGeometry(arg1,arg2);
31113 29 : SWIG_PYTHON_THREAD_END_ALLOW;
31114 : }
31115 29 : if ( bLocalUseExceptions ) {
31116 0 : 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 29 : resultobj = SWIG_From_int(static_cast< int >(result));
31128 29 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31129 : return resultobj;
31130 : fail:
31131 : return NULL;
31132 : }
31133 :
31134 :
31135 3083 : SWIGINTERN PyObject *_wrap_Geometry_GetLinearGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31136 3083 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31137 3083 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31138 3083 : double arg2 = (double) 0.0 ;
31139 3083 : char **arg3 = (char **) NULL ;
31140 3083 : void *argp1 = 0 ;
31141 3083 : int res1 = 0 ;
31142 3083 : double val2 ;
31143 3083 : int ecode2 = 0 ;
31144 3083 : PyObject * obj0 = 0 ;
31145 3083 : PyObject * obj1 = 0 ;
31146 3083 : PyObject * obj2 = 0 ;
31147 3083 : char * kwnames[] = {
31148 : (char *)"self", (char *)"dfMaxAngleStepSizeDegrees", (char *)"options", NULL
31149 : };
31150 3083 : OGRGeometryShadow *result = 0 ;
31151 :
31152 3083 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:Geometry_GetLinearGeometry", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
31153 3083 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31154 3083 : if (!SWIG_IsOK(res1)) {
31155 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetLinearGeometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31156 : }
31157 3083 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31158 3083 : if (obj1) {
31159 17 : ecode2 = SWIG_AsVal_double(obj1, &val2);
31160 17 : if (!SWIG_IsOK(ecode2)) {
31161 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_GetLinearGeometry" "', argument " "2"" of type '" "double""'");
31162 : }
31163 17 : arg2 = static_cast< double >(val2);
31164 : }
31165 3083 : if (obj2) {
31166 4 : {
31167 : /* %typemap(in) char **dict */
31168 4 : arg3 = NULL;
31169 4 : if ( PySequence_Check( obj2 ) ) {
31170 4 : int bErr = FALSE;
31171 4 : arg3 = CSLFromPySequence(obj2, &bErr);
31172 4 : if ( bErr )
31173 : {
31174 0 : SWIG_fail;
31175 : }
31176 : }
31177 0 : else if ( PyMapping_Check( obj2 ) ) {
31178 0 : int bErr = FALSE;
31179 0 : arg3 = CSLFromPyMapping(obj2, &bErr);
31180 0 : if ( bErr )
31181 : {
31182 0 : SWIG_fail;
31183 : }
31184 : }
31185 : else {
31186 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
31187 0 : SWIG_fail;
31188 : }
31189 : }
31190 : }
31191 3083 : {
31192 3083 : const int bLocalUseExceptions = GetUseExceptions();
31193 3083 : if ( bLocalUseExceptions ) {
31194 0 : pushErrorHandler();
31195 : }
31196 3083 : {
31197 3083 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31198 3083 : result = (OGRGeometryShadow *)OGRGeometryShadow_GetLinearGeometry(arg1,arg2,arg3);
31199 3083 : SWIG_PYTHON_THREAD_END_ALLOW;
31200 : }
31201 3083 : if ( bLocalUseExceptions ) {
31202 0 : popErrorHandler();
31203 : }
31204 : #ifndef SED_HACKS
31205 : if ( bLocalUseExceptions ) {
31206 : CPLErr eclass = CPLGetLastErrorType();
31207 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31208 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31209 : }
31210 : }
31211 : #endif
31212 : }
31213 3083 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
31214 3083 : {
31215 : /* %typemap(freearg) char **dict */
31216 3083 : CSLDestroy( arg3 );
31217 : }
31218 3083 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31219 : return resultobj;
31220 0 : fail:
31221 0 : {
31222 : /* %typemap(freearg) char **dict */
31223 0 : CSLDestroy( arg3 );
31224 : }
31225 : return NULL;
31226 : }
31227 :
31228 :
31229 3064 : SWIGINTERN PyObject *_wrap_Geometry_GetCurveGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31230 3064 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31231 3064 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31232 3064 : char **arg2 = (char **) NULL ;
31233 3064 : void *argp1 = 0 ;
31234 3064 : int res1 = 0 ;
31235 3064 : PyObject * obj0 = 0 ;
31236 3064 : PyObject * obj1 = 0 ;
31237 3064 : char * kwnames[] = {
31238 : (char *)"self", (char *)"options", NULL
31239 : };
31240 3064 : OGRGeometryShadow *result = 0 ;
31241 :
31242 3064 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Geometry_GetCurveGeometry", kwnames, &obj0, &obj1)) SWIG_fail;
31243 3064 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31244 3064 : if (!SWIG_IsOK(res1)) {
31245 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetCurveGeometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31246 : }
31247 3064 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31248 3064 : if (obj1) {
31249 0 : {
31250 : /* %typemap(in) char **dict */
31251 0 : arg2 = NULL;
31252 0 : if ( PySequence_Check( obj1 ) ) {
31253 0 : int bErr = FALSE;
31254 0 : arg2 = CSLFromPySequence(obj1, &bErr);
31255 0 : if ( bErr )
31256 : {
31257 0 : SWIG_fail;
31258 : }
31259 : }
31260 0 : else if ( PyMapping_Check( obj1 ) ) {
31261 0 : int bErr = FALSE;
31262 0 : arg2 = CSLFromPyMapping(obj1, &bErr);
31263 0 : if ( bErr )
31264 : {
31265 0 : SWIG_fail;
31266 : }
31267 : }
31268 : else {
31269 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
31270 0 : SWIG_fail;
31271 : }
31272 : }
31273 : }
31274 3064 : {
31275 3064 : const int bLocalUseExceptions = GetUseExceptions();
31276 3064 : if ( bLocalUseExceptions ) {
31277 0 : pushErrorHandler();
31278 : }
31279 3064 : {
31280 3064 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31281 3064 : result = (OGRGeometryShadow *)OGRGeometryShadow_GetCurveGeometry(arg1,arg2);
31282 3064 : SWIG_PYTHON_THREAD_END_ALLOW;
31283 : }
31284 3064 : if ( bLocalUseExceptions ) {
31285 0 : popErrorHandler();
31286 : }
31287 : #ifndef SED_HACKS
31288 : if ( bLocalUseExceptions ) {
31289 : CPLErr eclass = CPLGetLastErrorType();
31290 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31291 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31292 : }
31293 : }
31294 : #endif
31295 : }
31296 3064 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
31297 3064 : {
31298 : /* %typemap(freearg) char **dict */
31299 3064 : CSLDestroy( arg2 );
31300 : }
31301 3064 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31302 : return resultobj;
31303 0 : fail:
31304 0 : {
31305 : /* %typemap(freearg) char **dict */
31306 0 : CSLDestroy( arg2 );
31307 : }
31308 : return NULL;
31309 : }
31310 :
31311 :
31312 22 : SWIGINTERN PyObject *_wrap_Geometry_Value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31313 22 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31314 22 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31315 22 : double arg2 ;
31316 22 : void *argp1 = 0 ;
31317 22 : int res1 = 0 ;
31318 22 : double val2 ;
31319 22 : int ecode2 = 0 ;
31320 22 : PyObject *swig_obj[2] ;
31321 22 : OGRGeometryShadow *result = 0 ;
31322 :
31323 22 : if (!SWIG_Python_UnpackTuple(args, "Geometry_Value", 2, 2, swig_obj)) SWIG_fail;
31324 22 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31325 22 : if (!SWIG_IsOK(res1)) {
31326 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Value" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31327 : }
31328 22 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31329 22 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
31330 22 : if (!SWIG_IsOK(ecode2)) {
31331 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Geometry_Value" "', argument " "2"" of type '" "double""'");
31332 : }
31333 22 : arg2 = static_cast< double >(val2);
31334 22 : {
31335 22 : const int bLocalUseExceptions = GetUseExceptions();
31336 22 : if ( bLocalUseExceptions ) {
31337 0 : pushErrorHandler();
31338 : }
31339 22 : {
31340 22 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31341 22 : result = (OGRGeometryShadow *)OGRGeometryShadow_Value(arg1,arg2);
31342 22 : SWIG_PYTHON_THREAD_END_ALLOW;
31343 : }
31344 22 : if ( bLocalUseExceptions ) {
31345 0 : popErrorHandler();
31346 : }
31347 : #ifndef SED_HACKS
31348 : if ( bLocalUseExceptions ) {
31349 : CPLErr eclass = CPLGetLastErrorType();
31350 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31351 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31352 : }
31353 : }
31354 : #endif
31355 : }
31356 22 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
31357 22 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31358 : return resultobj;
31359 : fail:
31360 : return NULL;
31361 : }
31362 :
31363 :
31364 : SWIGINTERN PyObject *_wrap_Geometry_Transform__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
31365 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31366 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31367 : OGRGeomTransformerShadow *arg2 = (OGRGeomTransformerShadow *) 0 ;
31368 : void *argp1 = 0 ;
31369 : int res1 = 0 ;
31370 : void *argp2 = 0 ;
31371 : int res2 = 0 ;
31372 : OGRGeometryShadow *result = 0 ;
31373 :
31374 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31375 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31376 : if (!SWIG_IsOK(res1)) {
31377 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_Transform" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31378 : }
31379 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31380 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeomTransformerShadow, 0 | 0 );
31381 : if (!SWIG_IsOK(res2)) {
31382 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_Transform" "', argument " "2"" of type '" "OGRGeomTransformerShadow *""'");
31383 : }
31384 : arg2 = reinterpret_cast< OGRGeomTransformerShadow * >(argp2);
31385 : {
31386 : if (!arg2) {
31387 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
31388 : }
31389 : }
31390 : {
31391 : const int bLocalUseExceptions = GetUseExceptions();
31392 : if ( bLocalUseExceptions ) {
31393 : pushErrorHandler();
31394 : }
31395 : {
31396 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31397 : result = (OGRGeometryShadow *)OGRGeometryShadow_Transform__SWIG_1(arg1,arg2);
31398 : SWIG_PYTHON_THREAD_END_ALLOW;
31399 : }
31400 : if ( bLocalUseExceptions ) {
31401 : popErrorHandler();
31402 : }
31403 : #ifndef SED_HACKS
31404 : if ( bLocalUseExceptions ) {
31405 : CPLErr eclass = CPLGetLastErrorType();
31406 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31407 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31408 : }
31409 : }
31410 : #endif
31411 : }
31412 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
31413 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31414 : return resultobj;
31415 : fail:
31416 : return NULL;
31417 : }
31418 :
31419 :
31420 7 : SWIGINTERN PyObject *_wrap_Geometry_Transform(PyObject *self, PyObject *args) {
31421 7 : Py_ssize_t argc;
31422 7 : PyObject *argv[3] = {
31423 : 0
31424 : };
31425 :
31426 7 : if (!(argc = SWIG_Python_UnpackTuple(args, "Geometry_Transform", 0, 2, argv))) SWIG_fail;
31427 7 : --argc;
31428 7 : if (argc == 2) {
31429 7 : int _v;
31430 7 : void *vptr = 0;
31431 7 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
31432 11 : _v = SWIG_CheckState(res);
31433 7 : if (_v) {
31434 7 : void *vptr = 0;
31435 7 : int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_OSRCoordinateTransformationShadow, 0);
31436 7 : _v = SWIG_CheckState(res);
31437 4 : if (_v) {
31438 3 : return _wrap_Geometry_Transform__SWIG_0(self, argc, argv);
31439 : }
31440 : }
31441 : }
31442 4 : if (argc == 2) {
31443 4 : int _v;
31444 4 : void *vptr = 0;
31445 4 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRGeometryShadow, 0);
31446 4 : _v = SWIG_CheckState(res);
31447 4 : if (_v) {
31448 4 : void *vptr = 0;
31449 4 : int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_OGRGeomTransformerShadow, 0);
31450 4 : _v = SWIG_CheckState(res);
31451 0 : if (_v) {
31452 4 : return _wrap_Geometry_Transform__SWIG_1(self, argc, argv);
31453 : }
31454 : }
31455 : }
31456 :
31457 0 : fail:
31458 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Geometry_Transform'.\n"
31459 : " Possible C/C++ prototypes are:\n"
31460 : " OGRGeometryShadow::Transform(OSRCoordinateTransformationShadow *)\n"
31461 : " OGRGeometryShadow::Transform(OGRGeomTransformerShadow *)\n");
31462 : return 0;
31463 : }
31464 :
31465 :
31466 1 : SWIGINTERN PyObject *_wrap_Geometry_CreatePreparedGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31467 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31468 1 : OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
31469 1 : void *argp1 = 0 ;
31470 1 : int res1 = 0 ;
31471 1 : PyObject *swig_obj[1] ;
31472 1 : OGRPreparedGeometryShadow *result = 0 ;
31473 :
31474 1 : if (!args) SWIG_fail;
31475 1 : swig_obj[0] = args;
31476 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31477 1 : if (!SWIG_IsOK(res1)) {
31478 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_CreatePreparedGeometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'");
31479 : }
31480 1 : arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
31481 1 : {
31482 1 : const int bLocalUseExceptions = GetUseExceptions();
31483 1 : if ( bLocalUseExceptions ) {
31484 1 : pushErrorHandler();
31485 : }
31486 1 : {
31487 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31488 1 : result = (OGRPreparedGeometryShadow *)OGRGeometryShadow_CreatePreparedGeometry(arg1);
31489 1 : SWIG_PYTHON_THREAD_END_ALLOW;
31490 : }
31491 1 : if ( bLocalUseExceptions ) {
31492 1 : popErrorHandler();
31493 : }
31494 : #ifndef SED_HACKS
31495 : if ( bLocalUseExceptions ) {
31496 : CPLErr eclass = CPLGetLastErrorType();
31497 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31498 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31499 : }
31500 : }
31501 : #endif
31502 : }
31503 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRPreparedGeometryShadow, SWIG_POINTER_OWN | 0 );
31504 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31505 : return resultobj;
31506 : fail:
31507 : return NULL;
31508 : }
31509 :
31510 :
31511 275 : SWIGINTERN PyObject *Geometry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31512 275 : PyObject *obj;
31513 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
31514 275 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRGeometryShadow, SWIG_NewClientData(obj));
31515 275 : return SWIG_Py_Void();
31516 : }
31517 :
31518 160958 : SWIGINTERN PyObject *Geometry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31519 160958 : return SWIG_Python_InitShadowInstance(args);
31520 : }
31521 :
31522 1 : SWIGINTERN PyObject *_wrap_delete_PreparedGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31523 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31524 1 : OGRPreparedGeometryShadow *arg1 = (OGRPreparedGeometryShadow *) 0 ;
31525 1 : void *argp1 = 0 ;
31526 1 : int res1 = 0 ;
31527 1 : PyObject *swig_obj[1] ;
31528 :
31529 1 : if (!args) SWIG_fail;
31530 1 : swig_obj[0] = args;
31531 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRPreparedGeometryShadow, SWIG_POINTER_DISOWN | 0 );
31532 1 : if (!SWIG_IsOK(res1)) {
31533 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PreparedGeometry" "', argument " "1"" of type '" "OGRPreparedGeometryShadow *""'");
31534 : }
31535 1 : arg1 = reinterpret_cast< OGRPreparedGeometryShadow * >(argp1);
31536 1 : {
31537 1 : const int bLocalUseExceptions = GetUseExceptions();
31538 1 : if ( bLocalUseExceptions ) {
31539 1 : pushErrorHandler();
31540 : }
31541 1 : {
31542 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31543 1 : delete_OGRPreparedGeometryShadow(arg1);
31544 1 : SWIG_PYTHON_THREAD_END_ALLOW;
31545 : }
31546 1 : if ( bLocalUseExceptions ) {
31547 1 : popErrorHandler();
31548 : }
31549 : #ifndef SED_HACKS
31550 : if ( bLocalUseExceptions ) {
31551 : CPLErr eclass = CPLGetLastErrorType();
31552 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31553 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31554 : }
31555 : }
31556 : #endif
31557 : }
31558 1 : resultobj = SWIG_Py_Void();
31559 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31560 : return resultobj;
31561 : fail:
31562 : return NULL;
31563 : }
31564 :
31565 :
31566 3 : SWIGINTERN PyObject *_wrap_PreparedGeometry_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31567 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31568 3 : OGRPreparedGeometryShadow *arg1 = (OGRPreparedGeometryShadow *) 0 ;
31569 3 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
31570 3 : void *argp1 = 0 ;
31571 3 : int res1 = 0 ;
31572 3 : void *argp2 = 0 ;
31573 3 : int res2 = 0 ;
31574 3 : PyObject *swig_obj[2] ;
31575 3 : bool result;
31576 :
31577 3 : if (!SWIG_Python_UnpackTuple(args, "PreparedGeometry_Intersects", 2, 2, swig_obj)) SWIG_fail;
31578 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRPreparedGeometryShadow, 0 | 0 );
31579 3 : if (!SWIG_IsOK(res1)) {
31580 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PreparedGeometry_Intersects" "', argument " "1"" of type '" "OGRPreparedGeometryShadow *""'");
31581 : }
31582 3 : arg1 = reinterpret_cast< OGRPreparedGeometryShadow * >(argp1);
31583 3 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31584 3 : if (!SWIG_IsOK(res2)) {
31585 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PreparedGeometry_Intersects" "', argument " "2"" of type '" "OGRGeometryShadow const *""'");
31586 : }
31587 3 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
31588 3 : {
31589 3 : if (!arg2) {
31590 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
31591 : }
31592 : }
31593 3 : {
31594 3 : const int bLocalUseExceptions = GetUseExceptions();
31595 3 : if ( bLocalUseExceptions ) {
31596 3 : pushErrorHandler();
31597 : }
31598 3 : {
31599 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31600 3 : result = (bool)OGRPreparedGeometryShadow_Intersects(arg1,(OGRGeometryShadow const *)arg2);
31601 3 : SWIG_PYTHON_THREAD_END_ALLOW;
31602 : }
31603 3 : if ( bLocalUseExceptions ) {
31604 3 : popErrorHandler();
31605 : }
31606 : #ifndef SED_HACKS
31607 : if ( bLocalUseExceptions ) {
31608 : CPLErr eclass = CPLGetLastErrorType();
31609 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31610 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31611 : }
31612 : }
31613 : #endif
31614 : }
31615 3 : resultobj = SWIG_From_bool(static_cast< bool >(result));
31616 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31617 : return resultobj;
31618 : fail:
31619 : return NULL;
31620 : }
31621 :
31622 :
31623 3 : SWIGINTERN PyObject *_wrap_PreparedGeometry_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31624 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31625 3 : OGRPreparedGeometryShadow *arg1 = (OGRPreparedGeometryShadow *) 0 ;
31626 3 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
31627 3 : void *argp1 = 0 ;
31628 3 : int res1 = 0 ;
31629 3 : void *argp2 = 0 ;
31630 3 : int res2 = 0 ;
31631 3 : PyObject *swig_obj[2] ;
31632 3 : bool result;
31633 :
31634 3 : if (!SWIG_Python_UnpackTuple(args, "PreparedGeometry_Contains", 2, 2, swig_obj)) SWIG_fail;
31635 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRPreparedGeometryShadow, 0 | 0 );
31636 3 : if (!SWIG_IsOK(res1)) {
31637 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PreparedGeometry_Contains" "', argument " "1"" of type '" "OGRPreparedGeometryShadow *""'");
31638 : }
31639 3 : arg1 = reinterpret_cast< OGRPreparedGeometryShadow * >(argp1);
31640 3 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31641 3 : if (!SWIG_IsOK(res2)) {
31642 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PreparedGeometry_Contains" "', argument " "2"" of type '" "OGRGeometryShadow const *""'");
31643 : }
31644 3 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
31645 3 : {
31646 3 : if (!arg2) {
31647 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
31648 : }
31649 : }
31650 3 : {
31651 3 : const int bLocalUseExceptions = GetUseExceptions();
31652 3 : if ( bLocalUseExceptions ) {
31653 3 : pushErrorHandler();
31654 : }
31655 3 : {
31656 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31657 3 : result = (bool)OGRPreparedGeometryShadow_Contains(arg1,(OGRGeometryShadow const *)arg2);
31658 3 : SWIG_PYTHON_THREAD_END_ALLOW;
31659 : }
31660 3 : if ( bLocalUseExceptions ) {
31661 3 : popErrorHandler();
31662 : }
31663 : #ifndef SED_HACKS
31664 : if ( bLocalUseExceptions ) {
31665 : CPLErr eclass = CPLGetLastErrorType();
31666 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31667 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31668 : }
31669 : }
31670 : #endif
31671 : }
31672 3 : resultobj = SWIG_From_bool(static_cast< bool >(result));
31673 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31674 : return resultobj;
31675 : fail:
31676 : return NULL;
31677 : }
31678 :
31679 :
31680 275 : SWIGINTERN PyObject *PreparedGeometry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31681 275 : PyObject *obj;
31682 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
31683 275 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRPreparedGeometryShadow, SWIG_NewClientData(obj));
31684 275 : return SWIG_Py_Void();
31685 : }
31686 :
31687 6 : SWIGINTERN PyObject *_wrap_new_GeomTransformer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31688 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31689 6 : OSRCoordinateTransformationShadow *arg1 = (OSRCoordinateTransformationShadow *) 0 ;
31690 6 : char **arg2 = (char **) NULL ;
31691 6 : void *argp1 = 0 ;
31692 6 : int res1 = 0 ;
31693 6 : PyObject *swig_obj[2] ;
31694 6 : OGRGeomTransformerShadow *result = 0 ;
31695 :
31696 6 : if (!SWIG_Python_UnpackTuple(args, "new_GeomTransformer", 1, 2, swig_obj)) SWIG_fail;
31697 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSRCoordinateTransformationShadow, 0 | 0 );
31698 6 : if (!SWIG_IsOK(res1)) {
31699 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GeomTransformer" "', argument " "1"" of type '" "OSRCoordinateTransformationShadow *""'");
31700 : }
31701 6 : arg1 = reinterpret_cast< OSRCoordinateTransformationShadow * >(argp1);
31702 6 : if (swig_obj[1]) {
31703 4 : {
31704 : /* %typemap(in) char **dict */
31705 4 : arg2 = NULL;
31706 4 : if ( PySequence_Check( swig_obj[1] ) ) {
31707 4 : int bErr = FALSE;
31708 4 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
31709 4 : if ( bErr )
31710 : {
31711 0 : SWIG_fail;
31712 : }
31713 : }
31714 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
31715 0 : int bErr = FALSE;
31716 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
31717 0 : if ( bErr )
31718 : {
31719 0 : SWIG_fail;
31720 : }
31721 : }
31722 : else {
31723 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
31724 0 : SWIG_fail;
31725 : }
31726 : }
31727 : }
31728 6 : {
31729 6 : const int bLocalUseExceptions = GetUseExceptions();
31730 6 : if ( bLocalUseExceptions ) {
31731 0 : pushErrorHandler();
31732 : }
31733 6 : {
31734 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31735 6 : result = (OGRGeomTransformerShadow *)new_OGRGeomTransformerShadow(arg1,arg2);
31736 6 : SWIG_PYTHON_THREAD_END_ALLOW;
31737 : }
31738 6 : if ( bLocalUseExceptions ) {
31739 0 : popErrorHandler();
31740 : }
31741 : #ifndef SED_HACKS
31742 : if ( bLocalUseExceptions ) {
31743 : CPLErr eclass = CPLGetLastErrorType();
31744 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31745 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31746 : }
31747 : }
31748 : #endif
31749 : }
31750 6 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeomTransformerShadow, SWIG_POINTER_NEW | 0 );
31751 6 : {
31752 : /* %typemap(freearg) char **dict */
31753 6 : CSLDestroy( arg2 );
31754 : }
31755 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31756 : return resultobj;
31757 0 : fail:
31758 0 : {
31759 : /* %typemap(freearg) char **dict */
31760 0 : CSLDestroy( arg2 );
31761 : }
31762 : return NULL;
31763 : }
31764 :
31765 :
31766 6 : SWIGINTERN PyObject *_wrap_delete_GeomTransformer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31767 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31768 6 : OGRGeomTransformerShadow *arg1 = (OGRGeomTransformerShadow *) 0 ;
31769 6 : void *argp1 = 0 ;
31770 6 : int res1 = 0 ;
31771 6 : PyObject *swig_obj[1] ;
31772 :
31773 6 : if (!args) SWIG_fail;
31774 6 : swig_obj[0] = args;
31775 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomTransformerShadow, SWIG_POINTER_DISOWN | 0 );
31776 6 : if (!SWIG_IsOK(res1)) {
31777 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeomTransformer" "', argument " "1"" of type '" "OGRGeomTransformerShadow *""'");
31778 : }
31779 6 : arg1 = reinterpret_cast< OGRGeomTransformerShadow * >(argp1);
31780 6 : {
31781 6 : const int bLocalUseExceptions = GetUseExceptions();
31782 6 : if ( bLocalUseExceptions ) {
31783 0 : pushErrorHandler();
31784 : }
31785 6 : {
31786 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31787 6 : delete_OGRGeomTransformerShadow(arg1);
31788 6 : SWIG_PYTHON_THREAD_END_ALLOW;
31789 : }
31790 6 : if ( bLocalUseExceptions ) {
31791 0 : popErrorHandler();
31792 : }
31793 : #ifndef SED_HACKS
31794 : if ( bLocalUseExceptions ) {
31795 : CPLErr eclass = CPLGetLastErrorType();
31796 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31797 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31798 : }
31799 : }
31800 : #endif
31801 : }
31802 6 : resultobj = SWIG_Py_Void();
31803 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31804 : return resultobj;
31805 : fail:
31806 : return NULL;
31807 : }
31808 :
31809 :
31810 2 : SWIGINTERN PyObject *_wrap_GeomTransformer_Transform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31811 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31812 2 : OGRGeomTransformerShadow *arg1 = (OGRGeomTransformerShadow *) 0 ;
31813 2 : OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
31814 2 : void *argp1 = 0 ;
31815 2 : int res1 = 0 ;
31816 2 : void *argp2 = 0 ;
31817 2 : int res2 = 0 ;
31818 2 : PyObject *swig_obj[2] ;
31819 2 : OGRGeometryShadow *result = 0 ;
31820 :
31821 2 : if (!SWIG_Python_UnpackTuple(args, "GeomTransformer_Transform", 2, 2, swig_obj)) SWIG_fail;
31822 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomTransformerShadow, 0 | 0 );
31823 2 : if (!SWIG_IsOK(res1)) {
31824 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomTransformer_Transform" "', argument " "1"" of type '" "OGRGeomTransformerShadow *""'");
31825 : }
31826 2 : arg1 = reinterpret_cast< OGRGeomTransformerShadow * >(argp1);
31827 2 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
31828 2 : if (!SWIG_IsOK(res2)) {
31829 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomTransformer_Transform" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
31830 : }
31831 2 : arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
31832 2 : {
31833 2 : if (!arg2) {
31834 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
31835 : }
31836 : }
31837 2 : {
31838 2 : const int bLocalUseExceptions = GetUseExceptions();
31839 2 : if ( bLocalUseExceptions ) {
31840 0 : pushErrorHandler();
31841 : }
31842 2 : {
31843 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31844 2 : result = (OGRGeometryShadow *)OGRGeomTransformerShadow_Transform(arg1,arg2);
31845 2 : SWIG_PYTHON_THREAD_END_ALLOW;
31846 : }
31847 2 : if ( bLocalUseExceptions ) {
31848 0 : popErrorHandler();
31849 : }
31850 : #ifndef SED_HACKS
31851 : if ( bLocalUseExceptions ) {
31852 : CPLErr eclass = CPLGetLastErrorType();
31853 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31854 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31855 : }
31856 : }
31857 : #endif
31858 : }
31859 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN | 0 );
31860 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31861 : return resultobj;
31862 : fail:
31863 : return NULL;
31864 : }
31865 :
31866 :
31867 275 : SWIGINTERN PyObject *GeomTransformer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31868 275 : PyObject *obj;
31869 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
31870 275 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRGeomTransformerShadow, SWIG_NewClientData(obj));
31871 275 : return SWIG_Py_Void();
31872 : }
31873 :
31874 6 : SWIGINTERN PyObject *GeomTransformer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31875 6 : return SWIG_Python_InitShadowInstance(args);
31876 : }
31877 :
31878 44 : SWIGINTERN PyObject *_wrap_delete_FieldDomain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31879 44 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31880 44 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
31881 44 : void *argp1 = 0 ;
31882 44 : int res1 = 0 ;
31883 44 : PyObject *swig_obj[1] ;
31884 :
31885 44 : if (!args) SWIG_fail;
31886 44 : swig_obj[0] = args;
31887 44 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, SWIG_POINTER_DISOWN | 0 );
31888 44 : if (!SWIG_IsOK(res1)) {
31889 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FieldDomain" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
31890 : }
31891 44 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
31892 44 : {
31893 44 : const int bLocalUseExceptions = GetUseExceptions();
31894 44 : if ( bLocalUseExceptions ) {
31895 23 : pushErrorHandler();
31896 : }
31897 44 : {
31898 44 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31899 44 : delete_OGRFieldDomainShadow(arg1);
31900 44 : SWIG_PYTHON_THREAD_END_ALLOW;
31901 : }
31902 44 : if ( bLocalUseExceptions ) {
31903 23 : popErrorHandler();
31904 : }
31905 : #ifndef SED_HACKS
31906 : if ( bLocalUseExceptions ) {
31907 : CPLErr eclass = CPLGetLastErrorType();
31908 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31909 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31910 : }
31911 : }
31912 : #endif
31913 : }
31914 44 : resultobj = SWIG_Py_Void();
31915 44 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31916 : return resultobj;
31917 : fail:
31918 : return NULL;
31919 : }
31920 :
31921 :
31922 57 : SWIGINTERN PyObject *_wrap_FieldDomain_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31923 57 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31924 57 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
31925 57 : void *argp1 = 0 ;
31926 57 : int res1 = 0 ;
31927 57 : PyObject *swig_obj[1] ;
31928 57 : char *result = 0 ;
31929 :
31930 57 : if (!args) SWIG_fail;
31931 57 : swig_obj[0] = args;
31932 57 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
31933 57 : if (!SWIG_IsOK(res1)) {
31934 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetName" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
31935 : }
31936 57 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
31937 57 : {
31938 57 : const int bLocalUseExceptions = GetUseExceptions();
31939 57 : if ( bLocalUseExceptions ) {
31940 45 : pushErrorHandler();
31941 : }
31942 57 : {
31943 57 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31944 57 : result = (char *)OGRFieldDomainShadow_GetName(arg1);
31945 57 : SWIG_PYTHON_THREAD_END_ALLOW;
31946 : }
31947 57 : if ( bLocalUseExceptions ) {
31948 45 : popErrorHandler();
31949 : }
31950 : #ifndef SED_HACKS
31951 : if ( bLocalUseExceptions ) {
31952 : CPLErr eclass = CPLGetLastErrorType();
31953 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31954 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31955 : }
31956 : }
31957 : #endif
31958 : }
31959 57 : resultobj = SWIG_FromCharPtr((const char *)result);
31960 57 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
31961 : return resultobj;
31962 : fail:
31963 : return NULL;
31964 : }
31965 :
31966 :
31967 61 : SWIGINTERN PyObject *_wrap_FieldDomain_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31968 61 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31969 61 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
31970 61 : void *argp1 = 0 ;
31971 61 : int res1 = 0 ;
31972 61 : PyObject *swig_obj[1] ;
31973 61 : char *result = 0 ;
31974 :
31975 61 : if (!args) SWIG_fail;
31976 61 : swig_obj[0] = args;
31977 61 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
31978 61 : if (!SWIG_IsOK(res1)) {
31979 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetDescription" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
31980 : }
31981 61 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
31982 61 : {
31983 61 : const int bLocalUseExceptions = GetUseExceptions();
31984 61 : if ( bLocalUseExceptions ) {
31985 47 : pushErrorHandler();
31986 : }
31987 61 : {
31988 61 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31989 61 : result = (char *)OGRFieldDomainShadow_GetDescription(arg1);
31990 61 : SWIG_PYTHON_THREAD_END_ALLOW;
31991 : }
31992 61 : if ( bLocalUseExceptions ) {
31993 47 : popErrorHandler();
31994 : }
31995 : #ifndef SED_HACKS
31996 : if ( bLocalUseExceptions ) {
31997 : CPLErr eclass = CPLGetLastErrorType();
31998 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31999 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32000 : }
32001 : }
32002 : #endif
32003 : }
32004 61 : resultobj = SWIG_FromCharPtr((const char *)result);
32005 61 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32006 : return resultobj;
32007 : fail:
32008 : return NULL;
32009 : }
32010 :
32011 :
32012 60 : SWIGINTERN PyObject *_wrap_FieldDomain_GetFieldType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32013 60 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32014 60 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32015 60 : void *argp1 = 0 ;
32016 60 : int res1 = 0 ;
32017 60 : PyObject *swig_obj[1] ;
32018 60 : OGRFieldType result;
32019 :
32020 60 : if (!args) SWIG_fail;
32021 60 : swig_obj[0] = args;
32022 60 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32023 60 : if (!SWIG_IsOK(res1)) {
32024 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetFieldType" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32025 : }
32026 60 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32027 60 : {
32028 60 : const int bLocalUseExceptions = GetUseExceptions();
32029 60 : if ( bLocalUseExceptions ) {
32030 39 : pushErrorHandler();
32031 : }
32032 60 : {
32033 60 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32034 60 : result = (OGRFieldType)OGRFieldDomainShadow_GetFieldType(arg1);
32035 60 : SWIG_PYTHON_THREAD_END_ALLOW;
32036 : }
32037 60 : if ( bLocalUseExceptions ) {
32038 39 : popErrorHandler();
32039 : }
32040 : #ifndef SED_HACKS
32041 : if ( bLocalUseExceptions ) {
32042 : CPLErr eclass = CPLGetLastErrorType();
32043 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32044 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32045 : }
32046 : }
32047 : #endif
32048 : }
32049 60 : resultobj = SWIG_From_int(static_cast< int >(result));
32050 60 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32051 : return resultobj;
32052 : fail:
32053 : return NULL;
32054 : }
32055 :
32056 :
32057 40 : SWIGINTERN PyObject *_wrap_FieldDomain_GetFieldSubType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32058 40 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32059 40 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32060 40 : void *argp1 = 0 ;
32061 40 : int res1 = 0 ;
32062 40 : PyObject *swig_obj[1] ;
32063 40 : OGRFieldSubType result;
32064 :
32065 40 : if (!args) SWIG_fail;
32066 40 : swig_obj[0] = args;
32067 40 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32068 40 : if (!SWIG_IsOK(res1)) {
32069 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetFieldSubType" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32070 : }
32071 40 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32072 40 : {
32073 40 : const int bLocalUseExceptions = GetUseExceptions();
32074 40 : if ( bLocalUseExceptions ) {
32075 35 : pushErrorHandler();
32076 : }
32077 40 : {
32078 40 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32079 40 : result = (OGRFieldSubType)OGRFieldDomainShadow_GetFieldSubType(arg1);
32080 40 : SWIG_PYTHON_THREAD_END_ALLOW;
32081 : }
32082 40 : if ( bLocalUseExceptions ) {
32083 35 : popErrorHandler();
32084 : }
32085 : #ifndef SED_HACKS
32086 : if ( bLocalUseExceptions ) {
32087 : CPLErr eclass = CPLGetLastErrorType();
32088 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32089 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32090 : }
32091 : }
32092 : #endif
32093 : }
32094 40 : resultobj = SWIG_From_int(static_cast< int >(result));
32095 40 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32096 : return resultobj;
32097 : fail:
32098 : return NULL;
32099 : }
32100 :
32101 :
32102 54 : SWIGINTERN PyObject *_wrap_FieldDomain_GetDomainType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32103 54 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32104 54 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32105 54 : void *argp1 = 0 ;
32106 54 : int res1 = 0 ;
32107 54 : PyObject *swig_obj[1] ;
32108 54 : OGRFieldDomainType result;
32109 :
32110 54 : if (!args) SWIG_fail;
32111 54 : swig_obj[0] = args;
32112 54 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32113 54 : if (!SWIG_IsOK(res1)) {
32114 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetDomainType" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32115 : }
32116 54 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32117 54 : {
32118 54 : const int bLocalUseExceptions = GetUseExceptions();
32119 54 : if ( bLocalUseExceptions ) {
32120 42 : pushErrorHandler();
32121 : }
32122 54 : {
32123 54 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32124 54 : result = (OGRFieldDomainType)OGRFieldDomainShadow_GetDomainType(arg1);
32125 54 : SWIG_PYTHON_THREAD_END_ALLOW;
32126 : }
32127 54 : if ( bLocalUseExceptions ) {
32128 42 : popErrorHandler();
32129 : }
32130 : #ifndef SED_HACKS
32131 : if ( bLocalUseExceptions ) {
32132 : CPLErr eclass = CPLGetLastErrorType();
32133 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32134 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32135 : }
32136 : }
32137 : #endif
32138 : }
32139 54 : resultobj = SWIG_From_int(static_cast< int >(result));
32140 54 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32141 : return resultobj;
32142 : fail:
32143 : return NULL;
32144 : }
32145 :
32146 :
32147 2 : SWIGINTERN PyObject *_wrap_FieldDomain_GetSplitPolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32148 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32149 2 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32150 2 : void *argp1 = 0 ;
32151 2 : int res1 = 0 ;
32152 2 : PyObject *swig_obj[1] ;
32153 2 : OGRFieldDomainSplitPolicy result;
32154 :
32155 2 : if (!args) SWIG_fail;
32156 2 : swig_obj[0] = args;
32157 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32158 2 : if (!SWIG_IsOK(res1)) {
32159 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetSplitPolicy" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32160 : }
32161 2 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32162 2 : {
32163 2 : const int bLocalUseExceptions = GetUseExceptions();
32164 2 : if ( bLocalUseExceptions ) {
32165 2 : pushErrorHandler();
32166 : }
32167 2 : {
32168 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32169 2 : result = (OGRFieldDomainSplitPolicy)OGRFieldDomainShadow_GetSplitPolicy(arg1);
32170 2 : SWIG_PYTHON_THREAD_END_ALLOW;
32171 : }
32172 2 : if ( bLocalUseExceptions ) {
32173 2 : popErrorHandler();
32174 : }
32175 : #ifndef SED_HACKS
32176 : if ( bLocalUseExceptions ) {
32177 : CPLErr eclass = CPLGetLastErrorType();
32178 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32179 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32180 : }
32181 : }
32182 : #endif
32183 : }
32184 2 : resultobj = SWIG_From_int(static_cast< int >(result));
32185 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32186 : return resultobj;
32187 : fail:
32188 : return NULL;
32189 : }
32190 :
32191 :
32192 1 : SWIGINTERN PyObject *_wrap_FieldDomain_SetSplitPolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32193 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32194 1 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32195 1 : OGRFieldDomainSplitPolicy arg2 ;
32196 1 : void *argp1 = 0 ;
32197 1 : int res1 = 0 ;
32198 1 : int val2 ;
32199 1 : int ecode2 = 0 ;
32200 1 : PyObject *swig_obj[2] ;
32201 :
32202 1 : if (!SWIG_Python_UnpackTuple(args, "FieldDomain_SetSplitPolicy", 2, 2, swig_obj)) SWIG_fail;
32203 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32204 1 : if (!SWIG_IsOK(res1)) {
32205 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_SetSplitPolicy" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32206 : }
32207 1 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32208 1 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
32209 1 : if (!SWIG_IsOK(ecode2)) {
32210 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDomain_SetSplitPolicy" "', argument " "2"" of type '" "OGRFieldDomainSplitPolicy""'");
32211 : }
32212 1 : arg2 = static_cast< OGRFieldDomainSplitPolicy >(val2);
32213 1 : {
32214 1 : const int bLocalUseExceptions = GetUseExceptions();
32215 1 : if ( bLocalUseExceptions ) {
32216 1 : pushErrorHandler();
32217 : }
32218 1 : {
32219 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32220 1 : OGRFieldDomainShadow_SetSplitPolicy(arg1,arg2);
32221 1 : SWIG_PYTHON_THREAD_END_ALLOW;
32222 : }
32223 1 : if ( bLocalUseExceptions ) {
32224 1 : popErrorHandler();
32225 : }
32226 : #ifndef SED_HACKS
32227 : if ( bLocalUseExceptions ) {
32228 : CPLErr eclass = CPLGetLastErrorType();
32229 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32230 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32231 : }
32232 : }
32233 : #endif
32234 : }
32235 1 : resultobj = SWIG_Py_Void();
32236 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32237 : return resultobj;
32238 : fail:
32239 : return NULL;
32240 : }
32241 :
32242 :
32243 2 : SWIGINTERN PyObject *_wrap_FieldDomain_GetMergePolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32244 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32245 2 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32246 2 : void *argp1 = 0 ;
32247 2 : int res1 = 0 ;
32248 2 : PyObject *swig_obj[1] ;
32249 2 : OGRFieldDomainMergePolicy result;
32250 :
32251 2 : if (!args) SWIG_fail;
32252 2 : swig_obj[0] = args;
32253 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32254 2 : if (!SWIG_IsOK(res1)) {
32255 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetMergePolicy" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32256 : }
32257 2 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32258 2 : {
32259 2 : const int bLocalUseExceptions = GetUseExceptions();
32260 2 : if ( bLocalUseExceptions ) {
32261 2 : pushErrorHandler();
32262 : }
32263 2 : {
32264 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32265 2 : result = (OGRFieldDomainMergePolicy)OGRFieldDomainShadow_GetMergePolicy(arg1);
32266 2 : SWIG_PYTHON_THREAD_END_ALLOW;
32267 : }
32268 2 : if ( bLocalUseExceptions ) {
32269 2 : popErrorHandler();
32270 : }
32271 : #ifndef SED_HACKS
32272 : if ( bLocalUseExceptions ) {
32273 : CPLErr eclass = CPLGetLastErrorType();
32274 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32275 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32276 : }
32277 : }
32278 : #endif
32279 : }
32280 2 : resultobj = SWIG_From_int(static_cast< int >(result));
32281 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32282 : return resultobj;
32283 : fail:
32284 : return NULL;
32285 : }
32286 :
32287 :
32288 1 : SWIGINTERN PyObject *_wrap_FieldDomain_SetMergePolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32289 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32290 1 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32291 1 : OGRFieldDomainMergePolicy arg2 ;
32292 1 : void *argp1 = 0 ;
32293 1 : int res1 = 0 ;
32294 1 : int val2 ;
32295 1 : int ecode2 = 0 ;
32296 1 : PyObject *swig_obj[2] ;
32297 :
32298 1 : if (!SWIG_Python_UnpackTuple(args, "FieldDomain_SetMergePolicy", 2, 2, swig_obj)) SWIG_fail;
32299 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32300 1 : if (!SWIG_IsOK(res1)) {
32301 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_SetMergePolicy" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32302 : }
32303 1 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32304 1 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
32305 1 : if (!SWIG_IsOK(ecode2)) {
32306 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldDomain_SetMergePolicy" "', argument " "2"" of type '" "OGRFieldDomainMergePolicy""'");
32307 : }
32308 1 : arg2 = static_cast< OGRFieldDomainMergePolicy >(val2);
32309 1 : {
32310 1 : const int bLocalUseExceptions = GetUseExceptions();
32311 1 : if ( bLocalUseExceptions ) {
32312 1 : pushErrorHandler();
32313 : }
32314 1 : {
32315 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32316 1 : OGRFieldDomainShadow_SetMergePolicy(arg1,arg2);
32317 1 : SWIG_PYTHON_THREAD_END_ALLOW;
32318 : }
32319 1 : if ( bLocalUseExceptions ) {
32320 1 : popErrorHandler();
32321 : }
32322 : #ifndef SED_HACKS
32323 : if ( bLocalUseExceptions ) {
32324 : CPLErr eclass = CPLGetLastErrorType();
32325 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32326 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32327 : }
32328 : }
32329 : #endif
32330 : }
32331 1 : resultobj = SWIG_Py_Void();
32332 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32333 : return resultobj;
32334 : fail:
32335 : return NULL;
32336 : }
32337 :
32338 :
32339 38 : SWIGINTERN PyObject *_wrap_FieldDomain_GetEnumeration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32340 38 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32341 38 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32342 38 : void *argp1 = 0 ;
32343 38 : int res1 = 0 ;
32344 38 : PyObject *swig_obj[1] ;
32345 38 : OGRCodedValue *result = 0 ;
32346 :
32347 38 : if (!args) SWIG_fail;
32348 38 : swig_obj[0] = args;
32349 38 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32350 38 : if (!SWIG_IsOK(res1)) {
32351 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetEnumeration" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32352 : }
32353 38 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32354 38 : {
32355 38 : const int bLocalUseExceptions = GetUseExceptions();
32356 38 : if ( bLocalUseExceptions ) {
32357 35 : pushErrorHandler();
32358 : }
32359 38 : {
32360 38 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32361 38 : result = (OGRCodedValue *)OGRFieldDomainShadow_GetEnumeration(arg1);
32362 38 : SWIG_PYTHON_THREAD_END_ALLOW;
32363 : }
32364 38 : if ( bLocalUseExceptions ) {
32365 35 : popErrorHandler();
32366 : }
32367 : #ifndef SED_HACKS
32368 : if ( bLocalUseExceptions ) {
32369 : CPLErr eclass = CPLGetLastErrorType();
32370 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32371 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32372 : }
32373 : }
32374 : #endif
32375 : }
32376 38 : {
32377 : /* %typemap(out) OGRCodedValue* */
32378 38 : if( result == NULL )
32379 : {
32380 1 : PyErr_SetString( PyExc_RuntimeError, CPLGetLastErrorMsg() );
32381 1 : SWIG_fail;
32382 : }
32383 37 : PyObject *dict = PyDict_New();
32384 139 : for( int i = 0; (result)[i].pszCode != NULL; i++ )
32385 : {
32386 102 : if( (result)[i].pszValue )
32387 : {
32388 100 : PyObject* val = GDALPythonObjectFromCStr((result)[i].pszValue);
32389 100 : PyDict_SetItemString(dict, (result)[i].pszCode, val);
32390 102 : Py_DECREF(val);
32391 : }
32392 : else
32393 : {
32394 2 : PyDict_SetItemString(dict, (result)[i].pszCode, Py_None);
32395 : }
32396 : }
32397 37 : resultobj = dict;
32398 : }
32399 38 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32400 : return resultobj;
32401 : fail:
32402 : return NULL;
32403 : }
32404 :
32405 :
32406 12 : SWIGINTERN PyObject *_wrap_FieldDomain_GetMinAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32407 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32408 12 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32409 12 : void *argp1 = 0 ;
32410 12 : int res1 = 0 ;
32411 12 : PyObject *swig_obj[1] ;
32412 12 : double result;
32413 :
32414 12 : if (!args) SWIG_fail;
32415 12 : swig_obj[0] = args;
32416 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32417 12 : if (!SWIG_IsOK(res1)) {
32418 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetMinAsDouble" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32419 : }
32420 12 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32421 12 : {
32422 12 : const int bLocalUseExceptions = GetUseExceptions();
32423 12 : if ( bLocalUseExceptions ) {
32424 4 : pushErrorHandler();
32425 : }
32426 12 : {
32427 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32428 12 : result = (double)OGRFieldDomainShadow_GetMinAsDouble(arg1);
32429 12 : SWIG_PYTHON_THREAD_END_ALLOW;
32430 : }
32431 12 : if ( bLocalUseExceptions ) {
32432 4 : popErrorHandler();
32433 : }
32434 : #ifndef SED_HACKS
32435 : if ( bLocalUseExceptions ) {
32436 : CPLErr eclass = CPLGetLastErrorType();
32437 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32438 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32439 : }
32440 : }
32441 : #endif
32442 : }
32443 12 : resultobj = SWIG_From_double(static_cast< double >(result));
32444 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32445 : return resultobj;
32446 : fail:
32447 : return NULL;
32448 : }
32449 :
32450 :
32451 2 : SWIGINTERN PyObject *_wrap_FieldDomain_GetMinAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32452 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32453 2 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32454 2 : void *argp1 = 0 ;
32455 2 : int res1 = 0 ;
32456 2 : PyObject *swig_obj[1] ;
32457 2 : char *result = 0 ;
32458 :
32459 2 : if (!args) SWIG_fail;
32460 2 : swig_obj[0] = args;
32461 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32462 2 : if (!SWIG_IsOK(res1)) {
32463 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetMinAsString" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32464 : }
32465 2 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32466 2 : {
32467 2 : const int bLocalUseExceptions = GetUseExceptions();
32468 2 : if ( bLocalUseExceptions ) {
32469 1 : pushErrorHandler();
32470 : }
32471 2 : {
32472 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32473 2 : result = (char *)OGRFieldDomainShadow_GetMinAsString(arg1);
32474 2 : SWIG_PYTHON_THREAD_END_ALLOW;
32475 : }
32476 2 : if ( bLocalUseExceptions ) {
32477 1 : popErrorHandler();
32478 : }
32479 : #ifndef SED_HACKS
32480 : if ( bLocalUseExceptions ) {
32481 : CPLErr eclass = CPLGetLastErrorType();
32482 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32483 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32484 : }
32485 : }
32486 : #endif
32487 : }
32488 2 : resultobj = SWIG_FromCharPtr((const char *)result);
32489 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32490 : return resultobj;
32491 : fail:
32492 : return NULL;
32493 : }
32494 :
32495 :
32496 7 : SWIGINTERN PyObject *_wrap_FieldDomain_IsMinInclusive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32497 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32498 7 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32499 7 : void *argp1 = 0 ;
32500 7 : int res1 = 0 ;
32501 7 : PyObject *swig_obj[1] ;
32502 7 : bool result;
32503 :
32504 7 : if (!args) SWIG_fail;
32505 7 : swig_obj[0] = args;
32506 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32507 7 : if (!SWIG_IsOK(res1)) {
32508 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_IsMinInclusive" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32509 : }
32510 7 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32511 7 : {
32512 7 : const int bLocalUseExceptions = GetUseExceptions();
32513 7 : if ( bLocalUseExceptions ) {
32514 2 : pushErrorHandler();
32515 : }
32516 7 : {
32517 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32518 7 : result = (bool)OGRFieldDomainShadow_IsMinInclusive(arg1);
32519 7 : SWIG_PYTHON_THREAD_END_ALLOW;
32520 : }
32521 7 : if ( bLocalUseExceptions ) {
32522 2 : popErrorHandler();
32523 : }
32524 : #ifndef SED_HACKS
32525 : if ( bLocalUseExceptions ) {
32526 : CPLErr eclass = CPLGetLastErrorType();
32527 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32528 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32529 : }
32530 : }
32531 : #endif
32532 : }
32533 7 : resultobj = SWIG_From_bool(static_cast< bool >(result));
32534 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32535 : return resultobj;
32536 : fail:
32537 : return NULL;
32538 : }
32539 :
32540 :
32541 12 : SWIGINTERN PyObject *_wrap_FieldDomain_GetMaxAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32542 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32543 12 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32544 12 : void *argp1 = 0 ;
32545 12 : int res1 = 0 ;
32546 12 : PyObject *swig_obj[1] ;
32547 12 : double result;
32548 :
32549 12 : if (!args) SWIG_fail;
32550 12 : swig_obj[0] = args;
32551 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32552 12 : if (!SWIG_IsOK(res1)) {
32553 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetMaxAsDouble" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32554 : }
32555 12 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32556 12 : {
32557 12 : const int bLocalUseExceptions = GetUseExceptions();
32558 12 : if ( bLocalUseExceptions ) {
32559 4 : pushErrorHandler();
32560 : }
32561 12 : {
32562 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32563 12 : result = (double)OGRFieldDomainShadow_GetMaxAsDouble(arg1);
32564 12 : SWIG_PYTHON_THREAD_END_ALLOW;
32565 : }
32566 12 : if ( bLocalUseExceptions ) {
32567 4 : popErrorHandler();
32568 : }
32569 : #ifndef SED_HACKS
32570 : if ( bLocalUseExceptions ) {
32571 : CPLErr eclass = CPLGetLastErrorType();
32572 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32573 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32574 : }
32575 : }
32576 : #endif
32577 : }
32578 12 : resultobj = SWIG_From_double(static_cast< double >(result));
32579 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32580 : return resultobj;
32581 : fail:
32582 : return NULL;
32583 : }
32584 :
32585 :
32586 2 : SWIGINTERN PyObject *_wrap_FieldDomain_GetMaxAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32587 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32588 2 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32589 2 : void *argp1 = 0 ;
32590 2 : int res1 = 0 ;
32591 2 : PyObject *swig_obj[1] ;
32592 2 : char *result = 0 ;
32593 :
32594 2 : if (!args) SWIG_fail;
32595 2 : swig_obj[0] = args;
32596 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32597 2 : if (!SWIG_IsOK(res1)) {
32598 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetMaxAsString" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32599 : }
32600 2 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32601 2 : {
32602 2 : const int bLocalUseExceptions = GetUseExceptions();
32603 2 : if ( bLocalUseExceptions ) {
32604 1 : pushErrorHandler();
32605 : }
32606 2 : {
32607 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32608 2 : result = (char *)OGRFieldDomainShadow_GetMaxAsString(arg1);
32609 2 : SWIG_PYTHON_THREAD_END_ALLOW;
32610 : }
32611 2 : if ( bLocalUseExceptions ) {
32612 1 : popErrorHandler();
32613 : }
32614 : #ifndef SED_HACKS
32615 : if ( bLocalUseExceptions ) {
32616 : CPLErr eclass = CPLGetLastErrorType();
32617 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32618 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32619 : }
32620 : }
32621 : #endif
32622 : }
32623 2 : resultobj = SWIG_FromCharPtr((const char *)result);
32624 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32625 : return resultobj;
32626 : fail:
32627 : return NULL;
32628 : }
32629 :
32630 :
32631 7 : SWIGINTERN PyObject *_wrap_FieldDomain_IsMaxInclusive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32632 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32633 7 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32634 7 : void *argp1 = 0 ;
32635 7 : int res1 = 0 ;
32636 7 : PyObject *swig_obj[1] ;
32637 7 : bool result;
32638 :
32639 7 : if (!args) SWIG_fail;
32640 7 : swig_obj[0] = args;
32641 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32642 7 : if (!SWIG_IsOK(res1)) {
32643 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_IsMaxInclusive" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32644 : }
32645 7 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32646 7 : {
32647 7 : const int bLocalUseExceptions = GetUseExceptions();
32648 7 : if ( bLocalUseExceptions ) {
32649 2 : pushErrorHandler();
32650 : }
32651 7 : {
32652 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32653 7 : result = (bool)OGRFieldDomainShadow_IsMaxInclusive(arg1);
32654 7 : SWIG_PYTHON_THREAD_END_ALLOW;
32655 : }
32656 7 : if ( bLocalUseExceptions ) {
32657 2 : popErrorHandler();
32658 : }
32659 : #ifndef SED_HACKS
32660 : if ( bLocalUseExceptions ) {
32661 : CPLErr eclass = CPLGetLastErrorType();
32662 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32663 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32664 : }
32665 : }
32666 : #endif
32667 : }
32668 7 : resultobj = SWIG_From_bool(static_cast< bool >(result));
32669 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32670 : return resultobj;
32671 : fail:
32672 : return NULL;
32673 : }
32674 :
32675 :
32676 9 : SWIGINTERN PyObject *_wrap_FieldDomain_GetGlob(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32677 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32678 9 : OGRFieldDomainShadow *arg1 = (OGRFieldDomainShadow *) 0 ;
32679 9 : void *argp1 = 0 ;
32680 9 : int res1 = 0 ;
32681 9 : PyObject *swig_obj[1] ;
32682 9 : char *result = 0 ;
32683 :
32684 9 : if (!args) SWIG_fail;
32685 9 : swig_obj[0] = args;
32686 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
32687 9 : if (!SWIG_IsOK(res1)) {
32688 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldDomain_GetGlob" "', argument " "1"" of type '" "OGRFieldDomainShadow *""'");
32689 : }
32690 9 : arg1 = reinterpret_cast< OGRFieldDomainShadow * >(argp1);
32691 9 : {
32692 9 : const int bLocalUseExceptions = GetUseExceptions();
32693 9 : if ( bLocalUseExceptions ) {
32694 8 : pushErrorHandler();
32695 : }
32696 9 : {
32697 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32698 9 : result = (char *)OGRFieldDomainShadow_GetGlob(arg1);
32699 9 : SWIG_PYTHON_THREAD_END_ALLOW;
32700 : }
32701 9 : if ( bLocalUseExceptions ) {
32702 8 : popErrorHandler();
32703 : }
32704 : #ifndef SED_HACKS
32705 : if ( bLocalUseExceptions ) {
32706 : CPLErr eclass = CPLGetLastErrorType();
32707 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32708 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32709 : }
32710 : }
32711 : #endif
32712 : }
32713 9 : resultobj = SWIG_FromCharPtr((const char *)result);
32714 10 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32715 : return resultobj;
32716 : fail:
32717 : return NULL;
32718 : }
32719 :
32720 :
32721 275 : SWIGINTERN PyObject *FieldDomain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32722 275 : PyObject *obj;
32723 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
32724 275 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRFieldDomainShadow, SWIG_NewClientData(obj));
32725 275 : return SWIG_Py_Void();
32726 : }
32727 :
32728 23 : SWIGINTERN PyObject *_wrap_CreateCodedFieldDomain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32729 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32730 23 : char *arg1 = (char *) 0 ;
32731 23 : char *arg2 = (char *) 0 ;
32732 23 : OGRFieldType arg3 ;
32733 23 : OGRFieldSubType arg4 ;
32734 23 : OGRCodedValue *arg5 = (OGRCodedValue *) 0 ;
32735 23 : int res1 ;
32736 23 : char *buf1 = 0 ;
32737 23 : int alloc1 = 0 ;
32738 23 : int res2 ;
32739 23 : char *buf2 = 0 ;
32740 23 : int alloc2 = 0 ;
32741 23 : int val3 ;
32742 23 : int ecode3 = 0 ;
32743 23 : int val4 ;
32744 23 : int ecode4 = 0 ;
32745 23 : PyObject *swig_obj[5] ;
32746 23 : OGRFieldDomainShadow *result = 0 ;
32747 :
32748 23 : if (!SWIG_Python_UnpackTuple(args, "CreateCodedFieldDomain", 5, 5, swig_obj)) SWIG_fail;
32749 22 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
32750 22 : if (!SWIG_IsOK(res1)) {
32751 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateCodedFieldDomain" "', argument " "1"" of type '" "char const *""'");
32752 : }
32753 22 : arg1 = reinterpret_cast< char * >(buf1);
32754 22 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
32755 22 : if (!SWIG_IsOK(res2)) {
32756 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateCodedFieldDomain" "', argument " "2"" of type '" "char const *""'");
32757 : }
32758 22 : arg2 = reinterpret_cast< char * >(buf2);
32759 22 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
32760 22 : if (!SWIG_IsOK(ecode3)) {
32761 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CreateCodedFieldDomain" "', argument " "3"" of type '" "OGRFieldType""'");
32762 : }
32763 22 : arg3 = static_cast< OGRFieldType >(val3);
32764 22 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
32765 22 : if (!SWIG_IsOK(ecode4)) {
32766 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CreateCodedFieldDomain" "', argument " "4"" of type '" "OGRFieldSubType""'");
32767 : }
32768 22 : arg4 = static_cast< OGRFieldSubType >(val4);
32769 22 : {
32770 : /* %typemap(in) OGRCodedValue* enumeration */
32771 22 : arg5 = NULL;
32772 :
32773 22 : if (swig_obj[4] == NULL || !PyMapping_Check(swig_obj[4])) {
32774 2 : SWIG_exception_fail(SWIG_ValueError,"Expected dict.");
32775 : }
32776 20 : Py_ssize_t size = PyMapping_Length( swig_obj[4] );
32777 20 : arg5 = (OGRCodedValue*)VSICalloc(size+1, sizeof(OGRCodedValue) );
32778 20 : if( !arg5 ) {
32779 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
32780 0 : SWIG_fail;
32781 : }
32782 :
32783 20 : PyObject *item_list = PyMapping_Items( swig_obj[4] );
32784 20 : if( item_list == NULL )
32785 : {
32786 0 : PyErr_SetString(PyExc_TypeError,"Cannot retrieve items");
32787 0 : SWIG_fail;
32788 : }
32789 :
32790 61 : for( Py_ssize_t i=0; i<size; i++ ) {
32791 41 : PyObject *it = PySequence_GetItem( item_list, i );
32792 41 : if( it == NULL )
32793 : {
32794 0 : Py_DECREF(item_list);
32795 0 : PyErr_SetString(PyExc_TypeError,"Cannot retrieve key/value");
32796 0 : SWIG_fail;
32797 : }
32798 :
32799 41 : PyObject *k, *v;
32800 41 : if ( ! PyArg_ParseTuple( it, "OO", &k, &v ) ) {
32801 0 : Py_DECREF(it);
32802 0 : Py_DECREF(item_list);
32803 0 : PyErr_SetString(PyExc_TypeError,"Cannot retrieve key/value");
32804 0 : SWIG_fail;
32805 : }
32806 :
32807 41 : PyObject* kStr = PyObject_Str(k);
32808 41 : if( PyErr_Occurred() )
32809 : {
32810 0 : Py_DECREF(it);
32811 0 : Py_DECREF(item_list);
32812 0 : SWIG_fail;
32813 : }
32814 :
32815 41 : PyObject* vStr = v != Py_None ? PyObject_Str(v) : Py_None;
32816 41 : if( v == Py_None )
32817 10 : Py_INCREF(Py_None);
32818 41 : if( PyErr_Occurred() )
32819 : {
32820 0 : Py_DECREF(it);
32821 0 : Py_DECREF(kStr);
32822 0 : Py_DECREF(item_list);
32823 0 : SWIG_fail;
32824 : }
32825 :
32826 41 : int bFreeK, bFreeV;
32827 41 : char* pszK = GDALPythonObjectToCStr(kStr, &bFreeK);
32828 41 : char* pszV = vStr != Py_None ? GDALPythonObjectToCStr(vStr, &bFreeV) : NULL;
32829 41 : if( pszK == NULL || (pszV == NULL && vStr != Py_None) )
32830 : {
32831 0 : GDALPythonFreeCStr(pszK, bFreeK);
32832 0 : if( pszV )
32833 0 : GDALPythonFreeCStr(pszV, bFreeV);
32834 0 : Py_DECREF(kStr);
32835 0 : Py_DECREF(vStr);
32836 0 : Py_DECREF(it);
32837 0 : Py_DECREF(item_list);
32838 0 : PyErr_SetString(PyExc_TypeError,"Cannot get key/value as string");
32839 0 : SWIG_fail;
32840 : }
32841 41 : (arg5)[i].pszCode = CPLStrdup(pszK);
32842 41 : (arg5)[i].pszValue = pszV ? CPLStrdup(pszV) : NULL;
32843 :
32844 41 : GDALPythonFreeCStr(pszK, bFreeK);
32845 41 : if( pszV )
32846 31 : GDALPythonFreeCStr(pszV, bFreeV);
32847 41 : Py_DECREF(kStr);
32848 41 : Py_DECREF(vStr);
32849 41 : Py_DECREF(it);
32850 : }
32851 20 : Py_DECREF(item_list);
32852 : }
32853 20 : {
32854 20 : if (!arg1) {
32855 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
32856 : }
32857 : }
32858 20 : {
32859 20 : const int bLocalUseExceptions = GetUseExceptions();
32860 20 : if ( bLocalUseExceptions ) {
32861 7 : pushErrorHandler();
32862 : }
32863 20 : {
32864 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32865 20 : result = (OGRFieldDomainShadow *)CreateCodedFieldDomain((char const *)arg1,(char const *)arg2,arg3,arg4,(OGRCodedValue const *)arg5);
32866 20 : SWIG_PYTHON_THREAD_END_ALLOW;
32867 : }
32868 20 : if ( bLocalUseExceptions ) {
32869 7 : popErrorHandler();
32870 : }
32871 : #ifndef SED_HACKS
32872 : if ( bLocalUseExceptions ) {
32873 : CPLErr eclass = CPLGetLastErrorType();
32874 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32875 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32876 : }
32877 : }
32878 : #endif
32879 : }
32880 20 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDomainShadow, SWIG_POINTER_OWN | 0 );
32881 20 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
32882 20 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32883 : {
32884 : /* %typemap(freearg) OGRCodedValue* */
32885 : if( arg5 )
32886 : {
32887 61 : for( size_t i = 0; (arg5)[i].pszCode != NULL; ++i )
32888 : {
32889 41 : CPLFree((arg5)[i].pszCode);
32890 41 : CPLFree((arg5)[i].pszValue);
32891 : }
32892 : }
32893 20 : CPLFree( arg5 );
32894 : }
32895 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
32896 : return resultobj;
32897 3 : fail:
32898 3 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
32899 3 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32900 3 : {
32901 : /* %typemap(freearg) OGRCodedValue* */
32902 3 : if( arg5 )
32903 : {
32904 0 : for( size_t i = 0; (arg5)[i].pszCode != NULL; ++i )
32905 : {
32906 0 : CPLFree((arg5)[i].pszCode);
32907 0 : CPLFree((arg5)[i].pszValue);
32908 : }
32909 : }
32910 3 : CPLFree( arg5 );
32911 : }
32912 : return NULL;
32913 : }
32914 :
32915 :
32916 12 : SWIGINTERN PyObject *_wrap_CreateRangeFieldDomain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32917 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32918 12 : char *arg1 = (char *) 0 ;
32919 12 : char *arg2 = (char *) 0 ;
32920 12 : OGRFieldType arg3 ;
32921 12 : OGRFieldSubType arg4 ;
32922 12 : double arg5 ;
32923 12 : bool arg6 ;
32924 12 : double arg7 ;
32925 12 : double arg8 ;
32926 12 : int res1 ;
32927 12 : char *buf1 = 0 ;
32928 12 : int alloc1 = 0 ;
32929 12 : int res2 ;
32930 12 : char *buf2 = 0 ;
32931 12 : int alloc2 = 0 ;
32932 12 : int val3 ;
32933 12 : int ecode3 = 0 ;
32934 12 : int val4 ;
32935 12 : int ecode4 = 0 ;
32936 12 : double val5 ;
32937 12 : int ecode5 = 0 ;
32938 12 : bool val6 ;
32939 12 : int ecode6 = 0 ;
32940 12 : double val7 ;
32941 12 : int ecode7 = 0 ;
32942 12 : double val8 ;
32943 12 : int ecode8 = 0 ;
32944 12 : PyObject *swig_obj[8] ;
32945 12 : OGRFieldDomainShadow *result = 0 ;
32946 :
32947 12 : if (!SWIG_Python_UnpackTuple(args, "CreateRangeFieldDomain", 8, 8, swig_obj)) SWIG_fail;
32948 12 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
32949 12 : if (!SWIG_IsOK(res1)) {
32950 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateRangeFieldDomain" "', argument " "1"" of type '" "char const *""'");
32951 : }
32952 12 : arg1 = reinterpret_cast< char * >(buf1);
32953 12 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
32954 12 : if (!SWIG_IsOK(res2)) {
32955 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateRangeFieldDomain" "', argument " "2"" of type '" "char const *""'");
32956 : }
32957 12 : arg2 = reinterpret_cast< char * >(buf2);
32958 12 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
32959 12 : if (!SWIG_IsOK(ecode3)) {
32960 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CreateRangeFieldDomain" "', argument " "3"" of type '" "OGRFieldType""'");
32961 : }
32962 12 : arg3 = static_cast< OGRFieldType >(val3);
32963 12 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
32964 12 : if (!SWIG_IsOK(ecode4)) {
32965 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CreateRangeFieldDomain" "', argument " "4"" of type '" "OGRFieldSubType""'");
32966 : }
32967 12 : arg4 = static_cast< OGRFieldSubType >(val4);
32968 12 : ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
32969 12 : if (!SWIG_IsOK(ecode5)) {
32970 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CreateRangeFieldDomain" "', argument " "5"" of type '" "double""'");
32971 : }
32972 12 : arg5 = static_cast< double >(val5);
32973 12 : ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
32974 12 : if (!SWIG_IsOK(ecode6)) {
32975 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CreateRangeFieldDomain" "', argument " "6"" of type '" "bool""'");
32976 : }
32977 12 : arg6 = static_cast< bool >(val6);
32978 12 : ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
32979 12 : if (!SWIG_IsOK(ecode7)) {
32980 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CreateRangeFieldDomain" "', argument " "7"" of type '" "double""'");
32981 : }
32982 12 : arg7 = static_cast< double >(val7);
32983 12 : ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
32984 12 : if (!SWIG_IsOK(ecode8)) {
32985 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CreateRangeFieldDomain" "', argument " "8"" of type '" "double""'");
32986 : }
32987 12 : arg8 = static_cast< double >(val8);
32988 12 : {
32989 12 : if (!arg1) {
32990 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
32991 : }
32992 : }
32993 11 : {
32994 11 : const int bLocalUseExceptions = GetUseExceptions();
32995 11 : if ( bLocalUseExceptions ) {
32996 4 : pushErrorHandler();
32997 : }
32998 11 : {
32999 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33000 11 : result = (OGRFieldDomainShadow *)CreateRangeFieldDomain((char const *)arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
33001 11 : SWIG_PYTHON_THREAD_END_ALLOW;
33002 : }
33003 11 : if ( bLocalUseExceptions ) {
33004 4 : popErrorHandler();
33005 : }
33006 : #ifndef SED_HACKS
33007 : if ( bLocalUseExceptions ) {
33008 : CPLErr eclass = CPLGetLastErrorType();
33009 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33010 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33011 : }
33012 : }
33013 : #endif
33014 : }
33015 11 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDomainShadow, SWIG_POINTER_OWN | 0 );
33016 11 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
33017 11 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33018 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33019 : return resultobj;
33020 1 : fail:
33021 1 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
33022 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33023 : return NULL;
33024 : }
33025 :
33026 :
33027 2 : SWIGINTERN PyObject *_wrap_CreateRangeFieldDomainDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33028 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33029 2 : char *arg1 = (char *) 0 ;
33030 2 : char *arg2 = (char *) 0 ;
33031 2 : char *arg3 = (char *) 0 ;
33032 2 : bool arg4 ;
33033 2 : char *arg5 = (char *) 0 ;
33034 2 : double arg6 ;
33035 2 : int res1 ;
33036 2 : char *buf1 = 0 ;
33037 2 : int alloc1 = 0 ;
33038 2 : int res2 ;
33039 2 : char *buf2 = 0 ;
33040 2 : int alloc2 = 0 ;
33041 2 : int res3 ;
33042 2 : char *buf3 = 0 ;
33043 2 : int alloc3 = 0 ;
33044 2 : bool val4 ;
33045 2 : int ecode4 = 0 ;
33046 2 : int res5 ;
33047 2 : char *buf5 = 0 ;
33048 2 : int alloc5 = 0 ;
33049 2 : double val6 ;
33050 2 : int ecode6 = 0 ;
33051 2 : PyObject *swig_obj[6] ;
33052 2 : OGRFieldDomainShadow *result = 0 ;
33053 :
33054 2 : if (!SWIG_Python_UnpackTuple(args, "CreateRangeFieldDomainDateTime", 6, 6, swig_obj)) SWIG_fail;
33055 2 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
33056 2 : if (!SWIG_IsOK(res1)) {
33057 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateRangeFieldDomainDateTime" "', argument " "1"" of type '" "char const *""'");
33058 : }
33059 2 : arg1 = reinterpret_cast< char * >(buf1);
33060 2 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
33061 2 : if (!SWIG_IsOK(res2)) {
33062 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateRangeFieldDomainDateTime" "', argument " "2"" of type '" "char const *""'");
33063 : }
33064 2 : arg2 = reinterpret_cast< char * >(buf2);
33065 2 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
33066 2 : if (!SWIG_IsOK(res3)) {
33067 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CreateRangeFieldDomainDateTime" "', argument " "3"" of type '" "char const *""'");
33068 : }
33069 2 : arg3 = reinterpret_cast< char * >(buf3);
33070 2 : ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
33071 2 : if (!SWIG_IsOK(ecode4)) {
33072 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CreateRangeFieldDomainDateTime" "', argument " "4"" of type '" "bool""'");
33073 : }
33074 2 : arg4 = static_cast< bool >(val4);
33075 2 : res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
33076 2 : if (!SWIG_IsOK(res5)) {
33077 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CreateRangeFieldDomainDateTime" "', argument " "5"" of type '" "char const *""'");
33078 : }
33079 2 : arg5 = reinterpret_cast< char * >(buf5);
33080 2 : ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
33081 2 : if (!SWIG_IsOK(ecode6)) {
33082 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CreateRangeFieldDomainDateTime" "', argument " "6"" of type '" "double""'");
33083 : }
33084 2 : arg6 = static_cast< double >(val6);
33085 2 : {
33086 2 : if (!arg1) {
33087 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33088 : }
33089 : }
33090 2 : {
33091 2 : const int bLocalUseExceptions = GetUseExceptions();
33092 2 : if ( bLocalUseExceptions ) {
33093 1 : pushErrorHandler();
33094 : }
33095 2 : {
33096 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33097 2 : result = (OGRFieldDomainShadow *)CreateRangeFieldDomainDateTime((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,(char const *)arg5,arg6);
33098 2 : SWIG_PYTHON_THREAD_END_ALLOW;
33099 : }
33100 2 : if ( bLocalUseExceptions ) {
33101 1 : popErrorHandler();
33102 : }
33103 : #ifndef SED_HACKS
33104 : if ( bLocalUseExceptions ) {
33105 : CPLErr eclass = CPLGetLastErrorType();
33106 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33107 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33108 : }
33109 : }
33110 : #endif
33111 : }
33112 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
33113 2 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
33114 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33115 2 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
33116 2 : if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
33117 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33118 : return resultobj;
33119 0 : fail:
33120 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
33121 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33122 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
33123 0 : if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
33124 : return NULL;
33125 : }
33126 :
33127 :
33128 15 : SWIGINTERN PyObject *_wrap_CreateGlobFieldDomain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33129 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33130 15 : char *arg1 = (char *) 0 ;
33131 15 : char *arg2 = (char *) 0 ;
33132 15 : OGRFieldType arg3 ;
33133 15 : OGRFieldSubType arg4 ;
33134 15 : char *arg5 = (char *) 0 ;
33135 15 : int res1 ;
33136 15 : char *buf1 = 0 ;
33137 15 : int alloc1 = 0 ;
33138 15 : int res2 ;
33139 15 : char *buf2 = 0 ;
33140 15 : int alloc2 = 0 ;
33141 15 : int val3 ;
33142 15 : int ecode3 = 0 ;
33143 15 : int val4 ;
33144 15 : int ecode4 = 0 ;
33145 15 : int res5 ;
33146 15 : char *buf5 = 0 ;
33147 15 : int alloc5 = 0 ;
33148 15 : PyObject *swig_obj[5] ;
33149 15 : OGRFieldDomainShadow *result = 0 ;
33150 :
33151 15 : if (!SWIG_Python_UnpackTuple(args, "CreateGlobFieldDomain", 5, 5, swig_obj)) SWIG_fail;
33152 15 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
33153 15 : if (!SWIG_IsOK(res1)) {
33154 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateGlobFieldDomain" "', argument " "1"" of type '" "char const *""'");
33155 : }
33156 15 : arg1 = reinterpret_cast< char * >(buf1);
33157 15 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
33158 15 : if (!SWIG_IsOK(res2)) {
33159 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateGlobFieldDomain" "', argument " "2"" of type '" "char const *""'");
33160 : }
33161 15 : arg2 = reinterpret_cast< char * >(buf2);
33162 15 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
33163 15 : if (!SWIG_IsOK(ecode3)) {
33164 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CreateGlobFieldDomain" "', argument " "3"" of type '" "OGRFieldType""'");
33165 : }
33166 15 : arg3 = static_cast< OGRFieldType >(val3);
33167 15 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
33168 15 : if (!SWIG_IsOK(ecode4)) {
33169 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CreateGlobFieldDomain" "', argument " "4"" of type '" "OGRFieldSubType""'");
33170 : }
33171 15 : arg4 = static_cast< OGRFieldSubType >(val4);
33172 15 : res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
33173 15 : if (!SWIG_IsOK(res5)) {
33174 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CreateGlobFieldDomain" "', argument " "5"" of type '" "char const *""'");
33175 : }
33176 15 : arg5 = reinterpret_cast< char * >(buf5);
33177 15 : {
33178 15 : if (!arg1) {
33179 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33180 : }
33181 : }
33182 15 : {
33183 15 : if (!arg5) {
33184 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33185 : }
33186 : }
33187 14 : {
33188 14 : const int bLocalUseExceptions = GetUseExceptions();
33189 14 : if ( bLocalUseExceptions ) {
33190 13 : pushErrorHandler();
33191 : }
33192 14 : {
33193 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33194 14 : result = (OGRFieldDomainShadow *)CreateGlobFieldDomain((char const *)arg1,(char const *)arg2,arg3,arg4,(char const *)arg5);
33195 14 : SWIG_PYTHON_THREAD_END_ALLOW;
33196 : }
33197 14 : if ( bLocalUseExceptions ) {
33198 13 : popErrorHandler();
33199 : }
33200 : #ifndef SED_HACKS
33201 : if ( bLocalUseExceptions ) {
33202 : CPLErr eclass = CPLGetLastErrorType();
33203 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33204 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33205 : }
33206 : }
33207 : #endif
33208 : }
33209 14 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDomainShadow, SWIG_POINTER_OWN | 0 );
33210 14 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
33211 14 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33212 14 : if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
33213 15 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33214 : return resultobj;
33215 1 : fail:
33216 1 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
33217 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33218 1 : if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
33219 : return NULL;
33220 : }
33221 :
33222 :
33223 20 : SWIGINTERN PyObject *_wrap_delete_GeomCoordinatePrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33224 20 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33225 20 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33226 20 : void *argp1 = 0 ;
33227 20 : int res1 = 0 ;
33228 20 : PyObject *swig_obj[1] ;
33229 :
33230 20 : if (!args) SWIG_fail;
33231 20 : swig_obj[0] = args;
33232 20 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, SWIG_POINTER_DISOWN | 0 );
33233 20 : if (!SWIG_IsOK(res1)) {
33234 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeomCoordinatePrecision" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33235 : }
33236 20 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33237 20 : {
33238 20 : const int bLocalUseExceptions = GetUseExceptions();
33239 20 : if ( bLocalUseExceptions ) {
33240 14 : pushErrorHandler();
33241 : }
33242 20 : {
33243 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33244 20 : delete_OGRGeomCoordinatePrecisionShadow(arg1);
33245 20 : SWIG_PYTHON_THREAD_END_ALLOW;
33246 : }
33247 20 : if ( bLocalUseExceptions ) {
33248 14 : popErrorHandler();
33249 : }
33250 : #ifndef SED_HACKS
33251 : if ( bLocalUseExceptions ) {
33252 : CPLErr eclass = CPLGetLastErrorType();
33253 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33254 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33255 : }
33256 : }
33257 : #endif
33258 : }
33259 20 : resultobj = SWIG_Py_Void();
33260 20 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33261 : return resultobj;
33262 : fail:
33263 : return NULL;
33264 : }
33265 :
33266 :
33267 20 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33268 20 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33269 20 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33270 20 : double arg2 ;
33271 20 : double arg3 ;
33272 20 : double arg4 ;
33273 20 : void *argp1 = 0 ;
33274 20 : int res1 = 0 ;
33275 20 : double val2 ;
33276 20 : int ecode2 = 0 ;
33277 20 : double val3 ;
33278 20 : int ecode3 = 0 ;
33279 20 : double val4 ;
33280 20 : int ecode4 = 0 ;
33281 20 : PyObject *swig_obj[4] ;
33282 :
33283 20 : if (!SWIG_Python_UnpackTuple(args, "GeomCoordinatePrecision_Set", 4, 4, swig_obj)) SWIG_fail;
33284 20 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33285 20 : if (!SWIG_IsOK(res1)) {
33286 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_Set" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33287 : }
33288 20 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33289 20 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
33290 20 : if (!SWIG_IsOK(ecode2)) {
33291 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeomCoordinatePrecision_Set" "', argument " "2"" of type '" "double""'");
33292 : }
33293 20 : arg2 = static_cast< double >(val2);
33294 20 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
33295 20 : if (!SWIG_IsOK(ecode3)) {
33296 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GeomCoordinatePrecision_Set" "', argument " "3"" of type '" "double""'");
33297 : }
33298 20 : arg3 = static_cast< double >(val3);
33299 20 : ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
33300 20 : if (!SWIG_IsOK(ecode4)) {
33301 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GeomCoordinatePrecision_Set" "', argument " "4"" of type '" "double""'");
33302 : }
33303 20 : arg4 = static_cast< double >(val4);
33304 20 : {
33305 20 : const int bLocalUseExceptions = GetUseExceptions();
33306 20 : if ( bLocalUseExceptions ) {
33307 14 : pushErrorHandler();
33308 : }
33309 20 : {
33310 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33311 20 : OGRGeomCoordinatePrecisionShadow_Set(arg1,arg2,arg3,arg4);
33312 20 : SWIG_PYTHON_THREAD_END_ALLOW;
33313 : }
33314 20 : if ( bLocalUseExceptions ) {
33315 14 : popErrorHandler();
33316 : }
33317 : #ifndef SED_HACKS
33318 : if ( bLocalUseExceptions ) {
33319 : CPLErr eclass = CPLGetLastErrorType();
33320 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33321 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33322 : }
33323 : }
33324 : #endif
33325 : }
33326 20 : resultobj = SWIG_Py_Void();
33327 20 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33328 : return resultobj;
33329 : fail:
33330 : return NULL;
33331 : }
33332 :
33333 :
33334 4 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_SetFromMeter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33335 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33336 4 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33337 4 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
33338 4 : double arg3 ;
33339 4 : double arg4 ;
33340 4 : double arg5 ;
33341 4 : void *argp1 = 0 ;
33342 4 : int res1 = 0 ;
33343 4 : void *argp2 = 0 ;
33344 4 : int res2 = 0 ;
33345 4 : double val3 ;
33346 4 : int ecode3 = 0 ;
33347 4 : double val4 ;
33348 4 : int ecode4 = 0 ;
33349 4 : double val5 ;
33350 4 : int ecode5 = 0 ;
33351 4 : PyObject *swig_obj[5] ;
33352 :
33353 4 : if (!SWIG_Python_UnpackTuple(args, "GeomCoordinatePrecision_SetFromMeter", 5, 5, swig_obj)) SWIG_fail;
33354 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33355 4 : if (!SWIG_IsOK(res1)) {
33356 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_SetFromMeter" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33357 : }
33358 4 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33359 4 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
33360 4 : if (!SWIG_IsOK(res2)) {
33361 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomCoordinatePrecision_SetFromMeter" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
33362 : }
33363 4 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
33364 4 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
33365 4 : if (!SWIG_IsOK(ecode3)) {
33366 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GeomCoordinatePrecision_SetFromMeter" "', argument " "3"" of type '" "double""'");
33367 : }
33368 4 : arg3 = static_cast< double >(val3);
33369 4 : ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
33370 4 : if (!SWIG_IsOK(ecode4)) {
33371 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GeomCoordinatePrecision_SetFromMeter" "', argument " "4"" of type '" "double""'");
33372 : }
33373 4 : arg4 = static_cast< double >(val4);
33374 4 : ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
33375 4 : if (!SWIG_IsOK(ecode5)) {
33376 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GeomCoordinatePrecision_SetFromMeter" "', argument " "5"" of type '" "double""'");
33377 : }
33378 4 : arg5 = static_cast< double >(val5);
33379 4 : {
33380 4 : if (!arg2) {
33381 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33382 : }
33383 : }
33384 3 : {
33385 3 : const int bLocalUseExceptions = GetUseExceptions();
33386 3 : if ( bLocalUseExceptions ) {
33387 3 : pushErrorHandler();
33388 : }
33389 3 : {
33390 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33391 3 : OGRGeomCoordinatePrecisionShadow_SetFromMeter(arg1,arg2,arg3,arg4,arg5);
33392 3 : SWIG_PYTHON_THREAD_END_ALLOW;
33393 : }
33394 3 : if ( bLocalUseExceptions ) {
33395 3 : popErrorHandler();
33396 : }
33397 : #ifndef SED_HACKS
33398 : if ( bLocalUseExceptions ) {
33399 : CPLErr eclass = CPLGetLastErrorType();
33400 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33401 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33402 : }
33403 : }
33404 : #endif
33405 : }
33406 3 : resultobj = SWIG_Py_Void();
33407 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33408 : return resultobj;
33409 : fail:
33410 : return NULL;
33411 : }
33412 :
33413 :
33414 47 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_GetXYResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33415 47 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33416 47 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33417 47 : void *argp1 = 0 ;
33418 47 : int res1 = 0 ;
33419 47 : PyObject *swig_obj[1] ;
33420 47 : double result;
33421 :
33422 47 : if (!args) SWIG_fail;
33423 47 : swig_obj[0] = args;
33424 47 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33425 47 : if (!SWIG_IsOK(res1)) {
33426 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_GetXYResolution" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33427 : }
33428 47 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33429 47 : {
33430 47 : const int bLocalUseExceptions = GetUseExceptions();
33431 47 : if ( bLocalUseExceptions ) {
33432 38 : pushErrorHandler();
33433 : }
33434 47 : {
33435 47 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33436 47 : result = (double)OGRGeomCoordinatePrecisionShadow_GetXYResolution(arg1);
33437 47 : SWIG_PYTHON_THREAD_END_ALLOW;
33438 : }
33439 47 : if ( bLocalUseExceptions ) {
33440 38 : popErrorHandler();
33441 : }
33442 : #ifndef SED_HACKS
33443 : if ( bLocalUseExceptions ) {
33444 : CPLErr eclass = CPLGetLastErrorType();
33445 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33446 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33447 : }
33448 : }
33449 : #endif
33450 : }
33451 47 : resultobj = SWIG_From_double(static_cast< double >(result));
33452 47 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33453 : return resultobj;
33454 : fail:
33455 : return NULL;
33456 : }
33457 :
33458 :
33459 44 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_GetZResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33460 44 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33461 44 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33462 44 : void *argp1 = 0 ;
33463 44 : int res1 = 0 ;
33464 44 : PyObject *swig_obj[1] ;
33465 44 : double result;
33466 :
33467 44 : if (!args) SWIG_fail;
33468 44 : swig_obj[0] = args;
33469 44 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33470 44 : if (!SWIG_IsOK(res1)) {
33471 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_GetZResolution" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33472 : }
33473 44 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33474 44 : {
33475 44 : const int bLocalUseExceptions = GetUseExceptions();
33476 44 : if ( bLocalUseExceptions ) {
33477 35 : pushErrorHandler();
33478 : }
33479 44 : {
33480 44 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33481 44 : result = (double)OGRGeomCoordinatePrecisionShadow_GetZResolution(arg1);
33482 44 : SWIG_PYTHON_THREAD_END_ALLOW;
33483 : }
33484 44 : if ( bLocalUseExceptions ) {
33485 35 : popErrorHandler();
33486 : }
33487 : #ifndef SED_HACKS
33488 : if ( bLocalUseExceptions ) {
33489 : CPLErr eclass = CPLGetLastErrorType();
33490 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33491 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33492 : }
33493 : }
33494 : #endif
33495 : }
33496 44 : resultobj = SWIG_From_double(static_cast< double >(result));
33497 44 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33498 : return resultobj;
33499 : fail:
33500 : return NULL;
33501 : }
33502 :
33503 :
33504 29 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_GetMResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33505 29 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33506 29 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33507 29 : void *argp1 = 0 ;
33508 29 : int res1 = 0 ;
33509 29 : PyObject *swig_obj[1] ;
33510 29 : double result;
33511 :
33512 29 : if (!args) SWIG_fail;
33513 29 : swig_obj[0] = args;
33514 29 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33515 29 : if (!SWIG_IsOK(res1)) {
33516 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_GetMResolution" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33517 : }
33518 29 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33519 29 : {
33520 29 : const int bLocalUseExceptions = GetUseExceptions();
33521 29 : if ( bLocalUseExceptions ) {
33522 22 : pushErrorHandler();
33523 : }
33524 29 : {
33525 29 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33526 29 : result = (double)OGRGeomCoordinatePrecisionShadow_GetMResolution(arg1);
33527 29 : SWIG_PYTHON_THREAD_END_ALLOW;
33528 : }
33529 29 : if ( bLocalUseExceptions ) {
33530 22 : popErrorHandler();
33531 : }
33532 : #ifndef SED_HACKS
33533 : if ( bLocalUseExceptions ) {
33534 : CPLErr eclass = CPLGetLastErrorType();
33535 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33536 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33537 : }
33538 : }
33539 : #endif
33540 : }
33541 29 : resultobj = SWIG_From_double(static_cast< double >(result));
33542 29 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33543 : return resultobj;
33544 : fail:
33545 : return NULL;
33546 : }
33547 :
33548 :
33549 6 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_GetFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33550 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33551 6 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33552 6 : void *argp1 = 0 ;
33553 6 : int res1 = 0 ;
33554 6 : PyObject *swig_obj[1] ;
33555 6 : char **result = 0 ;
33556 :
33557 6 : if (!args) SWIG_fail;
33558 6 : swig_obj[0] = args;
33559 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33560 6 : if (!SWIG_IsOK(res1)) {
33561 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_GetFormats" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33562 : }
33563 6 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33564 6 : {
33565 6 : const int bLocalUseExceptions = GetUseExceptions();
33566 6 : if ( bLocalUseExceptions ) {
33567 2 : pushErrorHandler();
33568 : }
33569 6 : {
33570 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33571 6 : result = (char **)OGRGeomCoordinatePrecisionShadow_GetFormats(arg1);
33572 6 : SWIG_PYTHON_THREAD_END_ALLOW;
33573 : }
33574 6 : if ( bLocalUseExceptions ) {
33575 2 : popErrorHandler();
33576 : }
33577 : #ifndef SED_HACKS
33578 : if ( bLocalUseExceptions ) {
33579 : CPLErr eclass = CPLGetLastErrorType();
33580 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33581 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33582 : }
33583 : }
33584 : #endif
33585 : }
33586 6 : {
33587 : /* %typemap(out) char **CSL -> ( string ) */
33588 6 : bool bErr = false;
33589 6 : resultobj = CSLToList(result, &bErr);
33590 6 : CSLDestroy(result);
33591 6 : if( bErr ) {
33592 0 : SWIG_fail;
33593 : }
33594 : }
33595 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33596 : return resultobj;
33597 : fail:
33598 : return NULL;
33599 : }
33600 :
33601 :
33602 8 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_GetFormatSpecificOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33603 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33604 8 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33605 8 : char *arg2 = (char *) 0 ;
33606 8 : void *argp1 = 0 ;
33607 8 : int res1 = 0 ;
33608 8 : int res2 ;
33609 8 : char *buf2 = 0 ;
33610 8 : int alloc2 = 0 ;
33611 8 : PyObject *swig_obj[2] ;
33612 8 : char **result = 0 ;
33613 :
33614 8 : if (!SWIG_Python_UnpackTuple(args, "GeomCoordinatePrecision_GetFormatSpecificOptions", 2, 2, swig_obj)) SWIG_fail;
33615 8 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33616 8 : if (!SWIG_IsOK(res1)) {
33617 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_GetFormatSpecificOptions" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33618 : }
33619 8 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33620 8 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
33621 8 : if (!SWIG_IsOK(res2)) {
33622 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomCoordinatePrecision_GetFormatSpecificOptions" "', argument " "2"" of type '" "char const *""'");
33623 : }
33624 8 : arg2 = reinterpret_cast< char * >(buf2);
33625 8 : {
33626 8 : if (!arg2) {
33627 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33628 : }
33629 : }
33630 7 : {
33631 7 : const int bLocalUseExceptions = GetUseExceptions();
33632 7 : if ( bLocalUseExceptions ) {
33633 2 : pushErrorHandler();
33634 : }
33635 7 : {
33636 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33637 7 : result = (char **)OGRGeomCoordinatePrecisionShadow_GetFormatSpecificOptions(arg1,(char const *)arg2);
33638 7 : SWIG_PYTHON_THREAD_END_ALLOW;
33639 : }
33640 7 : if ( bLocalUseExceptions ) {
33641 2 : popErrorHandler();
33642 : }
33643 : #ifndef SED_HACKS
33644 : if ( bLocalUseExceptions ) {
33645 : CPLErr eclass = CPLGetLastErrorType();
33646 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33647 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33648 : }
33649 : }
33650 : #endif
33651 : }
33652 7 : {
33653 : /* %typemap(out) char **dict */
33654 7 : resultobj = GetCSLStringAsPyDict(result, false);
33655 : }
33656 7 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33657 8 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33658 : return resultobj;
33659 1 : fail:
33660 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33661 : return NULL;
33662 : }
33663 :
33664 :
33665 1 : SWIGINTERN PyObject *_wrap_GeomCoordinatePrecision_SetFormatSpecificOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33666 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33667 1 : OGRGeomCoordinatePrecisionShadow *arg1 = (OGRGeomCoordinatePrecisionShadow *) 0 ;
33668 1 : char *arg2 = (char *) 0 ;
33669 1 : char **arg3 = (char **) 0 ;
33670 1 : void *argp1 = 0 ;
33671 1 : int res1 = 0 ;
33672 1 : int res2 ;
33673 1 : char *buf2 = 0 ;
33674 1 : int alloc2 = 0 ;
33675 1 : PyObject *swig_obj[3] ;
33676 :
33677 1 : if (!SWIG_Python_UnpackTuple(args, "GeomCoordinatePrecision_SetFormatSpecificOptions", 3, 3, swig_obj)) SWIG_fail;
33678 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, 0 | 0 );
33679 1 : if (!SWIG_IsOK(res1)) {
33680 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomCoordinatePrecision_SetFormatSpecificOptions" "', argument " "1"" of type '" "OGRGeomCoordinatePrecisionShadow *""'");
33681 : }
33682 1 : arg1 = reinterpret_cast< OGRGeomCoordinatePrecisionShadow * >(argp1);
33683 1 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
33684 1 : if (!SWIG_IsOK(res2)) {
33685 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomCoordinatePrecision_SetFormatSpecificOptions" "', argument " "2"" of type '" "char const *""'");
33686 : }
33687 1 : arg2 = reinterpret_cast< char * >(buf2);
33688 1 : {
33689 : /* %typemap(in) char **dict */
33690 1 : arg3 = NULL;
33691 1 : if ( PySequence_Check( swig_obj[2] ) ) {
33692 0 : int bErr = FALSE;
33693 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
33694 0 : if ( bErr )
33695 : {
33696 0 : SWIG_fail;
33697 : }
33698 : }
33699 1 : else if ( PyMapping_Check( swig_obj[2] ) ) {
33700 1 : int bErr = FALSE;
33701 1 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
33702 1 : if ( bErr )
33703 : {
33704 0 : SWIG_fail;
33705 : }
33706 : }
33707 : else {
33708 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
33709 0 : SWIG_fail;
33710 : }
33711 : }
33712 1 : {
33713 1 : if (!arg2) {
33714 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33715 : }
33716 : }
33717 1 : {
33718 1 : const int bLocalUseExceptions = GetUseExceptions();
33719 1 : if ( bLocalUseExceptions ) {
33720 1 : pushErrorHandler();
33721 : }
33722 1 : {
33723 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33724 1 : OGRGeomCoordinatePrecisionShadow_SetFormatSpecificOptions(arg1,(char const *)arg2,arg3);
33725 1 : SWIG_PYTHON_THREAD_END_ALLOW;
33726 : }
33727 1 : if ( bLocalUseExceptions ) {
33728 1 : popErrorHandler();
33729 : }
33730 : #ifndef SED_HACKS
33731 : if ( bLocalUseExceptions ) {
33732 : CPLErr eclass = CPLGetLastErrorType();
33733 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33734 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33735 : }
33736 : }
33737 : #endif
33738 : }
33739 1 : resultobj = SWIG_Py_Void();
33740 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33741 1 : {
33742 : /* %typemap(freearg) char **dict */
33743 1 : CSLDestroy( arg3 );
33744 : }
33745 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33746 : return resultobj;
33747 0 : fail:
33748 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33749 0 : {
33750 : /* %typemap(freearg) char **dict */
33751 0 : CSLDestroy( arg3 );
33752 : }
33753 : return NULL;
33754 : }
33755 :
33756 :
33757 275 : SWIGINTERN PyObject *GeomCoordinatePrecision_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33758 275 : PyObject *obj;
33759 275 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
33760 275 : SWIG_TypeNewClientData(SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, SWIG_NewClientData(obj));
33761 275 : return SWIG_Py_Void();
33762 : }
33763 :
33764 20 : SWIGINTERN PyObject *_wrap_CreateGeomCoordinatePrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33765 20 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33766 20 : OGRGeomCoordinatePrecisionShadow *result = 0 ;
33767 :
33768 20 : if (!SWIG_Python_UnpackTuple(args, "CreateGeomCoordinatePrecision", 0, 0, 0)) SWIG_fail;
33769 20 : {
33770 20 : const int bLocalUseExceptions = GetUseExceptions();
33771 20 : if ( bLocalUseExceptions ) {
33772 14 : pushErrorHandler();
33773 : }
33774 20 : {
33775 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33776 20 : result = (OGRGeomCoordinatePrecisionShadow *)CreateGeomCoordinatePrecision();
33777 20 : SWIG_PYTHON_THREAD_END_ALLOW;
33778 : }
33779 20 : if ( bLocalUseExceptions ) {
33780 14 : popErrorHandler();
33781 : }
33782 : #ifndef SED_HACKS
33783 : if ( bLocalUseExceptions ) {
33784 : CPLErr eclass = CPLGetLastErrorType();
33785 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33786 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33787 : }
33788 : }
33789 : #endif
33790 : }
33791 20 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeomCoordinatePrecisionShadow, SWIG_POINTER_OWN | 0 );
33792 20 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33793 : return resultobj;
33794 0 : fail:
33795 0 : return NULL;
33796 : }
33797 :
33798 :
33799 0 : SWIGINTERN PyObject *_wrap_GetDriverCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33800 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33801 0 : int result;
33802 :
33803 0 : if (!SWIG_Python_UnpackTuple(args, "GetDriverCount", 0, 0, 0)) SWIG_fail;
33804 0 : {
33805 0 : const int bLocalUseExceptions = GetUseExceptions();
33806 0 : if ( bLocalUseExceptions ) {
33807 0 : pushErrorHandler();
33808 : }
33809 0 : {
33810 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33811 0 : result = (int)OGRGetDriverCount();
33812 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33813 : }
33814 0 : if ( bLocalUseExceptions ) {
33815 0 : popErrorHandler();
33816 : }
33817 : #ifndef SED_HACKS
33818 : if ( bLocalUseExceptions ) {
33819 : CPLErr eclass = CPLGetLastErrorType();
33820 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33821 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33822 : }
33823 : }
33824 : #endif
33825 : }
33826 0 : resultobj = SWIG_From_int(static_cast< int >(result));
33827 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33828 : return resultobj;
33829 0 : fail:
33830 0 : return NULL;
33831 : }
33832 :
33833 :
33834 0 : SWIGINTERN PyObject *_wrap_GetOpenDSCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33835 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33836 0 : int result;
33837 :
33838 0 : if (!SWIG_Python_UnpackTuple(args, "GetOpenDSCount", 0, 0, 0)) SWIG_fail;
33839 0 : {
33840 0 : const int bLocalUseExceptions = GetUseExceptions();
33841 0 : if ( bLocalUseExceptions ) {
33842 0 : pushErrorHandler();
33843 : }
33844 0 : {
33845 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33846 0 : result = (int)OGRGetOpenDSCount();
33847 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33848 : }
33849 0 : if ( bLocalUseExceptions ) {
33850 0 : popErrorHandler();
33851 : }
33852 : #ifndef SED_HACKS
33853 : if ( bLocalUseExceptions ) {
33854 : CPLErr eclass = CPLGetLastErrorType();
33855 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33856 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33857 : }
33858 : }
33859 : #endif
33860 : }
33861 0 : resultobj = SWIG_From_int(static_cast< int >(result));
33862 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33863 : return resultobj;
33864 0 : fail:
33865 0 : return NULL;
33866 : }
33867 :
33868 :
33869 4 : SWIGINTERN PyObject *_wrap_SetGenerate_DB2_V72_BYTE_ORDER(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33870 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33871 4 : int arg1 ;
33872 4 : int val1 ;
33873 4 : int ecode1 = 0 ;
33874 4 : PyObject *swig_obj[1] ;
33875 4 : OGRErr result;
33876 :
33877 4 : if (!args) SWIG_fail;
33878 4 : swig_obj[0] = args;
33879 4 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
33880 4 : if (!SWIG_IsOK(ecode1)) {
33881 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SetGenerate_DB2_V72_BYTE_ORDER" "', argument " "1"" of type '" "int""'");
33882 : }
33883 4 : arg1 = static_cast< int >(val1);
33884 4 : {
33885 4 : const int bLocalUseExceptions = GetUseExceptions();
33886 4 : if ( bLocalUseExceptions ) {
33887 4 : pushErrorHandler();
33888 : }
33889 4 : {
33890 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33891 4 : result = (OGRErr)OGRSetGenerate_DB2_V72_BYTE_ORDER(arg1);
33892 4 : SWIG_PYTHON_THREAD_END_ALLOW;
33893 : }
33894 4 : if ( bLocalUseExceptions ) {
33895 4 : popErrorHandler();
33896 : }
33897 : #ifndef SED_HACKS
33898 : if ( bLocalUseExceptions ) {
33899 : CPLErr eclass = CPLGetLastErrorType();
33900 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33901 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33902 : }
33903 : }
33904 : #endif
33905 : }
33906 4 : {
33907 : /* %typemap(out) OGRErr */
33908 4 : if ( result != 0 && GetUseExceptions()) {
33909 0 : const char* pszMessage = CPLGetLastErrorMsg();
33910 0 : if( pszMessage[0] != '\0' )
33911 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
33912 : else
33913 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
33914 0 : SWIG_fail;
33915 : }
33916 : }
33917 4 : {
33918 : /* %typemap(ret) OGRErr */
33919 4 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
33920 4 : resultobj = PyInt_FromLong( result );
33921 : }
33922 : }
33923 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33924 : return resultobj;
33925 : fail:
33926 : return NULL;
33927 : }
33928 :
33929 :
33930 3 : SWIGINTERN PyObject *_wrap_RegisterAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33931 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33932 :
33933 3 : if (!SWIG_Python_UnpackTuple(args, "RegisterAll", 0, 0, 0)) SWIG_fail;
33934 3 : {
33935 3 : const int bLocalUseExceptions = GetUseExceptions();
33936 3 : if ( bLocalUseExceptions ) {
33937 3 : pushErrorHandler();
33938 : }
33939 3 : {
33940 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33941 3 : OGRRegisterAll();
33942 3 : SWIG_PYTHON_THREAD_END_ALLOW;
33943 : }
33944 3 : if ( bLocalUseExceptions ) {
33945 3 : popErrorHandler();
33946 : }
33947 : #ifndef SED_HACKS
33948 : if ( bLocalUseExceptions ) {
33949 : CPLErr eclass = CPLGetLastErrorType();
33950 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33951 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33952 : }
33953 : }
33954 : #endif
33955 : }
33956 3 : resultobj = SWIG_Py_Void();
33957 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
33958 : return resultobj;
33959 0 : fail:
33960 0 : return NULL;
33961 : }
33962 :
33963 :
33964 71 : SWIGINTERN PyObject *_wrap_GeometryTypeToName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33965 71 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33966 71 : OGRwkbGeometryType arg1 ;
33967 71 : int val1 ;
33968 71 : int ecode1 = 0 ;
33969 71 : PyObject *swig_obj[1] ;
33970 71 : char *result = 0 ;
33971 :
33972 71 : if (!args) SWIG_fail;
33973 71 : swig_obj[0] = args;
33974 71 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
33975 71 : if (!SWIG_IsOK(ecode1)) {
33976 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GeometryTypeToName" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
33977 : }
33978 71 : arg1 = static_cast< OGRwkbGeometryType >(val1);
33979 71 : {
33980 71 : const int bLocalUseExceptions = GetUseExceptions();
33981 71 : if ( bLocalUseExceptions ) {
33982 46 : pushErrorHandler();
33983 : }
33984 71 : {
33985 71 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33986 71 : result = (char *)OGRGeometryTypeToName(arg1);
33987 71 : SWIG_PYTHON_THREAD_END_ALLOW;
33988 : }
33989 71 : if ( bLocalUseExceptions ) {
33990 46 : popErrorHandler();
33991 : }
33992 : #ifndef SED_HACKS
33993 : if ( bLocalUseExceptions ) {
33994 : CPLErr eclass = CPLGetLastErrorType();
33995 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33996 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33997 : }
33998 : }
33999 : #endif
34000 : }
34001 71 : resultobj = SWIG_FromCharPtr((const char *)result);
34002 71 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34003 : return resultobj;
34004 : fail:
34005 : return NULL;
34006 : }
34007 :
34008 :
34009 1649 : SWIGINTERN PyObject *_wrap_GetFieldTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34010 1649 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34011 1649 : OGRFieldType arg1 ;
34012 1649 : int val1 ;
34013 1649 : int ecode1 = 0 ;
34014 1649 : PyObject *swig_obj[1] ;
34015 1649 : char *result = 0 ;
34016 :
34017 1649 : if (!args) SWIG_fail;
34018 1649 : swig_obj[0] = args;
34019 1649 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34020 1649 : if (!SWIG_IsOK(ecode1)) {
34021 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetFieldTypeName" "', argument " "1"" of type '" "OGRFieldType""'");
34022 : }
34023 1649 : arg1 = static_cast< OGRFieldType >(val1);
34024 1649 : {
34025 1649 : const int bLocalUseExceptions = GetUseExceptions();
34026 1649 : if ( bLocalUseExceptions ) {
34027 1477 : pushErrorHandler();
34028 : }
34029 1649 : {
34030 1649 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34031 1649 : result = (char *)OGR_GetFieldTypeName(arg1);
34032 1649 : SWIG_PYTHON_THREAD_END_ALLOW;
34033 : }
34034 1649 : if ( bLocalUseExceptions ) {
34035 1477 : popErrorHandler();
34036 : }
34037 : #ifndef SED_HACKS
34038 : if ( bLocalUseExceptions ) {
34039 : CPLErr eclass = CPLGetLastErrorType();
34040 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34041 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34042 : }
34043 : }
34044 : #endif
34045 : }
34046 1649 : resultobj = SWIG_FromCharPtr((const char *)result);
34047 1649 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34048 : return resultobj;
34049 : fail:
34050 : return NULL;
34051 : }
34052 :
34053 :
34054 1480 : SWIGINTERN PyObject *_wrap_GetFieldSubTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34055 1480 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34056 1480 : OGRFieldSubType arg1 ;
34057 1480 : int val1 ;
34058 1480 : int ecode1 = 0 ;
34059 1480 : PyObject *swig_obj[1] ;
34060 1480 : char *result = 0 ;
34061 :
34062 1480 : if (!args) SWIG_fail;
34063 1480 : swig_obj[0] = args;
34064 1480 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34065 1480 : if (!SWIG_IsOK(ecode1)) {
34066 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetFieldSubTypeName" "', argument " "1"" of type '" "OGRFieldSubType""'");
34067 : }
34068 1480 : arg1 = static_cast< OGRFieldSubType >(val1);
34069 1480 : {
34070 1480 : const int bLocalUseExceptions = GetUseExceptions();
34071 1480 : if ( bLocalUseExceptions ) {
34072 1480 : pushErrorHandler();
34073 : }
34074 1480 : {
34075 1480 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34076 1480 : result = (char *)OGR_GetFieldSubTypeName(arg1);
34077 1480 : SWIG_PYTHON_THREAD_END_ALLOW;
34078 : }
34079 1480 : if ( bLocalUseExceptions ) {
34080 1480 : popErrorHandler();
34081 : }
34082 : #ifndef SED_HACKS
34083 : if ( bLocalUseExceptions ) {
34084 : CPLErr eclass = CPLGetLastErrorType();
34085 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34086 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34087 : }
34088 : }
34089 : #endif
34090 : }
34091 1480 : resultobj = SWIG_FromCharPtr((const char *)result);
34092 1480 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34093 : return resultobj;
34094 : fail:
34095 : return NULL;
34096 : }
34097 :
34098 :
34099 2077 : SWIGINTERN PyObject *_wrap_GT_Flatten(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34100 2077 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34101 2077 : OGRwkbGeometryType arg1 ;
34102 2077 : int val1 ;
34103 2077 : int ecode1 = 0 ;
34104 2077 : PyObject *swig_obj[1] ;
34105 2077 : OGRwkbGeometryType result;
34106 :
34107 2077 : if (!args) SWIG_fail;
34108 2077 : swig_obj[0] = args;
34109 2077 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34110 2077 : if (!SWIG_IsOK(ecode1)) {
34111 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_Flatten" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34112 : }
34113 2077 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34114 2077 : {
34115 2077 : const int bLocalUseExceptions = GetUseExceptions();
34116 2077 : if ( bLocalUseExceptions ) {
34117 119 : pushErrorHandler();
34118 : }
34119 2077 : {
34120 2077 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34121 2077 : result = (OGRwkbGeometryType)OGR_GT_Flatten(arg1);
34122 2077 : SWIG_PYTHON_THREAD_END_ALLOW;
34123 : }
34124 2077 : if ( bLocalUseExceptions ) {
34125 119 : popErrorHandler();
34126 : }
34127 : #ifndef SED_HACKS
34128 : if ( bLocalUseExceptions ) {
34129 : CPLErr eclass = CPLGetLastErrorType();
34130 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34131 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34132 : }
34133 : }
34134 : #endif
34135 : }
34136 2077 : resultobj = SWIG_From_int(static_cast< int >(result));
34137 2077 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34138 : return resultobj;
34139 : fail:
34140 : return NULL;
34141 : }
34142 :
34143 :
34144 36 : SWIGINTERN PyObject *_wrap_GT_SetZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34145 36 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34146 36 : OGRwkbGeometryType arg1 ;
34147 36 : int val1 ;
34148 36 : int ecode1 = 0 ;
34149 36 : PyObject *swig_obj[1] ;
34150 36 : OGRwkbGeometryType result;
34151 :
34152 36 : if (!args) SWIG_fail;
34153 36 : swig_obj[0] = args;
34154 36 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34155 36 : if (!SWIG_IsOK(ecode1)) {
34156 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_SetZ" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34157 : }
34158 36 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34159 36 : {
34160 36 : const int bLocalUseExceptions = GetUseExceptions();
34161 36 : if ( bLocalUseExceptions ) {
34162 0 : pushErrorHandler();
34163 : }
34164 36 : {
34165 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34166 36 : result = (OGRwkbGeometryType)OGR_GT_SetZ(arg1);
34167 36 : SWIG_PYTHON_THREAD_END_ALLOW;
34168 : }
34169 36 : if ( bLocalUseExceptions ) {
34170 0 : popErrorHandler();
34171 : }
34172 : #ifndef SED_HACKS
34173 : if ( bLocalUseExceptions ) {
34174 : CPLErr eclass = CPLGetLastErrorType();
34175 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34176 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34177 : }
34178 : }
34179 : #endif
34180 : }
34181 36 : resultobj = SWIG_From_int(static_cast< int >(result));
34182 36 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34183 : return resultobj;
34184 : fail:
34185 : return NULL;
34186 : }
34187 :
34188 :
34189 36 : SWIGINTERN PyObject *_wrap_GT_SetM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34190 36 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34191 36 : OGRwkbGeometryType arg1 ;
34192 36 : int val1 ;
34193 36 : int ecode1 = 0 ;
34194 36 : PyObject *swig_obj[1] ;
34195 36 : OGRwkbGeometryType result;
34196 :
34197 36 : if (!args) SWIG_fail;
34198 36 : swig_obj[0] = args;
34199 36 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34200 36 : if (!SWIG_IsOK(ecode1)) {
34201 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_SetM" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34202 : }
34203 36 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34204 36 : {
34205 36 : const int bLocalUseExceptions = GetUseExceptions();
34206 36 : if ( bLocalUseExceptions ) {
34207 0 : pushErrorHandler();
34208 : }
34209 36 : {
34210 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34211 36 : result = (OGRwkbGeometryType)OGR_GT_SetM(arg1);
34212 36 : SWIG_PYTHON_THREAD_END_ALLOW;
34213 : }
34214 36 : if ( bLocalUseExceptions ) {
34215 0 : popErrorHandler();
34216 : }
34217 : #ifndef SED_HACKS
34218 : if ( bLocalUseExceptions ) {
34219 : CPLErr eclass = CPLGetLastErrorType();
34220 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34221 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34222 : }
34223 : }
34224 : #endif
34225 : }
34226 36 : resultobj = SWIG_From_int(static_cast< int >(result));
34227 36 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34228 : return resultobj;
34229 : fail:
34230 : return NULL;
34231 : }
34232 :
34233 :
34234 18 : SWIGINTERN PyObject *_wrap_GT_SetModifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34235 18 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34236 18 : OGRwkbGeometryType arg1 ;
34237 18 : int arg2 ;
34238 18 : int arg3 = (int) FALSE ;
34239 18 : int val1 ;
34240 18 : int ecode1 = 0 ;
34241 18 : int val2 ;
34242 18 : int ecode2 = 0 ;
34243 18 : int val3 ;
34244 18 : int ecode3 = 0 ;
34245 18 : PyObject *swig_obj[3] ;
34246 18 : OGRwkbGeometryType result;
34247 :
34248 18 : if (!SWIG_Python_UnpackTuple(args, "GT_SetModifier", 2, 3, swig_obj)) SWIG_fail;
34249 18 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34250 18 : if (!SWIG_IsOK(ecode1)) {
34251 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_SetModifier" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34252 : }
34253 18 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34254 18 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34255 18 : if (!SWIG_IsOK(ecode2)) {
34256 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GT_SetModifier" "', argument " "2"" of type '" "int""'");
34257 : }
34258 18 : arg2 = static_cast< int >(val2);
34259 18 : if (swig_obj[2]) {
34260 18 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
34261 18 : if (!SWIG_IsOK(ecode3)) {
34262 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GT_SetModifier" "', argument " "3"" of type '" "int""'");
34263 : }
34264 : arg3 = static_cast< int >(val3);
34265 : }
34266 18 : {
34267 18 : const int bLocalUseExceptions = GetUseExceptions();
34268 18 : if ( bLocalUseExceptions ) {
34269 0 : pushErrorHandler();
34270 : }
34271 18 : {
34272 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34273 18 : result = (OGRwkbGeometryType)GT_SetModifier(arg1,arg2,arg3);
34274 18 : SWIG_PYTHON_THREAD_END_ALLOW;
34275 : }
34276 18 : if ( bLocalUseExceptions ) {
34277 0 : popErrorHandler();
34278 : }
34279 : #ifndef SED_HACKS
34280 : if ( bLocalUseExceptions ) {
34281 : CPLErr eclass = CPLGetLastErrorType();
34282 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34283 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34284 : }
34285 : }
34286 : #endif
34287 : }
34288 18 : resultobj = SWIG_From_int(static_cast< int >(result));
34289 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34290 : return resultobj;
34291 : fail:
34292 : return NULL;
34293 : }
34294 :
34295 :
34296 18 : SWIGINTERN PyObject *_wrap_GT_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34297 18 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34298 18 : OGRwkbGeometryType arg1 ;
34299 18 : int val1 ;
34300 18 : int ecode1 = 0 ;
34301 18 : PyObject *swig_obj[1] ;
34302 18 : int result;
34303 :
34304 18 : if (!args) SWIG_fail;
34305 18 : swig_obj[0] = args;
34306 18 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34307 18 : if (!SWIG_IsOK(ecode1)) {
34308 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_HasZ" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34309 : }
34310 18 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34311 18 : {
34312 18 : const int bLocalUseExceptions = GetUseExceptions();
34313 18 : if ( bLocalUseExceptions ) {
34314 0 : pushErrorHandler();
34315 : }
34316 18 : {
34317 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34318 18 : result = (int)OGR_GT_HasZ(arg1);
34319 18 : SWIG_PYTHON_THREAD_END_ALLOW;
34320 : }
34321 18 : if ( bLocalUseExceptions ) {
34322 0 : popErrorHandler();
34323 : }
34324 : #ifndef SED_HACKS
34325 : if ( bLocalUseExceptions ) {
34326 : CPLErr eclass = CPLGetLastErrorType();
34327 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34328 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34329 : }
34330 : }
34331 : #endif
34332 : }
34333 18 : resultobj = SWIG_From_int(static_cast< int >(result));
34334 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34335 : return resultobj;
34336 : fail:
34337 : return NULL;
34338 : }
34339 :
34340 :
34341 18 : SWIGINTERN PyObject *_wrap_GT_HasM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34342 18 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34343 18 : OGRwkbGeometryType arg1 ;
34344 18 : int val1 ;
34345 18 : int ecode1 = 0 ;
34346 18 : PyObject *swig_obj[1] ;
34347 18 : int result;
34348 :
34349 18 : if (!args) SWIG_fail;
34350 18 : swig_obj[0] = args;
34351 18 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34352 18 : if (!SWIG_IsOK(ecode1)) {
34353 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_HasM" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34354 : }
34355 18 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34356 18 : {
34357 18 : const int bLocalUseExceptions = GetUseExceptions();
34358 18 : if ( bLocalUseExceptions ) {
34359 0 : pushErrorHandler();
34360 : }
34361 18 : {
34362 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34363 18 : result = (int)OGR_GT_HasM(arg1);
34364 18 : SWIG_PYTHON_THREAD_END_ALLOW;
34365 : }
34366 18 : if ( bLocalUseExceptions ) {
34367 0 : popErrorHandler();
34368 : }
34369 : #ifndef SED_HACKS
34370 : if ( bLocalUseExceptions ) {
34371 : CPLErr eclass = CPLGetLastErrorType();
34372 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34373 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34374 : }
34375 : }
34376 : #endif
34377 : }
34378 18 : resultobj = SWIG_From_int(static_cast< int >(result));
34379 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34380 : return resultobj;
34381 : fail:
34382 : return NULL;
34383 : }
34384 :
34385 :
34386 14 : SWIGINTERN PyObject *_wrap_GT_IsSubClassOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34387 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34388 14 : OGRwkbGeometryType arg1 ;
34389 14 : OGRwkbGeometryType arg2 ;
34390 14 : int val1 ;
34391 14 : int ecode1 = 0 ;
34392 14 : int val2 ;
34393 14 : int ecode2 = 0 ;
34394 14 : PyObject *swig_obj[2] ;
34395 14 : int result;
34396 :
34397 14 : if (!SWIG_Python_UnpackTuple(args, "GT_IsSubClassOf", 2, 2, swig_obj)) SWIG_fail;
34398 14 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34399 14 : if (!SWIG_IsOK(ecode1)) {
34400 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_IsSubClassOf" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34401 : }
34402 14 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34403 14 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34404 14 : if (!SWIG_IsOK(ecode2)) {
34405 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GT_IsSubClassOf" "', argument " "2"" of type '" "OGRwkbGeometryType""'");
34406 : }
34407 14 : arg2 = static_cast< OGRwkbGeometryType >(val2);
34408 14 : {
34409 14 : const int bLocalUseExceptions = GetUseExceptions();
34410 14 : if ( bLocalUseExceptions ) {
34411 0 : pushErrorHandler();
34412 : }
34413 14 : {
34414 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34415 14 : result = (int)OGR_GT_IsSubClassOf(arg1,arg2);
34416 14 : SWIG_PYTHON_THREAD_END_ALLOW;
34417 : }
34418 14 : if ( bLocalUseExceptions ) {
34419 0 : popErrorHandler();
34420 : }
34421 : #ifndef SED_HACKS
34422 : if ( bLocalUseExceptions ) {
34423 : CPLErr eclass = CPLGetLastErrorType();
34424 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34425 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34426 : }
34427 : }
34428 : #endif
34429 : }
34430 14 : resultobj = SWIG_From_int(static_cast< int >(result));
34431 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34432 : return resultobj;
34433 : fail:
34434 : return NULL;
34435 : }
34436 :
34437 :
34438 15 : SWIGINTERN PyObject *_wrap_GT_IsCurve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34439 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34440 15 : OGRwkbGeometryType arg1 ;
34441 15 : int val1 ;
34442 15 : int ecode1 = 0 ;
34443 15 : PyObject *swig_obj[1] ;
34444 15 : int result;
34445 :
34446 15 : if (!args) SWIG_fail;
34447 15 : swig_obj[0] = args;
34448 15 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34449 15 : if (!SWIG_IsOK(ecode1)) {
34450 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_IsCurve" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34451 : }
34452 15 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34453 15 : {
34454 15 : const int bLocalUseExceptions = GetUseExceptions();
34455 15 : if ( bLocalUseExceptions ) {
34456 0 : pushErrorHandler();
34457 : }
34458 15 : {
34459 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34460 15 : result = (int)OGR_GT_IsCurve(arg1);
34461 15 : SWIG_PYTHON_THREAD_END_ALLOW;
34462 : }
34463 15 : if ( bLocalUseExceptions ) {
34464 0 : popErrorHandler();
34465 : }
34466 : #ifndef SED_HACKS
34467 : if ( bLocalUseExceptions ) {
34468 : CPLErr eclass = CPLGetLastErrorType();
34469 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34470 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34471 : }
34472 : }
34473 : #endif
34474 : }
34475 15 : resultobj = SWIG_From_int(static_cast< int >(result));
34476 15 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34477 : return resultobj;
34478 : fail:
34479 : return NULL;
34480 : }
34481 :
34482 :
34483 13 : SWIGINTERN PyObject *_wrap_GT_IsSurface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34484 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34485 13 : OGRwkbGeometryType arg1 ;
34486 13 : int val1 ;
34487 13 : int ecode1 = 0 ;
34488 13 : PyObject *swig_obj[1] ;
34489 13 : int result;
34490 :
34491 13 : if (!args) SWIG_fail;
34492 13 : swig_obj[0] = args;
34493 13 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34494 13 : if (!SWIG_IsOK(ecode1)) {
34495 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_IsSurface" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34496 : }
34497 13 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34498 13 : {
34499 13 : const int bLocalUseExceptions = GetUseExceptions();
34500 13 : if ( bLocalUseExceptions ) {
34501 0 : pushErrorHandler();
34502 : }
34503 13 : {
34504 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34505 13 : result = (int)OGR_GT_IsSurface(arg1);
34506 13 : SWIG_PYTHON_THREAD_END_ALLOW;
34507 : }
34508 13 : if ( bLocalUseExceptions ) {
34509 0 : popErrorHandler();
34510 : }
34511 : #ifndef SED_HACKS
34512 : if ( bLocalUseExceptions ) {
34513 : CPLErr eclass = CPLGetLastErrorType();
34514 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34515 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34516 : }
34517 : }
34518 : #endif
34519 : }
34520 13 : resultobj = SWIG_From_int(static_cast< int >(result));
34521 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34522 : return resultobj;
34523 : fail:
34524 : return NULL;
34525 : }
34526 :
34527 :
34528 15 : SWIGINTERN PyObject *_wrap_GT_IsNonLinear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34529 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34530 15 : OGRwkbGeometryType arg1 ;
34531 15 : int val1 ;
34532 15 : int ecode1 = 0 ;
34533 15 : PyObject *swig_obj[1] ;
34534 15 : int result;
34535 :
34536 15 : if (!args) SWIG_fail;
34537 15 : swig_obj[0] = args;
34538 15 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34539 15 : if (!SWIG_IsOK(ecode1)) {
34540 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_IsNonLinear" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34541 : }
34542 15 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34543 15 : {
34544 15 : const int bLocalUseExceptions = GetUseExceptions();
34545 15 : if ( bLocalUseExceptions ) {
34546 0 : pushErrorHandler();
34547 : }
34548 15 : {
34549 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34550 15 : result = (int)OGR_GT_IsNonLinear(arg1);
34551 15 : SWIG_PYTHON_THREAD_END_ALLOW;
34552 : }
34553 15 : if ( bLocalUseExceptions ) {
34554 0 : popErrorHandler();
34555 : }
34556 : #ifndef SED_HACKS
34557 : if ( bLocalUseExceptions ) {
34558 : CPLErr eclass = CPLGetLastErrorType();
34559 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34560 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34561 : }
34562 : }
34563 : #endif
34564 : }
34565 15 : resultobj = SWIG_From_int(static_cast< int >(result));
34566 15 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34567 : return resultobj;
34568 : fail:
34569 : return NULL;
34570 : }
34571 :
34572 :
34573 9 : SWIGINTERN PyObject *_wrap_GT_GetCollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34574 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34575 9 : OGRwkbGeometryType arg1 ;
34576 9 : int val1 ;
34577 9 : int ecode1 = 0 ;
34578 9 : PyObject *swig_obj[1] ;
34579 9 : OGRwkbGeometryType result;
34580 :
34581 9 : if (!args) SWIG_fail;
34582 9 : swig_obj[0] = args;
34583 9 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34584 9 : if (!SWIG_IsOK(ecode1)) {
34585 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_GetCollection" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34586 : }
34587 9 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34588 9 : {
34589 9 : const int bLocalUseExceptions = GetUseExceptions();
34590 9 : if ( bLocalUseExceptions ) {
34591 0 : pushErrorHandler();
34592 : }
34593 9 : {
34594 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34595 9 : result = (OGRwkbGeometryType)OGR_GT_GetCollection(arg1);
34596 9 : SWIG_PYTHON_THREAD_END_ALLOW;
34597 : }
34598 9 : if ( bLocalUseExceptions ) {
34599 0 : popErrorHandler();
34600 : }
34601 : #ifndef SED_HACKS
34602 : if ( bLocalUseExceptions ) {
34603 : CPLErr eclass = CPLGetLastErrorType();
34604 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34605 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34606 : }
34607 : }
34608 : #endif
34609 : }
34610 9 : resultobj = SWIG_From_int(static_cast< int >(result));
34611 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34612 : return resultobj;
34613 : fail:
34614 : return NULL;
34615 : }
34616 :
34617 :
34618 16 : SWIGINTERN PyObject *_wrap_GT_GetCurve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34619 16 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34620 16 : OGRwkbGeometryType arg1 ;
34621 16 : int val1 ;
34622 16 : int ecode1 = 0 ;
34623 16 : PyObject *swig_obj[1] ;
34624 16 : OGRwkbGeometryType result;
34625 :
34626 16 : if (!args) SWIG_fail;
34627 16 : swig_obj[0] = args;
34628 16 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34629 16 : if (!SWIG_IsOK(ecode1)) {
34630 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_GetCurve" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34631 : }
34632 16 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34633 16 : {
34634 16 : const int bLocalUseExceptions = GetUseExceptions();
34635 16 : if ( bLocalUseExceptions ) {
34636 0 : pushErrorHandler();
34637 : }
34638 16 : {
34639 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34640 16 : result = (OGRwkbGeometryType)OGR_GT_GetCurve(arg1);
34641 16 : SWIG_PYTHON_THREAD_END_ALLOW;
34642 : }
34643 16 : if ( bLocalUseExceptions ) {
34644 0 : popErrorHandler();
34645 : }
34646 : #ifndef SED_HACKS
34647 : if ( bLocalUseExceptions ) {
34648 : CPLErr eclass = CPLGetLastErrorType();
34649 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34650 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34651 : }
34652 : }
34653 : #endif
34654 : }
34655 16 : resultobj = SWIG_From_int(static_cast< int >(result));
34656 16 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34657 : return resultobj;
34658 : fail:
34659 : return NULL;
34660 : }
34661 :
34662 :
34663 16 : SWIGINTERN PyObject *_wrap_GT_GetLinear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34664 16 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34665 16 : OGRwkbGeometryType arg1 ;
34666 16 : int val1 ;
34667 16 : int ecode1 = 0 ;
34668 16 : PyObject *swig_obj[1] ;
34669 16 : OGRwkbGeometryType result;
34670 :
34671 16 : if (!args) SWIG_fail;
34672 16 : swig_obj[0] = args;
34673 16 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34674 16 : if (!SWIG_IsOK(ecode1)) {
34675 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GT_GetLinear" "', argument " "1"" of type '" "OGRwkbGeometryType""'");
34676 : }
34677 16 : arg1 = static_cast< OGRwkbGeometryType >(val1);
34678 16 : {
34679 16 : const int bLocalUseExceptions = GetUseExceptions();
34680 16 : if ( bLocalUseExceptions ) {
34681 0 : pushErrorHandler();
34682 : }
34683 16 : {
34684 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34685 16 : result = (OGRwkbGeometryType)OGR_GT_GetLinear(arg1);
34686 16 : SWIG_PYTHON_THREAD_END_ALLOW;
34687 : }
34688 16 : if ( bLocalUseExceptions ) {
34689 0 : popErrorHandler();
34690 : }
34691 : #ifndef SED_HACKS
34692 : if ( bLocalUseExceptions ) {
34693 : CPLErr eclass = CPLGetLastErrorType();
34694 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34695 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34696 : }
34697 : }
34698 : #endif
34699 : }
34700 16 : resultobj = SWIG_From_int(static_cast< int >(result));
34701 16 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34702 : return resultobj;
34703 : fail:
34704 : return NULL;
34705 : }
34706 :
34707 :
34708 2 : SWIGINTERN PyObject *_wrap_SetNonLinearGeometriesEnabledFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34709 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34710 2 : int arg1 ;
34711 2 : int val1 ;
34712 2 : int ecode1 = 0 ;
34713 2 : PyObject *swig_obj[1] ;
34714 :
34715 2 : if (!args) SWIG_fail;
34716 2 : swig_obj[0] = args;
34717 2 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34718 2 : if (!SWIG_IsOK(ecode1)) {
34719 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SetNonLinearGeometriesEnabledFlag" "', argument " "1"" of type '" "int""'");
34720 : }
34721 2 : arg1 = static_cast< int >(val1);
34722 2 : {
34723 2 : const int bLocalUseExceptions = GetUseExceptions();
34724 2 : if ( bLocalUseExceptions ) {
34725 0 : pushErrorHandler();
34726 : }
34727 2 : {
34728 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34729 2 : OGRSetNonLinearGeometriesEnabledFlag(arg1);
34730 2 : SWIG_PYTHON_THREAD_END_ALLOW;
34731 : }
34732 2 : if ( bLocalUseExceptions ) {
34733 0 : popErrorHandler();
34734 : }
34735 : #ifndef SED_HACKS
34736 : if ( bLocalUseExceptions ) {
34737 : CPLErr eclass = CPLGetLastErrorType();
34738 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34739 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34740 : }
34741 : }
34742 : #endif
34743 : }
34744 2 : resultobj = SWIG_Py_Void();
34745 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34746 : return resultobj;
34747 : fail:
34748 : return NULL;
34749 : }
34750 :
34751 :
34752 1 : SWIGINTERN PyObject *_wrap_GetNonLinearGeometriesEnabledFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34753 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34754 1 : int result;
34755 :
34756 1 : if (!SWIG_Python_UnpackTuple(args, "GetNonLinearGeometriesEnabledFlag", 0, 0, 0)) SWIG_fail;
34757 1 : {
34758 1 : const int bLocalUseExceptions = GetUseExceptions();
34759 1 : if ( bLocalUseExceptions ) {
34760 0 : pushErrorHandler();
34761 : }
34762 1 : {
34763 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34764 1 : result = (int)OGRGetNonLinearGeometriesEnabledFlag();
34765 1 : SWIG_PYTHON_THREAD_END_ALLOW;
34766 : }
34767 1 : if ( bLocalUseExceptions ) {
34768 0 : popErrorHandler();
34769 : }
34770 : #ifndef SED_HACKS
34771 : if ( bLocalUseExceptions ) {
34772 : CPLErr eclass = CPLGetLastErrorType();
34773 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34774 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34775 : }
34776 : }
34777 : #endif
34778 : }
34779 1 : resultobj = SWIG_From_int(static_cast< int >(result));
34780 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34781 : return resultobj;
34782 0 : fail:
34783 0 : return NULL;
34784 : }
34785 :
34786 :
34787 1 : SWIGINTERN PyObject *_wrap_GetOpenDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34788 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34789 1 : int arg1 ;
34790 1 : int val1 ;
34791 1 : int ecode1 = 0 ;
34792 1 : PyObject *swig_obj[1] ;
34793 1 : OGRDataSourceShadow *result = 0 ;
34794 :
34795 1 : if (!args) SWIG_fail;
34796 1 : swig_obj[0] = args;
34797 1 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
34798 1 : if (!SWIG_IsOK(ecode1)) {
34799 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetOpenDS" "', argument " "1"" of type '" "int""'");
34800 : }
34801 1 : arg1 = static_cast< int >(val1);
34802 1 : {
34803 1 : const int bLocalUseExceptions = GetUseExceptions();
34804 1 : if ( bLocalUseExceptions ) {
34805 0 : pushErrorHandler();
34806 : }
34807 1 : {
34808 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34809 1 : result = (OGRDataSourceShadow *)GetOpenDS(arg1);
34810 1 : SWIG_PYTHON_THREAD_END_ALLOW;
34811 : }
34812 1 : if ( bLocalUseExceptions ) {
34813 0 : popErrorHandler();
34814 : }
34815 : #ifndef SED_HACKS
34816 : if ( bLocalUseExceptions ) {
34817 : CPLErr eclass = CPLGetLastErrorType();
34818 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34819 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34820 : }
34821 : }
34822 : #endif
34823 : }
34824 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
34825 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34826 : return resultobj;
34827 : fail:
34828 : return NULL;
34829 : }
34830 :
34831 :
34832 6957 : SWIGINTERN PyObject *_wrap_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34833 6957 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34834 6957 : char *arg1 = (char *) 0 ;
34835 6957 : int arg2 = (int) 0 ;
34836 6957 : int bToFree1 = 0 ;
34837 6957 : int val2 ;
34838 6957 : int ecode2 = 0 ;
34839 6957 : PyObject * obj0 = 0 ;
34840 6957 : PyObject * obj1 = 0 ;
34841 6957 : char * kwnames[] = {
34842 : (char *)"utf8_path", (char *)"update", NULL
34843 : };
34844 6957 : OGRDataSourceShadow *result = 0 ;
34845 :
34846 6957 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Open", kwnames, &obj0, &obj1)) SWIG_fail;
34847 6957 : {
34848 : /* %typemap(in) (const char *utf8_path) */
34849 6957 : if (PyUnicode_Check(obj0) || PyBytes_Check(obj0))
34850 : {
34851 3769 : arg1 = GDALPythonObjectToCStr( obj0, &bToFree1 );
34852 : }
34853 : else
34854 : {
34855 3188 : arg1 = GDALPythonPathToCStr(obj0, &bToFree1);
34856 :
34857 : }
34858 6957 : if (arg1 == NULL)
34859 : {
34860 1 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
34861 1 : SWIG_fail;
34862 : }
34863 : }
34864 6956 : if (obj1) {
34865 1670 : ecode2 = SWIG_AsVal_int(obj1, &val2);
34866 1670 : if (!SWIG_IsOK(ecode2)) {
34867 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Open" "', argument " "2"" of type '" "int""'");
34868 : }
34869 : arg2 = static_cast< int >(val2);
34870 : }
34871 6956 : {
34872 6956 : const int bLocalUseExceptions = GetUseExceptions();
34873 6956 : if ( bLocalUseExceptions ) {
34874 2630 : pushErrorHandler();
34875 : }
34876 6956 : {
34877 6956 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34878 6956 : result = (OGRDataSourceShadow *)Open((char const *)arg1,arg2);
34879 6956 : SWIG_PYTHON_THREAD_END_ALLOW;
34880 : }
34881 6956 : if ( bLocalUseExceptions ) {
34882 2630 : popErrorHandler();
34883 : }
34884 : #ifndef SED_HACKS
34885 : if( result == NULL && bLocalUseExceptions ) {
34886 : CPLErr eclass = CPLGetLastErrorType();
34887 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34888 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34889 : }
34890 : }
34891 : #endif
34892 6956 : if( result != NULL && bLocalUseExceptions ) {
34893 : #ifdef SED_HACKS
34894 2558 : bLocalUseExceptionsCode = FALSE;
34895 : #endif
34896 : }
34897 : }
34898 6956 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
34899 6956 : {
34900 : /* %typemap(freearg) (const char *utf8_path) */
34901 6956 : GDALPythonFreeCStr(arg1, bToFree1);
34902 : }
34903 7028 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34904 : return resultobj;
34905 1 : fail:
34906 1 : {
34907 : /* %typemap(freearg) (const char *utf8_path) */
34908 6957 : GDALPythonFreeCStr(arg1, bToFree1);
34909 : }
34910 : return NULL;
34911 : }
34912 :
34913 :
34914 23 : SWIGINTERN PyObject *_wrap_OpenShared(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34915 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34916 23 : char *arg1 = (char *) 0 ;
34917 23 : int arg2 = (int) 0 ;
34918 23 : int bToFree1 = 0 ;
34919 23 : int val2 ;
34920 23 : int ecode2 = 0 ;
34921 23 : PyObject * obj0 = 0 ;
34922 23 : PyObject * obj1 = 0 ;
34923 23 : char * kwnames[] = {
34924 : (char *)"utf8_path", (char *)"update", NULL
34925 : };
34926 23 : OGRDataSourceShadow *result = 0 ;
34927 :
34928 23 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:OpenShared", kwnames, &obj0, &obj1)) SWIG_fail;
34929 23 : {
34930 : /* %typemap(in) (const char *utf8_path) */
34931 23 : if (PyUnicode_Check(obj0) || PyBytes_Check(obj0))
34932 : {
34933 23 : arg1 = GDALPythonObjectToCStr( obj0, &bToFree1 );
34934 : }
34935 : else
34936 : {
34937 0 : arg1 = GDALPythonPathToCStr(obj0, &bToFree1);
34938 :
34939 : }
34940 23 : if (arg1 == NULL)
34941 : {
34942 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
34943 0 : SWIG_fail;
34944 : }
34945 : }
34946 23 : if (obj1) {
34947 14 : ecode2 = SWIG_AsVal_int(obj1, &val2);
34948 14 : if (!SWIG_IsOK(ecode2)) {
34949 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OpenShared" "', argument " "2"" of type '" "int""'");
34950 : }
34951 : arg2 = static_cast< int >(val2);
34952 : }
34953 23 : {
34954 23 : const int bLocalUseExceptions = GetUseExceptions();
34955 23 : if ( bLocalUseExceptions ) {
34956 14 : pushErrorHandler();
34957 : }
34958 23 : {
34959 23 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34960 23 : result = (OGRDataSourceShadow *)OpenShared((char const *)arg1,arg2);
34961 23 : SWIG_PYTHON_THREAD_END_ALLOW;
34962 : }
34963 23 : if ( bLocalUseExceptions ) {
34964 14 : popErrorHandler();
34965 : }
34966 : #ifndef SED_HACKS
34967 : if( result == NULL && bLocalUseExceptions ) {
34968 : CPLErr eclass = CPLGetLastErrorType();
34969 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34970 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34971 : }
34972 : }
34973 : #endif
34974 23 : if( result != NULL && bLocalUseExceptions ) {
34975 : #ifdef SED_HACKS
34976 14 : bLocalUseExceptionsCode = FALSE;
34977 : #endif
34978 : }
34979 : }
34980 23 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
34981 23 : {
34982 : /* %typemap(freearg) (const char *utf8_path) */
34983 23 : GDALPythonFreeCStr(arg1, bToFree1);
34984 : }
34985 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
34986 : return resultobj;
34987 0 : fail:
34988 0 : {
34989 : /* %typemap(freearg) (const char *utf8_path) */
34990 23 : GDALPythonFreeCStr(arg1, bToFree1);
34991 : }
34992 : return NULL;
34993 : }
34994 :
34995 :
34996 2603 : SWIGINTERN PyObject *_wrap_GetDriverByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34997 2603 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34998 2603 : char *arg1 = (char *) 0 ;
34999 2603 : int res1 ;
35000 2603 : char *buf1 = 0 ;
35001 2603 : int alloc1 = 0 ;
35002 2603 : PyObject *swig_obj[1] ;
35003 2603 : OGRDriverShadow *result = 0 ;
35004 :
35005 2603 : if (!args) SWIG_fail;
35006 2603 : swig_obj[0] = args;
35007 2603 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
35008 2603 : if (!SWIG_IsOK(res1)) {
35009 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDriverByName" "', argument " "1"" of type '" "char const *""'");
35010 : }
35011 2603 : arg1 = reinterpret_cast< char * >(buf1);
35012 2603 : {
35013 2603 : const int bLocalUseExceptions = GetUseExceptions();
35014 2603 : if ( bLocalUseExceptions ) {
35015 1343 : pushErrorHandler();
35016 : }
35017 2603 : result = (OGRDriverShadow *)GetDriverByName((char const *)arg1);
35018 2603 : if ( bLocalUseExceptions ) {
35019 1343 : popErrorHandler();
35020 : }
35021 : #ifndef SED_HACKS
35022 : if ( bLocalUseExceptions ) {
35023 : CPLErr eclass = CPLGetLastErrorType();
35024 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35025 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35026 : }
35027 : }
35028 : #endif
35029 : }
35030 2603 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
35031 2603 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
35032 2603 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
35033 : return resultobj;
35034 0 : fail:
35035 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
35036 : return NULL;
35037 : }
35038 :
35039 :
35040 0 : SWIGINTERN PyObject *_wrap_GetDriver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35041 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35042 0 : int arg1 ;
35043 0 : int val1 ;
35044 0 : int ecode1 = 0 ;
35045 0 : PyObject *swig_obj[1] ;
35046 0 : OGRDriverShadow *result = 0 ;
35047 :
35048 0 : if (!args) SWIG_fail;
35049 0 : swig_obj[0] = args;
35050 0 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
35051 0 : if (!SWIG_IsOK(ecode1)) {
35052 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetDriver" "', argument " "1"" of type '" "int""'");
35053 : }
35054 0 : arg1 = static_cast< int >(val1);
35055 0 : {
35056 0 : const int bLocalUseExceptions = GetUseExceptions();
35057 0 : if ( bLocalUseExceptions ) {
35058 0 : pushErrorHandler();
35059 : }
35060 0 : result = (OGRDriverShadow *)GetDriver(arg1);
35061 0 : if ( bLocalUseExceptions ) {
35062 0 : popErrorHandler();
35063 : }
35064 : #ifndef SED_HACKS
35065 : if ( bLocalUseExceptions ) {
35066 : CPLErr eclass = CPLGetLastErrorType();
35067 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35068 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35069 : }
35070 : }
35071 : #endif
35072 : }
35073 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
35074 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
35075 : return resultobj;
35076 : fail:
35077 : return NULL;
35078 : }
35079 :
35080 :
35081 59 : SWIGINTERN PyObject *_wrap_GeneralCmdLineProcessor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35082 59 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35083 59 : char **arg1 = (char **) 0 ;
35084 59 : int arg2 = (int) 0 ;
35085 59 : int val2 ;
35086 59 : int ecode2 = 0 ;
35087 59 : PyObject *swig_obj[2] ;
35088 59 : char **result = 0 ;
35089 :
35090 59 : if (!SWIG_Python_UnpackTuple(args, "GeneralCmdLineProcessor", 1, 2, swig_obj)) SWIG_fail;
35091 59 : {
35092 : /* %typemap(in) char **dict */
35093 59 : arg1 = NULL;
35094 59 : if ( PySequence_Check( swig_obj[0] ) ) {
35095 59 : int bErr = FALSE;
35096 59 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
35097 59 : if ( bErr )
35098 : {
35099 0 : SWIG_fail;
35100 : }
35101 : }
35102 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
35103 0 : int bErr = FALSE;
35104 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
35105 0 : if ( bErr )
35106 : {
35107 0 : SWIG_fail;
35108 : }
35109 : }
35110 : else {
35111 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
35112 0 : SWIG_fail;
35113 : }
35114 : }
35115 59 : if (swig_obj[1]) {
35116 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35117 0 : if (!SWIG_IsOK(ecode2)) {
35118 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeneralCmdLineProcessor" "', argument " "2"" of type '" "int""'");
35119 : }
35120 : arg2 = static_cast< int >(val2);
35121 : }
35122 59 : {
35123 59 : const int bLocalUseExceptions = GetUseExceptions();
35124 59 : if ( bLocalUseExceptions ) {
35125 10 : pushErrorHandler();
35126 : }
35127 59 : result = (char **)GeneralCmdLineProcessor(arg1,arg2);
35128 59 : if ( bLocalUseExceptions ) {
35129 10 : popErrorHandler();
35130 : }
35131 : #ifndef SED_HACKS
35132 : if ( bLocalUseExceptions ) {
35133 : CPLErr eclass = CPLGetLastErrorType();
35134 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35135 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35136 : }
35137 : }
35138 : #endif
35139 : }
35140 59 : {
35141 : /* %typemap(out) char **CSL -> ( string ) */
35142 59 : bool bErr = false;
35143 59 : resultobj = CSLToList(result, &bErr);
35144 59 : CSLDestroy(result);
35145 59 : if( bErr ) {
35146 0 : SWIG_fail;
35147 : }
35148 : }
35149 59 : {
35150 : /* %typemap(freearg) char **dict */
35151 59 : CSLDestroy( arg1 );
35152 : }
35153 59 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
35154 : return resultobj;
35155 0 : fail:
35156 0 : {
35157 : /* %typemap(freearg) char **dict */
35158 0 : CSLDestroy( arg1 );
35159 : }
35160 : return NULL;
35161 : }
35162 :
35163 :
35164 11 : SWIGINTERN PyObject *_wrap_TermProgress_nocb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35165 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35166 11 : double arg1 ;
35167 11 : char *arg2 = (char *) NULL ;
35168 11 : void *arg3 = (void *) NULL ;
35169 11 : double val1 ;
35170 11 : int ecode1 = 0 ;
35171 11 : int res2 ;
35172 11 : char *buf2 = 0 ;
35173 11 : int alloc2 = 0 ;
35174 11 : int res3 ;
35175 11 : PyObject * obj0 = 0 ;
35176 11 : PyObject * obj1 = 0 ;
35177 11 : PyObject * obj2 = 0 ;
35178 11 : char * kwnames[] = {
35179 : (char *)"dfProgress", (char *)"pszMessage", (char *)"pData", NULL
35180 : };
35181 11 : int result;
35182 :
35183 11 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:TermProgress_nocb", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
35184 11 : ecode1 = SWIG_AsVal_double(obj0, &val1);
35185 11 : if (!SWIG_IsOK(ecode1)) {
35186 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TermProgress_nocb" "', argument " "1"" of type '" "double""'");
35187 : }
35188 11 : arg1 = static_cast< double >(val1);
35189 11 : if (obj1) {
35190 11 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35191 11 : if (!SWIG_IsOK(res2)) {
35192 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TermProgress_nocb" "', argument " "2"" of type '" "char const *""'");
35193 : }
35194 11 : arg2 = reinterpret_cast< char * >(buf2);
35195 : }
35196 11 : if (obj2) {
35197 11 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
35198 11 : if (!SWIG_IsOK(res3)) {
35199 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TermProgress_nocb" "', argument " "3"" of type '" "void *""'");
35200 : }
35201 : }
35202 11 : {
35203 11 : const int bLocalUseExceptions = GetUseExceptions();
35204 11 : if ( bLocalUseExceptions ) {
35205 5 : pushErrorHandler();
35206 : }
35207 11 : result = (int)GDALTermProgress_nocb(arg1,(char const *)arg2,arg3);
35208 11 : if ( bLocalUseExceptions ) {
35209 5 : popErrorHandler();
35210 : }
35211 : #ifndef SED_HACKS
35212 : if ( bLocalUseExceptions ) {
35213 : CPLErr eclass = CPLGetLastErrorType();
35214 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35215 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35216 : }
35217 : }
35218 : #endif
35219 : }
35220 11 : resultobj = SWIG_From_int(static_cast< int >(result));
35221 11 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
35222 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, CPLGetLastErrorMsg() ); return NULL; } }
35223 : return resultobj;
35224 0 : fail:
35225 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
35226 : return NULL;
35227 : }
35228 :
35229 :
35230 : static PyMethodDef SwigMethods[] = {
35231 : { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
35232 : { "GetUseExceptions", _wrap_GetUseExceptions, METH_NOARGS, "GetUseExceptions() -> int"},
35233 : { "_GetExceptionsLocal", _wrap__GetExceptionsLocal, METH_NOARGS, "_GetExceptionsLocal() -> int"},
35234 : { "_SetExceptionsLocal", _wrap__SetExceptionsLocal, METH_O, "_SetExceptionsLocal(int bVal)"},
35235 : { "_UseExceptions", _wrap__UseExceptions, METH_NOARGS, "_UseExceptions()"},
35236 : { "_DontUseExceptions", _wrap__DontUseExceptions, METH_NOARGS, "_DontUseExceptions()"},
35237 : { "_UserHasSpecifiedIfUsingExceptions", _wrap__UserHasSpecifiedIfUsingExceptions, METH_NOARGS, "_UserHasSpecifiedIfUsingExceptions() -> int"},
35238 : { "MajorObject_GetDescription", _wrap_MajorObject_GetDescription, METH_O, "MajorObject_GetDescription(MajorObject self) -> char const *"},
35239 : { "MajorObject_SetDescription", _wrap_MajorObject_SetDescription, METH_VARARGS, "MajorObject_SetDescription(MajorObject self, char const * pszNewDesc)"},
35240 : { "MajorObject_GetMetadataDomainList", _wrap_MajorObject_GetMetadataDomainList, METH_O, "MajorObject_GetMetadataDomainList(MajorObject self) -> char **"},
35241 : { "MajorObject_GetMetadata_Dict", _wrap_MajorObject_GetMetadata_Dict, METH_VARARGS, "MajorObject_GetMetadata_Dict(MajorObject self, char const * pszDomain=\"\") -> char **"},
35242 : { "MajorObject_GetMetadata_List", _wrap_MajorObject_GetMetadata_List, METH_VARARGS, "MajorObject_GetMetadata_List(MajorObject self, char const * pszDomain=\"\") -> char **"},
35243 : { "MajorObject_SetMetadata", _wrap_MajorObject_SetMetadata, METH_VARARGS, "\n"
35244 : "MajorObject_SetMetadata(MajorObject self, char ** papszMetadata, char const * pszDomain=\"\") -> CPLErr\n"
35245 : "MajorObject_SetMetadata(MajorObject self, char * pszMetadataString, char const * pszDomain=\"\") -> CPLErr\n"
35246 : ""},
35247 : { "MajorObject_GetMetadataItem", _wrap_MajorObject_GetMetadataItem, METH_VARARGS, "MajorObject_GetMetadataItem(MajorObject self, char const * pszName, char const * pszDomain=\"\") -> char const *"},
35248 : { "MajorObject_SetMetadataItem", _wrap_MajorObject_SetMetadataItem, METH_VARARGS, "MajorObject_SetMetadataItem(MajorObject self, char const * pszName, char const * pszValue, char const * pszDomain=\"\") -> CPLErr"},
35249 : { "MajorObject_swigregister", MajorObject_swigregister, METH_O, NULL},
35250 : { "GetGEOSVersionMajor", _wrap_GetGEOSVersionMajor, METH_NOARGS, "GetGEOSVersionMajor() -> int"},
35251 : { "GetGEOSVersionMinor", _wrap_GetGEOSVersionMinor, METH_NOARGS, "GetGEOSVersionMinor() -> int"},
35252 : { "GetGEOSVersionMicro", _wrap_GetGEOSVersionMicro, METH_NOARGS, "GetGEOSVersionMicro() -> int"},
35253 : { "new_StyleTable", _wrap_new_StyleTable, METH_NOARGS, "new_StyleTable() -> StyleTable"},
35254 : { "delete_StyleTable", _wrap_delete_StyleTable, METH_O, "delete_StyleTable(StyleTable self)"},
35255 : { "StyleTable_AddStyle", _wrap_StyleTable_AddStyle, METH_VARARGS, "StyleTable_AddStyle(StyleTable self, char const * pszName, char const * pszStyleString) -> int"},
35256 : { "StyleTable_LoadStyleTable", _wrap_StyleTable_LoadStyleTable, METH_VARARGS, "StyleTable_LoadStyleTable(StyleTable self, char const * utf8_path) -> int"},
35257 : { "StyleTable_SaveStyleTable", _wrap_StyleTable_SaveStyleTable, METH_VARARGS, "StyleTable_SaveStyleTable(StyleTable self, char const * utf8_path) -> int"},
35258 : { "StyleTable_Find", _wrap_StyleTable_Find, METH_VARARGS, "StyleTable_Find(StyleTable self, char const * pszName) -> char const *"},
35259 : { "StyleTable_ResetStyleStringReading", _wrap_StyleTable_ResetStyleStringReading, METH_O, "StyleTable_ResetStyleStringReading(StyleTable self)"},
35260 : { "StyleTable_GetNextStyle", _wrap_StyleTable_GetNextStyle, METH_O, "StyleTable_GetNextStyle(StyleTable self) -> char const *"},
35261 : { "StyleTable_GetLastStyleName", _wrap_StyleTable_GetLastStyleName, METH_O, "StyleTable_GetLastStyleName(StyleTable self) -> char const *"},
35262 : { "StyleTable_swigregister", StyleTable_swigregister, METH_O, NULL},
35263 : { "StyleTable_swiginit", StyleTable_swiginit, METH_VARARGS, NULL},
35264 : { "new_ArrowArray", _wrap_new_ArrowArray, METH_NOARGS, "new_ArrowArray() -> ArrowArray"},
35265 : { "delete_ArrowArray", _wrap_delete_ArrowArray, METH_O, "delete_ArrowArray(ArrowArray self)"},
35266 : { "ArrowArray__getPtr", _wrap_ArrowArray__getPtr, METH_O, "ArrowArray__getPtr(ArrowArray self) -> VoidPtrAsLong"},
35267 : { "ArrowArray_GetChildrenCount", _wrap_ArrowArray_GetChildrenCount, METH_O, "ArrowArray_GetChildrenCount(ArrowArray self) -> GIntBig"},
35268 : { "ArrowArray_GetLength", _wrap_ArrowArray_GetLength, METH_O, "ArrowArray_GetLength(ArrowArray self) -> GIntBig"},
35269 : { "ArrowArray_swigregister", ArrowArray_swigregister, METH_O, NULL},
35270 : { "ArrowArray_swiginit", ArrowArray_swiginit, METH_VARARGS, NULL},
35271 : { "new_ArrowSchema", _wrap_new_ArrowSchema, METH_NOARGS, "new_ArrowSchema() -> ArrowSchema"},
35272 : { "delete_ArrowSchema", _wrap_delete_ArrowSchema, METH_O, "delete_ArrowSchema(ArrowSchema self)"},
35273 : { "ArrowSchema__getPtr", _wrap_ArrowSchema__getPtr, METH_O, "ArrowSchema__getPtr(ArrowSchema self) -> VoidPtrAsLong"},
35274 : { "ArrowSchema_GetName", _wrap_ArrowSchema_GetName, METH_O, "ArrowSchema_GetName(ArrowSchema self) -> char const *"},
35275 : { "ArrowSchema_GetChildrenCount", _wrap_ArrowSchema_GetChildrenCount, METH_O, "ArrowSchema_GetChildrenCount(ArrowSchema self) -> GIntBig"},
35276 : { "ArrowSchema_GetChild", _wrap_ArrowSchema_GetChild, METH_VARARGS, "ArrowSchema_GetChild(ArrowSchema self, int iChild) -> ArrowSchema"},
35277 : { "ArrowSchema_swigregister", ArrowSchema_swigregister, METH_O, NULL},
35278 : { "ArrowSchema_swiginit", ArrowSchema_swiginit, METH_VARARGS, NULL},
35279 : { "delete_ArrowArrayStream", _wrap_delete_ArrowArrayStream, METH_O, "delete_ArrowArrayStream(ArrowArrayStream self)"},
35280 : { "ArrowArrayStream_GetSchema", _wrap_ArrowArrayStream_GetSchema, METH_O, "ArrowArrayStream_GetSchema(ArrowArrayStream self) -> ArrowSchema"},
35281 : { "ArrowArrayStream_GetNextRecordBatch", _wrap_ArrowArrayStream_GetNextRecordBatch, METH_VARARGS, "ArrowArrayStream_GetNextRecordBatch(ArrowArrayStream self, char ** options=None) -> ArrowArray"},
35282 : { "ArrowArrayStream_swigregister", ArrowArrayStream_swigregister, METH_O, NULL},
35283 : { "Layer_GetDataset", _wrap_Layer_GetDataset, METH_O, "\n"
35284 : "Layer_GetDataset(Layer self) -> GDALDatasetShadow *\n"
35285 : "\n"
35286 : "Return the dataset associated with this layer.\n"
35287 : "\n"
35288 : "For more details: :cpp:func:`OGR_L_GetDataset`\n"
35289 : "\n"
35290 : "Returns\n"
35291 : "-------\n"
35292 : "Dataset:\n"
35293 : " Dataset or None\n"
35294 : "\n"
35295 : ""},
35296 : { "Layer_Rename", _wrap_Layer_Rename, METH_VARARGS, "Layer_Rename(Layer self, char const * new_name) -> OGRErr"},
35297 : { "Layer_GetRefCount", _wrap_Layer_GetRefCount, METH_O, "\n"
35298 : "Layer_GetRefCount(Layer self) -> int\n"
35299 : "\n"
35300 : "For more details: :cpp:func:`OGR_L_GetRefCount`\n"
35301 : "\n"
35302 : ""},
35303 : { "Layer_SetSpatialFilter", _wrap_Layer_SetSpatialFilter, METH_VARARGS, "\n"
35304 : "Layer_SetSpatialFilter(Layer self, Geometry filter)\n"
35305 : "Layer_SetSpatialFilter(Layer self, int iGeomField, Geometry filter)\n"
35306 : "\n"
35307 : "Set a new spatial filter.\n"
35308 : "\n"
35309 : "For more details:\n"
35310 : "\n"
35311 : "- :cpp:func:`OGR_L_SetSpatialFilter`\n"
35312 : "- :cpp:func:`OGR_L_SetSpatialFilterEx`\n"
35313 : "\n"
35314 : "Parameters\n"
35315 : "-----------\n"
35316 : "iGeomField: int, optional\n"
35317 : " index of the geometry field on which the spatial filter operates.\n"
35318 : "filter: Geometry\n"
35319 : " The geometry to use as a filtering region. None may\n"
35320 : " be passed indicating that the current spatial filter should be\n"
35321 : " cleared, but no new one instituted.\n"
35322 : "\n"
35323 : ""},
35324 : { "Layer_SetSpatialFilterRect", _wrap_Layer_SetSpatialFilterRect, METH_VARARGS, "\n"
35325 : "Layer_SetSpatialFilterRect(Layer self, double minx, double miny, double maxx, double maxy)\n"
35326 : "Layer_SetSpatialFilterRect(Layer self, int iGeomField, double minx, double miny, double maxx, double maxy)\n"
35327 : "\n"
35328 : "Set a new rectangular spatial filter.\n"
35329 : "\n"
35330 : "For more details:\n"
35331 : "\n"
35332 : "- :cpp:func:`OGR_L_SetSpatialFilterRect`\n"
35333 : "- :cpp:func:`OGR_L_SetSpatialFilterRectEx`\n"
35334 : "\n"
35335 : "Parameters\n"
35336 : "-----------\n"
35337 : "iGeomField: int, optional\n"
35338 : " index of the geometry field on which the spatial filter operates.\n"
35339 : "minx: float\n"
35340 : " the minimum X coordinate for the rectangular region.\n"
35341 : "miny: float\n"
35342 : " the minimum Y coordinate for the rectangular region.\n"
35343 : "maxx: float\n"
35344 : " the maximum X coordinate for the rectangular region.\n"
35345 : "maxy: float\n"
35346 : " the maximum Y coordinate for the rectangular region.\n"
35347 : "\n"
35348 : ""},
35349 : { "Layer_GetSpatialFilter", _wrap_Layer_GetSpatialFilter, METH_O, "\n"
35350 : "Layer_GetSpatialFilter(Layer self) -> Geometry\n"
35351 : "\n"
35352 : "This function returns the current spatial filter for this layer.\n"
35353 : "\n"
35354 : "For more details: :cpp:func:`OGR_L_GetSpatialFilter`\n"
35355 : "\n"
35356 : "Returns\n"
35357 : "--------\n"
35358 : "Geometry:\n"
35359 : " The spatial filter geometry.\n"
35360 : "\n"
35361 : ""},
35362 : { "Layer_SetAttributeFilter", _wrap_Layer_SetAttributeFilter, METH_VARARGS, "\n"
35363 : "Layer_SetAttributeFilter(Layer self, char * filter_string) -> OGRErr\n"
35364 : "\n"
35365 : "Set a new attribute query.\n"
35366 : "\n"
35367 : "For more details: :cpp:func:`OGR_L_SetAttributeFilter`\n"
35368 : "\n"
35369 : "Parameters\n"
35370 : "-----------\n"
35371 : "filter_string: str\n"
35372 : " query in restricted SQL WHERE format, or None to clear the\n"
35373 : " current query.\n"
35374 : "\n"
35375 : "Returns\n"
35376 : "--------\n"
35377 : "int:\n"
35378 : " :py:const:`osgeo.ogr.OGRERR_NONE` if successfully installed,\n"
35379 : " or an error code if the query expression is in error,\n"
35380 : " or some other failure occurs.\n"
35381 : "\n"
35382 : ""},
35383 : { "Layer_ResetReading", _wrap_Layer_ResetReading, METH_O, "\n"
35384 : "Layer_ResetReading(Layer self)\n"
35385 : "\n"
35386 : "Reset feature reading to start on the first feature.\n"
35387 : "\n"
35388 : "For more details: :cpp:func:`OGR_L_ResetReading`\n"
35389 : "\n"
35390 : ""},
35391 : { "Layer_GetName", _wrap_Layer_GetName, METH_O, "\n"
35392 : "Layer_GetName(Layer self) -> char const *\n"
35393 : "\n"
35394 : "Return the layer name.\n"
35395 : "\n"
35396 : "For more details: :cpp:func:`OGR_L_GetName`\n"
35397 : "\n"
35398 : "Returns\n"
35399 : "--------\n"
35400 : "str:\n"
35401 : " The layer name\n"
35402 : "\n"
35403 : ""},
35404 : { "Layer_GetGeomType", _wrap_Layer_GetGeomType, METH_O, "\n"
35405 : "Layer_GetGeomType(Layer self) -> OGRwkbGeometryType\n"
35406 : "\n"
35407 : "Return the layer geometry type.\n"
35408 : "\n"
35409 : "For more details: :cpp:func:`OGR_L_GetGeomType`\n"
35410 : "\n"
35411 : "Returns\n"
35412 : "--------\n"
35413 : "int:\n"
35414 : " The geometry type code. The types can be found with\n"
35415 : " 'osgeo.ogr.wkb' prefix. For example :py:const:`osgeo.ogr.wkbPolygon`.\n"
35416 : "\n"
35417 : ""},
35418 : { "Layer_GetGeometryColumn", _wrap_Layer_GetGeometryColumn, METH_O, "\n"
35419 : "Layer_GetGeometryColumn(Layer self) -> char const *\n"
35420 : "\n"
35421 : "This method returns the name of the underlying database column being\n"
35422 : "used as the geometry column, or '' if not supported.\n"
35423 : "\n"
35424 : "For more details: :cpp:func:`OGR_L_GetGeometryColumn`\n"
35425 : "\n"
35426 : "Returns\n"
35427 : "--------\n"
35428 : "str:\n"
35429 : " geometry column name.\n"
35430 : "\n"
35431 : ""},
35432 : { "Layer_GetFIDColumn", _wrap_Layer_GetFIDColumn, METH_O, "\n"
35433 : "Layer_GetFIDColumn(Layer self) -> char const *\n"
35434 : "\n"
35435 : "This method returns the name of the underlying database column being\n"
35436 : "used as the FID column, or '' if not supported.\n"
35437 : "\n"
35438 : "For more details: :cpp:func:`OGR_L_GetFIDColumn`\n"
35439 : "\n"
35440 : "Returns\n"
35441 : "--------\n"
35442 : "str:\n"
35443 : " fid column name.\n"
35444 : "\n"
35445 : ""},
35446 : { "Layer_GetFeature", _wrap_Layer_GetFeature, METH_VARARGS, "\n"
35447 : "Layer_GetFeature(Layer self, GIntBig fid) -> Feature\n"
35448 : "\n"
35449 : "Fetch a feature by its identifier.\n"
35450 : "\n"
35451 : "For more details: :cpp:func:`OGR_L_GetFeature`\n"
35452 : "\n"
35453 : "Use :py:func:`TestCapability` with (:py:const:`osgeo.ogr.OLCRandomRead`)\n"
35454 : "to establish if this layer supports efficient random access reading via\n"
35455 : ":py:func:`GetFeature`; However, the call should always work if the feature exists.\n"
35456 : "\n"
35457 : "Sequential reads (with :py:func:`GetNextFeature`) are generally\n"
35458 : "considered interrupted by a :py:func:`GetFeature` call.\n"
35459 : "\n"
35460 : "Parameters\n"
35461 : "-----------\n"
35462 : "fid: int\n"
35463 : " The feature id of the feature to read.\n"
35464 : "\n"
35465 : "Returns\n"
35466 : "--------\n"
35467 : "Feature:\n"
35468 : " A new feature now owned by the caller, or None on failure.\n"
35469 : " The returned feature should be deleted with :py:func:`Destroy`.\n"
35470 : "\n"
35471 : ""},
35472 : { "Layer_GetNextFeature", _wrap_Layer_GetNextFeature, METH_O, "\n"
35473 : "Layer_GetNextFeature(Layer self) -> Feature\n"
35474 : "\n"
35475 : "Fetch the next available feature from this layer.\n"
35476 : "\n"
35477 : "For more details: :cpp:func:`OGR_L_GetNextFeature`\n"
35478 : "\n"
35479 : "Returns\n"
35480 : "--------\n"
35481 : "Feature:\n"
35482 : " A feature or None if no more features are available.\n"
35483 : "\n"
35484 : ""},
35485 : { "Layer_SetNextByIndex", _wrap_Layer_SetNextByIndex, METH_VARARGS, "\n"
35486 : "Layer_SetNextByIndex(Layer self, GIntBig new_index) -> OGRErr\n"
35487 : "\n"
35488 : "Move read cursor to the nIndex'th feature in the current resultset.\n"
35489 : "\n"
35490 : "For more details: :cpp:func:`OGR_L_SetNextByIndex`\n"
35491 : "\n"
35492 : "Parameters\n"
35493 : "-----------\n"
35494 : "new_index: int\n"
35495 : " The index indicating how many steps into the result set to seek.\n"
35496 : "\n"
35497 : "Returns\n"
35498 : "--------\n"
35499 : "int:\n"
35500 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success or an error code.\n"
35501 : "\n"
35502 : ""},
35503 : { "Layer_SetFeature", _wrap_Layer_SetFeature, METH_VARARGS, "\n"
35504 : "Layer_SetFeature(Layer self, Feature feature) -> OGRErr\n"
35505 : "\n"
35506 : "Rewrite an existing feature.\n"
35507 : "\n"
35508 : "For more details: :cpp:func:`OGR_L_SetFeature`\n"
35509 : "\n"
35510 : "To set a feature, but create it if it doesn't exist see :py:meth:`.Layer.UpsertFeature`.\n"
35511 : "\n"
35512 : "Parameters\n"
35513 : "-----------\n"
35514 : "feature: Feature\n"
35515 : " The feature to write.\n"
35516 : "\n"
35517 : "Returns\n"
35518 : "--------\n"
35519 : "int:\n"
35520 : " :py:const:`osgeo.ogr.OGRERR_NONE` if the operation works,\n"
35521 : " otherwise an appropriate error code\n"
35522 : " (e.g :py:const:`osgeo.ogr.OGRERR_NON_EXISTING_FEATURE` if the\n"
35523 : " feature does not exist).\n"
35524 : "\n"
35525 : ""},
35526 : { "Layer_CreateFeature", _wrap_Layer_CreateFeature, METH_VARARGS, "\n"
35527 : "Layer_CreateFeature(Layer self, Feature feature) -> OGRErr\n"
35528 : "\n"
35529 : "Create and write a new feature within a layer.\n"
35530 : "\n"
35531 : "For more details: :cpp:func:`OGR_L_CreateFeature`\n"
35532 : "\n"
35533 : "To create a feature, but set it if it exists see :py:meth:`.Layer.UpsertFeature`.\n"
35534 : "\n"
35535 : "Parameters\n"
35536 : "-----------\n"
35537 : "feature: Feature\n"
35538 : " The feature to write to disk.\n"
35539 : "\n"
35540 : "Returns\n"
35541 : "--------\n"
35542 : "int:\n"
35543 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35544 : "\n"
35545 : ""},
35546 : { "Layer_UpsertFeature", _wrap_Layer_UpsertFeature, METH_VARARGS, "\n"
35547 : "Layer_UpsertFeature(Layer self, Feature feature) -> OGRErr\n"
35548 : "\n"
35549 : "Rewrite an existing feature or create a new feature within a layer.\n"
35550 : "\n"
35551 : "For more details: :cpp:func:`OGR_L_UpsertFeature`\n"
35552 : "\n"
35553 : "Parameters\n"
35554 : "-----------\n"
35555 : "feature: Feature\n"
35556 : " The feature to write to disk.\n"
35557 : "\n"
35558 : "Returns\n"
35559 : "--------\n"
35560 : "int:\n"
35561 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35562 : "\n"
35563 : ""},
35564 : { "Layer_UpdateFeature", _wrap_Layer_UpdateFeature, METH_VARARGS, "Layer_UpdateFeature(Layer self, Feature feature, int nUpdatedFieldsCount, int nUpdatedGeomFieldsCount, bool bUpdateStyleString) -> OGRErr"},
35565 : { "Layer_DeleteFeature", _wrap_Layer_DeleteFeature, METH_VARARGS, "\n"
35566 : "Layer_DeleteFeature(Layer self, GIntBig fid) -> OGRErr\n"
35567 : "\n"
35568 : "Delete feature from layer.\n"
35569 : "\n"
35570 : "For more details: :cpp:func:`OGR_L_DeleteFeature`\n"
35571 : "\n"
35572 : "Parameters\n"
35573 : "-----------\n"
35574 : "fid: int\n"
35575 : " The feature id to be deleted from the layer\n"
35576 : "\n"
35577 : "Returns\n"
35578 : "--------\n"
35579 : "int:\n"
35580 : " :py:const:`osgeo.ogr.OGRERR_NONE` if the operation works,\n"
35581 : " otherwise an appropriate error code\n"
35582 : " (e.g :py:const:`osgeo.ogr.OGRERR_NON_EXISTING_FEATURE`)\n"
35583 : " if the feature does not exist.\n"
35584 : "\n"
35585 : ""},
35586 : { "Layer_SyncToDisk", _wrap_Layer_SyncToDisk, METH_O, "\n"
35587 : "Layer_SyncToDisk(Layer self) -> OGRErr\n"
35588 : "\n"
35589 : "Flush pending changes to disk.\n"
35590 : "\n"
35591 : "For more details: :cpp:func:`OGR_L_SyncToDisk`\n"
35592 : "\n"
35593 : "Returns\n"
35594 : "--------\n"
35595 : "int:\n"
35596 : " :py:const:`osgeo.ogr.OGRERR_NONE` if no error occurs\n"
35597 : " (even if nothing is done) or an error code.\n"
35598 : "\n"
35599 : ""},
35600 : { "Layer_GetLayerDefn", _wrap_Layer_GetLayerDefn, METH_O, "\n"
35601 : "Layer_GetLayerDefn(Layer self) -> FeatureDefn\n"
35602 : "\n"
35603 : "Fetch the schema information for this layer.\n"
35604 : "\n"
35605 : "For more details: :cpp:func:`OGR_L_GetLayerDefn`\n"
35606 : "\n"
35607 : "Returns\n"
35608 : "--------\n"
35609 : "FeatureDefn:\n"
35610 : " The feature definition.\n"
35611 : "\n"
35612 : ""},
35613 : { "Layer_GetFeatureCount", (PyCFunction)(void(*)(void))_wrap_Layer_GetFeatureCount, METH_VARARGS|METH_KEYWORDS, "\n"
35614 : "Layer_GetFeatureCount(Layer self, int force=1) -> GIntBig\n"
35615 : "\n"
35616 : "Fetch the feature count in this layer.\n"
35617 : "\n"
35618 : "For more details: :cpp:func:`OGR_L_GetFeatureCount`\n"
35619 : "\n"
35620 : "Parameters\n"
35621 : "-----------\n"
35622 : "force: int\n"
35623 : " Flag indicating whether the count should be computed even if\n"
35624 : " it is expensive.\n"
35625 : "\n"
35626 : "Returns\n"
35627 : "--------\n"
35628 : "int:\n"
35629 : " Feature count, -1 if count not known.\n"
35630 : "\n"
35631 : ""},
35632 : { "Layer_GetExtent", (PyCFunction)(void(*)(void))_wrap_Layer_GetExtent, METH_VARARGS|METH_KEYWORDS, "\n"
35633 : "Layer_GetExtent(Layer self, int force=1, int can_return_null=0, int geom_field=0)\n"
35634 : "\n"
35635 : "Fetch the extent of this layer.\n"
35636 : "\n"
35637 : "For more details:\n"
35638 : "\n"
35639 : "- :cpp:func:`OGR_L_GetExtent`\n"
35640 : "- :cpp:func:`OGR_L_GetExtentEx`\n"
35641 : "\n"
35642 : ".. warning:: Check the return order of the bounds.\n"
35643 : "\n"
35644 : "Parameters\n"
35645 : "-----------\n"
35646 : "force: int, default=False\n"
35647 : " Flag indicating whether the extent should be computed even if\n"
35648 : " it is expensive.\n"
35649 : "can_return_null: int, default=False\n"
35650 : " Whether None can be returned in the response.\n"
35651 : "geom_field: int, default=0\n"
35652 : " The index of the geometry field on which to compute the extent.\n"
35653 : " Can be iterated over using :py:func:`range` and :py:func:`GetGeomFieldCount`.\n"
35654 : "\n"
35655 : "Returns\n"
35656 : "--------\n"
35657 : "minx: float\n"
35658 : "maxx: float\n"
35659 : "miny: float\n"
35660 : "maxy: float\n"
35661 : "\n"
35662 : ""},
35663 : { "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)"},
35664 : { "Layer_TestCapability", _wrap_Layer_TestCapability, METH_VARARGS, "\n"
35665 : "Layer_TestCapability(Layer self, char const * cap) -> bool\n"
35666 : "\n"
35667 : "Test if this layer supported the named capability.\n"
35668 : "\n"
35669 : "For more details: :cpp:func:`OGR_L_TestCapability`\n"
35670 : "\n"
35671 : "Parameters\n"
35672 : "-----------\n"
35673 : "cap: str\n"
35674 : " The name of the capability to test. These can\n"
35675 : " be found in the `osgeo.ogr` namespace. For example,\n"
35676 : " :py:const:`osgeo.ogr.OLCRandomRead`.\n"
35677 : "\n"
35678 : "Returns\n"
35679 : "--------\n"
35680 : "int:\n"
35681 : " True if the layer has the requested capability, or False otherwise.\n"
35682 : " Will return False for any unrecognized capabilities.\n"
35683 : "\n"
35684 : ""},
35685 : { "Layer_CreateField", (PyCFunction)(void(*)(void))_wrap_Layer_CreateField, METH_VARARGS|METH_KEYWORDS, "\n"
35686 : "Layer_CreateField(Layer self, FieldDefn field_def, int approx_ok=1) -> OGRErr\n"
35687 : "\n"
35688 : "Create a new field on a layer.\n"
35689 : "\n"
35690 : "For more details: :cpp:func:`OGR_L_CreateField`\n"
35691 : "\n"
35692 : "Parameters\n"
35693 : "-----------\n"
35694 : "field_def: FieldDefn\n"
35695 : " The field definition to write to disk.\n"
35696 : "approx_ok: bool, default=True\n"
35697 : " If True, the field may be created in a slightly different\n"
35698 : " form depending on the limitations of the format driver.\n"
35699 : "\n"
35700 : "Returns\n"
35701 : "--------\n"
35702 : "int:\n"
35703 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35704 : "\n"
35705 : ""},
35706 : { "Layer_DeleteField", _wrap_Layer_DeleteField, METH_VARARGS, "\n"
35707 : "Layer_DeleteField(Layer self, int iField) -> OGRErr\n"
35708 : "\n"
35709 : "Delete an existing field on a layer.\n"
35710 : "\n"
35711 : "For more details: :cpp:func:`OGR_L_DeleteField`\n"
35712 : "\n"
35713 : "Parameters\n"
35714 : "-----------\n"
35715 : "iField: int\n"
35716 : " index of the field to delete.\n"
35717 : "\n"
35718 : "Returns\n"
35719 : "--------\n"
35720 : "int:\n"
35721 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35722 : "\n"
35723 : ""},
35724 : { "Layer_ReorderField", _wrap_Layer_ReorderField, METH_VARARGS, "\n"
35725 : "Layer_ReorderField(Layer self, int iOldFieldPos, int iNewFieldPos) -> OGRErr\n"
35726 : "\n"
35727 : "Reorder an existing field on a layer.\n"
35728 : "\n"
35729 : "For more details: :cpp:func:`OGR_L_ReorderField`\n"
35730 : "\n"
35731 : "Parameters\n"
35732 : "-----------\n"
35733 : "iOldFieldPos: int\n"
35734 : " previous position of the field to move. Must be in the\n"
35735 : " range [0,GetFieldCount()-1].\n"
35736 : "iNewFieldPos: int\n"
35737 : " new position of the field to move. Must be in the range\n"
35738 : " [0,GetFieldCount()-1].\n"
35739 : "\n"
35740 : "Returns\n"
35741 : "--------\n"
35742 : "int:\n"
35743 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35744 : "\n"
35745 : ""},
35746 : { "Layer_ReorderFields", _wrap_Layer_ReorderFields, METH_VARARGS, "\n"
35747 : "Layer_ReorderFields(Layer self, int nList) -> OGRErr\n"
35748 : "\n"
35749 : "Reorder all the fields of a layer.\n"
35750 : "\n"
35751 : "For more details: :cpp:func:`OGR_L_ReorderFields`\n"
35752 : "\n"
35753 : "Parameters\n"
35754 : "-----------\n"
35755 : "nList: list[int]\n"
35756 : " A list of GetLayerDefn().GetFieldCount()\n"
35757 : " elements which is a permutation of\n"
35758 : " [0, GetLayerDefn().GetFieldCount()-1].\n"
35759 : "\n"
35760 : "Returns\n"
35761 : "--------\n"
35762 : "int:\n"
35763 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35764 : "\n"
35765 : ""},
35766 : { "Layer_AlterFieldDefn", _wrap_Layer_AlterFieldDefn, METH_VARARGS, "\n"
35767 : "Layer_AlterFieldDefn(Layer self, int iField, FieldDefn field_def, int nFlags) -> OGRErr\n"
35768 : "\n"
35769 : "Alter the definition of an existing field on a layer.\n"
35770 : "\n"
35771 : "For more details: :cpp:func:`OGR_L_AlterFieldDefn`\n"
35772 : "\n"
35773 : "Parameters\n"
35774 : "-----------\n"
35775 : "iField: int\n"
35776 : " index of the field whose definition must be altered.\n"
35777 : "field_def: FieldDefn\n"
35778 : " new field definition\n"
35779 : "nFlags: int\n"
35780 : " Combination of\n"
35781 : " :py:const:`osgeo.ogr.ALTER_NAME_FLAG`,\n"
35782 : " :py:const:`osgeo.ogr.ALTER_TYPE_FLAG`,\n"
35783 : " :py:const:`osgeo.ogr.ALTER_WIDTH_PRECISION_FLAG`,\n"
35784 : " :py:const:`osgeo.ogr.ALTER_NULLABLE_FLAG` and\n"
35785 : " :py:const:`osgeo.ogr.ALTER_DEFAULT_FLAG`\n"
35786 : " to indicate which of the name and/or type and/or width and precision\n"
35787 : " fields and/or nullability from the new field definition must be taken\n"
35788 : " into account.\n"
35789 : "\n"
35790 : "Returns\n"
35791 : "--------\n"
35792 : "int:\n"
35793 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35794 : "\n"
35795 : ""},
35796 : { "Layer_AlterGeomFieldDefn", _wrap_Layer_AlterGeomFieldDefn, METH_VARARGS, "Layer_AlterGeomFieldDefn(Layer self, int iGeomField, GeomFieldDefn field_def, int nFlags) -> OGRErr"},
35797 : { "Layer_CreateGeomField", (PyCFunction)(void(*)(void))_wrap_Layer_CreateGeomField, METH_VARARGS|METH_KEYWORDS, "\n"
35798 : "Layer_CreateGeomField(Layer self, GeomFieldDefn field_def, int approx_ok=1) -> OGRErr\n"
35799 : "\n"
35800 : "Create a new geometry field on a layer.\n"
35801 : "\n"
35802 : "For more details: :cpp:func:`OGR_L_CreateGeomField`\n"
35803 : "\n"
35804 : "Parameters\n"
35805 : "-----------\n"
35806 : "field_def: GeomFieldDefn\n"
35807 : " The geometry field definition to write to disk.\n"
35808 : "approx_ok: bool, default=True\n"
35809 : " If True, the field may be created in a slightly different\n"
35810 : " form depending on the limitations of the format driver.\n"
35811 : "\n"
35812 : "Returns\n"
35813 : "--------\n"
35814 : "int:\n"
35815 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35816 : "\n"
35817 : ""},
35818 : { "Layer_StartTransaction", _wrap_Layer_StartTransaction, METH_O, "\n"
35819 : "Layer_StartTransaction(Layer self) -> OGRErr\n"
35820 : "\n"
35821 : "For datasources which support transactions, this creates a transaction.\n"
35822 : "\n"
35823 : "For more details: :cpp:func:`OGR_L_StartTransaction`\n"
35824 : "\n"
35825 : "Returns\n"
35826 : "--------\n"
35827 : "int:\n"
35828 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35829 : "\n"
35830 : ""},
35831 : { "Layer_CommitTransaction", _wrap_Layer_CommitTransaction, METH_O, "\n"
35832 : "Layer_CommitTransaction(Layer self) -> OGRErr\n"
35833 : "\n"
35834 : "For datasources which support transactions, this commits a transaction.\n"
35835 : "\n"
35836 : "For more details: :cpp:func:`OGR_L_CommitTransaction`\n"
35837 : "\n"
35838 : "Returns\n"
35839 : "--------\n"
35840 : "int:\n"
35841 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35842 : "\n"
35843 : ""},
35844 : { "Layer_RollbackTransaction", _wrap_Layer_RollbackTransaction, METH_O, "\n"
35845 : "Layer_RollbackTransaction(Layer self) -> OGRErr\n"
35846 : "\n"
35847 : "Roll back a datasource to its state before the start of the current transaction.\n"
35848 : "\n"
35849 : "For more details: :cpp:func:`OGR_L_RollbackTransaction`\n"
35850 : "\n"
35851 : "Returns\n"
35852 : "--------\n"
35853 : "int:\n"
35854 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success.\n"
35855 : "\n"
35856 : ""},
35857 : { "Layer_FindFieldIndex", _wrap_Layer_FindFieldIndex, METH_VARARGS, "\n"
35858 : "Layer_FindFieldIndex(Layer self, char const * pszFieldName, int bExactMatch) -> int\n"
35859 : "\n"
35860 : "Find the index of field in a layer.\n"
35861 : "\n"
35862 : "For more details: :cpp:func:`OGR_L_FindFieldIndex`\n"
35863 : "\n"
35864 : "Returns\n"
35865 : "--------\n"
35866 : "int:\n"
35867 : " field index, or -1 if the field doesn't exist\n"
35868 : "\n"
35869 : ""},
35870 : { "Layer_GetSpatialRef", _wrap_Layer_GetSpatialRef, METH_O, "\n"
35871 : "Layer_GetSpatialRef(Layer self) -> SpatialReference\n"
35872 : "\n"
35873 : "Fetch the spatial reference system for this layer.\n"
35874 : "\n"
35875 : "For more details: :cpp:func:`OGR_L_GetSpatialRef`\n"
35876 : "\n"
35877 : "Returns\n"
35878 : "--------\n"
35879 : "SpatialReference:\n"
35880 : " spatial reference, or None if there isn't one.\n"
35881 : "\n"
35882 : ""},
35883 : { "Layer_GetFeaturesRead", _wrap_Layer_GetFeaturesRead, METH_O, "\n"
35884 : "Layer_GetFeaturesRead(Layer self) -> GIntBig\n"
35885 : "\n"
35886 : "For more details: :cpp:func:`OGR_L_GetFeaturesRead`\n"
35887 : "\n"
35888 : ""},
35889 : { "Layer_SetIgnoredFields", _wrap_Layer_SetIgnoredFields, METH_VARARGS, "\n"
35890 : "Layer_SetIgnoredFields(Layer self, char const ** options) -> OGRErr\n"
35891 : "\n"
35892 : "Set which fields can be omitted when retrieving features from the\n"
35893 : "layer.\n"
35894 : "\n"
35895 : "For more details: :cpp:func:`OGR_L_SetIgnoredFields`\n"
35896 : "\n"
35897 : "Parameters\n"
35898 : "-----------\n"
35899 : "options: list[str]\n"
35900 : " A list of field names.\n"
35901 : " If an empty list is passed, the ignored list is cleared.\n"
35902 : "\n"
35903 : "Returns\n"
35904 : "-------\n"
35905 : "int:\n"
35906 : " :py:const:`osgeo.ogr.OGRERR_NONE` if all field names have been resolved\n"
35907 : " (even if the driver does not support this method)\n"
35908 : "\n"
35909 : ""},
35910 : { "Layer_Intersection", (PyCFunction)(void(*)(void))_wrap_Layer_Intersection, METH_VARARGS|METH_KEYWORDS, "\n"
35911 : "Layer_Intersection(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr\n"
35912 : "\n"
35913 : "Intersection of two layers.\n"
35914 : "\n"
35915 : "For more details: :cpp:func:`OGR_L_Intersection`\n"
35916 : "\n"
35917 : "Parameters\n"
35918 : "-----------\n"
35919 : "method_layer: Layer\n"
35920 : " the method layer. Should not be None.\n"
35921 : "result_layer: Layer\n"
35922 : " the layer where the features resulting from the\n"
35923 : " operation are inserted. Should not be None.\n"
35924 : "options: list[str], optional\n"
35925 : " List of options (empty list is allowed). For example [\"PROMOTE_TO_MULTI=YES\"].\n"
35926 : "callback: Callable, optional\n"
35927 : " a GDALProgressFunc() compatible callback function for\n"
35928 : " reporting progress or None.\n"
35929 : "callback_data:\n"
35930 : " Argument to be passed to 'callback'. May be None.\n"
35931 : "\n"
35932 : "Returns\n"
35933 : "-------\n"
35934 : "int:\n"
35935 : " An error code if there was an error or the execution was interrupted,\n"
35936 : " :py:const:`osgeo.ogr.OGRERR_NONE` otherwise.\n"
35937 : "\n"
35938 : ""},
35939 : { "Layer_Union", (PyCFunction)(void(*)(void))_wrap_Layer_Union, METH_VARARGS|METH_KEYWORDS, "\n"
35940 : "Layer_Union(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr\n"
35941 : "\n"
35942 : "Union of two layers.\n"
35943 : "\n"
35944 : "For more details: :cpp:func:`OGR_L_Union`\n"
35945 : "\n"
35946 : "The first geometry field is always used.\n"
35947 : "\n"
35948 : "Parameters\n"
35949 : "-----------\n"
35950 : "method_layer: Layer\n"
35951 : " the method layer. Should not be None.\n"
35952 : "result_layer: Layer\n"
35953 : " the layer where the features resulting from the\n"
35954 : " operation are inserted. Should not be None.\n"
35955 : "options: list[str], optional\n"
35956 : " List of options (empty list is allowed). For example [\"PROMOTE_TO_MULTI=YES\"].\n"
35957 : "callback: Callable, optional\n"
35958 : " a GDALProgressFunc() compatible callback function for\n"
35959 : " reporting progress or None.\n"
35960 : "callback_data:\n"
35961 : " Argument to be passed to 'callback'. May be None.\n"
35962 : "\n"
35963 : "Returns\n"
35964 : "-------\n"
35965 : "int:\n"
35966 : " An error code if there was an error or the execution was interrupted,\n"
35967 : " :py:const:`osgeo.ogr.OGRERR_NONE` otherwise.\n"
35968 : "\n"
35969 : ""},
35970 : { "Layer_SymDifference", (PyCFunction)(void(*)(void))_wrap_Layer_SymDifference, METH_VARARGS|METH_KEYWORDS, "\n"
35971 : "Layer_SymDifference(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr\n"
35972 : "\n"
35973 : "Symmetrical difference of two layers.\n"
35974 : "\n"
35975 : "For more details: :cpp:func:`OGR_L_SymDifference`\n"
35976 : "\n"
35977 : "Parameters\n"
35978 : "-----------\n"
35979 : "method_layer: Layer\n"
35980 : " the method layer. Should not be None.\n"
35981 : "result_layer: Layer\n"
35982 : " the layer where the features resulting from the\n"
35983 : " operation are inserted. Should not be None.\n"
35984 : "options: list[str], optional\n"
35985 : " List of options (empty list is allowed). For example [\"PROMOTE_TO_MULTI=YES\"].\n"
35986 : "callback: Callable, optional\n"
35987 : " a GDALProgressFunc() compatible callback function for\n"
35988 : " reporting progress or None.\n"
35989 : "callback_data:\n"
35990 : " Argument to be passed to 'callback'. May be None.\n"
35991 : "\n"
35992 : "Returns\n"
35993 : "-------\n"
35994 : "int:\n"
35995 : " An error code if there was an error or the execution was interrupted,\n"
35996 : " :py:const:`osgeo.ogr.OGRERR_NONE` otherwise.\n"
35997 : "\n"
35998 : ""},
35999 : { "Layer_Identity", (PyCFunction)(void(*)(void))_wrap_Layer_Identity, METH_VARARGS|METH_KEYWORDS, "\n"
36000 : "Layer_Identity(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr\n"
36001 : "\n"
36002 : "Identify the features of this layer with the ones from the identity layer.\n"
36003 : "\n"
36004 : "For more details: :cpp:func:`OGR_L_Identity`\n"
36005 : "\n"
36006 : "Parameters\n"
36007 : "-----------\n"
36008 : "method_layer: Layer\n"
36009 : " the method layer. Should not be None.\n"
36010 : "result_layer: Layer\n"
36011 : " the layer where the features resulting from the\n"
36012 : " operation are inserted. Should not be None.\n"
36013 : "options: list[str], optional\n"
36014 : " List of options (empty list is allowed). For example [\"PROMOTE_TO_MULTI=YES\"].\n"
36015 : "callback: Callable, optional\n"
36016 : " a GDALProgressFunc() compatible callback function for\n"
36017 : " reporting progress or None.\n"
36018 : "callback_data:\n"
36019 : " Argument to be passed to 'callback'. May be None.\n"
36020 : "\n"
36021 : "Returns\n"
36022 : "-------\n"
36023 : "int:\n"
36024 : " An error code if there was an error or the execution was interrupted,\n"
36025 : " :py:const:`osgeo.ogr.OGRERR_NONE` otherwise.\n"
36026 : "\n"
36027 : ""},
36028 : { "Layer_Update", (PyCFunction)(void(*)(void))_wrap_Layer_Update, METH_VARARGS|METH_KEYWORDS, "\n"
36029 : "Layer_Update(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr\n"
36030 : "\n"
36031 : "Update this layer with features from the update layer.\n"
36032 : "\n"
36033 : "For more details: :cpp:func:`OGR_L_Update`\n"
36034 : "\n"
36035 : "Parameters\n"
36036 : "-----------\n"
36037 : "method_layer: Layer\n"
36038 : " the method layer. Should not be None.\n"
36039 : "result_layer: Layer\n"
36040 : " the layer where the features resulting from the\n"
36041 : " operation are inserted. Should not be None.\n"
36042 : "options: list[str], optional\n"
36043 : " List of options (empty list is allowed). For example [\"PROMOTE_TO_MULTI=YES\"].\n"
36044 : "callback: Callable, optional\n"
36045 : " a GDALProgressFunc() compatible callback function for\n"
36046 : " reporting progress or None.\n"
36047 : "callback_data:\n"
36048 : " Argument to be passed to 'callback'. May be None.\n"
36049 : "\n"
36050 : "Returns\n"
36051 : "-------\n"
36052 : "int:\n"
36053 : " An error code if there was an error or the execution was interrupted,\n"
36054 : " :py:const:`osgeo.ogr.OGRERR_NONE` otherwise.\n"
36055 : "\n"
36056 : ""},
36057 : { "Layer_Clip", (PyCFunction)(void(*)(void))_wrap_Layer_Clip, METH_VARARGS|METH_KEYWORDS, "\n"
36058 : "Layer_Clip(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr\n"
36059 : "\n"
36060 : "Clip off areas that are not covered by the method layer.\n"
36061 : "\n"
36062 : "For more details: :cpp:func:`OGR_L_Clip`\n"
36063 : "\n"
36064 : "Parameters\n"
36065 : "-----------\n"
36066 : "method_layer: Layer\n"
36067 : " the method layer. Should not be None.\n"
36068 : "result_layer: Layer\n"
36069 : " the layer where the features resulting from the\n"
36070 : " operation are inserted. Should not be None.\n"
36071 : "options: list[str], optional\n"
36072 : " List of options (empty list is allowed). For example [\"PROMOTE_TO_MULTI=YES\"].\n"
36073 : "callback: Callable, optional\n"
36074 : " a GDALProgressFunc() compatible callback function for\n"
36075 : " reporting progress or None.\n"
36076 : "callback_data:\n"
36077 : " Argument to be passed to 'callback'. May be None.\n"
36078 : "\n"
36079 : "Returns\n"
36080 : "-------\n"
36081 : "int:\n"
36082 : " An error code if there was an error or the execution was interrupted,\n"
36083 : " :py:const:`osgeo.ogr.OGRERR_NONE` otherwise.\n"
36084 : "\n"
36085 : ""},
36086 : { "Layer_Erase", (PyCFunction)(void(*)(void))_wrap_Layer_Erase, METH_VARARGS|METH_KEYWORDS, "\n"
36087 : "Layer_Erase(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr\n"
36088 : "\n"
36089 : "Remove areas that are covered by the method layer.\n"
36090 : "\n"
36091 : "For more details: :cpp:func:`OGR_L_Erase`\n"
36092 : "\n"
36093 : "Parameters\n"
36094 : "-----------\n"
36095 : "method_layer: Layer\n"
36096 : " the method layer. Should not be None.\n"
36097 : "result_layer: Layer\n"
36098 : " the layer where the features resulting from the\n"
36099 : " operation are inserted. Should not be None.\n"
36100 : "options: list[str], optional\n"
36101 : " List of options (empty list is allowed). For example [\"PROMOTE_TO_MULTI=YES\"].\n"
36102 : "callback: Callable, optional\n"
36103 : " a GDALProgressFunc() compatible callback function for\n"
36104 : " reporting progress or None.\n"
36105 : "callback_data:\n"
36106 : " Argument to be passed to 'callback'. May be None.\n"
36107 : "\n"
36108 : "Returns\n"
36109 : "-------\n"
36110 : "int:\n"
36111 : " An error code if there was an error or the execution was interrupted,\n"
36112 : " :py:const:`osgeo.ogr.OGRERR_NONE` otherwise.\n"
36113 : "\n"
36114 : ""},
36115 : { "Layer_GetStyleTable", _wrap_Layer_GetStyleTable, METH_O, "\n"
36116 : "Layer_GetStyleTable(Layer self) -> StyleTable\n"
36117 : "\n"
36118 : "Get style table.\n"
36119 : "\n"
36120 : "For more details: :cpp:func:`OGR_L_GetStyleTable`\n"
36121 : "\n"
36122 : ""},
36123 : { "Layer_SetStyleTable", _wrap_Layer_SetStyleTable, METH_VARARGS, "\n"
36124 : "Layer_SetStyleTable(Layer self, StyleTable table)\n"
36125 : "\n"
36126 : "Set style table.\n"
36127 : "\n"
36128 : "For more details: :cpp:func:`OGR_L_SetStyleTable`\n"
36129 : "\n"
36130 : ""},
36131 : { "Layer_ExportArrowArrayStreamPyCapsule", _wrap_Layer_ExportArrowArrayStreamPyCapsule, METH_VARARGS, "Layer_ExportArrowArrayStreamPyCapsule(Layer self, char ** options=None) -> PyObject *"},
36132 : { "Layer_GetArrowStream", _wrap_Layer_GetArrowStream, METH_VARARGS, "Layer_GetArrowStream(Layer self, char ** options=None) -> ArrowArrayStream"},
36133 : { "Layer_IsArrowSchemaSupported", _wrap_Layer_IsArrowSchemaSupported, METH_VARARGS, "Layer_IsArrowSchemaSupported(Layer self, ArrowSchema schema, char ** options=None)"},
36134 : { "Layer_CreateFieldFromArrowSchema", _wrap_Layer_CreateFieldFromArrowSchema, METH_VARARGS, "Layer_CreateFieldFromArrowSchema(Layer self, ArrowSchema schema, char ** options=None) -> OGRErr"},
36135 : { "Layer_WriteArrowBatch", _wrap_Layer_WriteArrowBatch, METH_VARARGS, "Layer_WriteArrowBatch(Layer self, ArrowSchema schema, ArrowArray array, char ** options=None) -> OGRErr"},
36136 : { "Layer_WriteArrowStreamCapsule", _wrap_Layer_WriteArrowStreamCapsule, METH_VARARGS, "Layer_WriteArrowStreamCapsule(Layer self, PyObject * capsule, int createFieldsFromSchema, char ** options=None) -> OGRErr"},
36137 : { "Layer_WriteArrowSchemaAndArrowArrayCapsule", _wrap_Layer_WriteArrowSchemaAndArrowArrayCapsule, METH_VARARGS, "Layer_WriteArrowSchemaAndArrowArrayCapsule(Layer self, PyObject * schemaCapsule, PyObject * arrayCapsule, int createFieldsFromSchema, char ** options=None) -> OGRErr"},
36138 : { "Layer_GetGeometryTypes", (PyCFunction)(void(*)(void))_wrap_Layer_GetGeometryTypes, METH_VARARGS|METH_KEYWORDS, "\n"
36139 : "Layer_GetGeometryTypes(Layer self, int geom_field=0, int flags=0, GDALProgressFunc callback=0, void * callback_data=None)\n"
36140 : "\n"
36141 : "Get actual geometry types found in features.\n"
36142 : "\n"
36143 : "For more details: :cpp:func:`OGR_L_GetGeometryTypes`\n"
36144 : "\n"
36145 : "Parameters\n"
36146 : "-----------\n"
36147 : "geom_field: int, optional\n"
36148 : " index of the geometry field\n"
36149 : "flags: int, optional\n"
36150 : " 0, or a combination of :py:const:`osgeo.ogr.GGT_COUNT_NOT_NEEDED`,\n"
36151 : " :py:const:`osgeo.ogr.GGT_STOP_IF_MIXED` and\n"
36152 : " :py:const:`osgeo.ogr.GGT_GEOMCOLLECTIONZ_TINZ`\n"
36153 : "callback: Callable, optional\n"
36154 : " a GDALProgressFunc() compatible callback function for\n"
36155 : " cancellation or None.\n"
36156 : "callback_data:\n"
36157 : " Argument to be passed to 'callback'. May be None.\n"
36158 : "\n"
36159 : "Returns\n"
36160 : "-------\n"
36161 : "dict:\n"
36162 : " A dictionary whose keys are :py:const:`osgeo.ogr.wkbXXXX` constants and\n"
36163 : " values the corresponding number of geometries of that type in the layer.\n"
36164 : "\n"
36165 : ""},
36166 : { "Layer_GetSupportedSRSList", (PyCFunction)(void(*)(void))_wrap_Layer_GetSupportedSRSList, METH_VARARGS|METH_KEYWORDS, "Layer_GetSupportedSRSList(Layer self, int geom_field=0)"},
36167 : { "Layer_SetActiveSRS", _wrap_Layer_SetActiveSRS, METH_VARARGS, "Layer_SetActiveSRS(Layer self, int geom_field, SpatialReference srs) -> OGRErr"},
36168 : { "Layer_swigregister", Layer_swigregister, METH_O, NULL},
36169 : { "delete_Feature", _wrap_delete_Feature, METH_O, "delete_Feature(Feature self)"},
36170 : { "new_Feature", (PyCFunction)(void(*)(void))_wrap_new_Feature, METH_VARARGS|METH_KEYWORDS, "\n"
36171 : "new_Feature(FeatureDefn feature_def) -> Feature\n"
36172 : "\n"
36173 : "\n"
36174 : "Parameters\n"
36175 : "-----------\n"
36176 : "feature_def:\n"
36177 : " :py:class:`FeatureDefn` to which the feature will adhere.\n"
36178 : "\n"
36179 : ""},
36180 : { "Feature_GetDefnRef", _wrap_Feature_GetDefnRef, METH_O, "\n"
36181 : "Feature_GetDefnRef(Feature self) -> FeatureDefn\n"
36182 : "\n"
36183 : "\n"
36184 : "Fetch the :py:class:`FeatureDefn` associated with this Feature.\n"
36185 : "\n"
36186 : "See :cpp:func:`OGRFeature::GetDefnRef()`.\n"
36187 : "\n"
36188 : "Returns\n"
36189 : "--------\n"
36190 : "FeatureDefn\n"
36191 : "\n"
36192 : ""},
36193 : { "Feature_SetGeometry", _wrap_Feature_SetGeometry, METH_VARARGS, "\n"
36194 : "Feature_SetGeometry(Feature self, Geometry geom) -> OGRErr\n"
36195 : "\n"
36196 : "\n"
36197 : "Set feature geometry.\n"
36198 : "\n"
36199 : "This function updates the features geometry, and operates exactly as\n"
36200 : ":py:meth:`SetGeometryDirectly`, except that this function does not assume\n"
36201 : "ownership of the passed geometry, but instead makes a copy of it.\n"
36202 : "\n"
36203 : "See :cpp:func:`OGRFeature::SetGeometry`.\n"
36204 : "\n"
36205 : "This method has only an effect on the in-memory feature object. If\n"
36206 : "this object comes from a layer and the modifications must be\n"
36207 : "serialized back to the datasource, :py:meth:`Layer.SetFeature` must be used\n"
36208 : "afterwards. Or if this is a new feature, :py:meth:`Layer.CreateFeature` must be\n"
36209 : "used afterwards.\n"
36210 : "\n"
36211 : "Parameters\n"
36212 : "-----------\n"
36213 : "geom : Geometry\n"
36214 : " new geometry to apply to feature.\n"
36215 : "\n"
36216 : "Returns\n"
36217 : "--------\n"
36218 : "int:\n"
36219 : " :py:const:`OGRERR_NONE` if successful, or\n"
36220 : " :py:const:`OGR_UNSUPPORTED_GEOMETRY_TYPE` if the geometry type is illegal for\n"
36221 : " the :py:class:`FeatureDefn` (checking not yet implemented).\n"
36222 : "\n"
36223 : ""},
36224 : { "Feature_SetGeometryDirectly", _wrap_Feature_SetGeometryDirectly, METH_VARARGS, "Feature_SetGeometryDirectly(Feature self, Geometry geom) -> OGRErr"},
36225 : { "Feature_GetGeometryRef", _wrap_Feature_GetGeometryRef, METH_O, "\n"
36226 : "Feature_GetGeometryRef(Feature self) -> Geometry\n"
36227 : "\n"
36228 : "Return the feature geometry\n"
36229 : "\n"
36230 : "The lifetime of the returned geometry is bound to the one of its belonging\n"
36231 : "feature.\n"
36232 : "\n"
36233 : "See :cpp:func:`OGRFeature::GetGeometryRef`\n"
36234 : "\n"
36235 : "The :py:func:`Feature.geometry` method is also available as an alias of :py:func:`Feature.GetGeometryRef`.\n"
36236 : "\n"
36237 : "Returns\n"
36238 : "--------\n"
36239 : "Geometry:\n"
36240 : " the geometry, or None.\n"
36241 : "\n"
36242 : ""},
36243 : { "Feature_SetGeomField", _wrap_Feature_SetGeomField, METH_VARARGS, "\n"
36244 : "Feature_SetGeomField(Feature self, int iField, Geometry geom) -> OGRErr\n"
36245 : "Feature_SetGeomField(Feature self, char const * field_name, Geometry geom) -> OGRErr\n"
36246 : "\n"
36247 : "\n"
36248 : "Set feature geometry of a specified geometry field.\n"
36249 : "\n"
36250 : "This function updates the features geometry, and operates exactly as\n"
36251 : ":py:meth:`SetGeomFieldDirectly`, except that this function does not assume\n"
36252 : "ownership of the passed geometry, but instead makes a copy of it.\n"
36253 : "\n"
36254 : "See :cpp:func:`OGRFeature::SetGeomField`.\n"
36255 : "\n"
36256 : "Parameters\n"
36257 : "-----------\n"
36258 : "fld_index : int / str\n"
36259 : " Geometry field name or 0-based numeric index. For repeated\n"
36260 : " access, use of the numeric index avoids a lookup\n"
36261 : " step.\n"
36262 : "geom : Geometry\n"
36263 : " handle to the new geometry to apply to feature.\n"
36264 : "\n"
36265 : "Returns\n"
36266 : "--------\n"
36267 : "int:\n"
36268 : " :py:const:`OGRERR_NONE` if successful, or\n"
36269 : " :py:const:`OGR_UNSUPPORTED_GEOMETRY_TYPE` if the geometry type is illegal for\n"
36270 : " the :py:class:`FeatureDefn` (checking not yet implemented).\n"
36271 : "\n"
36272 : ""},
36273 : { "Feature_SetGeomFieldDirectly", _wrap_Feature_SetGeomFieldDirectly, METH_VARARGS, "\n"
36274 : "Feature_SetGeomFieldDirectly(Feature self, int iField, Geometry geom) -> OGRErr\n"
36275 : "Feature_SetGeomFieldDirectly(Feature self, char const * field_name, Geometry geom) -> OGRErr\n"
36276 : ""},
36277 : { "Feature_GetGeomFieldRef", _wrap_Feature_GetGeomFieldRef, METH_VARARGS, "\n"
36278 : "Feature_GetGeomFieldRef(Feature self, int iField) -> Geometry\n"
36279 : "Feature_GetGeomFieldRef(Feature self, char const * field_name) -> Geometry\n"
36280 : "\n"
36281 : "\n"
36282 : "Fetch a feature :py:class:`Geometry`.\n"
36283 : "\n"
36284 : "See :cpp:func:`OGRFeature::GetGeomFieldRef`.\n"
36285 : "\n"
36286 : "Parameters\n"
36287 : "-----------\n"
36288 : "fld_index : int / str\n"
36289 : " Field name or 0-based numeric index. For repeated\n"
36290 : " access, use of the numeric index avoids a lookup\n"
36291 : " step.\n"
36292 : "\n"
36293 : "Returns\n"
36294 : "-------\n"
36295 : "Geometry\n"
36296 : "\n"
36297 : "\n"
36298 : ""},
36299 : { "Feature_Clone", _wrap_Feature_Clone, METH_O, "\n"
36300 : "Feature_Clone(Feature self) -> Feature\n"
36301 : "\n"
36302 : "Duplicate a Feature.\n"
36303 : "See :cpp:func:`OGRFeature::Clone`.\n"
36304 : "\n"
36305 : "Returns\n"
36306 : "--------\n"
36307 : "Feature\n"
36308 : "\n"
36309 : ""},
36310 : { "Feature_Equal", _wrap_Feature_Equal, METH_VARARGS, "\n"
36311 : "Feature_Equal(Feature self, Feature feature) -> bool\n"
36312 : "\n"
36313 : "\n"
36314 : "Test if two features are the same.\n"
36315 : "\n"
36316 : "Two features are considered equal if they reference the\n"
36317 : "same :py:class:`FeatureDefn`, have the same field values, and the same geometry\n"
36318 : "(as tested by :py:func:`Geometry.Equal`) as well as the same feature id.\n"
36319 : "\n"
36320 : "See :cpp:func:`OGRFeature::Equal`.\n"
36321 : "\n"
36322 : "Parameters\n"
36323 : "-----------\n"
36324 : "feature : Feature\n"
36325 : " feature to test this one against\n"
36326 : "\n"
36327 : "Returns\n"
36328 : "--------\n"
36329 : "bool\n"
36330 : "\n"
36331 : ""},
36332 : { "Feature_GetFieldCount", _wrap_Feature_GetFieldCount, METH_O, "\n"
36333 : "Feature_GetFieldCount(Feature self) -> int\n"
36334 : "\n"
36335 : "\n"
36336 : "Fetch number of fields on this feature This will always be the same as\n"
36337 : "the field count for the :py:class:`FeatureDefn`.\n"
36338 : "\n"
36339 : "See :cpp:func:`OGRFeature::GetFieldCount`.\n"
36340 : "\n"
36341 : "Returns\n"
36342 : "--------\n"
36343 : "int:\n"
36344 : " count of fields.\n"
36345 : "\n"
36346 : ""},
36347 : { "Feature_GetFieldDefnRef", _wrap_Feature_GetFieldDefnRef, METH_VARARGS, "\n"
36348 : "Feature_GetFieldDefnRef(Feature self, int id) -> FieldDefn\n"
36349 : "Feature_GetFieldDefnRef(Feature self, char const * field_name) -> FieldDefn\n"
36350 : "\n"
36351 : "\n"
36352 : "Fetch definition for this field.\n"
36353 : "\n"
36354 : "See :cpp:func:`OGRFeature::GetFieldDefnRef`.\n"
36355 : "\n"
36356 : "Parameters\n"
36357 : "-----------\n"
36358 : "fld_index : int / str\n"
36359 : " Field name or 0-based numeric index. For repeated\n"
36360 : " access, use of the numeric index avoids a lookup\n"
36361 : " step.\n"
36362 : "\n"
36363 : "Returns\n"
36364 : "--------\n"
36365 : "FieldDefn\n"
36366 : " a reference to the field definition. This reference should\n"
36367 : " not be modified.\n"
36368 : "\n"
36369 : ""},
36370 : { "Feature_GetGeomFieldCount", _wrap_Feature_GetGeomFieldCount, METH_O, "\n"
36371 : "Feature_GetGeomFieldCount(Feature self) -> int\n"
36372 : "\n"
36373 : "\n"
36374 : "Fetch number of geometry fields on this feature This will always be\n"
36375 : "the same as the geometry field count for the :py:class:`FeatureDefn`.\n"
36376 : "\n"
36377 : "See :cpp:func:`OGRFeature::GetGeomFieldCount`.\n"
36378 : "\n"
36379 : "Returns\n"
36380 : "--------\n"
36381 : "int:\n"
36382 : " count of geometry fields.\n"
36383 : "\n"
36384 : ""},
36385 : { "Feature_GetGeomFieldDefnRef", _wrap_Feature_GetGeomFieldDefnRef, METH_VARARGS, "\n"
36386 : "Feature_GetGeomFieldDefnRef(Feature self, int id) -> GeomFieldDefn\n"
36387 : "Feature_GetGeomFieldDefnRef(Feature self, char const * field_name) -> GeomFieldDefn\n"
36388 : "\n"
36389 : "\n"
36390 : "Fetch definition for this geometry field.\n"
36391 : "\n"
36392 : "See :cpp:func:`OGRFeature::GetGeomFieldDefnRef`.\n"
36393 : "\n"
36394 : "Parameters\n"
36395 : "-----------\n"
36396 : "fld_index : int / str\n"
36397 : " Field name or 0-based numeric index. For repeated\n"
36398 : " access, use of the numeric index avoids a lookup\n"
36399 : " step.\n"
36400 : "\n"
36401 : "Returns\n"
36402 : "--------\n"
36403 : "GeomFieldDefn:\n"
36404 : " a reference to the field definition.\n"
36405 : " Should not be deleted or modified.\n"
36406 : "\n"
36407 : ""},
36408 : { "Feature_GetFieldAsString", _wrap_Feature_GetFieldAsString, METH_VARARGS, "\n"
36409 : "Feature_GetFieldAsString(Feature self, int id) -> char const\n"
36410 : "Feature_GetFieldAsString(Feature self, char const * field_name) -> char const *\n"
36411 : "\n"
36412 : "\n"
36413 : ":py:const:`OFTReal` and :py:const:`OFTInteger` fields will be translated to string using\n"
36414 : "sprintf(), but not necessarily using the established formatting rules.\n"
36415 : "Other field types, or errors will result in a return value of zero.\n"
36416 : "\n"
36417 : "See :cpp:func:`OGRFeature::GetFieldAsString`.\n"
36418 : "\n"
36419 : "Parameters\n"
36420 : "-----------\n"
36421 : "fld_index : int / str\n"
36422 : " Field name or 0-based numeric index. For repeated\n"
36423 : " access, use of the numeric index avoids a lookup\n"
36424 : " step.\n"
36425 : "\n"
36426 : "Returns\n"
36427 : "--------\n"
36428 : "str:\n"
36429 : " the field value.\n"
36430 : "\n"
36431 : ""},
36432 : { "Feature_GetFieldAsISO8601DateTime", _wrap_Feature_GetFieldAsISO8601DateTime, METH_VARARGS, "\n"
36433 : "Feature_GetFieldAsISO8601DateTime(Feature self, int id, char ** options=None) -> char const\n"
36434 : "Feature_GetFieldAsISO8601DateTime(Feature self, char const * field_name, char ** options=None) -> char const *\n"
36435 : "\n"
36436 : "\n"
36437 : "Fetch :py:const:`OFTDateTime` field value as a ISO8601 representation.\n"
36438 : "\n"
36439 : "Return a string like 'YYYY-MM-DDTHH:MM:SS(.sss)?(Z|([+|-]HH:MM))?'\n"
36440 : "Milliseconds are omitted if equal to zero.\n"
36441 : "Other field types, or errors will result in a return of an empty string.\n"
36442 : "\n"
36443 : "See :cpp:func:`OGRFeature::GetFieldAsISO8601DateTime`.\n"
36444 : "\n"
36445 : ".. versionadded:: 3.7\n"
36446 : "\n"
36447 : "Parameters\n"
36448 : "-----------\n"
36449 : "fld_index : int / str\n"
36450 : " Field name or 0-based numeric index. For repeated\n"
36451 : " access, use of the numeric index avoids a lookup\n"
36452 : " step.\n"
36453 : "options : dict / str\n"
36454 : " Not currently used.\n"
36455 : "\n"
36456 : ""},
36457 : { "Feature_GetFieldAsInteger", _wrap_Feature_GetFieldAsInteger, METH_VARARGS, "\n"
36458 : "Feature_GetFieldAsInteger(Feature self, int id) -> int\n"
36459 : "Feature_GetFieldAsInteger(Feature self, char const * field_name) -> int\n"
36460 : "\n"
36461 : "\n"
36462 : "Fetch field value as a 32-bit integer.\n"
36463 : "\n"
36464 : ":py:const:`OFTString` features will be translated using atoi().\n"
36465 : ":py:const:`OFTReal` fields will be cast to integer. Other field types, or\n"
36466 : "errors will result in a return value of zero.\n"
36467 : "\n"
36468 : "See :cpp:func:`GetFieldAsInteger`.\n"
36469 : "\n"
36470 : "Parameters\n"
36471 : "-----------\n"
36472 : "fld_index : int / str\n"
36473 : " Field name or 0-based numeric index. For repeated\n"
36474 : " access, use of the numeric index avoids a lookup\n"
36475 : " step.\n"
36476 : "\n"
36477 : "Returns\n"
36478 : "--------\n"
36479 : "int:\n"
36480 : " the field value.\n"
36481 : "\n"
36482 : "Examples\n"
36483 : "--------\n"
36484 : ">>> defn = ogr.FeatureDefn()\n"
36485 : ">>> defn.AddFieldDefn(ogr.FieldDefn('my_int', ogr.OFTInteger64))\n"
36486 : ">>> feature = ogr.Feature(defn)\n"
36487 : ">>> feature['my_int'] = 2**32 + 1\n"
36488 : ">>> feature.GetFieldAsInteger('my_int')\n"
36489 : "Warning 1: Integer overflow occurred when trying to return 64bit integer. Use GetFieldAsInteger64() instead\n"
36490 : "2147483647\n"
36491 : ">>> feature.GetFieldAsInteger64('my_int')\n"
36492 : "4294967297\n"
36493 : ">>> feature.GetField('my_int')\n"
36494 : "4294967297\n"
36495 : "\n"
36496 : ""},
36497 : { "Feature_GetFieldAsInteger64", _wrap_Feature_GetFieldAsInteger64, METH_VARARGS, "\n"
36498 : "Feature_GetFieldAsInteger64(Feature self, int id) -> GIntBig\n"
36499 : "Feature_GetFieldAsInteger64(Feature self, char const * field_name) -> GIntBig\n"
36500 : "\n"
36501 : "\n"
36502 : "Fetch field value as integer 64 bit.\n"
36503 : "\n"
36504 : ":py:const:`OFTInteger` are promoted to 64 bit. :py:const:`OFTString` features\n"
36505 : "will be translated using :cpp:func:`CPLAtoGIntBig`. :py:const:`OFTReal` fields\n"
36506 : "will be cast to integer. Other field types, or errors will result in a return\n"
36507 : "value of zero.\n"
36508 : "\n"
36509 : "See :cpp:func:`OGRFeature::GetFieldAsInteger64`.\n"
36510 : "\n"
36511 : "Parameters\n"
36512 : "-----------\n"
36513 : "fld_index : int / str\n"
36514 : " Field name or 0-based numeric index. For repeated\n"
36515 : " access, use of the numeric index avoids a lookup\n"
36516 : " step.\n"
36517 : "\n"
36518 : "Returns\n"
36519 : "--------\n"
36520 : "int:\n"
36521 : " the field value.\n"
36522 : "\n"
36523 : ""},
36524 : { "Feature_GetFieldAsDouble", _wrap_Feature_GetFieldAsDouble, METH_VARARGS, "\n"
36525 : "Feature_GetFieldAsDouble(Feature self, int id) -> double\n"
36526 : "Feature_GetFieldAsDouble(Feature self, char const * field_name) -> double\n"
36527 : "\n"
36528 : "Fetch field value as a double.\n"
36529 : "\n"
36530 : ":py:const:`OFTString` features will be translated using :cpp:func:`CPLAtof`. :py:const:`OFTInteger`\n"
36531 : "fields will be cast to double. Other field types, or errors will\n"
36532 : "result in a return value of zero.\n"
36533 : "\n"
36534 : "See :cpp:func:`OGRFeature::GetFieldAsDouble`.\n"
36535 : "\n"
36536 : "Parameters\n"
36537 : "-----------\n"
36538 : "fld_index : int / str\n"
36539 : " Field name or 0-based numeric index. For repeated\n"
36540 : " access, use of the numeric index avoids a lookup\n"
36541 : " step.\n"
36542 : "\n"
36543 : "Returns\n"
36544 : "--------\n"
36545 : "float:\n"
36546 : " the field value.\n"
36547 : "\n"
36548 : ""},
36549 : { "Feature_GetFieldAsDateTime", _wrap_Feature_GetFieldAsDateTime, METH_VARARGS, "\n"
36550 : "Feature_GetFieldAsDateTime(Feature self, int id)\n"
36551 : "Feature_GetFieldAsDateTime(Feature self, char const * field_name)\n"
36552 : "\n"
36553 : "\n"
36554 : "Fetch field value as date and time.\n"
36555 : "\n"
36556 : "Currently this method only works for :py:const:`OFTDate`, :py:const:`OFTTime`\n"
36557 : "and :py:const:`OFTDateTime` fields.\n"
36558 : "\n"
36559 : "See :cpp:func:`OGRFeature::GetFieldAsDateTime`.\n"
36560 : "\n"
36561 : "Parameters\n"
36562 : "-----------\n"
36563 : "fld_index : int / str\n"
36564 : " Field name or 0-based numeric index. For repeated\n"
36565 : " access, use of the numeric index avoids a lookup\n"
36566 : " step.\n"
36567 : "\n"
36568 : "Returns\n"
36569 : "--------\n"
36570 : "list\n"
36571 : " list containing [ year, month, day, hour, minute, second, timezone flag ]\n"
36572 : "\n"
36573 : "Examples\n"
36574 : "--------\n"
36575 : ">>> from datetime import datetime\n"
36576 : ">>> from zoneinfo import ZoneInfo\n"
36577 : ">>> defn = ogr.FeatureDefn()\n"
36578 : ">>> defn.AddFieldDefn(ogr.FieldDefn('unknown', ogr.OFTDateTime))\n"
36579 : ">>> defn.AddFieldDefn(ogr.FieldDefn('local', ogr.OFTDateTime))\n"
36580 : ">>> defn.AddFieldDefn(ogr.FieldDefn('utc', ogr.OFTDateTime))\n"
36581 : ">>> feature = ogr.Feature(defn)\n"
36582 : ">>> feature['unknown'] = datetime.now()\n"
36583 : ">>> feature['local'] = datetime.now(ZoneInfo('Canada/Eastern'))\n"
36584 : ">>> feature['utc'] = datetime.now(ZoneInfo('UTC'))\n"
36585 : ">>> feature.GetFieldAsDateTime('unknown')\n"
36586 : "[2024, 3, 15, 20, 34, 52.594173431396484, 0]\n"
36587 : ">>> feature.GetFieldAsDateTime('local')\n"
36588 : "[2024, 3, 15, 20, 34, 52.59502410888672, 84]\n"
36589 : ">>> feature.GetFieldAsDateTime('utc')\n"
36590 : "[2024, 3, 16, 0, 34, 52.59580993652344, 100]\n"
36591 : "\n"
36592 : "See Also\n"
36593 : "--------\n"
36594 : ":py:func:`Feature.GetFieldAsISO8601DateTime`\n"
36595 : "\n"
36596 : ""},
36597 : { "Feature_GetFieldAsIntegerList", _wrap_Feature_GetFieldAsIntegerList, METH_VARARGS, "\n"
36598 : "Feature_GetFieldAsIntegerList(Feature self, int id)\n"
36599 : "Feature_GetFieldAsIntegerList(Feature self, char const * field_name)\n"
36600 : "\n"
36601 : "\n"
36602 : "Fetch field value as a list of integers.\n"
36603 : "\n"
36604 : "Currently this function only works for :py:const:`OFTIntegerList` fields.\n"
36605 : "\n"
36606 : "This function is the same as the C++ method\n"
36607 : ":cpp:func:`OGRFeature::GetFieldAsIntegerList`.\n"
36608 : "\n"
36609 : "Parameters\n"
36610 : "-----------\n"
36611 : "fld_index : int / str\n"
36612 : " Field name or 0-based numeric index. For repeated\n"
36613 : " access, use of the numeric index avoids a lookup\n"
36614 : " step.\n"
36615 : "\n"
36616 : "Returns\n"
36617 : "--------\n"
36618 : "list:\n"
36619 : " the field value.\n"
36620 : "\n"
36621 : ""},
36622 : { "Feature_GetFieldAsInteger64List", _wrap_Feature_GetFieldAsInteger64List, METH_VARARGS, "\n"
36623 : "Feature_GetFieldAsInteger64List(Feature self, int id)\n"
36624 : "\n"
36625 : "Fetch field value as a list of 64 bit integers.\n"
36626 : "\n"
36627 : "Currently this function only works for :py:const:`OFTInteger64List` fields.\n"
36628 : "\n"
36629 : "See :cpp:func:`OGRFeature::GetFieldAsInteger64List`.\n"
36630 : "\n"
36631 : "Parameters\n"
36632 : "-----------\n"
36633 : "fld_index : int / str\n"
36634 : " Field name or 0-based numeric index. For repeated\n"
36635 : " access, use of the numeric index avoids a lookup\n"
36636 : " step.\n"
36637 : "\n"
36638 : "Returns\n"
36639 : "--------\n"
36640 : "list:\n"
36641 : " the field value.\n"
36642 : "\n"
36643 : ""},
36644 : { "Feature_GetFieldAsDoubleList", _wrap_Feature_GetFieldAsDoubleList, METH_VARARGS, "\n"
36645 : "Feature_GetFieldAsDoubleList(Feature self, int id)\n"
36646 : "Feature_GetFieldAsDoubleList(Feature self, char const * field_name)\n"
36647 : "\n"
36648 : "\n"
36649 : "Fetch field value as a list of doubles.\n"
36650 : "\n"
36651 : "Currently this function only works for :py:const:`OFTRealList` fields.\n"
36652 : "\n"
36653 : "See :cpp:func:`OGRFeature::GetFieldAsDoubleList`.\n"
36654 : "\n"
36655 : "Parameters\n"
36656 : "-----------\n"
36657 : "fld_index : int / str\n"
36658 : " Field name or 0-based numeric index. For repeated\n"
36659 : " access, use of the numeric index avoids a lookup\n"
36660 : " step.\n"
36661 : "\n"
36662 : "Returns\n"
36663 : "-------\n"
36664 : "list\n"
36665 : "\n"
36666 : "Examples\n"
36667 : "--------\n"
36668 : ">>> defn = ogr.FeatureDefn()\n"
36669 : ">>> defn.AddFieldDefn(ogr.FieldDefn('list', ogr.OFTRealList))\n"
36670 : ">>> feature = ogr.Feature(defn)\n"
36671 : ">>> feature['list'] = [1.1, 2.2, 3.3]\n"
36672 : ">>> feature.GetFieldAsDoubleList('list')\n"
36673 : "[1.1, 2.2, 3.3]\n"
36674 : "\n"
36675 : ""},
36676 : { "Feature_GetFieldAsStringList", _wrap_Feature_GetFieldAsStringList, METH_VARARGS, "\n"
36677 : "Feature_GetFieldAsStringList(Feature self, int id) -> char **\n"
36678 : "\n"
36679 : "\n"
36680 : "Fetch field value as a list of strings.\n"
36681 : "\n"
36682 : "Currently this method only works for :py:const:`OFTStringList` fields.\n"
36683 : "\n"
36684 : "See :cpp:func:`OGRFeature::GetFieldAsStringList`.\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 : "list:\n"
36696 : " the field value.\n"
36697 : "\n"
36698 : ""},
36699 : { "Feature_GetFieldAsBinary", _wrap_Feature_GetFieldAsBinary, METH_VARARGS, "\n"
36700 : "Feature_GetFieldAsBinary(Feature self, int id) -> OGRErr\n"
36701 : "Feature_GetFieldAsBinary(Feature self, char const * field_name) -> OGRErr\n"
36702 : "\n"
36703 : "\n"
36704 : "Fetch field value as binary.\n"
36705 : "\n"
36706 : "This method only works for :py:const:`OFTBinary` and :py:const:`OFTString` fields.\n"
36707 : "\n"
36708 : "See :cpp:func:`OGRFeature::GetFieldAsBinary`.\n"
36709 : "\n"
36710 : "Parameters\n"
36711 : "-----------\n"
36712 : "fld_index : int / str\n"
36713 : " Field name or 0-based numeric index. For repeated\n"
36714 : " access, use of the numeric index avoids a lookup\n"
36715 : " step.\n"
36716 : "\n"
36717 : "Returns\n"
36718 : "--------\n"
36719 : "bytearray\n"
36720 : "\n"
36721 : ""},
36722 : { "Feature_IsFieldSet", _wrap_Feature_IsFieldSet, METH_VARARGS, "\n"
36723 : "Feature_IsFieldSet(Feature self, int id) -> bool\n"
36724 : "Feature_IsFieldSet(Feature self, char const * field_name) -> bool\n"
36725 : "\n"
36726 : "\n"
36727 : "Test if a field has ever been assigned a value or not.\n"
36728 : "\n"
36729 : "See :cpp:func:`OGRFeature::IsFieldSet`.\n"
36730 : "\n"
36731 : "Parameters\n"
36732 : "-----------\n"
36733 : "fld_index : int / str\n"
36734 : " Field name or 0-based numeric index. For repeated\n"
36735 : " access, use of the numeric index avoids a lookup\n"
36736 : " step.\n"
36737 : "\n"
36738 : "Returns\n"
36739 : "--------\n"
36740 : "bool:\n"
36741 : " ``True`` if the field has been set, otherwise ``False``.\n"
36742 : "\n"
36743 : ""},
36744 : { "Feature_IsFieldNull", _wrap_Feature_IsFieldNull, METH_VARARGS, "\n"
36745 : "Feature_IsFieldNull(Feature self, int id) -> bool\n"
36746 : "Feature_IsFieldNull(Feature self, char const * field_name) -> bool\n"
36747 : "\n"
36748 : "\n"
36749 : "Test if a field is null.\n"
36750 : "\n"
36751 : "See :cpp:func:OGRFeature::`IsFieldNull`.\n"
36752 : "\n"
36753 : "Parameters\n"
36754 : "-----------\n"
36755 : "fld_index : int / str\n"
36756 : " Field name or 0-based numeric index. For repeated\n"
36757 : " access, use of the numeric index avoids a lookup\n"
36758 : " step.\n"
36759 : "\n"
36760 : "Returns\n"
36761 : "--------\n"
36762 : "bool:\n"
36763 : " ``True`` if the field is null, otherwise ``False``\n"
36764 : "\n"
36765 : ""},
36766 : { "Feature_IsFieldSetAndNotNull", _wrap_Feature_IsFieldSetAndNotNull, METH_VARARGS, "\n"
36767 : "Feature_IsFieldSetAndNotNull(Feature self, int id) -> bool\n"
36768 : "Feature_IsFieldSetAndNotNull(Feature self, char const * field_name) -> bool\n"
36769 : "\n"
36770 : "\n"
36771 : "Test if a field is set and not null.\n"
36772 : "\n"
36773 : "See :cpp:func:`OGRFeature::IsFieldSetAndNotNull`.\n"
36774 : "\n"
36775 : "Parameters\n"
36776 : "-----------\n"
36777 : "fld_index : int / str\n"
36778 : " Field name or 0-based numeric index. For repeated\n"
36779 : " access, use of the numeric index avoids a lookup\n"
36780 : " step.\n"
36781 : "\n"
36782 : "Returns\n"
36783 : "--------\n"
36784 : "bool:\n"
36785 : " ``True`` if the field is set and not null, otherwise ``False``.\n"
36786 : "\n"
36787 : ""},
36788 : { "Feature_GetFieldIndex", _wrap_Feature_GetFieldIndex, METH_VARARGS, "\n"
36789 : "Feature_GetFieldIndex(Feature self, char const * field_name) -> int\n"
36790 : "\n"
36791 : "\n"
36792 : "Fetch the field index given field name.\n"
36793 : "\n"
36794 : "See :cpp:func:`OGRFeature::GetFieldIndex`.\n"
36795 : "\n"
36796 : "Parameters\n"
36797 : "-----------\n"
36798 : "field_name:\n"
36799 : " the name of the field to search for.\n"
36800 : "\n"
36801 : "Returns\n"
36802 : "--------\n"
36803 : "int:\n"
36804 : " the field index, or -1 if no matching field is found.\n"
36805 : "\n"
36806 : ""},
36807 : { "Feature_GetGeomFieldIndex", _wrap_Feature_GetGeomFieldIndex, METH_VARARGS, "\n"
36808 : "Feature_GetGeomFieldIndex(Feature self, char const * field_name) -> int\n"
36809 : "\n"
36810 : "\n"
36811 : "Fetch the geometry field index given geometry field name.\n"
36812 : "\n"
36813 : "See :cpp:func:`OGRFeature::GetGeomFieldIndex`.\n"
36814 : "\n"
36815 : "Parameters\n"
36816 : "-----------\n"
36817 : "field_name:\n"
36818 : " the name of the geometry field to search for.\n"
36819 : "\n"
36820 : "Returns\n"
36821 : "--------\n"
36822 : "int:\n"
36823 : " the geometry field index, or -1 if no matching geometry field is found.\n"
36824 : "\n"
36825 : ""},
36826 : { "Feature_GetFID", _wrap_Feature_GetFID, METH_O, "\n"
36827 : "Feature_GetFID(Feature self) -> GIntBig\n"
36828 : "\n"
36829 : "\n"
36830 : "Get feature identifier.\n"
36831 : "See :cpp:func:`OGRFeature::GetFID`\n"
36832 : "\n"
36833 : "Returns\n"
36834 : "-------\n"
36835 : "int:\n"
36836 : " feature id or :py:const:`NullFID` if none has been assigned.\n"
36837 : "\n"
36838 : ""},
36839 : { "Feature_SetFID", _wrap_Feature_SetFID, METH_VARARGS, "\n"
36840 : "Feature_SetFID(Feature self, GIntBig fid) -> OGRErr\n"
36841 : "\n"
36842 : "\n"
36843 : "Set the feature identifier.\n"
36844 : "\n"
36845 : "For specific types of features this operation may fail on illegal\n"
36846 : "features ids. Generally it always succeeds. Feature ids should be\n"
36847 : "greater than or equal to zero, with the exception of :py:const:NullFID` (-1)\n"
36848 : "indicating that the feature id is unknown.\n"
36849 : "\n"
36850 : "See :cpp:func:`OGRFeature::SetFID`.\n"
36851 : "\n"
36852 : "Parameters\n"
36853 : "-----------\n"
36854 : "fid:\n"
36855 : " the new feature identifier value to assign.\n"
36856 : "\n"
36857 : "Returns\n"
36858 : "--------\n"
36859 : "int:\n"
36860 : " :py:const:`OGRERR_NONE` on success, or some other value on failure.\n"
36861 : "\n"
36862 : ""},
36863 : { "Feature_DumpReadable", _wrap_Feature_DumpReadable, METH_O, "\n"
36864 : "Feature_DumpReadable(Feature self)\n"
36865 : "\n"
36866 : "\n"
36867 : "Print this feature in a human readable form.\n"
36868 : "\n"
36869 : "This dumps the attributes and geometry. It doesn't include\n"
36870 : "definition information other than field types and names nor does it\n"
36871 : "report the geometry spatial reference system.\n"
36872 : "\n"
36873 : "See :cpp:func:`OGRFeature::DumpReadable`.\n"
36874 : "\n"
36875 : "Examples\n"
36876 : "--------\n"
36877 : ">>> with gdal.OpenEx('data/poly.shp') as ds:\n"
36878 : "... lyr = ds.GetLayer(0)\n"
36879 : "... feature = lyr.GetNextFeature()\n"
36880 : "... feature.DumpReadable()\n"
36881 : "...\n"
36882 : "OGRFeature(poly):0\n"
36883 : " AREA (Real) = 215229.266\n"
36884 : " EAS_ID (Integer64) = 168\n"
36885 : " PRFEDEA (String) = 35043411\n"
36886 : " 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"
36887 : "\n"
36888 : ""},
36889 : { "Feature_DumpReadableAsString", _wrap_Feature_DumpReadableAsString, METH_VARARGS, "\n"
36890 : "Feature_DumpReadableAsString(Feature self, char ** options=None) -> retStringAndCPLFree *\n"
36891 : "\n"
36892 : "\n"
36893 : "Return feature information in a human-readable form.\n"
36894 : "Returns the text printed by :py:func:`Feature.DumpReadable`.\n"
36895 : "\n"
36896 : "Returns\n"
36897 : "-------\n"
36898 : "str\n"
36899 : "\n"
36900 : ""},
36901 : { "Feature_UnsetField", _wrap_Feature_UnsetField, METH_VARARGS, "\n"
36902 : "Feature_UnsetField(Feature self, int id)\n"
36903 : "Feature_UnsetField(Feature self, char const * field_name)\n"
36904 : "\n"
36905 : "\n"
36906 : "Clear a field, marking it as unset.\n"
36907 : "\n"
36908 : "See :cpp:func:`OGRFeature::UnsetField`.\n"
36909 : "\n"
36910 : "Parameters\n"
36911 : "-----------\n"
36912 : "fld_index : int / str\n"
36913 : " Field name or 0-based numeric index. For repeated\n"
36914 : " access, use of the numeric index avoids a lookup\n"
36915 : " step.\n"
36916 : "\n"
36917 : ""},
36918 : { "Feature_SetFieldNull", _wrap_Feature_SetFieldNull, METH_VARARGS, "\n"
36919 : "Feature_SetFieldNull(Feature self, int id)\n"
36920 : "Feature_SetFieldNull(Feature self, char const * field_name)\n"
36921 : "\n"
36922 : "\n"
36923 : "Clear a field, marking it as null.\n"
36924 : "\n"
36925 : "See :cpp:func:`OGRFeature::SetFieldNull`.\n"
36926 : "\n"
36927 : "Parameters\n"
36928 : "-----------\n"
36929 : "fld_index : int / str\n"
36930 : " Field name or 0-based numeric index. For repeated\n"
36931 : " access, use of the numeric index avoids a lookup\n"
36932 : " step.\n"
36933 : "\n"
36934 : "\n"
36935 : ""},
36936 : { "Feature_SetFieldInteger64", _wrap_Feature_SetFieldInteger64, METH_VARARGS, "Feature_SetFieldInteger64(Feature self, int id, GIntBig value)"},
36937 : { "Feature_SetField", _wrap_Feature_SetField, METH_VARARGS, "\n"
36938 : "Feature_SetField(Feature self, int id, char const * value)\n"
36939 : "Feature_SetField(Feature self, char const * field_name, char const * value)\n"
36940 : "Feature_SetField(Feature self, int id, double value)\n"
36941 : "Feature_SetField(Feature self, char const * field_name, double value)\n"
36942 : "Feature_SetField(Feature self, int id, int year, int month, int day, int hour, int minute, float second, int tzflag)\n"
36943 : "Feature_SetField(Feature self, char const * field_name, int year, int month, int day, int hour, int minute, float second, int tzflag)\n"
36944 : ""},
36945 : { "Feature_SetFieldIntegerList", _wrap_Feature_SetFieldIntegerList, METH_VARARGS, "\n"
36946 : "Feature_SetFieldIntegerList(Feature self, int id, int nList)\n"
36947 : "void\n"
36948 : "\n"
36949 : "Set field to list of integer values.\n"
36950 : "\n"
36951 : "This function currently on has an effect of :py:const:`OFTIntegerList`,\n"
36952 : ":py:const:`OFTInteger64List`, :py:const:`OFTRealList` fields.\n"
36953 : "\n"
36954 : "See :cpp:func:`OGRFeature::SetField`.\n"
36955 : "\n"
36956 : "This method has only an effect on the in-memory feature object. If\n"
36957 : "this object comes from a layer and the modifications must be\n"
36958 : "serialized back to the datasource, :py:meth:`Layer.SetFeature` must be used\n"
36959 : "afterwards. Or if this is a new feature, :py:meth:`Layer.CreateFeature` must be\n"
36960 : "used afterwards.\n"
36961 : "\n"
36962 : "Parameters\n"
36963 : "-----------\n"
36964 : "id : int\n"
36965 : " the field to set, from 0 to :py:meth:`GetFieldCount`-1.\n"
36966 : "nList : list\n"
36967 : " the values to assign.\n"
36968 : "\n"
36969 : ""},
36970 : { "Feature_SetFieldInteger64List", _wrap_Feature_SetFieldInteger64List, METH_VARARGS, "\n"
36971 : "Feature_SetFieldInteger64List(Feature self, int id, int nList)\n"
36972 : "void\n"
36973 : "\n"
36974 : "Set field to list of 64 bit integer values.\n"
36975 : "\n"
36976 : "This function currently on has an effect of :py:const:`OFTIntegerList`,\n"
36977 : ":py:const:`OFTInteger64List`, :py:const:`OFTRealList` fields.\n"
36978 : "\n"
36979 : "See :cpp:func:`OGRFeature::SetField`.\n"
36980 : "\n"
36981 : "This method has only an effect on the in-memory feature object. If\n"
36982 : "this object comes from a layer and the modifications must be\n"
36983 : "serialized back to the datasource, :py:meth:`Layer.SetFeature` must be used\n"
36984 : "afterwards. Or if this is a new feature, :py:meth:`Layer.CreateFeature` must be\n"
36985 : "used afterwards.\n"
36986 : "\n"
36987 : "Parameters\n"
36988 : "-----------\n"
36989 : "id : int\n"
36990 : " the field to set, from 0 to :py:meth:`GetFieldCount`-1.\n"
36991 : "nList : list\n"
36992 : " the values to assign.\n"
36993 : "\n"
36994 : ""},
36995 : { "Feature_SetFieldDoubleList", _wrap_Feature_SetFieldDoubleList, METH_VARARGS, "\n"
36996 : "Feature_SetFieldDoubleList(Feature self, int id, int nList)\n"
36997 : "\n"
36998 : "\n"
36999 : "Set field to list of double values.\n"
37000 : "\n"
37001 : "This function currently on has an effect of :py:const:`OFTIntegerList`,\n"
37002 : ":py:const:`OFTInteger64List`, :py:const:`OFTRealList` fields.\n"
37003 : "\n"
37004 : "See :cpp:func:`OGRFeature::SetField`.\n"
37005 : "\n"
37006 : "This method has only an effect on the in-memory feature object. If\n"
37007 : "this object comes from a layer and the modifications must be\n"
37008 : "serialized back to the datasource, :py:meth:`Layer.SetFeature` must be used\n"
37009 : "afterwards. Or if this is a new feature, :py:meth:`Layer.CreateFeature` must be\n"
37010 : "used afterwards.\n"
37011 : "\n"
37012 : "Parameters\n"
37013 : "-----------\n"
37014 : "id : int\n"
37015 : " the field to set, from 0 to :py:meth:`GetFieldCount`-1.\n"
37016 : "nList : list\n"
37017 : " the values to assign.\n"
37018 : "\n"
37019 : ""},
37020 : { "Feature_SetFieldStringList", _wrap_Feature_SetFieldStringList, METH_VARARGS, "\n"
37021 : "Feature_SetFieldStringList(Feature self, int id, char ** pList)\n"
37022 : "\n"
37023 : "\n"
37024 : "Set field to list of strings value.\n"
37025 : "\n"
37026 : "This function currently only has an effect of :py:const:`OFTStringList` fields.\n"
37027 : "\n"
37028 : "See :cpp:func:`OGRFeature::SetField`.\n"
37029 : "\n"
37030 : "This method has only an effect on the in-memory feature object. If\n"
37031 : "this object comes from a layer and the modifications must be\n"
37032 : "serialized back to the datasource, :py:meth:`Layer.SetFeature` must be used\n"
37033 : "afterwards. Or if this is a new feature, :py:meth:`Layer.CreateFeature` must be\n"
37034 : "used afterwards.\n"
37035 : "\n"
37036 : "Parameters\n"
37037 : "-----------\n"
37038 : "fld_index : int / str\n"
37039 : " Field name or 0-based numeric index. For repeated\n"
37040 : " access, use of the numeric index avoids a lookup\n"
37041 : " step.\n"
37042 : "value:\n"
37043 : " the value to assign.\n"
37044 : "\n"
37045 : ""},
37046 : { "Feature__SetFieldBinary", _wrap_Feature__SetFieldBinary, METH_VARARGS, "Feature__SetFieldBinary(Feature self, int id, int nLen)"},
37047 : { "Feature_SetFieldBinaryFromHexString", _wrap_Feature_SetFieldBinaryFromHexString, METH_VARARGS, "\n"
37048 : "Feature_SetFieldBinaryFromHexString(Feature self, int id, char const * pszValue)\n"
37049 : "Feature_SetFieldBinaryFromHexString(Feature self, char const * field_name, char const * pszValue)\n"
37050 : ""},
37051 : { "Feature_SetFrom", (PyCFunction)(void(*)(void))_wrap_Feature_SetFrom, METH_VARARGS|METH_KEYWORDS, "\n"
37052 : "Feature_SetFrom(Feature self, Feature other, int forgiving=1) -> OGRErr\n"
37053 : "\n"
37054 : "Set one feature from another.\n"
37055 : "\n"
37056 : "Overwrite the contents of this feature from the geometry and\n"
37057 : "attributes of another. The other feature does not need to have the\n"
37058 : "same :py:class:`FeatureDefn`. Field values are copied by corresponding field\n"
37059 : "names. Field types do not have to exactly match. OGR_F_SetField\\*()\n"
37060 : "function conversion rules will be applied as needed.\n"
37061 : "\n"
37062 : "See :cpp:func:`OGRFeature::SetFrom`.\n"
37063 : "\n"
37064 : "Parameters\n"
37065 : "-----------\n"
37066 : "other : Feature\n"
37067 : " feature from which geometry and field values will be copied.\n"
37068 : "forgiving : bool, default = True\n"
37069 : " ``True`` if the operation should continue despite lacking\n"
37070 : " output fields matching some of the source fields.\n"
37071 : "\n"
37072 : "Returns\n"
37073 : "--------\n"
37074 : "int:\n"
37075 : " :py:const:`OGRERR_NONE` if the operation succeeds, even if some values are not\n"
37076 : " transferred, otherwise an error code.\n"
37077 : "\n"
37078 : ""},
37079 : { "Feature_SetFromWithMap", _wrap_Feature_SetFromWithMap, METH_VARARGS, "\n"
37080 : "Feature_SetFromWithMap(Feature self, Feature other, int forgiving, int nList) -> OGRErr\n"
37081 : "\n"
37082 : "\n"
37083 : "Set one feature from another.\n"
37084 : "\n"
37085 : "Overwrite the contents of this feature from the geometry and\n"
37086 : "attributes of another. The other feature does not need to have the\n"
37087 : "same :py:class:`FeatureDefn`. Field values are copied according to the provided\n"
37088 : "indices map. Field types do not have to exactly match.\n"
37089 : "OGR_F_SetField\\*() function conversion rules will be applied as needed.\n"
37090 : "This is more efficient than :py:meth:SetFrom` in that this doesn't\n"
37091 : "lookup the fields by their names. Particularly useful when the field\n"
37092 : "names don't match.\n"
37093 : "\n"
37094 : "See :cpp:func:`OGRFeature::SetFrom`.\n"
37095 : "\n"
37096 : "Parameters\n"
37097 : "-----------\n"
37098 : "other : Feature\n"
37099 : " handle to the feature from which geometry, and field\n"
37100 : " values will be copied.\n"
37101 : "forgiving : bool\n"
37102 : " ``True`` if the operation should continue despite lacking\n"
37103 : " output fields matching some of the source fields.\n"
37104 : "nList : list\n"
37105 : " Array of the indices of the destination feature's fields\n"
37106 : " stored at the corresponding index of the source feature's fields. A\n"
37107 : " value of -1 should be used to ignore the source's field. The array\n"
37108 : " should not be NULL and be as long as the number of fields in the\n"
37109 : " source feature.\n"
37110 : "\n"
37111 : "Returns\n"
37112 : "--------\n"
37113 : "OGRErr:\n"
37114 : " :py:const:`OGRERR_NONE` if the operation succeeds, even if some values are not\n"
37115 : " transferred, otherwise an error code.\n"
37116 : "\n"
37117 : ""},
37118 : { "Feature_GetStyleString", _wrap_Feature_GetStyleString, METH_O, "\n"
37119 : "Feature_GetStyleString(Feature self) -> char const *\n"
37120 : "\n"
37121 : "\n"
37122 : "Fetch style string for this feature.\n"
37123 : "\n"
37124 : "Set the OGR Feature Style Specification for details on the format of\n"
37125 : "this string, and :source_file:`ogr/ogr_featurestyle.h` for services available to parse\n"
37126 : "it.\n"
37127 : "\n"
37128 : "See :cpp:func:`OGRFeature::GetStyleString`.\n"
37129 : "\n"
37130 : "Returns\n"
37131 : "--------\n"
37132 : "str or None\n"
37133 : "\n"
37134 : ""},
37135 : { "Feature_SetStyleString", _wrap_Feature_SetStyleString, METH_VARARGS, "\n"
37136 : "Feature_SetStyleString(Feature self, char const * the_string)\n"
37137 : "\n"
37138 : "\n"
37139 : "Set feature style string.\n"
37140 : "\n"
37141 : "See :cpp:func:`OGRFeature::SetStyleString`.\n"
37142 : "\n"
37143 : "Parameters\n"
37144 : "-----------\n"
37145 : "the_string : str\n"
37146 : " the style string to apply to this feature\n"
37147 : "\n"
37148 : ""},
37149 : { "Feature_GetFieldType", _wrap_Feature_GetFieldType, METH_VARARGS, "\n"
37150 : "Feature_GetFieldType(Feature self, int id) -> OGRFieldType\n"
37151 : "Feature_GetFieldType(Feature self, char const * field_name) -> OGRFieldType\n"
37152 : "\n"
37153 : "\n"
37154 : "Return the type of the given field.\n"
37155 : "\n"
37156 : "Parameters\n"
37157 : "-----------\n"
37158 : "fld_index : int / str\n"
37159 : " Field name or 0-based numeric index. For repeated\n"
37160 : " access, use of the numeric index avoids a lookup\n"
37161 : " step.\n"
37162 : "\n"
37163 : "Returns\n"
37164 : "--------\n"
37165 : "int\n"
37166 : " field type code (e.g., :py:const:`OFTInteger`)\n"
37167 : "\n"
37168 : ""},
37169 : { "Feature_Validate", _wrap_Feature_Validate, METH_VARARGS, "\n"
37170 : "Feature_Validate(Feature self, int flags=OGR_F_VAL_ALL, int bEmitError=TRUE) -> int\n"
37171 : "\n"
37172 : "\n"
37173 : "Validate that a feature meets constraints of its schema.\n"
37174 : "\n"
37175 : "The scope of test is specified with the ``flags`` parameter.\n"
37176 : "\n"
37177 : "Regarding :py:const:`OGR_F_VAL_WIDTH`, the test is done assuming the string\n"
37178 : "width must be interpreted as the number of UTF-8 characters. Some drivers might\n"
37179 : "interpret the width as the number of bytes instead. So this test is rather\n"
37180 : "conservative (if it fails, then it will fail for all interpretations).\n"
37181 : "\n"
37182 : "See :cpp:func:`OGRFeature::Validate`.\n"
37183 : "\n"
37184 : "Parameters\n"
37185 : "-----------\n"
37186 : "flags : int, default = :py:const:`F_VAL_ALL`\n"
37187 : " One ore more of :py:const:`OGR_F_VAL_NULL`,\n"
37188 : " :py:const:`OGR_F_VAL_GEOM_TYPE`, py:const:`OGR_F_VAL_WIDTH` and\n"
37189 : " :py:const:`OGR_F_VAL_ALLOW_NULL_WHEN_DEFAULT` combined with\n"
37190 : " the with ``|`` operator\n"
37191 : "bEmitError : bool, default = True\n"
37192 : " TRUE if a CPLError() must be emitted when a check fails\n"
37193 : "\n"
37194 : "Returns\n"
37195 : "-------\n"
37196 : "int:\n"
37197 : " TRUE if all enabled validation tests pass.\n"
37198 : "\n"
37199 : ""},
37200 : { "Feature_FillUnsetWithDefault", _wrap_Feature_FillUnsetWithDefault, METH_VARARGS, "\n"
37201 : "Feature_FillUnsetWithDefault(Feature self, int bNotNullableOnly=FALSE, char ** options=None)\n"
37202 : "\n"
37203 : "\n"
37204 : "Fill unset fields with default values that might be defined.\n"
37205 : "\n"
37206 : "See :cpp:func:`OGRFeature::FillUnsetWithDefault`.\n"
37207 : "\n"
37208 : "Parameters\n"
37209 : "-----------\n"
37210 : "bNotNullableOnly : bool\n"
37211 : " if we should fill only unset fields with a not-null\n"
37212 : " constraint.\n"
37213 : "options : dict\n"
37214 : " unused currently.\n"
37215 : "\n"
37216 : ""},
37217 : { "Feature_GetNativeData", _wrap_Feature_GetNativeData, METH_O, "\n"
37218 : "Feature_GetNativeData(Feature self) -> char const *\n"
37219 : "\n"
37220 : "\n"
37221 : "Returns the native data for the feature.\n"
37222 : "\n"
37223 : "The native data is the representation in a \"natural\" form that comes\n"
37224 : "from the driver that created this feature, or that is aimed at an\n"
37225 : "output driver. The native data may be in different format, which is\n"
37226 : "indicated by :py:func:`GetNativeMediaType`.\n"
37227 : "\n"
37228 : "Note that most drivers do not support storing the native data in the\n"
37229 : "feature object, and if they do, generally the ``NATIVE_DATA`` open option\n"
37230 : "must be passed at dataset opening.\n"
37231 : "\n"
37232 : "The \"native data\" does not imply it is something more performant or\n"
37233 : "powerful than what can be obtained with the rest of the API, but it\n"
37234 : "may be useful in round-tripping scenarios where some characteristics\n"
37235 : "of the underlying format are not captured otherwise by the OGR\n"
37236 : "abstraction.\n"
37237 : "\n"
37238 : "See :cpp:func:`OGRFeature::GetNativeData` and :ref:`rfc-60`.\n"
37239 : "\n"
37240 : "Returns\n"
37241 : "-------\n"
37242 : "str:\n"
37243 : " a string with the native data, or ``None``.\n"
37244 : "\n"
37245 : ""},
37246 : { "Feature_GetNativeMediaType", _wrap_Feature_GetNativeMediaType, METH_O, "\n"
37247 : "Feature_GetNativeMediaType(Feature self) -> char const *\n"
37248 : "\n"
37249 : "\n"
37250 : "Returns the native media type for the feature.\n"
37251 : "\n"
37252 : "The native media type is the identifier for the format of the native\n"
37253 : "data. It follows the IANA RFC 2045\n"
37254 : "(see https://en.wikipedia.org/wiki/Media_type), e.g.\n"
37255 : "\"application/vnd.geo+json\" for JSon.\n"
37256 : "\n"
37257 : "See :cpp:func:`OGRFeature::GetNativeMediaType` and :ref:`rfc-60`.\n"
37258 : "\n"
37259 : "Returns\n"
37260 : "--------\n"
37261 : "str:\n"
37262 : " a string with the native media type, or ``None``.\n"
37263 : "\n"
37264 : ""},
37265 : { "Feature_SetNativeData", _wrap_Feature_SetNativeData, METH_VARARGS, "\n"
37266 : "Feature_SetNativeData(Feature self, char const * nativeData)\n"
37267 : "\n"
37268 : "\n"
37269 : "Sets the native data for the feature.\n"
37270 : "\n"
37271 : "The native data is the representation in a \"natural\" form that comes\n"
37272 : "from the driver that created this feature, or that is aimed at an\n"
37273 : "output driver. The native data may be in different format, which is\n"
37274 : "indicated by :py:meth:`GetNativeMediaType`.\n"
37275 : "\n"
37276 : "See :cpp:func:`OGRFeature::SetNativeData` and :ref:`rfc-60`.\n"
37277 : "\n"
37278 : "Parameters\n"
37279 : "-----------\n"
37280 : "nativeData : str\n"
37281 : " a string with the native data, or ``None``\n"
37282 : "\n"
37283 : ""},
37284 : { "Feature_SetNativeMediaType", _wrap_Feature_SetNativeMediaType, METH_VARARGS, "\n"
37285 : "Feature_SetNativeMediaType(Feature self, char const * nativeMediaType)\n"
37286 : "\n"
37287 : "\n"
37288 : "Sets the native media type for the feature.\n"
37289 : "\n"
37290 : "The native media type is the identifier for the format of the native\n"
37291 : "data. It follows the IANA RFC 2045\n"
37292 : "(see https://en.wikipedia.org/wiki/Media_type), e.g.\n"
37293 : "\"application/vnd.geo+json\" for JSon.\n"
37294 : "\n"
37295 : "See :cpp:func:`OGRFeature::SetNativeMediaType` and :ref:`rfc-60`.\n"
37296 : "\n"
37297 : "Parameters\n"
37298 : "-----------\n"
37299 : "nativeMediaType : str\n"
37300 : " a string with the native media type, or ``None``\n"
37301 : "\n"
37302 : ""},
37303 : { "Feature_SetFieldString", _wrap_Feature_SetFieldString, METH_VARARGS, "\n"
37304 : "Feature_SetFieldString(Feature self, int id, char const * value)\n"
37305 : "\n"
37306 : "\n"
37307 : "Set field to string value.\n"
37308 : "\n"
37309 : ":py:const:`OFTInteger` fields will be set based on an atoi() conversion of the\n"
37310 : "string. :py:const:`OFTInteger64` fields will be set based on an :cpp:func:`CPLAtoGIntBig`\n"
37311 : "conversion of the string. :py:const:`OFTReal` fields will be set based on an\n"
37312 : ":cpp:func:`CPLAtof` conversion of the string. Other field types may be\n"
37313 : "unaffected.\n"
37314 : "\n"
37315 : "See :cpp:func:`OGRFeature::SetField`.\n"
37316 : "\n"
37317 : "This method has only an effect on the in-memory feature object. If\n"
37318 : "this object comes from a layer and the modifications must be\n"
37319 : "serialized back to the datasource, :py:meth:`Layer.SetFeature` must be used\n"
37320 : "afterwards. Or if this is a new feature, :py:meth:`Layer.CreateFeature` must be\n"
37321 : "used afterwards.\n"
37322 : "\n"
37323 : "Parameters\n"
37324 : "-----------\n"
37325 : "fld_index : int / str\n"
37326 : " Field name or 0-based numeric index. For repeated\n"
37327 : " access, use of the numeric index avoids a lookup\n"
37328 : " step.\n"
37329 : "value:\n"
37330 : " the value to assign.\n"
37331 : "\n"
37332 : ""},
37333 : { "Feature_swigregister", Feature_swigregister, METH_O, NULL},
37334 : { "Feature_swiginit", Feature_swiginit, METH_VARARGS, NULL},
37335 : { "delete_FeatureDefn", _wrap_delete_FeatureDefn, METH_O, "delete_FeatureDefn(FeatureDefn self)"},
37336 : { "new_FeatureDefn", (PyCFunction)(void(*)(void))_wrap_new_FeatureDefn, METH_VARARGS|METH_KEYWORDS, "\n"
37337 : "new_FeatureDefn(char const * name_null_ok=None) -> FeatureDefn\n"
37338 : "\n"
37339 : "\n"
37340 : "Create a new feature definition object to hold the field definitions.\n"
37341 : "\n"
37342 : "Parameters\n"
37343 : "----------\n"
37344 : "name_null_ok : str, optional\n"
37345 : " Name for the :py:class:`FeatureDefn`.\n"
37346 : "\n"
37347 : ""},
37348 : { "FeatureDefn_GetName", _wrap_FeatureDefn_GetName, METH_O, "\n"
37349 : "FeatureDefn_GetName(FeatureDefn self) -> char const *\n"
37350 : "\n"
37351 : "\n"
37352 : "Get name of the :py:class:`FeatureDefn`.\n"
37353 : "\n"
37354 : "See :cpp:func:`OGRFeatureDefn::GetName`.\n"
37355 : "\n"
37356 : "Returns\n"
37357 : "--------\n"
37358 : "str:\n"
37359 : " the name\n"
37360 : "\n"
37361 : ""},
37362 : { "FeatureDefn_GetFieldCount", _wrap_FeatureDefn_GetFieldCount, METH_O, "\n"
37363 : "FeatureDefn_GetFieldCount(FeatureDefn self) -> int\n"
37364 : "\n"
37365 : "\n"
37366 : "Fetch number of fields on the passed feature definition.\n"
37367 : "\n"
37368 : "See :cpp:func:`OGRFeatureDefn::GetFieldCount`.\n"
37369 : "\n"
37370 : "Returns\n"
37371 : "--------\n"
37372 : "int:\n"
37373 : " count of fields.\n"
37374 : "\n"
37375 : ""},
37376 : { "FeatureDefn_GetFieldDefn", _wrap_FeatureDefn_GetFieldDefn, METH_VARARGS, "\n"
37377 : "FeatureDefn_GetFieldDefn(FeatureDefn self, int i) -> FieldDefn\n"
37378 : "\n"
37379 : "\n"
37380 : "Fetch field definition of the passed feature definition.\n"
37381 : "\n"
37382 : "See :cpp:func:`OGRFeatureDefn::GetFieldDefn`.\n"
37383 : "\n"
37384 : "Parameters\n"
37385 : "-----------\n"
37386 : "i : int / str\n"
37387 : " Field name or 0-based numeric index. For repeated\n"
37388 : " access, use of the numeric index avoids a lookup\n"
37389 : " step.\n"
37390 : "\n"
37391 : "Returns\n"
37392 : "--------\n"
37393 : "FieldDefn:\n"
37394 : " internal field definition object or ``None`` if the field does not\n"
37395 : " exist. This object should not be modified by the application.\n"
37396 : "\n"
37397 : ""},
37398 : { "FeatureDefn_GetFieldIndex", _wrap_FeatureDefn_GetFieldIndex, METH_VARARGS, "\n"
37399 : "FeatureDefn_GetFieldIndex(FeatureDefn self, char const * field_name) -> int\n"
37400 : "\n"
37401 : "\n"
37402 : "Find field by name.\n"
37403 : "\n"
37404 : "The field index of the first field matching the passed field name\n"
37405 : "(case insensitively) is returned.\n"
37406 : "\n"
37407 : "See :cpp:func:`OGRFeatureDefn::GetFieldIndex`.\n"
37408 : "\n"
37409 : "Parameters\n"
37410 : "-----------\n"
37411 : "field_name : str\n"
37412 : " the field name to search for.\n"
37413 : "\n"
37414 : "Returns\n"
37415 : "--------\n"
37416 : "int:\n"
37417 : " the field index, or -1 if no match found.\n"
37418 : "\n"
37419 : ""},
37420 : { "FeatureDefn_AddFieldDefn", _wrap_FeatureDefn_AddFieldDefn, METH_VARARGS, "\n"
37421 : "FeatureDefn_AddFieldDefn(FeatureDefn self, FieldDefn defn)\n"
37422 : "\n"
37423 : "\n"
37424 : "Add a new field definition.\n"
37425 : "\n"
37426 : "To add a new field definition to a layer definition, do not use this\n"
37427 : "function directly, but use :py:meth:`Layer.CreateField` instead.\n"
37428 : "\n"
37429 : "This function should only be called while there are no :py:class:`Feature`\n"
37430 : "objects in existence based on this :py:class:`FeatureDefn`. The\n"
37431 : ":py:class:`FieldDefn` passed in is copied.\n"
37432 : "\n"
37433 : "See :cpp:func:`OGRFeatureDefn::AddFieldDefn`.\n"
37434 : "\n"
37435 : "Parameters\n"
37436 : "-----------\n"
37437 : "defn : FieldDefn\n"
37438 : " the new field definition.\n"
37439 : "\n"
37440 : ""},
37441 : { "FeatureDefn_GetGeomFieldCount", _wrap_FeatureDefn_GetGeomFieldCount, METH_O, "\n"
37442 : "FeatureDefn_GetGeomFieldCount(FeatureDefn self) -> int\n"
37443 : "\n"
37444 : "\n"
37445 : "Fetch number of geometry fields on the passed feature definition.\n"
37446 : "\n"
37447 : "See :cpp:func:`OGRFeatureDefn::GetGeomFieldCount`.\n"
37448 : "\n"
37449 : "Returns\n"
37450 : "--------\n"
37451 : "int:\n"
37452 : " count of geometry fields.\n"
37453 : "\n"
37454 : ""},
37455 : { "FeatureDefn_GetGeomFieldDefn", _wrap_FeatureDefn_GetGeomFieldDefn, METH_VARARGS, "\n"
37456 : "FeatureDefn_GetGeomFieldDefn(FeatureDefn self, int i) -> GeomFieldDefn\n"
37457 : "\n"
37458 : "\n"
37459 : "Fetch geometry field definition of the passed feature definition.\n"
37460 : "\n"
37461 : "See :cpp:func:`OGRFeatureDefn::GetGeomFieldDefn`.\n"
37462 : "\n"
37463 : "Parameters\n"
37464 : "-----------\n"
37465 : "i : int\n"
37466 : " the geometry field to fetch, between 0 and GetGeomFieldCount() - 1.\n"
37467 : "\n"
37468 : "Returns\n"
37469 : "--------\n"
37470 : "GeomFieldDefn:\n"
37471 : " an internal field definition object or ``None`` if invalid\n"
37472 : " index. This object should not be modified by the application.\n"
37473 : "\n"
37474 : ""},
37475 : { "FeatureDefn_GetGeomFieldIndex", _wrap_FeatureDefn_GetGeomFieldIndex, METH_VARARGS, "\n"
37476 : "FeatureDefn_GetGeomFieldIndex(FeatureDefn self, char const * field_name) -> int\n"
37477 : "\n"
37478 : "\n"
37479 : "Find geometry field by name.\n"
37480 : "\n"
37481 : "The geometry field index of the first geometry field matching the\n"
37482 : "passed field name (case insensitively) is returned.\n"
37483 : "\n"
37484 : "See :cpp:func:`OGRFeatureDefn::GetGeomFieldIndex`.\n"
37485 : "\n"
37486 : "Parameters\n"
37487 : "-----------\n"
37488 : "field_name : str\n"
37489 : " the geometry field name to search for.\n"
37490 : "\n"
37491 : "Returns\n"
37492 : "--------\n"
37493 : "int:\n"
37494 : " the geometry field index, or -1 if no match found.\n"
37495 : "\n"
37496 : ""},
37497 : { "FeatureDefn_AddGeomFieldDefn", _wrap_FeatureDefn_AddGeomFieldDefn, METH_VARARGS, "\n"
37498 : "FeatureDefn_AddGeomFieldDefn(FeatureDefn self, GeomFieldDefn defn)\n"
37499 : "\n"
37500 : "\n"
37501 : "Add a new geometry field definition.\n"
37502 : "\n"
37503 : "To add a new field definition to a layer definition, do not use this\n"
37504 : "function directly, but use :py:meth:`Layer.CreateGeomField` instead.\n"
37505 : "\n"
37506 : "This function should only be called while there are no :py:class:`Feature`\n"
37507 : "objects in existence based on this :py:class:`FeatureDefn`. The\n"
37508 : ":py:class:`GeomFieldDefn` passed in is copied.\n"
37509 : "\n"
37510 : "See :cpp:Func:`OGRFeatureDefn::AddGeomFieldDefn`.\n"
37511 : "\n"
37512 : "Parameters\n"
37513 : "-----------\n"
37514 : "defn : GeomFieldDefn\n"
37515 : " new geometry field definition.\n"
37516 : "\n"
37517 : ""},
37518 : { "FeatureDefn_DeleteGeomFieldDefn", _wrap_FeatureDefn_DeleteGeomFieldDefn, METH_VARARGS, "\n"
37519 : "FeatureDefn_DeleteGeomFieldDefn(FeatureDefn self, int idx) -> OGRErr\n"
37520 : "\n"
37521 : "\n"
37522 : "Delete an existing geometry field definition.\n"
37523 : "\n"
37524 : "To delete an existing geometry field definition from a layer\n"
37525 : "definition, do not use this function directly, but use\n"
37526 : ":py:meth:`Layer.DeleteGeomField` instead ( not implemented yet).\n"
37527 : "\n"
37528 : "This function should only be called while there are no :py:class:`Feature`\n"
37529 : "objects in existence based on this :py:class:`FeatureDefn`.\n"
37530 : "\n"
37531 : "See :cpp:func:`OGRFeatureDefn::DeleteGeomFieldDefn`.\n"
37532 : "\n"
37533 : "Parameters\n"
37534 : "-----------\n"
37535 : "idx : int\n"
37536 : " the index of the geometry field definition.\n"
37537 : "\n"
37538 : "Returns\n"
37539 : "--------\n"
37540 : "int:\n"
37541 : " :py:const:`OGRERR_NONE` in case of success.\n"
37542 : "\n"
37543 : ""},
37544 : { "FeatureDefn_GetGeomType", _wrap_FeatureDefn_GetGeomType, METH_O, "\n"
37545 : "FeatureDefn_GetGeomType(FeatureDefn self) -> OGRwkbGeometryType\n"
37546 : "\n"
37547 : "\n"
37548 : "Fetch the geometry base type of the passed feature definition.\n"
37549 : "\n"
37550 : "This is equivalent to ``GetGeomFieldDefn(0).GetType()``.\n"
37551 : "\n"
37552 : "See :cpp:func:`OGRFeatureDefn::GetGeomType`.\n"
37553 : "\n"
37554 : "Returns\n"
37555 : "--------\n"
37556 : "int :\n"
37557 : " the base type for all geometry related to this definition.\n"
37558 : "\n"
37559 : ""},
37560 : { "FeatureDefn_SetGeomType", _wrap_FeatureDefn_SetGeomType, METH_VARARGS, "\n"
37561 : "FeatureDefn_SetGeomType(FeatureDefn self, OGRwkbGeometryType geom_type)\n"
37562 : "\n"
37563 : "\n"
37564 : "Assign the base geometry type for the passed layer (the same as the\n"
37565 : "feature definition).\n"
37566 : "\n"
37567 : "This is equivalent to ``GetGeomFieldDefn(0).SetType()``.\n"
37568 : "\n"
37569 : "All geometry objects using this type must be of the defined type or a\n"
37570 : "derived type. The default upon creation is :py:const:`wkbUnknown` which allows for\n"
37571 : "any geometry type. The geometry type should generally not be changed\n"
37572 : "after any :py:class:`Feature` objects have been created against this definition.\n"
37573 : "\n"
37574 : "See :cpp:func:`OGRFeatureDefn::SetGeomType`.\n"
37575 : "\n"
37576 : "Parameters\n"
37577 : "-----------\n"
37578 : "geom_type : int\n"
37579 : " the new type to assign.\n"
37580 : "\n"
37581 : ""},
37582 : { "FeatureDefn_GetReferenceCount", _wrap_FeatureDefn_GetReferenceCount, METH_O, "\n"
37583 : "FeatureDefn_GetReferenceCount(FeatureDefn self) -> int\n"
37584 : "\n"
37585 : "\n"
37586 : "Fetch current reference count.\n"
37587 : "\n"
37588 : "See :cpp:func:`OGRFeatureDefn::GetReferenceCount`.\n"
37589 : "\n"
37590 : "Returns\n"
37591 : "--------\n"
37592 : "int:\n"
37593 : " the current reference count.\n"
37594 : "\n"
37595 : ""},
37596 : { "FeatureDefn_IsGeometryIgnored", _wrap_FeatureDefn_IsGeometryIgnored, METH_O, "\n"
37597 : "FeatureDefn_IsGeometryIgnored(FeatureDefn self) -> int\n"
37598 : "\n"
37599 : "\n"
37600 : "Determine whether the geometry can be omitted when fetching features.\n"
37601 : "\n"
37602 : "Equivalent to ``GetGeomFieldDefn(0).IsIgnored()``.\n"
37603 : "\n"
37604 : "See :cpp:func:`OGRFeatureDefn::IsGeometryIgnored`.\n"
37605 : "\n"
37606 : "Returns\n"
37607 : "--------\n"
37608 : "int:\n"
37609 : " ignore state\n"
37610 : "\n"
37611 : ""},
37612 : { "FeatureDefn_SetGeometryIgnored", _wrap_FeatureDefn_SetGeometryIgnored, METH_VARARGS, "\n"
37613 : "FeatureDefn_SetGeometryIgnored(FeatureDefn self, int bIgnored)\n"
37614 : "\n"
37615 : "\n"
37616 : "Set whether the geometry can be omitted when fetching features.\n"
37617 : "\n"
37618 : "This is equivalent to ``GetGeomFieldDefn(0).SetIgnored()``.\n"
37619 : "\n"
37620 : "See :cpp:func:`OGRFeatureDefn::SetGeometryIgnored`.\n"
37621 : "\n"
37622 : "Parameters\n"
37623 : "-----------\n"
37624 : "bignored : bool\n"
37625 : " ignore state\n"
37626 : "\n"
37627 : ""},
37628 : { "FeatureDefn_IsStyleIgnored", _wrap_FeatureDefn_IsStyleIgnored, METH_O, "\n"
37629 : "FeatureDefn_IsStyleIgnored(FeatureDefn self) -> int\n"
37630 : "\n"
37631 : "\n"
37632 : "Determine whether the style can be omitted when fetching features.\n"
37633 : "\n"
37634 : "See :cpp:func:`OGRFeatureDefn::IsStyleIgnored`.\n"
37635 : "\n"
37636 : "Returns\n"
37637 : "--------\n"
37638 : "int:\n"
37639 : " ignore state\n"
37640 : "\n"
37641 : ""},
37642 : { "FeatureDefn_SetStyleIgnored", _wrap_FeatureDefn_SetStyleIgnored, METH_VARARGS, "\n"
37643 : "FeatureDefn_SetStyleIgnored(FeatureDefn self, int bIgnored)\n"
37644 : "\n"
37645 : "\n"
37646 : "Set whether the style can be omitted when fetching features.\n"
37647 : "\n"
37648 : "See :cpp:func:`OGRFeatureDefn::SetStyleIgnored`.\n"
37649 : "\n"
37650 : "Parameters\n"
37651 : "-----------\n"
37652 : "bignored : bool\n"
37653 : " ignore state\n"
37654 : "\n"
37655 : ""},
37656 : { "FeatureDefn_IsSame", _wrap_FeatureDefn_IsSame, METH_VARARGS, "\n"
37657 : "FeatureDefn_IsSame(FeatureDefn self, FeatureDefn other_defn) -> int\n"
37658 : "\n"
37659 : "\n"
37660 : "Test if the feature definition is identical to the other one.\n"
37661 : "\n"
37662 : "Parameters\n"
37663 : "-----------\n"
37664 : "other_defn : FeatureDefn\n"
37665 : " other feature definition to compare to.\n"
37666 : "\n"
37667 : "Returns\n"
37668 : "--------\n"
37669 : "int:\n"
37670 : " 1 if the feature definition is identical to the other one.\n"
37671 : "\n"
37672 : ""},
37673 : { "FeatureDefn_swigregister", FeatureDefn_swigregister, METH_O, NULL},
37674 : { "FeatureDefn_swiginit", FeatureDefn_swiginit, METH_VARARGS, NULL},
37675 : { "delete_FieldDefn", _wrap_delete_FieldDefn, METH_O, "delete_FieldDefn(FieldDefn self)"},
37676 : { "new_FieldDefn", (PyCFunction)(void(*)(void))_wrap_new_FieldDefn, METH_VARARGS|METH_KEYWORDS, "\n"
37677 : "new_FieldDefn(char const * name_null_ok=\"unnamed\", OGRFieldType field_type=OFTString) -> FieldDefn\n"
37678 : "\n"
37679 : "Python proxy of an :cpp:class:`OGRFieldDefn`.\n"
37680 : "\n"
37681 : ""},
37682 : { "FieldDefn_GetName", _wrap_FieldDefn_GetName, METH_O, "FieldDefn_GetName(FieldDefn self) -> char const *"},
37683 : { "FieldDefn_GetNameRef", _wrap_FieldDefn_GetNameRef, METH_O, "\n"
37684 : "FieldDefn_GetNameRef(FieldDefn self) -> char const *\n"
37685 : "\n"
37686 : "\n"
37687 : "Fetch name of this field.\n"
37688 : "\n"
37689 : "See :cpp:func:`OGRFieldDefn::GetNameRef`.\n"
37690 : "\n"
37691 : "Returns\n"
37692 : "--------\n"
37693 : "str:\n"
37694 : " the name of the field definition.\n"
37695 : "\n"
37696 : ""},
37697 : { "FieldDefn_SetName", _wrap_FieldDefn_SetName, METH_VARARGS, "\n"
37698 : "FieldDefn_SetName(FieldDefn self, char const * name)\n"
37699 : "\n"
37700 : "\n"
37701 : "Reset the name of this field.\n"
37702 : "\n"
37703 : "See :cpp:func:`OGRFieldDefn::SetName`.\n"
37704 : "\n"
37705 : "Parameters\n"
37706 : "-----------\n"
37707 : "name : str\n"
37708 : " the new name to apply\n"
37709 : "\n"
37710 : ""},
37711 : { "FieldDefn_GetAlternativeName", _wrap_FieldDefn_GetAlternativeName, METH_O, "FieldDefn_GetAlternativeName(FieldDefn self) -> char const *"},
37712 : { "FieldDefn_GetAlternativeNameRef", _wrap_FieldDefn_GetAlternativeNameRef, METH_O, "\n"
37713 : "FieldDefn_GetAlternativeNameRef(FieldDefn self) -> char const *\n"
37714 : "\n"
37715 : "\n"
37716 : "Fetch the alternative name (or \"alias\") for this field.\n"
37717 : "\n"
37718 : "The alternative name is an optional attribute for a field which can\n"
37719 : "provide a more user-friendly, descriptive name of a field which is not\n"
37720 : "subject to the usual naming constraints defined by the data provider.\n"
37721 : "\n"
37722 : "This is a metadata style attribute only: the alternative name cannot\n"
37723 : "be used in place of the actual field name during SQL queries or other\n"
37724 : "field name dependent API calls.\n"
37725 : "\n"
37726 : "See :cpp:func:`OGRFieldDefn::GetAlternativeNameRef`.\n"
37727 : "\n"
37728 : ".. versionadded:: 3.2\n"
37729 : "\n"
37730 : "Returns\n"
37731 : "--------\n"
37732 : "str:\n"
37733 : " the alternative name of the field definition.\n"
37734 : "\n"
37735 : ""},
37736 : { "FieldDefn_SetAlternativeName", _wrap_FieldDefn_SetAlternativeName, METH_VARARGS, "\n"
37737 : "FieldDefn_SetAlternativeName(FieldDefn self, char const * alternativeName)\n"
37738 : "\n"
37739 : "\n"
37740 : "Reset the alternative name (or \"alias\") for this field.\n"
37741 : "\n"
37742 : "The alternative name is an optional attribute for a field which can\n"
37743 : "provide a more user-friendly, descriptive name of a field which is not\n"
37744 : "subject to the usual naming constraints defined by the data provider.\n"
37745 : "\n"
37746 : "This is a metadata style attribute only: the alternative name cannot\n"
37747 : "be used in place of the actual field name during SQL queries or other\n"
37748 : "field name dependent API calls.\n"
37749 : "\n"
37750 : "See :cpp:func:`OGRFieldDefn::SetAlternativeName`.\n"
37751 : "\n"
37752 : ".. versionadded:: 3.2\n"
37753 : "\n"
37754 : "Parameters\n"
37755 : "-----------\n"
37756 : "alternativeName : str\n"
37757 : " the new alternative name to apply.\n"
37758 : "\n"
37759 : ""},
37760 : { "FieldDefn_GetType", _wrap_FieldDefn_GetType, METH_O, "\n"
37761 : "FieldDefn_GetType(FieldDefn self) -> OGRFieldType\n"
37762 : "\n"
37763 : "\n"
37764 : "Fetch type of this field.\n"
37765 : "\n"
37766 : "See :cpp:func:`OGRFieldDefn::GetType`.\n"
37767 : "\n"
37768 : "Returns\n"
37769 : "--------\n"
37770 : "int\n"
37771 : " field type code, e.g. :py:const:`OFTInteger`\n"
37772 : "\n"
37773 : ""},
37774 : { "FieldDefn_SetType", _wrap_FieldDefn_SetType, METH_VARARGS, "\n"
37775 : "FieldDefn_SetType(FieldDefn self, OGRFieldType type)\n"
37776 : "\n"
37777 : "\n"
37778 : "Set the type of this field.\n"
37779 : "\n"
37780 : "This should never be done to a :py:class:`FieldDefn` that is already part of\n"
37781 : "an :py:class:`FeatureDefn`.\n"
37782 : "\n"
37783 : "See :cpp:func:`OGRFieldDefn::SetType`.\n"
37784 : "\n"
37785 : "Parameters\n"
37786 : "-----------\n"
37787 : "type : int\n"
37788 : " the new field type.\n"
37789 : "\n"
37790 : "Examples\n"
37791 : "--------\n"
37792 : ">>> f = ogr.FieldDefn()\n"
37793 : ">>> f.SetType(ogr.OFTReal)\n"
37794 : "\n"
37795 : ""},
37796 : { "FieldDefn_GetSubType", _wrap_FieldDefn_GetSubType, METH_O, "\n"
37797 : "FieldDefn_GetSubType(FieldDefn self) -> OGRFieldSubType\n"
37798 : "\n"
37799 : "\n"
37800 : "Fetch subtype of this field.\n"
37801 : "\n"
37802 : "See :cpp:func:`OGRFieldDefn::GetSubType`.\n"
37803 : "\n"
37804 : "Returns\n"
37805 : "--------\n"
37806 : "int\n"
37807 : " field subtype code, default = :py:const:`OFSTNone`\n"
37808 : "\n"
37809 : ""},
37810 : { "FieldDefn_SetSubType", _wrap_FieldDefn_SetSubType, METH_VARARGS, "\n"
37811 : "FieldDefn_SetSubType(FieldDefn self, OGRFieldSubType type)\n"
37812 : "\n"
37813 : "\n"
37814 : "Set the subtype of this field.\n"
37815 : "\n"
37816 : "This should never be done to a :py:class:`FieldDefn` that is already part of\n"
37817 : "an :py:class:FeatureDefn`.\n"
37818 : "\n"
37819 : "See :cpp:func:`OGRFieldDefn::SetSubType`.\n"
37820 : "\n"
37821 : "Parameters\n"
37822 : "-----------\n"
37823 : "type :\n"
37824 : " the new field subtype.\n"
37825 : "\n"
37826 : "Examples\n"
37827 : "--------\n"
37828 : ">>> f = ogr.FieldDefn()\n"
37829 : ">>> f.SetType(ogr.OFTReal)\n"
37830 : ">>> f.SetSubType(ogr.OFSTJSON)\n"
37831 : "Warning 1: Type and subtype of field definition are not compatible. Resetting to OFSTNone\n"
37832 : ">>> f.SetSubType(ogr.OFSTFloat32)\n"
37833 : "\n"
37834 : ""},
37835 : { "FieldDefn_GetJustify", _wrap_FieldDefn_GetJustify, METH_O, "\n"
37836 : "FieldDefn_GetJustify(FieldDefn self) -> OGRJustification\n"
37837 : "\n"
37838 : "\n"
37839 : "Get the justification for this field.\n"
37840 : "\n"
37841 : "See :cpp:func:`OGRFieldDefn::GetJustify`.\n"
37842 : "\n"
37843 : "Note: no driver is know to use the concept of field justification.\n"
37844 : "\n"
37845 : "Returns\n"
37846 : "--------\n"
37847 : "OGRJustification:\n"
37848 : " the justification.\n"
37849 : "\n"
37850 : ""},
37851 : { "FieldDefn_SetJustify", _wrap_FieldDefn_SetJustify, METH_VARARGS, "\n"
37852 : "FieldDefn_SetJustify(FieldDefn self, OGRJustification justify)\n"
37853 : "\n"
37854 : "\n"
37855 : "Set the justification for this field.\n"
37856 : "\n"
37857 : "Note: no driver is know to use the concept of field justification.\n"
37858 : "\n"
37859 : "See :cpp:func:`OGRFieldDefn::SetJustify`.\n"
37860 : "\n"
37861 : "Parameters\n"
37862 : "-----------\n"
37863 : "justify : int\n"
37864 : " the new justification\n"
37865 : "\n"
37866 : "Examples\n"
37867 : "--------\n"
37868 : ">>> f = ogr.FieldDefn('desc', ogr.OFTString)\n"
37869 : ">>> f.SetJustify(ogr.OJRight)\n"
37870 : "\n"
37871 : ""},
37872 : { "FieldDefn_GetWidth", _wrap_FieldDefn_GetWidth, METH_O, "\n"
37873 : "FieldDefn_GetWidth(FieldDefn self) -> int\n"
37874 : "\n"
37875 : "\n"
37876 : "Get the formatting width for this field.\n"
37877 : "\n"
37878 : "See :cpp:func:`OGRFieldDefn::GetWidth`.\n"
37879 : "\n"
37880 : "Returns\n"
37881 : "--------\n"
37882 : "int:\n"
37883 : " the width, zero means no specified width.\n"
37884 : "\n"
37885 : ""},
37886 : { "FieldDefn_SetWidth", _wrap_FieldDefn_SetWidth, METH_VARARGS, "\n"
37887 : "FieldDefn_SetWidth(FieldDefn self, int width)\n"
37888 : "\n"
37889 : "\n"
37890 : "Set the formatting width for this field in characters.\n"
37891 : "\n"
37892 : "See :cpp:func:`OGRFieldDefn::SetWidth`.\n"
37893 : "\n"
37894 : "Parameters\n"
37895 : "-----------\n"
37896 : "width : int\n"
37897 : " the new width\n"
37898 : "\n"
37899 : ""},
37900 : { "FieldDefn_GetPrecision", _wrap_FieldDefn_GetPrecision, METH_O, "\n"
37901 : "FieldDefn_GetPrecision(FieldDefn self) -> int\n"
37902 : "\n"
37903 : "\n"
37904 : "Get the formatting precision for this field.\n"
37905 : "\n"
37906 : "This should normally be zero for fields of types other than :py:const:`OFTReal`.\n"
37907 : "\n"
37908 : "See :cpp:func:`OGRFieldDefn::GetPrecision`.\n"
37909 : "\n"
37910 : "Returns\n"
37911 : "--------\n"
37912 : "int:\n"
37913 : " the precision.\n"
37914 : "\n"
37915 : ""},
37916 : { "FieldDefn_SetPrecision", _wrap_FieldDefn_SetPrecision, METH_VARARGS, "\n"
37917 : "FieldDefn_SetPrecision(FieldDefn self, int precision)\n"
37918 : "\n"
37919 : "\n"
37920 : "Set the formatting precision for this field in characters.\n"
37921 : "\n"
37922 : "This should normally be zero for fields of types other than :py:const:`OFTReal`.\n"
37923 : "\n"
37924 : "See :cpp:func:`OGRFieldDefn::SetPrecision`.\n"
37925 : "\n"
37926 : "Parameters\n"
37927 : "-----------\n"
37928 : "precision : int\n"
37929 : " the new precision.\n"
37930 : "\n"
37931 : ""},
37932 : { "FieldDefn_GetTZFlag", _wrap_FieldDefn_GetTZFlag, METH_O, "FieldDefn_GetTZFlag(FieldDefn self) -> int"},
37933 : { "FieldDefn_SetTZFlag", _wrap_FieldDefn_SetTZFlag, METH_VARARGS, "FieldDefn_SetTZFlag(FieldDefn self, int tzflag)"},
37934 : { "FieldDefn_GetTypeName", _wrap_FieldDefn_GetTypeName, METH_O, "FieldDefn_GetTypeName(FieldDefn self) -> char const *"},
37935 : { "FieldDefn_GetFieldTypeName", _wrap_FieldDefn_GetFieldTypeName, METH_VARARGS, "FieldDefn_GetFieldTypeName(FieldDefn self, OGRFieldType type) -> char const *"},
37936 : { "FieldDefn_IsIgnored", _wrap_FieldDefn_IsIgnored, METH_O, "\n"
37937 : "FieldDefn_IsIgnored(FieldDefn self) -> int\n"
37938 : "\n"
37939 : "\n"
37940 : "Return whether this field should be omitted when fetching features.\n"
37941 : "\n"
37942 : "See :cpp:func:`OGRFieldDefn::IsIgnored`.\n"
37943 : "\n"
37944 : "Returns\n"
37945 : "--------\n"
37946 : "int:\n"
37947 : " ignore state\n"
37948 : "\n"
37949 : ""},
37950 : { "FieldDefn_SetIgnored", _wrap_FieldDefn_SetIgnored, METH_VARARGS, "\n"
37951 : "FieldDefn_SetIgnored(FieldDefn self, int bIgnored)\n"
37952 : "\n"
37953 : "\n"
37954 : "Set whether this field should be omitted when fetching features.\n"
37955 : "\n"
37956 : "See :cpp:func:`OGRFieldDefn::SetIgnored`.\n"
37957 : "\n"
37958 : "Parameters\n"
37959 : "-----------\n"
37960 : "bignored : bool\n"
37961 : " ignore state\n"
37962 : "\n"
37963 : ""},
37964 : { "FieldDefn_IsNullable", _wrap_FieldDefn_IsNullable, METH_O, "\n"
37965 : "FieldDefn_IsNullable(FieldDefn self) -> int\n"
37966 : "\n"
37967 : "\n"
37968 : "Return whether this field can receive null values.\n"
37969 : "\n"
37970 : "By default, fields are nullable.\n"
37971 : "\n"
37972 : "Even if this method returns FALSE (i.e not-nullable field), it doesn't\n"
37973 : "mean that :py:meth:`Feature.IsFieldSet` will necessary return TRUE, as\n"
37974 : "fields can be temporary unset and null/not-null validation is usually\n"
37975 : "done when :py:meth:`Layer.CreateFeature`/:py:meth:`Layer.SetFeature` is called.\n"
37976 : "\n"
37977 : "See :cpp:func:`OGRFieldDefn::IsNullable`.\n"
37978 : "\n"
37979 : "Returns\n"
37980 : "--------\n"
37981 : "int:\n"
37982 : " TRUE if the field is authorized to be null.\n"
37983 : "\n"
37984 : ""},
37985 : { "FieldDefn_SetNullable", _wrap_FieldDefn_SetNullable, METH_VARARGS, "\n"
37986 : "FieldDefn_SetNullable(FieldDefn self, int bNullable)\n"
37987 : "\n"
37988 : "\n"
37989 : "Set whether this field can receive null values.\n"
37990 : "\n"
37991 : "By default, fields are nullable, so this method is generally called\n"
37992 : "with ``False`` to set a not-null constraint.\n"
37993 : "\n"
37994 : "Drivers that support writing not-null constraint will advertise the\n"
37995 : "``GDAL_DCAP_NOTNULL_FIELDS`` driver metadata item.\n"
37996 : "\n"
37997 : "See :cpp:func:`OGRFieldDefn::SetNullable`.\n"
37998 : "\n"
37999 : "Parameters\n"
38000 : "-----------\n"
38001 : "bNullable : bool\n"
38002 : " ``False`` if the field must have a not-null constraint.\n"
38003 : "\n"
38004 : ""},
38005 : { "FieldDefn_IsUnique", _wrap_FieldDefn_IsUnique, METH_O, "\n"
38006 : "FieldDefn_IsUnique(FieldDefn self) -> int\n"
38007 : "\n"
38008 : "\n"
38009 : "Return whether this field has a unique constraint.\n"
38010 : "\n"
38011 : "By default, fields have no unique constraint.\n"
38012 : "\n"
38013 : "See :cpp:func:`OGRFieldDefn::IsUnique`.\n"
38014 : "\n"
38015 : ".. versionadded:: 3.2\n"
38016 : "\n"
38017 : "Returns\n"
38018 : "--------\n"
38019 : "int:\n"
38020 : " TRUE if the field has a unique constraint.\n"
38021 : "\n"
38022 : ""},
38023 : { "FieldDefn_SetUnique", _wrap_FieldDefn_SetUnique, METH_VARARGS, "\n"
38024 : "FieldDefn_SetUnique(FieldDefn self, int bUnique)\n"
38025 : "\n"
38026 : "\n"
38027 : "Set whether this field has a unique constraint.\n"
38028 : "\n"
38029 : "By default, fields have no unique constraint, so this method is\n"
38030 : "generally called with TRUE to set a unique constraint.\n"
38031 : "\n"
38032 : "Drivers that support writing unique constraint will advertise the\n"
38033 : "``GDAL_DCAP_UNIQUE_FIELDS`` driver metadata item.\n"
38034 : "\n"
38035 : "Note that once a :py:class:`FieldDefn` has been added to a layer definition with\n"
38036 : ":py:meth:`Layer.AddFieldDefn`, its setter methods should not be called on the\n"
38037 : "object returned with ``GetLayerDefn().GetFieldDefn()``. Instead,\n"
38038 : ":py:meth:`Layer::AlterFieldDefn` should be called on a new instance of\n"
38039 : ":py:class:`FieldDefn`, for drivers that support :py:meth:`Layer.AlterFieldDefn`.\n"
38040 : "\n"
38041 : "See :cpp:func:`OGRFieldDefn::SetUnique`.\n"
38042 : "\n"
38043 : ".. versionadded:: 3.2\n"
38044 : "\n"
38045 : "Parameters\n"
38046 : "-----------\n"
38047 : "bUnique : bool\n"
38048 : " ``True`` if the field must have a unique constraint\n"
38049 : "\n"
38050 : ""},
38051 : { "FieldDefn_GetDefault", _wrap_FieldDefn_GetDefault, METH_O, "\n"
38052 : "FieldDefn_GetDefault(FieldDefn self) -> char const *\n"
38053 : "\n"
38054 : "\n"
38055 : "Get default field value.\n"
38056 : "\n"
38057 : "See :cpp:func:`OGRFieldDefn::GetDefault`.\n"
38058 : "\n"
38059 : "Returns\n"
38060 : "--------\n"
38061 : "str:\n"
38062 : " default field value or ``None``.\n"
38063 : "\n"
38064 : ""},
38065 : { "FieldDefn_SetDefault", _wrap_FieldDefn_SetDefault, METH_VARARGS, "\n"
38066 : "FieldDefn_SetDefault(FieldDefn self, char const * pszValue)\n"
38067 : "\n"
38068 : "\n"
38069 : "Set default field value.\n"
38070 : "\n"
38071 : "The default field value is taken into account by drivers (generally\n"
38072 : "those with a SQL interface) that support it at field creation time.\n"
38073 : "OGR will generally not automatically set the default field value to\n"
38074 : "null fields by itself when calling OGRFeature::CreateFeature() /\n"
38075 : "OGRFeature::SetFeature(), but will let the low-level layers to do the\n"
38076 : "job. So retrieving the feature from the layer is recommended.\n"
38077 : "\n"
38078 : "The accepted values are NULL, a numeric value, a literal value\n"
38079 : "enclosed between single quote characters (and inner single quote\n"
38080 : "characters escaped by repetition of the single quote character),\n"
38081 : "CURRENT_TIMESTAMP, CURRENT_TIME, CURRENT_DATE or a driver specific\n"
38082 : "expression (that might be ignored by other drivers). For a datetime\n"
38083 : "literal value, format should be 'YYYY/MM/DD HH:MM:SS[.sss]'\n"
38084 : "(considered as UTC time).\n"
38085 : "\n"
38086 : "Drivers that support writing DEFAULT clauses will advertise the\n"
38087 : "GDAL_DCAP_DEFAULT_FIELDS driver metadata item.\n"
38088 : "\n"
38089 : "See :cpp:func:`OGRFieldDefn::SetDefault`.\n"
38090 : "\n"
38091 : "Parameters\n"
38092 : "-----------\n"
38093 : "pszValue : str\n"
38094 : " new default field value or NULL pointer.\n"
38095 : "\n"
38096 : ""},
38097 : { "FieldDefn_IsDefaultDriverSpecific", _wrap_FieldDefn_IsDefaultDriverSpecific, METH_O, "\n"
38098 : "FieldDefn_IsDefaultDriverSpecific(FieldDefn self) -> int\n"
38099 : "\n"
38100 : "\n"
38101 : "Returns whether the default value is driver specific.\n"
38102 : "\n"
38103 : "Driver specific default values are those that are not NULL, a numeric\n"
38104 : "value, a literal value enclosed between single quote characters,\n"
38105 : "CURRENT_TIMESTAMP, CURRENT_TIME, CURRENT_DATE or datetime literal\n"
38106 : "value.\n"
38107 : "\n"
38108 : "See :cpp:func:`OGRFieldDefn::IsDefaultDriverSpecific`.\n"
38109 : "\n"
38110 : "Returns\n"
38111 : "--------\n"
38112 : "int:\n"
38113 : " TRUE if the default value is driver specific.\n"
38114 : "\n"
38115 : ""},
38116 : { "FieldDefn_GetDomainName", _wrap_FieldDefn_GetDomainName, METH_O, "\n"
38117 : "FieldDefn_GetDomainName(FieldDefn self) -> char const *\n"
38118 : "\n"
38119 : "\n"
38120 : "Return the name of the field domain for this field.\n"
38121 : "\n"
38122 : "By default an empty string is returned.\n"
38123 : "\n"
38124 : "Field domains ( :py:class:`FieldDomain` class) are attached at the :py:class:`Dataset` level and should be retrieved with :py:meth:`Dataset.GetFieldDomain`.\n"
38125 : "\n"
38126 : "See :cpp:func:`OGRFieldDefn::GetDomainName`.\n"
38127 : "\n"
38128 : ".. versionadded:: 3.3\n"
38129 : "\n"
38130 : "Returns\n"
38131 : "--------\n"
38132 : "str:\n"
38133 : " the field domain name, or an empty string if there is none.\n"
38134 : "\n"
38135 : ""},
38136 : { "FieldDefn_SetDomainName", _wrap_FieldDefn_SetDomainName, METH_VARARGS, "\n"
38137 : "FieldDefn_SetDomainName(FieldDefn self, char const * name)\n"
38138 : "\n"
38139 : "\n"
38140 : "Set the name of the field domain for this field.\n"
38141 : "\n"
38142 : "Field domains ( :py:class:`FieldDomain`) are attached at the :py:class:`Dataset` level.\n"
38143 : "\n"
38144 : "See :cpp:func:`OGRFieldDefn::SetDomainName`.\n"
38145 : "\n"
38146 : ".. versionadded:: 3.3\n"
38147 : "\n"
38148 : "Parameters\n"
38149 : "-----------\n"
38150 : "name : str\n"
38151 : " Field domain name.\n"
38152 : "\n"
38153 : ""},
38154 : { "FieldDefn_GetComment", _wrap_FieldDefn_GetComment, METH_O, "FieldDefn_GetComment(FieldDefn self) -> char const *"},
38155 : { "FieldDefn_SetComment", _wrap_FieldDefn_SetComment, METH_VARARGS, "FieldDefn_SetComment(FieldDefn self, char const * comment)"},
38156 : { "FieldDefn_swigregister", FieldDefn_swigregister, METH_O, NULL},
38157 : { "FieldDefn_swiginit", FieldDefn_swiginit, METH_VARARGS, NULL},
38158 : { "delete_GeomFieldDefn", _wrap_delete_GeomFieldDefn, METH_O, "delete_GeomFieldDefn(GeomFieldDefn self)"},
38159 : { "new_GeomFieldDefn", (PyCFunction)(void(*)(void))_wrap_new_GeomFieldDefn, METH_VARARGS|METH_KEYWORDS, "new_GeomFieldDefn(char const * name_null_ok=\"\", OGRwkbGeometryType field_type=wkbUnknown) -> GeomFieldDefn"},
38160 : { "GeomFieldDefn_GetName", _wrap_GeomFieldDefn_GetName, METH_O, "GeomFieldDefn_GetName(GeomFieldDefn self) -> char const *"},
38161 : { "GeomFieldDefn_GetNameRef", _wrap_GeomFieldDefn_GetNameRef, METH_O, "GeomFieldDefn_GetNameRef(GeomFieldDefn self) -> char const *"},
38162 : { "GeomFieldDefn_SetName", _wrap_GeomFieldDefn_SetName, METH_VARARGS, "GeomFieldDefn_SetName(GeomFieldDefn self, char const * name)"},
38163 : { "GeomFieldDefn_GetType", _wrap_GeomFieldDefn_GetType, METH_O, "GeomFieldDefn_GetType(GeomFieldDefn self) -> OGRwkbGeometryType"},
38164 : { "GeomFieldDefn_SetType", _wrap_GeomFieldDefn_SetType, METH_VARARGS, "GeomFieldDefn_SetType(GeomFieldDefn self, OGRwkbGeometryType type)"},
38165 : { "GeomFieldDefn_GetSpatialRef", _wrap_GeomFieldDefn_GetSpatialRef, METH_O, "GeomFieldDefn_GetSpatialRef(GeomFieldDefn self) -> SpatialReference"},
38166 : { "GeomFieldDefn_SetSpatialRef", _wrap_GeomFieldDefn_SetSpatialRef, METH_VARARGS, "GeomFieldDefn_SetSpatialRef(GeomFieldDefn self, SpatialReference srs)"},
38167 : { "GeomFieldDefn_IsIgnored", _wrap_GeomFieldDefn_IsIgnored, METH_O, "GeomFieldDefn_IsIgnored(GeomFieldDefn self) -> int"},
38168 : { "GeomFieldDefn_SetIgnored", _wrap_GeomFieldDefn_SetIgnored, METH_VARARGS, "GeomFieldDefn_SetIgnored(GeomFieldDefn self, int bIgnored)"},
38169 : { "GeomFieldDefn_IsNullable", _wrap_GeomFieldDefn_IsNullable, METH_O, "GeomFieldDefn_IsNullable(GeomFieldDefn self) -> int"},
38170 : { "GeomFieldDefn_SetNullable", _wrap_GeomFieldDefn_SetNullable, METH_VARARGS, "GeomFieldDefn_SetNullable(GeomFieldDefn self, int bNullable)"},
38171 : { "GeomFieldDefn_GetCoordinatePrecision", _wrap_GeomFieldDefn_GetCoordinatePrecision, METH_O, "GeomFieldDefn_GetCoordinatePrecision(GeomFieldDefn self) -> GeomCoordinatePrecision"},
38172 : { "GeomFieldDefn_SetCoordinatePrecision", _wrap_GeomFieldDefn_SetCoordinatePrecision, METH_VARARGS, "GeomFieldDefn_SetCoordinatePrecision(GeomFieldDefn self, GeomCoordinatePrecision coordPrec)"},
38173 : { "GeomFieldDefn_swigregister", GeomFieldDefn_swigregister, METH_O, NULL},
38174 : { "GeomFieldDefn_swiginit", GeomFieldDefn_swiginit, METH_VARARGS, NULL},
38175 : { "CreateGeometryFromWkb", (PyCFunction)(void(*)(void))_wrap_CreateGeometryFromWkb, METH_VARARGS|METH_KEYWORDS, "CreateGeometryFromWkb(size_t len, SpatialReference reference=None) -> Geometry"},
38176 : { "CreateGeometryFromWkt", (PyCFunction)(void(*)(void))_wrap_CreateGeometryFromWkt, METH_VARARGS|METH_KEYWORDS, "CreateGeometryFromWkt(char ** val, SpatialReference reference=None) -> Geometry"},
38177 : { "CreateGeometryFromGML", _wrap_CreateGeometryFromGML, METH_O, "CreateGeometryFromGML(char const * input_string) -> Geometry"},
38178 : { "CreateGeometryFromJson", _wrap_CreateGeometryFromJson, METH_O, "CreateGeometryFromJson(char const * input_string) -> Geometry"},
38179 : { "CreateGeometryFromEsriJson", _wrap_CreateGeometryFromEsriJson, METH_O, "CreateGeometryFromEsriJson(char const * input_string) -> Geometry"},
38180 : { "BuildPolygonFromEdges", (PyCFunction)(void(*)(void))_wrap_BuildPolygonFromEdges, METH_VARARGS|METH_KEYWORDS, "BuildPolygonFromEdges(Geometry hLineCollection, int bBestEffort=0, int bAutoClose=0, double dfTolerance=0) -> Geometry"},
38181 : { "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"},
38182 : { "ForceToPolygon", _wrap_ForceToPolygon, METH_O, "ForceToPolygon(Geometry geom_in) -> Geometry"},
38183 : { "ForceToLineString", _wrap_ForceToLineString, METH_O, "ForceToLineString(Geometry geom_in) -> Geometry"},
38184 : { "ForceToMultiPolygon", _wrap_ForceToMultiPolygon, METH_O, "ForceToMultiPolygon(Geometry geom_in) -> Geometry"},
38185 : { "ForceToMultiPoint", _wrap_ForceToMultiPoint, METH_O, "ForceToMultiPoint(Geometry geom_in) -> Geometry"},
38186 : { "ForceToMultiLineString", _wrap_ForceToMultiLineString, METH_O, "ForceToMultiLineString(Geometry geom_in) -> Geometry"},
38187 : { "ForceTo", _wrap_ForceTo, METH_VARARGS, "ForceTo(Geometry geom_in, OGRwkbGeometryType eTargetType, char ** options=None) -> Geometry"},
38188 : { "delete_Geometry", _wrap_delete_Geometry, METH_O, "delete_Geometry(Geometry self)"},
38189 : { "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"},
38190 : { "Geometry_ExportToWkt", _wrap_Geometry_ExportToWkt, METH_O, "\n"
38191 : "Geometry_ExportToWkt(Geometry self) -> OGRErr\n"
38192 : "\n"
38193 : "Convert a geometry into well known text format.\n"
38194 : "\n"
38195 : "For more details: :cpp:func:`OGR_G_ExportToWkt`\n"
38196 : "\n"
38197 : "Returns\n"
38198 : "--------\n"
38199 : "str\n"
38200 : "\n"
38201 : ""},
38202 : { "Geometry_ExportToIsoWkt", _wrap_Geometry_ExportToIsoWkt, METH_O, "\n"
38203 : "Geometry_ExportToIsoWkt(Geometry self) -> OGRErr\n"
38204 : "\n"
38205 : "Convert a geometry into SFSQL 1.2 / ISO SQL/MM Part 3 well known text\n"
38206 : "format.\n"
38207 : "\n"
38208 : "For more details: :cpp:func:`OGR_G_ExportToIsoWkt`\n"
38209 : "\n"
38210 : ".. versionadded:: 2.0\n"
38211 : "\n"
38212 : "Returns\n"
38213 : "--------\n"
38214 : "str\n"
38215 : "\n"
38216 : ""},
38217 : { "Geometry_ExportToWkb", (PyCFunction)(void(*)(void))_wrap_Geometry_ExportToWkb, METH_VARARGS|METH_KEYWORDS, "\n"
38218 : "Geometry_ExportToWkb(Geometry self, OGRwkbByteOrder byte_order=wkbNDR) -> OGRErr\n"
38219 : "\n"
38220 : "Convert a geometry well known binary format.\n"
38221 : "\n"
38222 : "For more details: :cpp:func:`OGR_G_ExportToWkb`\n"
38223 : "\n"
38224 : "Parameters\n"
38225 : "-----------\n"
38226 : "byte_order: osgeo.ogr.wkbXDR | osgeo.ogr.wkbNDR, default=osgeo.ogr.wkbNDR\n"
38227 : " One of wkbXDR or wkbNDR indicating MSB or LSB byte order respectively.\n"
38228 : "\n"
38229 : "Returns\n"
38230 : "--------\n"
38231 : "bytes\n"
38232 : "\n"
38233 : ""},
38234 : { "Geometry_ExportToIsoWkb", (PyCFunction)(void(*)(void))_wrap_Geometry_ExportToIsoWkb, METH_VARARGS|METH_KEYWORDS, "\n"
38235 : "Geometry_ExportToIsoWkb(Geometry self, OGRwkbByteOrder byte_order=wkbNDR) -> OGRErr\n"
38236 : "\n"
38237 : "Convert a geometry into SFSQL 1.2 / ISO SQL/MM Part 3 well known\n"
38238 : "binary format.\n"
38239 : "\n"
38240 : "For more details: :cpp:func:`OGR_G_ExportToIsoWkb`\n"
38241 : "\n"
38242 : ".. versionadded:: 2.0\n"
38243 : "\n"
38244 : "Parameters\n"
38245 : "-----------\n"
38246 : "byte_order: osgeo.ogr.wkbXDR | osgeo.ogr.wkbNDR, default=osgeo.ogr.wkbNDR\n"
38247 : " One of wkbXDR or wkbNDR indicating MSB or LSB byte order respectively.\n"
38248 : "\n"
38249 : "Returns\n"
38250 : "--------\n"
38251 : "bytes\n"
38252 : "\n"
38253 : ""},
38254 : { "Geometry_ExportToGML", (PyCFunction)(void(*)(void))_wrap_Geometry_ExportToGML, METH_VARARGS|METH_KEYWORDS, "Geometry_ExportToGML(Geometry self, char ** options=None) -> retStringAndCPLFree *"},
38255 : { "Geometry_ExportToKML", _wrap_Geometry_ExportToKML, METH_VARARGS, "Geometry_ExportToKML(Geometry self, char const * altitude_mode=None) -> retStringAndCPLFree *"},
38256 : { "Geometry_ExportToJson", (PyCFunction)(void(*)(void))_wrap_Geometry_ExportToJson, METH_VARARGS|METH_KEYWORDS, "Geometry_ExportToJson(Geometry self, char ** options=None) -> retStringAndCPLFree *"},
38257 : { "Geometry_AddPoint", (PyCFunction)(void(*)(void))_wrap_Geometry_AddPoint, METH_VARARGS|METH_KEYWORDS, "Geometry_AddPoint(Geometry self, double x, double y, double z=0)"},
38258 : { "Geometry_AddPointM", (PyCFunction)(void(*)(void))_wrap_Geometry_AddPointM, METH_VARARGS|METH_KEYWORDS, "Geometry_AddPointM(Geometry self, double x, double y, double m)"},
38259 : { "Geometry_AddPointZM", (PyCFunction)(void(*)(void))_wrap_Geometry_AddPointZM, METH_VARARGS|METH_KEYWORDS, "Geometry_AddPointZM(Geometry self, double x, double y, double z, double m)"},
38260 : { "Geometry_AddPoint_2D", _wrap_Geometry_AddPoint_2D, METH_VARARGS, "Geometry_AddPoint_2D(Geometry self, double x, double y)"},
38261 : { "Geometry_AddGeometryDirectly", _wrap_Geometry_AddGeometryDirectly, METH_VARARGS, "Geometry_AddGeometryDirectly(Geometry self, Geometry other_disown) -> OGRErr"},
38262 : { "Geometry_AddGeometry", _wrap_Geometry_AddGeometry, METH_VARARGS, "Geometry_AddGeometry(Geometry self, Geometry other) -> OGRErr"},
38263 : { "Geometry_RemoveGeometry", _wrap_Geometry_RemoveGeometry, METH_VARARGS, "Geometry_RemoveGeometry(Geometry self, int iSubGeom) -> OGRErr"},
38264 : { "Geometry_Clone", _wrap_Geometry_Clone, METH_O, "\n"
38265 : "Geometry_Clone(Geometry self) -> Geometry\n"
38266 : "\n"
38267 : "Make a copy of this object.\n"
38268 : "\n"
38269 : "For more details: :cpp:func:`OGR_G_Clone`\n"
38270 : "\n"
38271 : "Returns\n"
38272 : "--------\n"
38273 : "Geometry:\n"
38274 : " The copy of the geometry with the same spatial reference system\n"
38275 : " as the original.\n"
38276 : "\n"
38277 : ""},
38278 : { "Geometry_GetGeometryType", _wrap_Geometry_GetGeometryType, METH_O, "\n"
38279 : "Geometry_GetGeometryType(Geometry self) -> OGRwkbGeometryType\n"
38280 : "\n"
38281 : "Fetch geometry type.\n"
38282 : "\n"
38283 : "For more details: :cpp:func:`OGR_G_GetGeometryType`\n"
38284 : "\n"
38285 : "Returns\n"
38286 : "--------\n"
38287 : "int:\n"
38288 : " The geometry type code. The types can be found with\n"
38289 : " 'osgeo.ogr.wkb' prefix. For example :py:const:`osgeo.ogr.wkbPolygon`.\n"
38290 : "\n"
38291 : ""},
38292 : { "Geometry_GetGeometryName", _wrap_Geometry_GetGeometryName, METH_O, "\n"
38293 : "Geometry_GetGeometryName(Geometry self) -> char const *\n"
38294 : "\n"
38295 : "Fetch WKT name for geometry type.\n"
38296 : "\n"
38297 : "For more details: :cpp:func:`OGR_G_GetGeometryName`\n"
38298 : "\n"
38299 : "geometry to get name from.\n"
38300 : "\n"
38301 : "Returns\n"
38302 : "--------\n"
38303 : "str\n"
38304 : "\n"
38305 : ""},
38306 : { "Geometry_Length", _wrap_Geometry_Length, METH_O, "\n"
38307 : "Geometry_Length(Geometry self) -> double\n"
38308 : "\n"
38309 : "Compute geometry length.\n"
38310 : "\n"
38311 : "The returned length is a 2D Cartesian (planar) area in units of the\n"
38312 : "spatial reference system in use, so potentially 'degrees' for a\n"
38313 : "geometry expressed in a geographic SRS.\n"
38314 : "\n"
38315 : "For more details: :cpp:func:`OGR_G_Length`\n"
38316 : "\n"
38317 : "Returns\n"
38318 : "--------\n"
38319 : "float:\n"
38320 : " the length of the geometry in units of the spatial reference\n"
38321 : " system in use, or 0.0 for unsupported geometry types.\n"
38322 : "\n"
38323 : "\n"
38324 : ""},
38325 : { "Geometry_Area", _wrap_Geometry_Area, METH_O, "\n"
38326 : "Geometry_Area(Geometry self) -> double\n"
38327 : "\n"
38328 : "Compute geometry area.\n"
38329 : "\n"
38330 : "The returned area is a 2D Cartesian (planar) area in square units of the\n"
38331 : "spatial reference system in use, so potentially 'square degrees' for a\n"
38332 : "geometry expressed in a geographic SRS.\n"
38333 : "\n"
38334 : "For more details: :cpp:func:`OGR_G_Area`\n"
38335 : "\n"
38336 : "Returns\n"
38337 : "--------\n"
38338 : "float:\n"
38339 : " the area of the geometry in square units of the spatial reference\n"
38340 : " system in use, or 0.0 for unsupported geometry types.\n"
38341 : "\n"
38342 : "\n"
38343 : ""},
38344 : { "Geometry_GeodesicLength", _wrap_Geometry_GeodesicLength, METH_O, "\n"
38345 : "Geometry_GeodesicLength(Geometry self) -> double\n"
38346 : "\n"
38347 : "Compute geometry length, considered as a curve on the underlying\n"
38348 : "ellipsoid of the SRS attached to the geometry.\n"
38349 : "\n"
38350 : "For more details: :cpp:func:`OGR_G_GeodesicLength`\n"
38351 : "\n"
38352 : "Returns\n"
38353 : "--------\n"
38354 : "float:\n"
38355 : " the area in meters, or a negative value for unsupported geometry types.\n"
38356 : "\n"
38357 : "\n"
38358 : ""},
38359 : { "Geometry_GeodesicArea", _wrap_Geometry_GeodesicArea, METH_O, "\n"
38360 : "Geometry_GeodesicArea(Geometry self) -> double\n"
38361 : "\n"
38362 : "Compute geometry area, considered as a surface on the underlying\n"
38363 : "ellipsoid of the SRS attached to the geometry.\n"
38364 : "\n"
38365 : "For more details: :cpp:func:`OGR_G_GeodesicArea`\n"
38366 : "\n"
38367 : "Returns\n"
38368 : "--------\n"
38369 : "float:\n"
38370 : " the area in square meters, or a negative value for unsupported geometry types.\n"
38371 : "\n"
38372 : "\n"
38373 : ""},
38374 : { "Geometry_IsClockwise", _wrap_Geometry_IsClockwise, METH_O, "Geometry_IsClockwise(Geometry self) -> bool"},
38375 : { "Geometry_GetArea", _wrap_Geometry_GetArea, METH_O, "Geometry_GetArea(Geometry self) -> double"},
38376 : { "Geometry_GetPointCount", _wrap_Geometry_GetPointCount, METH_O, "Geometry_GetPointCount(Geometry self) -> int"},
38377 : { "Geometry_GetPoints", (PyCFunction)(void(*)(void))_wrap_Geometry_GetPoints, METH_VARARGS|METH_KEYWORDS, "Geometry_GetPoints(Geometry self, int nCoordDimension=0)"},
38378 : { "Geometry_GetX", (PyCFunction)(void(*)(void))_wrap_Geometry_GetX, METH_VARARGS|METH_KEYWORDS, "Geometry_GetX(Geometry self, int point=0) -> double"},
38379 : { "Geometry_GetY", (PyCFunction)(void(*)(void))_wrap_Geometry_GetY, METH_VARARGS|METH_KEYWORDS, "Geometry_GetY(Geometry self, int point=0) -> double"},
38380 : { "Geometry_GetZ", (PyCFunction)(void(*)(void))_wrap_Geometry_GetZ, METH_VARARGS|METH_KEYWORDS, "Geometry_GetZ(Geometry self, int point=0) -> double"},
38381 : { "Geometry_GetM", (PyCFunction)(void(*)(void))_wrap_Geometry_GetM, METH_VARARGS|METH_KEYWORDS, "Geometry_GetM(Geometry self, int point=0) -> double"},
38382 : { "Geometry_GetPoint", _wrap_Geometry_GetPoint, METH_VARARGS, "Geometry_GetPoint(Geometry self, int iPoint=0)"},
38383 : { "Geometry_GetPointZM", _wrap_Geometry_GetPointZM, METH_VARARGS, "Geometry_GetPointZM(Geometry self, int iPoint=0)"},
38384 : { "Geometry_GetPoint_2D", _wrap_Geometry_GetPoint_2D, METH_VARARGS, "Geometry_GetPoint_2D(Geometry self, int iPoint=0)"},
38385 : { "Geometry_GetGeometryCount", _wrap_Geometry_GetGeometryCount, METH_O, "Geometry_GetGeometryCount(Geometry self) -> int"},
38386 : { "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)"},
38387 : { "Geometry_SetPointM", (PyCFunction)(void(*)(void))_wrap_Geometry_SetPointM, METH_VARARGS|METH_KEYWORDS, "Geometry_SetPointM(Geometry self, int point, double x, double y, double m)"},
38388 : { "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)"},
38389 : { "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)"},
38390 : { "Geometry_SwapXY", _wrap_Geometry_SwapXY, METH_O, "\n"
38391 : "Geometry_SwapXY(Geometry self)\n"
38392 : "\n"
38393 : "Swap x and y coordinates.\n"
38394 : "\n"
38395 : "For more details: :cpp:func:`OGR_G_SwapXY`\n"
38396 : "\n"
38397 : ".. versionadded:: 2.3.0\n"
38398 : "\n"
38399 : "\n"
38400 : ""},
38401 : { "Geometry_GetGeometryRef", _wrap_Geometry_GetGeometryRef, METH_VARARGS, "Geometry_GetGeometryRef(Geometry self, int geom) -> Geometry"},
38402 : { "Geometry_Simplify", _wrap_Geometry_Simplify, METH_VARARGS, "\n"
38403 : "Geometry_Simplify(Geometry self, double tolerance) -> Geometry\n"
38404 : "\n"
38405 : "Compute a simplified geometry.\n"
38406 : "\n"
38407 : "For more details: :cpp:func:`OGR_G_Simplify`\n"
38408 : "\n"
38409 : "Parameters\n"
38410 : "-----------\n"
38411 : "tolerance: float\n"
38412 : " The distance tolerance for the simplification.\n"
38413 : "\n"
38414 : "Returns\n"
38415 : "--------\n"
38416 : "Geometry:\n"
38417 : " The simplified geometry or None if an error occurs.\n"
38418 : "\n"
38419 : ""},
38420 : { "Geometry_SimplifyPreserveTopology", _wrap_Geometry_SimplifyPreserveTopology, METH_VARARGS, "\n"
38421 : "Geometry_SimplifyPreserveTopology(Geometry self, double tolerance) -> Geometry\n"
38422 : "\n"
38423 : "Simplify the geometry while preserving topology.\n"
38424 : "\n"
38425 : "For more details: :cpp:func:`OGR_G_SimplifyPreserveTopology`\n"
38426 : "\n"
38427 : "Parameters\n"
38428 : "-----------\n"
38429 : "tolerance: float\n"
38430 : " The distance tolerance for the simplification.\n"
38431 : "\n"
38432 : "Returns\n"
38433 : "--------\n"
38434 : "Geometry:\n"
38435 : " The simplified geometry or None if an error occurs.\n"
38436 : "\n"
38437 : ""},
38438 : { "Geometry_DelaunayTriangulation", (PyCFunction)(void(*)(void))_wrap_Geometry_DelaunayTriangulation, METH_VARARGS|METH_KEYWORDS, "\n"
38439 : "Geometry_DelaunayTriangulation(Geometry self, double dfTolerance=0.0, int bOnlyEdges=FALSE) -> Geometry\n"
38440 : "\n"
38441 : "Return a Delaunay triangulation of the vertices of the geometry.\n"
38442 : "\n"
38443 : "For more details: :cpp:func:`OGR_G_DelaunayTriangulation`\n"
38444 : "\n"
38445 : ".. versionadded:: 2.1\n"
38446 : "\n"
38447 : "Parameters\n"
38448 : "-----------\n"
38449 : "dfTolerance: float\n"
38450 : " optional snapping tolerance to use for improved robustness\n"
38451 : "bOnlyEdges: bool\n"
38452 : " If True, will return a MULTILINESTRING, otherwise it will\n"
38453 : " return a GEOMETRYCOLLECTION containing triangular POLYGONs.\n"
38454 : "\n"
38455 : "Returns\n"
38456 : "--------\n"
38457 : "Geometry:\n"
38458 : " The geometry resulting from the Delaunay triangulation or None if an\n"
38459 : " error occurs.\n"
38460 : "\n"
38461 : ""},
38462 : { "Geometry_Polygonize", _wrap_Geometry_Polygonize, METH_O, "\n"
38463 : "Geometry_Polygonize(Geometry self) -> Geometry\n"
38464 : "\n"
38465 : "Polygonizes a set of sparse edges.\n"
38466 : "\n"
38467 : "For more details: :cpp:func:`OGR_G_Polygonize`\n"
38468 : "\n"
38469 : "Returns\n"
38470 : "--------\n"
38471 : "Geometry:\n"
38472 : " A new geometry or None on failure.\n"
38473 : "\n"
38474 : ""},
38475 : { "Geometry_Boundary", _wrap_Geometry_Boundary, METH_O, "\n"
38476 : "Geometry_Boundary(Geometry self) -> Geometry\n"
38477 : "\n"
38478 : "Compute boundary.\n"
38479 : "\n"
38480 : "For more details: :cpp:func:`OGR_G_Boundary`\n"
38481 : "\n"
38482 : "Returns\n"
38483 : "--------\n"
38484 : "Geometry:\n"
38485 : " A new geometry or None on failure.\n"
38486 : "\n"
38487 : ""},
38488 : { "Geometry_GetBoundary", _wrap_Geometry_GetBoundary, METH_O, "\n"
38489 : "Geometry_GetBoundary(Geometry self) -> Geometry\n"
38490 : "\n"
38491 : "Compute boundary (deprecated)\n"
38492 : "\n"
38493 : "For more details: :cpp:func:`OGR_G_GetBoundary`\n"
38494 : "\n"
38495 : "..warning:: Deprecated\n"
38496 : "\n"
38497 : "See: :cpp:func:`OGR_G_Boundary`\n"
38498 : "\n"
38499 : ""},
38500 : { "Geometry_ConvexHull", _wrap_Geometry_ConvexHull, METH_O, "\n"
38501 : "Geometry_ConvexHull(Geometry self) -> Geometry\n"
38502 : "\n"
38503 : "Compute convex hull.\n"
38504 : "\n"
38505 : "For more details: :cpp:func:`OGR_G_ConvexHull`\n"
38506 : "\n"
38507 : "Returns\n"
38508 : "--------\n"
38509 : "Geometry:\n"
38510 : " a handle to A newly allocated geometry now owned by the caller, or\n"
38511 : " None on failure.\n"
38512 : "\n"
38513 : ""},
38514 : { "Geometry_ConcaveHull", _wrap_Geometry_ConcaveHull, METH_VARARGS, "Geometry_ConcaveHull(Geometry self, double ratio, bool allowHoles) -> Geometry"},
38515 : { "Geometry_MakeValid", _wrap_Geometry_MakeValid, METH_VARARGS, "\n"
38516 : "Geometry_MakeValid(Geometry self, char ** options=None) -> Geometry\n"
38517 : "\n"
38518 : "Attempts to make an invalid geometry valid without losing vertices.\n"
38519 : "\n"
38520 : "For more details: :cpp:func:`OGR_G_MakeValidEx`\n"
38521 : "\n"
38522 : ".. versionadded:: 3.0\n"
38523 : ".. versionadded:: 3.4 options\n"
38524 : "\n"
38525 : "Parameters\n"
38526 : "-----------\n"
38527 : "options: list[str], optional\n"
38528 : " papszOptions to be passed in. For example: [\"METHOD=STRUCTURE\"].\n"
38529 : "\n"
38530 : "Returns\n"
38531 : "--------\n"
38532 : "Geometry:\n"
38533 : " A newly allocated geometry now owned by the caller, or None on\n"
38534 : " failure.\n"
38535 : "\n"
38536 : ""},
38537 : { "Geometry_SetPrecision", _wrap_Geometry_SetPrecision, METH_VARARGS, "Geometry_SetPrecision(Geometry self, double gridSize, int flags=0) -> Geometry"},
38538 : { "Geometry_Normalize", _wrap_Geometry_Normalize, METH_O, "\n"
38539 : "Geometry_Normalize(Geometry self) -> Geometry\n"
38540 : "\n"
38541 : "Attempts to bring geometry into normalized/canonical form.\n"
38542 : "\n"
38543 : "For more details: :cpp:func:`OGR_G_Normalize`\n"
38544 : "\n"
38545 : ".. versionadded:: 3.3\n"
38546 : "\n"
38547 : "Returns\n"
38548 : "--------\n"
38549 : "Geometry:\n"
38550 : " A newly allocated geometry now owned by the caller, or None on\n"
38551 : " failure.\n"
38552 : "\n"
38553 : ""},
38554 : { "Geometry_RemoveLowerDimensionSubGeoms", _wrap_Geometry_RemoveLowerDimensionSubGeoms, METH_O, "Geometry_RemoveLowerDimensionSubGeoms(Geometry self) -> Geometry"},
38555 : { "Geometry_Buffer", _wrap_Geometry_Buffer, METH_VARARGS, "\n"
38556 : "Geometry_Buffer(Geometry self, double distance, int quadsecs=30) -> Geometry\n"
38557 : "Geometry_Buffer(Geometry self, double distance, char ** options) -> Geometry\n"
38558 : "\n"
38559 : "Compute buffer of geometry.\n"
38560 : "\n"
38561 : "For more details: :cpp:func:`OGR_G_Buffer`\n"
38562 : "\n"
38563 : "Parameters\n"
38564 : "-----------\n"
38565 : "distance: float\n"
38566 : " The buffer distance to be applied. Should be expressed into\n"
38567 : " the same unit as the coordinates of the geometry.\n"
38568 : "quadsecs: int, default=30\n"
38569 : " The number of segments used to approximate a 90 degree\n"
38570 : " (quadrant) of curvature.\n"
38571 : "options: list/dict\n"
38572 : " An optional list of options to control the buffer output.\n"
38573 : " See :cpp:func:`OGR_G_BufferEx`.\n"
38574 : "\n"
38575 : "Returns\n"
38576 : "--------\n"
38577 : "Geometry:\n"
38578 : " The newly created geometry or None if an error occurs.\n"
38579 : "\n"
38580 : ""},
38581 : { "Geometry_Intersection", _wrap_Geometry_Intersection, METH_VARARGS, "\n"
38582 : "Geometry_Intersection(Geometry self, Geometry other) -> Geometry\n"
38583 : "\n"
38584 : "Compute intersection.\n"
38585 : "\n"
38586 : "For more details: :cpp:func:`OGR_G_Intersection`\n"
38587 : "\n"
38588 : "Parameters\n"
38589 : "-----------\n"
38590 : "other: Geometry\n"
38591 : " The other geometry.\n"
38592 : "\n"
38593 : "Returns\n"
38594 : "--------\n"
38595 : "Geometry:\n"
38596 : " A new geometry representing the intersection or None if there is no\n"
38597 : " intersection or an error occurs.\n"
38598 : "\n"
38599 : ""},
38600 : { "Geometry_Union", _wrap_Geometry_Union, METH_VARARGS, "\n"
38601 : "Geometry_Union(Geometry self, Geometry other) -> Geometry\n"
38602 : "\n"
38603 : "Compute union.\n"
38604 : "\n"
38605 : "For more details: :cpp:func:`OGR_G_Union`\n"
38606 : "\n"
38607 : "Parameters\n"
38608 : "-----------\n"
38609 : "other: Geometry\n"
38610 : " The other geometry.\n"
38611 : "\n"
38612 : "Returns\n"
38613 : "--------\n"
38614 : "Geometry:\n"
38615 : " A new geometry representing the union or None if an error occurs.\n"
38616 : "\n"
38617 : ""},
38618 : { "Geometry_UnionCascaded", _wrap_Geometry_UnionCascaded, METH_O, "\n"
38619 : "Geometry_UnionCascaded(Geometry self) -> Geometry\n"
38620 : "\n"
38621 : "Compute union using cascading.\n"
38622 : "\n"
38623 : "For more deails: :cpp:func:`OGR_G_UnionCascaded`\n"
38624 : "\n"
38625 : "Returns\n"
38626 : "--------\n"
38627 : "Geometry:\n"
38628 : " A new geometry representing the union or None if an error occurs.\n"
38629 : "\n"
38630 : ""},
38631 : { "Geometry_UnaryUnion", _wrap_Geometry_UnaryUnion, METH_O, "Geometry_UnaryUnion(Geometry self) -> Geometry"},
38632 : { "Geometry_Difference", _wrap_Geometry_Difference, METH_VARARGS, "\n"
38633 : "Geometry_Difference(Geometry self, Geometry other) -> Geometry\n"
38634 : "\n"
38635 : "Compute difference.\n"
38636 : "\n"
38637 : "For more details: :cpp:func:`OGR_G_Difference`\n"
38638 : "\n"
38639 : "Parameters\n"
38640 : "-----------\n"
38641 : "other: Geometry\n"
38642 : " The other geometry.\n"
38643 : "\n"
38644 : "Returns\n"
38645 : "--------\n"
38646 : "Geometry:\n"
38647 : " A new geometry representing the difference or None if the difference\n"
38648 : " is empty or an error occurs.\n"
38649 : "\n"
38650 : ""},
38651 : { "Geometry_SymDifference", _wrap_Geometry_SymDifference, METH_VARARGS, "\n"
38652 : "Geometry_SymDifference(Geometry self, Geometry other) -> Geometry\n"
38653 : "\n"
38654 : "Compute symmetric difference.\n"
38655 : "\n"
38656 : "For more details: :cpp:func:`OGR_G_SymDifference`\n"
38657 : "\n"
38658 : "Parameters\n"
38659 : "-----------\n"
38660 : "other:\n"
38661 : " the other geometry.\n"
38662 : "\n"
38663 : "Returns\n"
38664 : "--------\n"
38665 : "Geometry:\n"
38666 : " A new geometry representing the symmetric difference or None if the\n"
38667 : " difference is empty or an error occurs.\n"
38668 : "\n"
38669 : ""},
38670 : { "Geometry_SymmetricDifference", _wrap_Geometry_SymmetricDifference, METH_VARARGS, "\n"
38671 : "Geometry_SymmetricDifference(Geometry self, Geometry other) -> Geometry\n"
38672 : "\n"
38673 : "Compute symmetric difference (deprecated)\n"
38674 : "\n"
38675 : "For more details: :cpp:func:`OGR_G_SymmetricDifference`\n"
38676 : "\n"
38677 : ".. warning:: Deprecated\n"
38678 : "\n"
38679 : "\n"
38680 : ""},
38681 : { "Geometry_Distance", _wrap_Geometry_Distance, METH_VARARGS, "\n"
38682 : "Geometry_Distance(Geometry self, Geometry other) -> double\n"
38683 : "\n"
38684 : "Compute distance between two geometries.\n"
38685 : "\n"
38686 : "For more details: :cpp:func:`OGR_G_Distance`\n"
38687 : "\n"
38688 : "Parameters\n"
38689 : "-----------\n"
38690 : "other: Geometry\n"
38691 : " The other geometry to compare against.\n"
38692 : "\n"
38693 : "Returns\n"
38694 : "--------\n"
38695 : "float:\n"
38696 : " The distance between the geometries or -1 if an error occurs.\n"
38697 : "\n"
38698 : ""},
38699 : { "Geometry_Distance3D", _wrap_Geometry_Distance3D, METH_VARARGS, "\n"
38700 : "Geometry_Distance3D(Geometry self, Geometry other) -> double\n"
38701 : "\n"
38702 : "Returns the 3D distance between two geometries.\n"
38703 : "\n"
38704 : "For more details: :cpp:func:`OGR_G_Distance3D`\n"
38705 : "\n"
38706 : ".. versionadded:: 2.2\n"
38707 : "\n"
38708 : "Parameters\n"
38709 : "-----------\n"
38710 : "other: Geometry\n"
38711 : " The other geometry to compare against.\n"
38712 : "\n"
38713 : "Returns\n"
38714 : "--------\n"
38715 : "float:\n"
38716 : " The distance between the geometries or -1 if an error occurs.\n"
38717 : "\n"
38718 : ""},
38719 : { "Geometry_Empty", _wrap_Geometry_Empty, METH_O, "\n"
38720 : "Geometry_Empty(Geometry self)\n"
38721 : "\n"
38722 : "Clear geometry information.\n"
38723 : "\n"
38724 : "For more details: :cpp:func:`OGR_G_Empty`\n"
38725 : "\n"
38726 : ""},
38727 : { "Geometry_IsEmpty", _wrap_Geometry_IsEmpty, METH_O, "\n"
38728 : "Geometry_IsEmpty(Geometry self) -> bool\n"
38729 : "\n"
38730 : "Test if the geometry is empty.\n"
38731 : "\n"
38732 : "For more details: :cpp:func:`OGR_G_IsEmpty`\n"
38733 : "\n"
38734 : "Returns\n"
38735 : "--------\n"
38736 : "int:\n"
38737 : " True if the geometry has no points, otherwise False.\n"
38738 : "\n"
38739 : ""},
38740 : { "Geometry_IsValid", _wrap_Geometry_IsValid, METH_O, "\n"
38741 : "Geometry_IsValid(Geometry self) -> bool\n"
38742 : "\n"
38743 : "Test if the geometry is valid.\n"
38744 : "\n"
38745 : "For more details: :cpp:func:`OGR_G_IsValid`\n"
38746 : "\n"
38747 : "Returns\n"
38748 : "--------\n"
38749 : "int:\n"
38750 : " True if the geometry has no points, otherwise False.\n"
38751 : "\n"
38752 : ""},
38753 : { "Geometry_IsSimple", _wrap_Geometry_IsSimple, METH_O, "\n"
38754 : "Geometry_IsSimple(Geometry self) -> bool\n"
38755 : "\n"
38756 : "Returns True if the geometry is simple.\n"
38757 : "\n"
38758 : "For more details: :cpp:func:`OGR_G_IsSimple`\n"
38759 : "\n"
38760 : "Returns\n"
38761 : "--------\n"
38762 : "int:\n"
38763 : " True if object is simple, otherwise False.\n"
38764 : "\n"
38765 : ""},
38766 : { "Geometry_IsRing", _wrap_Geometry_IsRing, METH_O, "\n"
38767 : "Geometry_IsRing(Geometry self) -> bool\n"
38768 : "\n"
38769 : "Test if the geometry is a ring.\n"
38770 : "\n"
38771 : "For more details: :cpp:func:`OGR_G_IsRing`\n"
38772 : "\n"
38773 : "Returns\n"
38774 : "--------\n"
38775 : "int:\n"
38776 : " True if the geometry has no points, otherwise False.\n"
38777 : "\n"
38778 : ""},
38779 : { "Geometry_Intersects", _wrap_Geometry_Intersects, METH_VARARGS, "\n"
38780 : "Geometry_Intersects(Geometry self, Geometry other) -> bool\n"
38781 : "\n"
38782 : "Determines whether two geometries intersect.\n"
38783 : "\n"
38784 : "For more details: :cpp:func:`OGR_G_Intersects`\n"
38785 : "\n"
38786 : "Parameters\n"
38787 : "-----------\n"
38788 : "other: Geometry\n"
38789 : " The other geometry to test against.\n"
38790 : "\n"
38791 : "Returns\n"
38792 : "--------\n"
38793 : "int:\n"
38794 : " True if the geometries intersect, otherwise False.\n"
38795 : "\n"
38796 : ""},
38797 : { "Geometry_Intersect", _wrap_Geometry_Intersect, METH_VARARGS, "Geometry_Intersect(Geometry self, Geometry other) -> bool"},
38798 : { "Geometry_Equals", _wrap_Geometry_Equals, METH_VARARGS, "\n"
38799 : "Geometry_Equals(Geometry self, Geometry other) -> bool\n"
38800 : "\n"
38801 : "Returns True if two geometries are equivalent.\n"
38802 : "\n"
38803 : "For more details: :cpp:func:`OGR_G_Equals`\n"
38804 : "\n"
38805 : "Parameters\n"
38806 : "-----------\n"
38807 : "other: Geometry\n"
38808 : " The other geometry to test against.\n"
38809 : "\n"
38810 : "Returns\n"
38811 : "--------\n"
38812 : "int:\n"
38813 : " True if equivalent or False otherwise.\n"
38814 : "\n"
38815 : ""},
38816 : { "Geometry_Equal", _wrap_Geometry_Equal, METH_VARARGS, "Geometry_Equal(Geometry self, Geometry other) -> bool"},
38817 : { "Geometry_Disjoint", _wrap_Geometry_Disjoint, METH_VARARGS, "\n"
38818 : "Geometry_Disjoint(Geometry self, Geometry other) -> bool\n"
38819 : "\n"
38820 : "Test for disjointness.\n"
38821 : "\n"
38822 : "For more details: :cpp:func:`OGR_G_Disjoint`\n"
38823 : "\n"
38824 : "Parameters\n"
38825 : "-----------\n"
38826 : "other: Geometry\n"
38827 : " The other geometry to compare.\n"
38828 : "\n"
38829 : "Returns\n"
38830 : "--------\n"
38831 : "int:\n"
38832 : " True if they are disjoint, otherwise False.\n"
38833 : "\n"
38834 : ""},
38835 : { "Geometry_Touches", _wrap_Geometry_Touches, METH_VARARGS, "\n"
38836 : "Geometry_Touches(Geometry self, Geometry other) -> bool\n"
38837 : "\n"
38838 : "Test for touching.\n"
38839 : "\n"
38840 : "For more details: :cpp:func:`OGR_G_Touches`\n"
38841 : "\n"
38842 : "Parameters\n"
38843 : "-----------\n"
38844 : "other:\n"
38845 : " the other geometry to compare.\n"
38846 : "\n"
38847 : "Returns\n"
38848 : "--------\n"
38849 : "int:\n"
38850 : " True if they are touching, otherwise False.\n"
38851 : "\n"
38852 : ""},
38853 : { "Geometry_Crosses", _wrap_Geometry_Crosses, METH_VARARGS, "\n"
38854 : "Geometry_Crosses(Geometry self, Geometry other) -> bool\n"
38855 : "\n"
38856 : "Test for crossing.\n"
38857 : "\n"
38858 : "For more details: :cpp:func:`OGR_G_Crosses`\n"
38859 : "\n"
38860 : "Parameters\n"
38861 : "-----------\n"
38862 : "other: Geometry\n"
38863 : " the other geometry to compare.\n"
38864 : "\n"
38865 : "Returns\n"
38866 : "--------\n"
38867 : "int:\n"
38868 : " True if they are crossing, otherwise False.\n"
38869 : "\n"
38870 : ""},
38871 : { "Geometry_Within", _wrap_Geometry_Within, METH_VARARGS, "\n"
38872 : "Geometry_Within(Geometry self, Geometry other) -> bool\n"
38873 : "\n"
38874 : "Test for containment.\n"
38875 : "\n"
38876 : "For more details: :cpp:func:`OGR_G_Within`\n"
38877 : "\n"
38878 : "Parameters\n"
38879 : "-----------\n"
38880 : "other: Geometry\n"
38881 : " the other geometry to compare.\n"
38882 : "\n"
38883 : "Returns\n"
38884 : "--------\n"
38885 : "int:\n"
38886 : " True if this is within other, otherwise False.\n"
38887 : "\n"
38888 : ""},
38889 : { "Geometry_Contains", _wrap_Geometry_Contains, METH_VARARGS, "\n"
38890 : "Geometry_Contains(Geometry self, Geometry other) -> bool\n"
38891 : "\n"
38892 : "Test for containment.\n"
38893 : "\n"
38894 : "For more details: :cpp:func:`OGR_G_Contains`\n"
38895 : "\n"
38896 : "Parameters\n"
38897 : "-----------\n"
38898 : "other: Geometry\n"
38899 : " the other geometry to compare.\n"
38900 : "\n"
38901 : "Returns\n"
38902 : "--------\n"
38903 : "int:\n"
38904 : " True if this contains the other geometry, otherwise False.\n"
38905 : "\n"
38906 : ""},
38907 : { "Geometry_Overlaps", _wrap_Geometry_Overlaps, METH_VARARGS, "\n"
38908 : "Geometry_Overlaps(Geometry self, Geometry other) -> bool\n"
38909 : "\n"
38910 : "Test for overlap.\n"
38911 : "\n"
38912 : "For more details: :cpp:func:`OGR_G_Overlaps`\n"
38913 : "\n"
38914 : "Parameters\n"
38915 : "-----------\n"
38916 : "other: Geometry\n"
38917 : " the other geometry to compare.\n"
38918 : "\n"
38919 : "Returns\n"
38920 : "--------\n"
38921 : "int:\n"
38922 : " True if they are overlapping, otherwise False.\n"
38923 : "\n"
38924 : ""},
38925 : { "Geometry_TransformTo", _wrap_Geometry_TransformTo, METH_VARARGS, "\n"
38926 : "Geometry_TransformTo(Geometry self, SpatialReference reference) -> OGRErr\n"
38927 : "\n"
38928 : "Transform geometry to new spatial reference system.\n"
38929 : "\n"
38930 : "For more details: :cpp:func:`OGR_G_TransformTo`\n"
38931 : "\n"
38932 : "Parameters\n"
38933 : "-----------\n"
38934 : "reference: SpatialReference\n"
38935 : " The spatial reference system to apply.\n"
38936 : "\n"
38937 : "Returns\n"
38938 : "--------\n"
38939 : "int:\n"
38940 : " :py:const:`osgeo.ogr.OGRERR_NONE` on success, or an error code.\n"
38941 : "\n"
38942 : ""},
38943 : { "Geometry_GetSpatialReference", _wrap_Geometry_GetSpatialReference, METH_O, "\n"
38944 : "Geometry_GetSpatialReference(Geometry self) -> SpatialReference\n"
38945 : "\n"
38946 : "For more details: :cpp:func:`OGR_G_GetSpatialReference`\n"
38947 : "\n"
38948 : "Returns spatial reference system for geometry.\n"
38949 : "\n"
38950 : "Returns\n"
38951 : "--------\n"
38952 : "SpatialReference\n"
38953 : "\n"
38954 : ""},
38955 : { "Geometry_AssignSpatialReference", _wrap_Geometry_AssignSpatialReference, METH_VARARGS, "\n"
38956 : "Geometry_AssignSpatialReference(Geometry self, SpatialReference reference)\n"
38957 : "\n"
38958 : "Assign spatial reference to this object.\n"
38959 : "\n"
38960 : "For more details: :cpp:func:`OGR_G_AssignSpatialReference`\n"
38961 : "\n"
38962 : "Parameters\n"
38963 : "-----------\n"
38964 : "reference: SpatialReference\n"
38965 : " The new spatial reference system to apply.\n"
38966 : "\n"
38967 : ""},
38968 : { "Geometry_CloseRings", _wrap_Geometry_CloseRings, METH_O, "\n"
38969 : "Geometry_CloseRings(Geometry self)\n"
38970 : "\n"
38971 : "Force rings to be closed.\n"
38972 : "\n"
38973 : "For more details: :cpp:func:`OGR_G_CloseRings`\n"
38974 : "\n"
38975 : ""},
38976 : { "Geometry_FlattenTo2D", _wrap_Geometry_FlattenTo2D, METH_O, "\n"
38977 : "Geometry_FlattenTo2D(Geometry self)\n"
38978 : "\n"
38979 : "Convert geometry to strictly 2D.\n"
38980 : "\n"
38981 : "For more details: :cpp:func:`OGR_G_FlattenTo2D`\n"
38982 : "\n"
38983 : ""},
38984 : { "Geometry_Segmentize", _wrap_Geometry_Segmentize, METH_VARARGS, "\n"
38985 : "Geometry_Segmentize(Geometry self, double dfMaxLength)\n"
38986 : "\n"
38987 : "Modify the geometry such it has no segment longer then the given\n"
38988 : "distance.\n"
38989 : "\n"
38990 : "For more details: :cpp:func:`OGR_G_Segmentize`\n"
38991 : "\n"
38992 : "Parameters\n"
38993 : "-----------\n"
38994 : "dfMaxLength: float\n"
38995 : " the maximum distance between 2 points after segmentization\n"
38996 : "\n"
38997 : ""},
38998 : { "Geometry_GetEnvelope", _wrap_Geometry_GetEnvelope, METH_O, "\n"
38999 : "Geometry_GetEnvelope(Geometry self)\n"
39000 : "\n"
39001 : "Computes and returns the bounding envelope for this geometry in the\n"
39002 : "passed psEnvelope structure.\n"
39003 : "\n"
39004 : "For more details: :cpp:func:`OGR_G_GetEnvelope`\n"
39005 : "\n"
39006 : ".. warning:: Check the return order of the bounds.\n"
39007 : "\n"
39008 : "Returns\n"
39009 : "--------\n"
39010 : "minx: float\n"
39011 : "maxx: float\n"
39012 : "miny: float\n"
39013 : "maxy: float\n"
39014 : "\n"
39015 : ""},
39016 : { "Geometry_GetEnvelope3D", _wrap_Geometry_GetEnvelope3D, METH_O, "\n"
39017 : "Geometry_GetEnvelope3D(Geometry self)\n"
39018 : "\n"
39019 : "Computes and returns the bounding envelope (3D) for this geometry in\n"
39020 : "the passed psEnvelope structure.\n"
39021 : "\n"
39022 : "For more details: :cpp:func:`OGR_G_GetEnvelope3D`\n"
39023 : "\n"
39024 : ".. warning:: Check the return order of the bounds.\n"
39025 : "\n"
39026 : "Returns\n"
39027 : "--------\n"
39028 : "minx: float\n"
39029 : "maxx: float\n"
39030 : "miny: float\n"
39031 : "maxy: float\n"
39032 : "minz: float\n"
39033 : "maxz: float\n"
39034 : "\n"
39035 : ""},
39036 : { "Geometry_Centroid", _wrap_Geometry_Centroid, METH_O, "\n"
39037 : "Geometry_Centroid(Geometry self) -> Geometry\n"
39038 : "\n"
39039 : "Compute the geometry centroid.\n"
39040 : "\n"
39041 : "For more details: :cpp:func:`OGR_G_Centroid`\n"
39042 : "\n"
39043 : "Returns\n"
39044 : "--------\n"
39045 : "Geometry\n"
39046 : "\n"
39047 : ""},
39048 : { "Geometry_PointOnSurface", _wrap_Geometry_PointOnSurface, METH_O, "\n"
39049 : "Geometry_PointOnSurface(Geometry self) -> Geometry\n"
39050 : "\n"
39051 : "Returns a point guaranteed to lie on the surface.\n"
39052 : "\n"
39053 : "For more details: :cpp:func:`OGR_G_PointOnSurface`\n"
39054 : "\n"
39055 : "Returns\n"
39056 : "--------\n"
39057 : "Geometry:\n"
39058 : " A point guaranteed to lie on the surface or None if an error occurred.\n"
39059 : "\n"
39060 : ""},
39061 : { "Geometry_WkbSize", _wrap_Geometry_WkbSize, METH_O, "\n"
39062 : "Geometry_WkbSize(Geometry self) -> size_t\n"
39063 : "\n"
39064 : "Returns size of related binary representation.\n"
39065 : "\n"
39066 : "For more details: :cpp:func:`OGR_G_WkbSize`\n"
39067 : "\n"
39068 : "Returns\n"
39069 : "--------\n"
39070 : "int\n"
39071 : "\n"
39072 : ""},
39073 : { "Geometry_GetCoordinateDimension", _wrap_Geometry_GetCoordinateDimension, METH_O, "\n"
39074 : "Geometry_GetCoordinateDimension(Geometry self) -> int\n"
39075 : "\n"
39076 : "Get the dimension of the coordinates in this geometry.\n"
39077 : "\n"
39078 : "For more details: :cpp:func:`OGR_G_GetCoordinateDimension`\n"
39079 : "\n"
39080 : ".. warning:: Deprecated. Use :py:func:`CoordinateDimension`,\n"
39081 : " :py:func:`Is3D`, or :py:func:`IsMeasured`.\n"
39082 : "\n"
39083 : "Returns\n"
39084 : "--------\n"
39085 : "int:\n"
39086 : " This will return 2 or 3.\n"
39087 : "\n"
39088 : ""},
39089 : { "Geometry_CoordinateDimension", _wrap_Geometry_CoordinateDimension, METH_O, "\n"
39090 : "Geometry_CoordinateDimension(Geometry self) -> int\n"
39091 : "\n"
39092 : "Get the dimension of the coordinates in this geometry.\n"
39093 : "\n"
39094 : "For more details: :cpp:func:`OGR_G_CoordinateDimension`\n"
39095 : "\n"
39096 : ".. versionadded:: 2.1\n"
39097 : "\n"
39098 : "Returns\n"
39099 : "--------\n"
39100 : "int:\n"
39101 : " This will return 2 for XY, 3 for XYZ and XYM, and 4 for XYZM data.\n"
39102 : "\n"
39103 : ""},
39104 : { "Geometry_Is3D", _wrap_Geometry_Is3D, METH_O, "\n"
39105 : "Geometry_Is3D(Geometry self) -> int\n"
39106 : "\n"
39107 : "See whether this geometry has Z coordinates.\n"
39108 : "\n"
39109 : "For more details: :cpp:func:`OGR_G_Is3D`\n"
39110 : "\n"
39111 : ".. versionadded:: 2.1\n"
39112 : "\n"
39113 : "Returns\n"
39114 : "--------\n"
39115 : "int:\n"
39116 : " True if the geometry has Z coordinates.\n"
39117 : "\n"
39118 : ""},
39119 : { "Geometry_IsMeasured", _wrap_Geometry_IsMeasured, METH_O, "\n"
39120 : "Geometry_IsMeasured(Geometry self) -> int\n"
39121 : "\n"
39122 : "See whether this geometry is measured.\n"
39123 : "\n"
39124 : "For more details: :cpp:func:`OGR_G_IsMeasured`\n"
39125 : "\n"
39126 : ".. versionadded:: 2.1\n"
39127 : "\n"
39128 : "Returns\n"
39129 : "--------\n"
39130 : "int:\n"
39131 : " True if the geometry has M coordinates.\n"
39132 : "\n"
39133 : ""},
39134 : { "Geometry_SetCoordinateDimension", _wrap_Geometry_SetCoordinateDimension, METH_VARARGS, "\n"
39135 : "Geometry_SetCoordinateDimension(Geometry self, int dimension)\n"
39136 : "\n"
39137 : "Set the coordinate dimension.\n"
39138 : "\n"
39139 : "For more details: :cpp:func:`OGR_G_SetCoordinateDimension`\n"
39140 : "\n"
39141 : ".. warning:: Deprecated. Use :py:func:`Set3D` or :py:func:`SetMeasured`.\n"
39142 : "\n"
39143 : "Parameters\n"
39144 : "-----------\n"
39145 : "dimension: int\n"
39146 : " New coordinate dimension value, either 2 or 3.\n"
39147 : "\n"
39148 : ""},
39149 : { "Geometry_Set3D", _wrap_Geometry_Set3D, METH_VARARGS, "\n"
39150 : "Geometry_Set3D(Geometry self, int b3D)\n"
39151 : "\n"
39152 : "Add or remove the Z coordinate dimension.\n"
39153 : "\n"
39154 : "For more details: :cpp:func:`OGR_G_Set3D`\n"
39155 : "\n"
39156 : ".. versionadded:: 2.1\n"
39157 : "\n"
39158 : "Parameters\n"
39159 : "-----------\n"
39160 : "bIs3D: bool\n"
39161 : " Should the geometry have a Z dimension, either True or False.\n"
39162 : "\n"
39163 : ""},
39164 : { "Geometry_SetMeasured", _wrap_Geometry_SetMeasured, METH_VARARGS, "\n"
39165 : "Geometry_SetMeasured(Geometry self, int bMeasured)\n"
39166 : "\n"
39167 : "Add or remove the M coordinate dimension.\n"
39168 : "\n"
39169 : "For more details: :cpp:func:`OGR_G_SetMeasured`\n"
39170 : "\n"
39171 : ".. versionadded:: 2.1\n"
39172 : "\n"
39173 : "Parameters\n"
39174 : "-----------\n"
39175 : "bIsMeasured: bool\n"
39176 : " Should the geometry have a M dimension, either True or False.\n"
39177 : "\n"
39178 : ""},
39179 : { "Geometry_GetDimension", _wrap_Geometry_GetDimension, METH_O, "\n"
39180 : "Geometry_GetDimension(Geometry self) -> int\n"
39181 : "\n"
39182 : "Get the dimension of this geometry.\n"
39183 : "\n"
39184 : "For more details: :cpp:func:`OGR_G_GetDimension`\n"
39185 : "\n"
39186 : "Returns\n"
39187 : "--------\n"
39188 : "int:\n"
39189 : " 0 for points, 1 for lines, and 2 for surfaces.\n"
39190 : "\n"
39191 : ""},
39192 : { "Geometry_HasCurveGeometry", _wrap_Geometry_HasCurveGeometry, METH_VARARGS, "Geometry_HasCurveGeometry(Geometry self, int bLookForCircular=FALSE) -> int"},
39193 : { "Geometry_GetLinearGeometry", (PyCFunction)(void(*)(void))_wrap_Geometry_GetLinearGeometry, METH_VARARGS|METH_KEYWORDS, "Geometry_GetLinearGeometry(Geometry self, double dfMaxAngleStepSizeDegrees=0.0, char ** options=None) -> Geometry"},
39194 : { "Geometry_GetCurveGeometry", (PyCFunction)(void(*)(void))_wrap_Geometry_GetCurveGeometry, METH_VARARGS|METH_KEYWORDS, "Geometry_GetCurveGeometry(Geometry self, char ** options=None) -> Geometry"},
39195 : { "Geometry_Value", _wrap_Geometry_Value, METH_VARARGS, "Geometry_Value(Geometry self, double dfDistance) -> Geometry"},
39196 : { "Geometry_Transform", _wrap_Geometry_Transform, METH_VARARGS, "\n"
39197 : "Geometry_Transform(Geometry self, CoordinateTransformation trans) -> OGRErr\n"
39198 : "Geometry_Transform(Geometry self, GeomTransformer transformer) -> Geometry\n"
39199 : "\n"
39200 : "Apply arbitrary coordinate transformation to geometry.\n"
39201 : "\n"
39202 : "For more details: :cpp:func:`OGR_G_Transform`\n"
39203 : "\n"
39204 : "Parameters\n"
39205 : "-----------\n"
39206 : "trans: CoordinateTransform\n"
39207 : " The transformation to apply.\n"
39208 : "\n"
39209 : "Returns\n"
39210 : "--------\n"
39211 : "Geometry:\n"
39212 : " The transformed geometry.\n"
39213 : "\n"
39214 : ""},
39215 : { "Geometry_CreatePreparedGeometry", _wrap_Geometry_CreatePreparedGeometry, METH_O, "Geometry_CreatePreparedGeometry(Geometry self) -> PreparedGeometry"},
39216 : { "Geometry_swigregister", Geometry_swigregister, METH_O, NULL},
39217 : { "Geometry_swiginit", Geometry_swiginit, METH_VARARGS, NULL},
39218 : { "delete_PreparedGeometry", _wrap_delete_PreparedGeometry, METH_O, "delete_PreparedGeometry(PreparedGeometry self)"},
39219 : { "PreparedGeometry_Intersects", _wrap_PreparedGeometry_Intersects, METH_VARARGS, "PreparedGeometry_Intersects(PreparedGeometry self, Geometry otherGeom) -> bool"},
39220 : { "PreparedGeometry_Contains", _wrap_PreparedGeometry_Contains, METH_VARARGS, "PreparedGeometry_Contains(PreparedGeometry self, Geometry otherGeom) -> bool"},
39221 : { "PreparedGeometry_swigregister", PreparedGeometry_swigregister, METH_O, NULL},
39222 : { "new_GeomTransformer", _wrap_new_GeomTransformer, METH_VARARGS, "new_GeomTransformer(CoordinateTransformation ct, char ** options=None) -> GeomTransformer"},
39223 : { "delete_GeomTransformer", _wrap_delete_GeomTransformer, METH_O, "delete_GeomTransformer(GeomTransformer self)"},
39224 : { "GeomTransformer_Transform", _wrap_GeomTransformer_Transform, METH_VARARGS, "GeomTransformer_Transform(GeomTransformer self, Geometry src_geom) -> Geometry"},
39225 : { "GeomTransformer_swigregister", GeomTransformer_swigregister, METH_O, NULL},
39226 : { "GeomTransformer_swiginit", GeomTransformer_swiginit, METH_VARARGS, NULL},
39227 : { "delete_FieldDomain", _wrap_delete_FieldDomain, METH_O, "delete_FieldDomain(FieldDomain self)"},
39228 : { "FieldDomain_GetName", _wrap_FieldDomain_GetName, METH_O, "\n"
39229 : "FieldDomain_GetName(FieldDomain self) -> char const *\n"
39230 : "\n"
39231 : "\n"
39232 : "Get the name of the field domain.\n"
39233 : "\n"
39234 : "See :cpp:func:`OGRFieldDomain::GetName`.\n"
39235 : "\n"
39236 : ".. versionadded:: 3.3\n"
39237 : "\n"
39238 : "Returns\n"
39239 : "--------\n"
39240 : "str\n"
39241 : " the field domain name.\n"
39242 : "\n"
39243 : ""},
39244 : { "FieldDomain_GetDescription", _wrap_FieldDomain_GetDescription, METH_O, "\n"
39245 : "FieldDomain_GetDescription(FieldDomain self) -> char const *\n"
39246 : "\n"
39247 : "\n"
39248 : "Get the description of the field domain.\n"
39249 : "\n"
39250 : "See :cpp:func:`OGRFieldDomain::GetDescription`.\n"
39251 : "\n"
39252 : ".. versionadded:: 3.3\n"
39253 : "\n"
39254 : "Returns\n"
39255 : "--------\n"
39256 : "str\n"
39257 : " the field domain description (might be empty string).\n"
39258 : "\n"
39259 : ""},
39260 : { "FieldDomain_GetFieldType", _wrap_FieldDomain_GetFieldType, METH_O, "\n"
39261 : "FieldDomain_GetFieldType(FieldDomain self) -> OGRFieldType\n"
39262 : "\n"
39263 : "\n"
39264 : "Get the field type of the field domain.\n"
39265 : "\n"
39266 : "See :cpp:func:`OGRFieldDomain::GetFieldType`.\n"
39267 : "\n"
39268 : ".. versionadded:: 3.3\n"
39269 : "\n"
39270 : "Returns\n"
39271 : "--------\n"
39272 : "int\n"
39273 : " the field type of the field domain.\n"
39274 : "\n"
39275 : ""},
39276 : { "FieldDomain_GetFieldSubType", _wrap_FieldDomain_GetFieldSubType, METH_O, "\n"
39277 : "FieldDomain_GetFieldSubType(FieldDomain self) -> OGRFieldSubType\n"
39278 : "\n"
39279 : "\n"
39280 : "Get the field subtype of the field domain.\n"
39281 : "\n"
39282 : "See :cpp:func:`OGRFieldDomain::GetFieldSubType`.\n"
39283 : "\n"
39284 : ".. versionadded:: 3.3\n"
39285 : "\n"
39286 : "Returns\n"
39287 : "--------\n"
39288 : "int\n"
39289 : " the field subtype of the field domain.\n"
39290 : "\n"
39291 : ""},
39292 : { "FieldDomain_GetDomainType", _wrap_FieldDomain_GetDomainType, METH_O, "\n"
39293 : "FieldDomain_GetDomainType(FieldDomain self) -> OGRFieldDomainType\n"
39294 : "\n"
39295 : "\n"
39296 : "Get the type of the field domain.\n"
39297 : "\n"
39298 : "See :cpp:func:`OGRFieldDomain::GetDomainType`.\n"
39299 : "\n"
39300 : ".. versionadded:: 3.3\n"
39301 : "\n"
39302 : "Returns\n"
39303 : "--------\n"
39304 : "int\n"
39305 : " the type of the field domain.\n"
39306 : "\n"
39307 : "Examples\n"
39308 : "--------\n"
39309 : ">>> d = ogr.CreateCodedFieldDomain('my_code', None, ogr.OFTInteger, ogr.OFSTNone, { 1 : 'owned', 2 : 'leased' })\n"
39310 : ">>> d.GetDomainType() == ogr.OFDT_CODED\n"
39311 : "True\n"
39312 : "\n"
39313 : "\n"
39314 : ""},
39315 : { "FieldDomain_GetSplitPolicy", _wrap_FieldDomain_GetSplitPolicy, METH_O, "\n"
39316 : "FieldDomain_GetSplitPolicy(FieldDomain self) -> OGRFieldDomainSplitPolicy\n"
39317 : "\n"
39318 : "\n"
39319 : "Get the split policy of the field domain.\n"
39320 : "\n"
39321 : "See :cpp:func:`OGRFieldDomain::GetSplitPolicy`.\n"
39322 : "\n"
39323 : ".. versionadded:: 3.3\n"
39324 : "\n"
39325 : "Returns\n"
39326 : "--------\n"
39327 : "int\n"
39328 : " the split policy of the field domain (default = :py:const:`OFDSP_DEFAULT_VALUE`)\n"
39329 : "\n"
39330 : ""},
39331 : { "FieldDomain_SetSplitPolicy", _wrap_FieldDomain_SetSplitPolicy, METH_VARARGS, "\n"
39332 : "FieldDomain_SetSplitPolicy(FieldDomain self, OGRFieldDomainSplitPolicy policy)\n"
39333 : "\n"
39334 : "\n"
39335 : "Set the split policy of the field domain.\n"
39336 : "\n"
39337 : "See :cpp:func:`OGRFieldDomain::SetSplitPolicy`.\n"
39338 : "\n"
39339 : ".. versionadded:: 3.3\n"
39340 : "\n"
39341 : "policy : int\n"
39342 : " the split policy code of the field domain.\n"
39343 : "\n"
39344 : ""},
39345 : { "FieldDomain_GetMergePolicy", _wrap_FieldDomain_GetMergePolicy, METH_O, "\n"
39346 : "FieldDomain_GetMergePolicy(FieldDomain self) -> OGRFieldDomainMergePolicy\n"
39347 : "\n"
39348 : "\n"
39349 : "Get the merge policy of the field domain.\n"
39350 : "\n"
39351 : "See :cpp:func:`OGRFieldDomain::GetMergePolicy`.\n"
39352 : "\n"
39353 : ".. versionadded:: 3.3\n"
39354 : "\n"
39355 : "Returns\n"
39356 : "--------\n"
39357 : "int\n"
39358 : " the merge policy of the field domain (default = :py:const:`OFDMP_DEFAULT_VALUE`)\n"
39359 : "\n"
39360 : ""},
39361 : { "FieldDomain_SetMergePolicy", _wrap_FieldDomain_SetMergePolicy, METH_VARARGS, "\n"
39362 : "FieldDomain_SetMergePolicy(FieldDomain self, OGRFieldDomainMergePolicy policy)\n"
39363 : "\n"
39364 : "\n"
39365 : "Set the merge policy of the field domain.\n"
39366 : "\n"
39367 : "See :cpp:func:`OGRFieldDomain::SetMergePolicy`.\n"
39368 : "\n"
39369 : ".. versionadded:: 3.3\n"
39370 : "\n"
39371 : "Parameters\n"
39372 : "-----------\n"
39373 : "policy : int\n"
39374 : " the merge policy code of the field domain.\n"
39375 : "\n"
39376 : ""},
39377 : { "FieldDomain_GetEnumeration", _wrap_FieldDomain_GetEnumeration, METH_O, "\n"
39378 : "FieldDomain_GetEnumeration(FieldDomain self) -> OGRCodedValue const *\n"
39379 : "\n"
39380 : "\n"
39381 : "Get the enumeration as a mapping of codes to values.\n"
39382 : "\n"
39383 : "See :cpp:func:`OGRCodedFieldDomain::GetEnumeration`.\n"
39384 : "\n"
39385 : ".. versionadded:: 3.3\n"
39386 : "\n"
39387 : "Returns\n"
39388 : "--------\n"
39389 : "dict\n"
39390 : "\n"
39391 : "Examples\n"
39392 : "--------\n"
39393 : ">>> d = ogr.CreateCodedFieldDomain('my_domain', None, ogr.OFTInteger, ogr.OFSTNone, { 1 : 'owned', 2 : 'leased' })\n"
39394 : ">>> d.GetEnumeration()\n"
39395 : "{'1': 'owned', '2': 'leased'}\n"
39396 : "\n"
39397 : "\n"
39398 : ""},
39399 : { "FieldDomain_GetMinAsDouble", _wrap_FieldDomain_GetMinAsDouble, METH_O, "\n"
39400 : "FieldDomain_GetMinAsDouble(FieldDomain self) -> double\n"
39401 : "\n"
39402 : "\n"
39403 : "Get the minimum value of a range domain.\n"
39404 : "\n"
39405 : "See :cpp:func:`OGRRangeFieldDomain::GetMin()`\n"
39406 : "\n"
39407 : ".. versionadded:: 3.3\n"
39408 : "\n"
39409 : "Returns\n"
39410 : "--------\n"
39411 : "float\n"
39412 : " the minimum value of the range\n"
39413 : "\n"
39414 : ""},
39415 : { "FieldDomain_GetMinAsString", _wrap_FieldDomain_GetMinAsString, METH_O, "\n"
39416 : "FieldDomain_GetMinAsString(FieldDomain self) -> char const *\n"
39417 : "\n"
39418 : "\n"
39419 : "Get the minimum value of a range domain.\n"
39420 : "\n"
39421 : "See :cpp:func:`OGRRangeFieldDomain::GetMin()`\n"
39422 : "\n"
39423 : ".. versionadded:: 3.3\n"
39424 : "\n"
39425 : "Returns\n"
39426 : "--------\n"
39427 : "str\n"
39428 : " the minimum value of the range\n"
39429 : "\n"
39430 : ""},
39431 : { "FieldDomain_IsMinInclusive", _wrap_FieldDomain_IsMinInclusive, METH_O, "FieldDomain_IsMinInclusive(FieldDomain self) -> bool"},
39432 : { "FieldDomain_GetMaxAsDouble", _wrap_FieldDomain_GetMaxAsDouble, METH_O, "\n"
39433 : "FieldDomain_GetMaxAsDouble(FieldDomain self) -> double\n"
39434 : "\n"
39435 : "\n"
39436 : "Get the maximum value of a range domain.\n"
39437 : "\n"
39438 : "See :cpp:func:`OGRRangeFieldDomain::GetMax()`\n"
39439 : "\n"
39440 : ".. versionadded:: 3.3\n"
39441 : "\n"
39442 : "Returns\n"
39443 : "--------\n"
39444 : "float\n"
39445 : " the maximum value of the range\n"
39446 : "\n"
39447 : ""},
39448 : { "FieldDomain_GetMaxAsString", _wrap_FieldDomain_GetMaxAsString, METH_O, "\n"
39449 : "FieldDomain_GetMaxAsString(FieldDomain self) -> char const *\n"
39450 : "\n"
39451 : "\n"
39452 : "Get the maximum value of a range domain.\n"
39453 : "\n"
39454 : "See :cpp:func:`OGRRangeFieldDomain::GetMax()`\n"
39455 : "\n"
39456 : ".. versionadded:: 3.3\n"
39457 : "\n"
39458 : "Returns\n"
39459 : "--------\n"
39460 : "str\n"
39461 : " the maximum value of the range\n"
39462 : "\n"
39463 : ""},
39464 : { "FieldDomain_IsMaxInclusive", _wrap_FieldDomain_IsMaxInclusive, METH_O, "FieldDomain_IsMaxInclusive(FieldDomain self) -> bool"},
39465 : { "FieldDomain_GetGlob", _wrap_FieldDomain_GetGlob, METH_O, "\n"
39466 : "FieldDomain_GetGlob(FieldDomain self) -> char const *\n"
39467 : "\n"
39468 : "\n"
39469 : "Get the glob expression.\n"
39470 : "\n"
39471 : "See :cpp:func:`OGRGlobFieldDomain::GetGlob`.\n"
39472 : "\n"
39473 : ".. versionadded:: 3.3\n"
39474 : "\n"
39475 : "Returns\n"
39476 : "--------\n"
39477 : "str\n"
39478 : " the glob expression, or ``None`` in case of error\n"
39479 : "\n"
39480 : ""},
39481 : { "FieldDomain_swigregister", FieldDomain_swigregister, METH_O, NULL},
39482 : { "CreateCodedFieldDomain", _wrap_CreateCodedFieldDomain, METH_VARARGS, "\n"
39483 : "CreateCodedFieldDomain(char const * name, char const * description, OGRFieldType type, OGRFieldSubType subtype, OGRCodedValue const * enumeration) -> FieldDomain\n"
39484 : "\n"
39485 : "\n"
39486 : "Creates a new coded field domain.\n"
39487 : "\n"
39488 : "See :cpp:func:`OGRCodedFieldDomain::OGRCodedFieldDomain`.\n"
39489 : "\n"
39490 : ".. versionadded:: 3.3\n"
39491 : "\n"
39492 : "Parameters\n"
39493 : "-----------\n"
39494 : "name : str\n"
39495 : " Domain name. Should not be ``None``.\n"
39496 : "description : str, optional\n"
39497 : " Domain description (can be ``None``)\n"
39498 : "type : int\n"
39499 : " Field type.\n"
39500 : "subtype : int\n"
39501 : " Field subtype.\n"
39502 : "enumeration : dict\n"
39503 : " Enumeration as a dictionary of (code : value) pairs. Should not be ``None``.\n"
39504 : "\n"
39505 : "Returns\n"
39506 : "--------\n"
39507 : "FieldDomain\n"
39508 : "\n"
39509 : ""},
39510 : { "CreateRangeFieldDomain", _wrap_CreateRangeFieldDomain, METH_VARARGS, "\n"
39511 : "CreateRangeFieldDomain(char const * name, char const * description, OGRFieldType type, OGRFieldSubType subtype, double min, bool minIsInclusive, double max, double maxIsInclusive) -> FieldDomain\n"
39512 : "\n"
39513 : "Creates a new range field domain.\n"
39514 : "\n"
39515 : "See :cpp:func:`OGRRangeFieldDomain::OGRRangeFieldDomain`.\n"
39516 : "\n"
39517 : ".. versionadded:: 3.3\n"
39518 : "\n"
39519 : "Parameters\n"
39520 : "-----------\n"
39521 : "name : str\n"
39522 : " Domain name. Should not be ``None``.\n"
39523 : "description : str, optional\n"
39524 : " Domain description (can be ``None``)\n"
39525 : "type : int\n"
39526 : " Field type. Generally numeric. Potentially :py:const:`OFTDateTime`.\n"
39527 : "subtype : int\n"
39528 : " Field subtype.\n"
39529 : "min : float, optional\n"
39530 : " Minimum value (can be ``None``).\n"
39531 : "minIsInclusive : bool\n"
39532 : " Whether the minimum value is included in the range.\n"
39533 : "max : float, optional\n"
39534 : " Maximum value (can be ``None``).\n"
39535 : "maxIsInclusive : bool\n"
39536 : " Whether the maximum value is included in the range.\n"
39537 : "\n"
39538 : "Returns\n"
39539 : "--------\n"
39540 : "FieldDomain\n"
39541 : "\n"
39542 : ""},
39543 : { "CreateRangeFieldDomainDateTime", _wrap_CreateRangeFieldDomainDateTime, METH_VARARGS, "CreateRangeFieldDomainDateTime(char const * name, char const * description, char const * min, bool minIsInclusive, char const * max, double maxIsInclusive) -> FieldDomain"},
39544 : { "CreateGlobFieldDomain", _wrap_CreateGlobFieldDomain, METH_VARARGS, "\n"
39545 : "CreateGlobFieldDomain(char const * name, char const * description, OGRFieldType type, OGRFieldSubType subtype, char const * glob) -> FieldDomain\n"
39546 : "\n"
39547 : "\n"
39548 : "Creates a new glob field domain.\n"
39549 : "\n"
39550 : "See :cpp:func:`OGRGlobFieldDomain::OGRGlobFieldDomain`\n"
39551 : "\n"
39552 : ".. versionadded:: 3.3\n"
39553 : "\n"
39554 : "Parameters\n"
39555 : "-----------\n"
39556 : "name : str\n"
39557 : " Domain name. Should not be ``None``.\n"
39558 : "description : str, optional\n"
39559 : " Domain description (can be ``None``)\n"
39560 : "type : int\n"
39561 : " Field type.\n"
39562 : "subtype : int\n"
39563 : " Field subtype.\n"
39564 : "glob : str\n"
39565 : " Glob expression. Should not be ``None``.\n"
39566 : "\n"
39567 : "Returns\n"
39568 : "--------\n"
39569 : "FieldDomain\n"
39570 : "\n"
39571 : ""},
39572 : { "delete_GeomCoordinatePrecision", _wrap_delete_GeomCoordinatePrecision, METH_O, "delete_GeomCoordinatePrecision(GeomCoordinatePrecision self)"},
39573 : { "GeomCoordinatePrecision_Set", _wrap_GeomCoordinatePrecision_Set, METH_VARARGS, "GeomCoordinatePrecision_Set(GeomCoordinatePrecision self, double xyResolution, double zResolution, double mResolution)"},
39574 : { "GeomCoordinatePrecision_SetFromMeter", _wrap_GeomCoordinatePrecision_SetFromMeter, METH_VARARGS, "GeomCoordinatePrecision_SetFromMeter(GeomCoordinatePrecision self, SpatialReference srs, double xyMeterResolution, double zMeterResolution, double mResolution)"},
39575 : { "GeomCoordinatePrecision_GetXYResolution", _wrap_GeomCoordinatePrecision_GetXYResolution, METH_O, "GeomCoordinatePrecision_GetXYResolution(GeomCoordinatePrecision self) -> double"},
39576 : { "GeomCoordinatePrecision_GetZResolution", _wrap_GeomCoordinatePrecision_GetZResolution, METH_O, "GeomCoordinatePrecision_GetZResolution(GeomCoordinatePrecision self) -> double"},
39577 : { "GeomCoordinatePrecision_GetMResolution", _wrap_GeomCoordinatePrecision_GetMResolution, METH_O, "GeomCoordinatePrecision_GetMResolution(GeomCoordinatePrecision self) -> double"},
39578 : { "GeomCoordinatePrecision_GetFormats", _wrap_GeomCoordinatePrecision_GetFormats, METH_O, "GeomCoordinatePrecision_GetFormats(GeomCoordinatePrecision self) -> char **"},
39579 : { "GeomCoordinatePrecision_GetFormatSpecificOptions", _wrap_GeomCoordinatePrecision_GetFormatSpecificOptions, METH_VARARGS, "GeomCoordinatePrecision_GetFormatSpecificOptions(GeomCoordinatePrecision self, char const * formatName) -> char **"},
39580 : { "GeomCoordinatePrecision_SetFormatSpecificOptions", _wrap_GeomCoordinatePrecision_SetFormatSpecificOptions, METH_VARARGS, "GeomCoordinatePrecision_SetFormatSpecificOptions(GeomCoordinatePrecision self, char const * formatName, char ** formatSpecificOptions)"},
39581 : { "GeomCoordinatePrecision_swigregister", GeomCoordinatePrecision_swigregister, METH_O, NULL},
39582 : { "CreateGeomCoordinatePrecision", _wrap_CreateGeomCoordinatePrecision, METH_NOARGS, "CreateGeomCoordinatePrecision() -> GeomCoordinatePrecision"},
39583 : { "GetDriverCount", _wrap_GetDriverCount, METH_NOARGS, "GetDriverCount() -> int"},
39584 : { "GetOpenDSCount", _wrap_GetOpenDSCount, METH_NOARGS, "GetOpenDSCount() -> int"},
39585 : { "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"},
39586 : { "RegisterAll", _wrap_RegisterAll, METH_NOARGS, "RegisterAll()"},
39587 : { "GeometryTypeToName", _wrap_GeometryTypeToName, METH_O, "GeometryTypeToName(OGRwkbGeometryType eType) -> char const *"},
39588 : { "GetFieldTypeName", _wrap_GetFieldTypeName, METH_O, "\n"
39589 : "GetFieldTypeName(OGRFieldType type) -> char const *\n"
39590 : "\n"
39591 : "Fetch human readable name for a field type.\n"
39592 : "\n"
39593 : "See :cpp:func:`OGRFieldDefn::GetFieldTypeName`.\n"
39594 : "\n"
39595 : "Parameters\n"
39596 : "-----------\n"
39597 : "type : int\n"
39598 : " the field type code to get name for\n"
39599 : "\n"
39600 : "Returns\n"
39601 : "--------\n"
39602 : "str\n"
39603 : " the name\n"
39604 : "\n"
39605 : "Examples\n"
39606 : "--------\n"
39607 : ">>> ogr.GetFieldTypeName(0)\n"
39608 : "'Integer'\n"
39609 : "\n"
39610 : ">>> ogr.GetFieldTypeName(ogr.OFTReal)\n"
39611 : "'Real'\n"
39612 : "\n"
39613 : ""},
39614 : { "GetFieldSubTypeName", _wrap_GetFieldSubTypeName, METH_O, "\n"
39615 : "GetFieldSubTypeName(OGRFieldSubType type) -> char const *\n"
39616 : "\n"
39617 : "\n"
39618 : "Fetch human readable name for a field subtype.\n"
39619 : "\n"
39620 : "See :cpp:func:`OGRFieldDefn::GetFieldSubTypeName`.\n"
39621 : "\n"
39622 : "Parameters\n"
39623 : "-----------\n"
39624 : "type : int\n"
39625 : " the field subtype to get name for.\n"
39626 : "\n"
39627 : "Returns\n"
39628 : "--------\n"
39629 : "str\n"
39630 : " the name.\n"
39631 : "\n"
39632 : "Examples\n"
39633 : "--------\n"
39634 : ">>> ogr.GetFieldSubTypeName(1)\n"
39635 : "'Boolean'\n"
39636 : "\n"
39637 : ">>> ogr.GetFieldSubTypeName(ogr.OFSTInt16)\n"
39638 : "'Int16'\n"
39639 : "\n"
39640 : "\n"
39641 : ""},
39642 : { "GT_Flatten", _wrap_GT_Flatten, METH_O, "GT_Flatten(OGRwkbGeometryType eType) -> OGRwkbGeometryType"},
39643 : { "GT_SetZ", _wrap_GT_SetZ, METH_O, "GT_SetZ(OGRwkbGeometryType eType) -> OGRwkbGeometryType"},
39644 : { "GT_SetM", _wrap_GT_SetM, METH_O, "GT_SetM(OGRwkbGeometryType eType) -> OGRwkbGeometryType"},
39645 : { "GT_SetModifier", _wrap_GT_SetModifier, METH_VARARGS, "GT_SetModifier(OGRwkbGeometryType eType, int bSetZ, int bSetM=FALSE) -> OGRwkbGeometryType"},
39646 : { "GT_HasZ", _wrap_GT_HasZ, METH_O, "GT_HasZ(OGRwkbGeometryType eType) -> int"},
39647 : { "GT_HasM", _wrap_GT_HasM, METH_O, "GT_HasM(OGRwkbGeometryType eType) -> int"},
39648 : { "GT_IsSubClassOf", _wrap_GT_IsSubClassOf, METH_VARARGS, "GT_IsSubClassOf(OGRwkbGeometryType eType, OGRwkbGeometryType eSuperType) -> int"},
39649 : { "GT_IsCurve", _wrap_GT_IsCurve, METH_O, "GT_IsCurve(OGRwkbGeometryType arg1) -> int"},
39650 : { "GT_IsSurface", _wrap_GT_IsSurface, METH_O, "GT_IsSurface(OGRwkbGeometryType arg1) -> int"},
39651 : { "GT_IsNonLinear", _wrap_GT_IsNonLinear, METH_O, "GT_IsNonLinear(OGRwkbGeometryType arg1) -> int"},
39652 : { "GT_GetCollection", _wrap_GT_GetCollection, METH_O, "GT_GetCollection(OGRwkbGeometryType eType) -> OGRwkbGeometryType"},
39653 : { "GT_GetCurve", _wrap_GT_GetCurve, METH_O, "GT_GetCurve(OGRwkbGeometryType eType) -> OGRwkbGeometryType"},
39654 : { "GT_GetLinear", _wrap_GT_GetLinear, METH_O, "GT_GetLinear(OGRwkbGeometryType eType) -> OGRwkbGeometryType"},
39655 : { "SetNonLinearGeometriesEnabledFlag", _wrap_SetNonLinearGeometriesEnabledFlag, METH_O, "SetNonLinearGeometriesEnabledFlag(int bFlag)"},
39656 : { "GetNonLinearGeometriesEnabledFlag", _wrap_GetNonLinearGeometriesEnabledFlag, METH_NOARGS, "GetNonLinearGeometriesEnabledFlag() -> int"},
39657 : { "GetOpenDS", _wrap_GetOpenDS, METH_O, "GetOpenDS(int ds_number) -> OGRDataSourceShadow *"},
39658 : { "Open", (PyCFunction)(void(*)(void))_wrap_Open, METH_VARARGS|METH_KEYWORDS, "\n"
39659 : "Open(char const * utf8_path, int update=0) -> OGRDataSourceShadow *\n"
39660 : "\n"
39661 : "\n"
39662 : "Open a vector file as a :py:class:`gdal.Dataset`.\n"
39663 : "Equivalent to calling :py:func:`gdal.OpenEx` with the\n"
39664 : ":py:const:`gdal.OF_VECTOR` flag.\n"
39665 : "\n"
39666 : "Parameters\n"
39667 : "----------\n"
39668 : "utf8_path : str\n"
39669 : " name of the file to open\n"
39670 : "\n"
39671 : "Returns\n"
39672 : "-------\n"
39673 : "gdal.Dataset, or ``None`` on failure\n"
39674 : "\n"
39675 : "Examples\n"
39676 : "--------\n"
39677 : ">>> from osgeo import ogr\n"
39678 : ">>> ogr.GetDriverByName('ESRI Shapefile').GetDescription()\n"
39679 : "'ESRI Shapefile'\n"
39680 : ">>> ogr.GetDriverByName('GTiff')\n"
39681 : ">>>\n"
39682 : "\n"
39683 : ""},
39684 : { "OpenShared", (PyCFunction)(void(*)(void))_wrap_OpenShared, METH_VARARGS|METH_KEYWORDS, "\n"
39685 : "OpenShared(char const * utf8_path, int update=0) -> OGRDataSourceShadow *\n"
39686 : "\n"
39687 : "\n"
39688 : "Open a vector file as a :py:class:`gdal.Dataset`. If the file has already been\n"
39689 : "opened in the current thread, return a reference to the already-opened\n"
39690 : ":py:class:`gdal.Dataset`. Equivalent to calling :py:func:`gdal.OpenEx` with the\n"
39691 : ":py:const:`gdal.OF_VECTOR` and :py:const:`gdal.OF_SHARED` flags.\n"
39692 : "\n"
39693 : "Parameters\n"
39694 : "----------\n"
39695 : "utf8_path : str\n"
39696 : " name of the file to open\n"
39697 : "\n"
39698 : "Returns\n"
39699 : "-------\n"
39700 : "gdal.Dataset, or ``None`` on failure\n"
39701 : "\n"
39702 : "\n"
39703 : ""},
39704 : { "GetDriverByName", _wrap_GetDriverByName, METH_O, "\n"
39705 : "GetDriverByName(char const * name) -> OGRDriverShadow *\n"
39706 : "\n"
39707 : "\n"
39708 : "Get a vector driver. Like :py:func:`gdal.GetDriverByName`, but\n"
39709 : "only returns drivers that handle vector data.\n"
39710 : "\n"
39711 : "Parameters\n"
39712 : "----------\n"
39713 : "name : str\n"
39714 : " name of the driver to fetch\n"
39715 : "\n"
39716 : "Returns\n"
39717 : "-------\n"
39718 : "gdal.Driver\n"
39719 : "\n"
39720 : "Examples\n"
39721 : "--------\n"
39722 : ">>> ogr.GetDriverByName('ESRI Shapefile').GetDescription()\n"
39723 : "'ESRI Shapefile'\n"
39724 : "\n"
39725 : ">>> ogr.GetDriverByName('GTiff')\n"
39726 : ">>>\n"
39727 : "\n"
39728 : ""},
39729 : { "GetDriver", _wrap_GetDriver, METH_O, "GetDriver(int driver_number) -> OGRDriverShadow *"},
39730 : { "GeneralCmdLineProcessor", _wrap_GeneralCmdLineProcessor, METH_VARARGS, "GeneralCmdLineProcessor(char ** papszArgv, int nOptions=0) -> char **"},
39731 : { "TermProgress_nocb", (PyCFunction)(void(*)(void))_wrap_TermProgress_nocb, METH_VARARGS|METH_KEYWORDS, "TermProgress_nocb(double dfProgress, char const * pszMessage=None, void * pData=None) -> int"},
39732 : { NULL, NULL, 0, NULL }
39733 : };
39734 :
39735 : static PyMethodDef SwigMethods_proxydocs[] = {
39736 : { NULL, NULL, 0, NULL }
39737 : };
39738 :
39739 :
39740 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
39741 :
39742 0 : static void *_p_OGRLayerShadowTo_p_GDALMajorObjectShadow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
39743 0 : return (void *)((GDALMajorObjectShadow *) ((OGRLayerShadow *) x));
39744 : }
39745 : static swig_type_info _swigt__p_ArrowArray = {"_p_ArrowArray", "ArrowArray *", 0, 0, (void*)0, 0};
39746 : static swig_type_info _swigt__p_ArrowArrayStream = {"_p_ArrowArrayStream", "ArrowArrayStream *", 0, 0, (void*)0, 0};
39747 : static swig_type_info _swigt__p_ArrowSchema = {"_p_ArrowSchema", "ArrowSchema *", 0, 0, (void*)0, 0};
39748 : static swig_type_info _swigt__p_GDALDatasetShadow = {"_p_GDALDatasetShadow", "GDALDatasetShadow *|OGRDataSourceShadow *", 0, 0, (void*)0, 0};
39749 : static swig_type_info _swigt__p_GDALDriverShadow = {"_p_GDALDriverShadow", "GDALDriverShadow *|OGRDriverShadow *", 0, 0, (void*)0, 0};
39750 : static swig_type_info _swigt__p_GDALMajorObjectShadow = {"_p_GDALMajorObjectShadow", "GDALMajorObjectShadow *", 0, 0, (void*)0, 0};
39751 : static swig_type_info _swigt__p_GDALProgressFunc = {"_p_GDALProgressFunc", "GDALProgressFunc *", 0, 0, (void*)0, 0};
39752 : static swig_type_info _swigt__p_GIntBig = {"_p_GIntBig", "GIntBig *", 0, 0, (void*)0, 0};
39753 : static swig_type_info _swigt__p_OGRCodedValue = {"_p_OGRCodedValue", "OGRCodedValue *", 0, 0, (void*)0, 0};
39754 : static swig_type_info _swigt__p_OGRFeatureDefnShadow = {"_p_OGRFeatureDefnShadow", "OGRFeatureDefnShadow *", 0, 0, (void*)0, 0};
39755 : static swig_type_info _swigt__p_OGRFeatureShadow = {"_p_OGRFeatureShadow", "OGRFeatureShadow *", 0, 0, (void*)0, 0};
39756 : static swig_type_info _swigt__p_OGRFieldDefnShadow = {"_p_OGRFieldDefnShadow", "OGRFieldDefnShadow *", 0, 0, (void*)0, 0};
39757 : static swig_type_info _swigt__p_OGRFieldDomainShadow = {"_p_OGRFieldDomainShadow", "OGRFieldDomainShadow *", 0, 0, (void*)0, 0};
39758 : static swig_type_info _swigt__p_OGRGeomCoordinatePrecisionShadow = {"_p_OGRGeomCoordinatePrecisionShadow", "OGRGeomCoordinatePrecisionShadow *", 0, 0, (void*)0, 0};
39759 : static swig_type_info _swigt__p_OGRGeomFieldDefnShadow = {"_p_OGRGeomFieldDefnShadow", "OGRGeomFieldDefnShadow *", 0, 0, (void*)0, 0};
39760 : static swig_type_info _swigt__p_OGRGeomTransformerShadow = {"_p_OGRGeomTransformerShadow", "OGRGeomTransformerShadow *", 0, 0, (void*)0, 0};
39761 : static swig_type_info _swigt__p_OGRGeometryShadow = {"_p_OGRGeometryShadow", "OGRGeometryShadow *", 0, 0, (void*)0, 0};
39762 : static swig_type_info _swigt__p_OGRLayerShadow = {"_p_OGRLayerShadow", "OGRLayerShadow *", 0, 0, (void*)0, 0};
39763 : static swig_type_info _swigt__p_OGRPreparedGeometryShadow = {"_p_OGRPreparedGeometryShadow", "OGRPreparedGeometryShadow *", 0, 0, (void*)0, 0};
39764 : static swig_type_info _swigt__p_OGRStyleTableShadow = {"_p_OGRStyleTableShadow", "OGRStyleTableShadow *", 0, 0, (void*)0, 0};
39765 : static swig_type_info _swigt__p_OSRCoordinateTransformationShadow = {"_p_OSRCoordinateTransformationShadow", "OSRCoordinateTransformationShadow *", 0, 0, (void*)0, 0};
39766 : static swig_type_info _swigt__p_OSRSpatialReferenceShadow = {"_p_OSRSpatialReferenceShadow", "OSRSpatialReferenceShadow *", 0, 0, (void*)0, 0};
39767 : static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
39768 : static swig_type_info _swigt__p_char = {"_p_char", "char *|retStringAndCPLFree *", 0, 0, (void*)0, 0};
39769 : static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
39770 : 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};
39771 : static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0};
39772 : 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};
39773 : static swig_type_info _swigt__p_p_GIntBig = {"_p_p_GIntBig", "GIntBig **", 0, 0, (void*)0, 0};
39774 : static swig_type_info _swigt__p_p_OGRGeometryTypeCounter = {"_p_p_OGRGeometryTypeCounter", "OGRGeometryTypeCounter **", 0, 0, (void*)0, 0};
39775 : static swig_type_info _swigt__p_p_OGRSpatialReferenceH = {"_p_p_OGRSpatialReferenceH", "OGRSpatialReferenceH **", 0, 0, (void*)0, 0};
39776 : static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
39777 : static swig_type_info _swigt__p_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0};
39778 : static swig_type_info _swigt__p_p_int = {"_p_p_int", "int **", 0, 0, (void*)0, 0};
39779 : static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
39780 :
39781 : static swig_type_info *swig_type_initial[] = {
39782 : &_swigt__p_ArrowArray,
39783 : &_swigt__p_ArrowArrayStream,
39784 : &_swigt__p_ArrowSchema,
39785 : &_swigt__p_GDALDatasetShadow,
39786 : &_swigt__p_GDALDriverShadow,
39787 : &_swigt__p_GDALMajorObjectShadow,
39788 : &_swigt__p_GDALProgressFunc,
39789 : &_swigt__p_GIntBig,
39790 : &_swigt__p_OGRCodedValue,
39791 : &_swigt__p_OGRFeatureDefnShadow,
39792 : &_swigt__p_OGRFeatureShadow,
39793 : &_swigt__p_OGRFieldDefnShadow,
39794 : &_swigt__p_OGRFieldDomainShadow,
39795 : &_swigt__p_OGRGeomCoordinatePrecisionShadow,
39796 : &_swigt__p_OGRGeomFieldDefnShadow,
39797 : &_swigt__p_OGRGeomTransformerShadow,
39798 : &_swigt__p_OGRGeometryShadow,
39799 : &_swigt__p_OGRLayerShadow,
39800 : &_swigt__p_OGRPreparedGeometryShadow,
39801 : &_swigt__p_OGRStyleTableShadow,
39802 : &_swigt__p_OSRCoordinateTransformationShadow,
39803 : &_swigt__p_OSRSpatialReferenceShadow,
39804 : &_swigt__p_bool,
39805 : &_swigt__p_char,
39806 : &_swigt__p_double,
39807 : &_swigt__p_f_double_p_q_const__char_p_void__int,
39808 : &_swigt__p_float,
39809 : &_swigt__p_int,
39810 : &_swigt__p_p_GIntBig,
39811 : &_swigt__p_p_OGRGeometryTypeCounter,
39812 : &_swigt__p_p_OGRSpatialReferenceH,
39813 : &_swigt__p_p_char,
39814 : &_swigt__p_p_double,
39815 : &_swigt__p_p_int,
39816 : &_swigt__p_size_t,
39817 : };
39818 :
39819 : static swig_cast_info _swigc__p_ArrowArray[] = { {&_swigt__p_ArrowArray, 0, 0, 0},{0, 0, 0, 0}};
39820 : static swig_cast_info _swigc__p_ArrowArrayStream[] = { {&_swigt__p_ArrowArrayStream, 0, 0, 0},{0, 0, 0, 0}};
39821 : static swig_cast_info _swigc__p_ArrowSchema[] = { {&_swigt__p_ArrowSchema, 0, 0, 0},{0, 0, 0, 0}};
39822 : static swig_cast_info _swigc__p_GDALDatasetShadow[] = { {&_swigt__p_GDALDatasetShadow, 0, 0, 0},{0, 0, 0, 0}};
39823 : static swig_cast_info _swigc__p_GDALDriverShadow[] = { {&_swigt__p_GDALDriverShadow, 0, 0, 0},{0, 0, 0, 0}};
39824 : 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}};
39825 : static swig_cast_info _swigc__p_GDALProgressFunc[] = { {&_swigt__p_GDALProgressFunc, 0, 0, 0},{0, 0, 0, 0}};
39826 : static swig_cast_info _swigc__p_GIntBig[] = { {&_swigt__p_GIntBig, 0, 0, 0},{0, 0, 0, 0}};
39827 : static swig_cast_info _swigc__p_OGRCodedValue[] = { {&_swigt__p_OGRCodedValue, 0, 0, 0},{0, 0, 0, 0}};
39828 : static swig_cast_info _swigc__p_OGRFeatureDefnShadow[] = { {&_swigt__p_OGRFeatureDefnShadow, 0, 0, 0},{0, 0, 0, 0}};
39829 : static swig_cast_info _swigc__p_OGRFeatureShadow[] = { {&_swigt__p_OGRFeatureShadow, 0, 0, 0},{0, 0, 0, 0}};
39830 : static swig_cast_info _swigc__p_OGRFieldDefnShadow[] = { {&_swigt__p_OGRFieldDefnShadow, 0, 0, 0},{0, 0, 0, 0}};
39831 : static swig_cast_info _swigc__p_OGRFieldDomainShadow[] = { {&_swigt__p_OGRFieldDomainShadow, 0, 0, 0},{0, 0, 0, 0}};
39832 : static swig_cast_info _swigc__p_OGRGeomCoordinatePrecisionShadow[] = { {&_swigt__p_OGRGeomCoordinatePrecisionShadow, 0, 0, 0},{0, 0, 0, 0}};
39833 : static swig_cast_info _swigc__p_OGRGeomFieldDefnShadow[] = { {&_swigt__p_OGRGeomFieldDefnShadow, 0, 0, 0},{0, 0, 0, 0}};
39834 : static swig_cast_info _swigc__p_OGRGeomTransformerShadow[] = { {&_swigt__p_OGRGeomTransformerShadow, 0, 0, 0},{0, 0, 0, 0}};
39835 : static swig_cast_info _swigc__p_OGRGeometryShadow[] = { {&_swigt__p_OGRGeometryShadow, 0, 0, 0},{0, 0, 0, 0}};
39836 : static swig_cast_info _swigc__p_OGRLayerShadow[] = { {&_swigt__p_OGRLayerShadow, 0, 0, 0},{0, 0, 0, 0}};
39837 : static swig_cast_info _swigc__p_OGRPreparedGeometryShadow[] = { {&_swigt__p_OGRPreparedGeometryShadow, 0, 0, 0},{0, 0, 0, 0}};
39838 : static swig_cast_info _swigc__p_OGRStyleTableShadow[] = { {&_swigt__p_OGRStyleTableShadow, 0, 0, 0},{0, 0, 0, 0}};
39839 : static swig_cast_info _swigc__p_OSRCoordinateTransformationShadow[] = { {&_swigt__p_OSRCoordinateTransformationShadow, 0, 0, 0},{0, 0, 0, 0}};
39840 : static swig_cast_info _swigc__p_OSRSpatialReferenceShadow[] = { {&_swigt__p_OSRSpatialReferenceShadow, 0, 0, 0},{0, 0, 0, 0}};
39841 : static swig_cast_info _swigc__p_bool[] = { {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
39842 : static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
39843 : static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
39844 : 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}};
39845 : static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
39846 : static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
39847 : static swig_cast_info _swigc__p_p_GIntBig[] = { {&_swigt__p_p_GIntBig, 0, 0, 0},{0, 0, 0, 0}};
39848 : static swig_cast_info _swigc__p_p_OGRGeometryTypeCounter[] = { {&_swigt__p_p_OGRGeometryTypeCounter, 0, 0, 0},{0, 0, 0, 0}};
39849 : static swig_cast_info _swigc__p_p_OGRSpatialReferenceH[] = { {&_swigt__p_p_OGRSpatialReferenceH, 0, 0, 0},{0, 0, 0, 0}};
39850 : static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
39851 : static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
39852 : static swig_cast_info _swigc__p_p_int[] = { {&_swigt__p_p_int, 0, 0, 0},{0, 0, 0, 0}};
39853 : static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
39854 :
39855 : static swig_cast_info *swig_cast_initial[] = {
39856 : _swigc__p_ArrowArray,
39857 : _swigc__p_ArrowArrayStream,
39858 : _swigc__p_ArrowSchema,
39859 : _swigc__p_GDALDatasetShadow,
39860 : _swigc__p_GDALDriverShadow,
39861 : _swigc__p_GDALMajorObjectShadow,
39862 : _swigc__p_GDALProgressFunc,
39863 : _swigc__p_GIntBig,
39864 : _swigc__p_OGRCodedValue,
39865 : _swigc__p_OGRFeatureDefnShadow,
39866 : _swigc__p_OGRFeatureShadow,
39867 : _swigc__p_OGRFieldDefnShadow,
39868 : _swigc__p_OGRFieldDomainShadow,
39869 : _swigc__p_OGRGeomCoordinatePrecisionShadow,
39870 : _swigc__p_OGRGeomFieldDefnShadow,
39871 : _swigc__p_OGRGeomTransformerShadow,
39872 : _swigc__p_OGRGeometryShadow,
39873 : _swigc__p_OGRLayerShadow,
39874 : _swigc__p_OGRPreparedGeometryShadow,
39875 : _swigc__p_OGRStyleTableShadow,
39876 : _swigc__p_OSRCoordinateTransformationShadow,
39877 : _swigc__p_OSRSpatialReferenceShadow,
39878 : _swigc__p_bool,
39879 : _swigc__p_char,
39880 : _swigc__p_double,
39881 : _swigc__p_f_double_p_q_const__char_p_void__int,
39882 : _swigc__p_float,
39883 : _swigc__p_int,
39884 : _swigc__p_p_GIntBig,
39885 : _swigc__p_p_OGRGeometryTypeCounter,
39886 : _swigc__p_p_OGRSpatialReferenceH,
39887 : _swigc__p_p_char,
39888 : _swigc__p_p_double,
39889 : _swigc__p_p_int,
39890 : _swigc__p_size_t,
39891 : };
39892 :
39893 :
39894 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
39895 :
39896 : static swig_const_info swig_const_table[] = {
39897 : { SWIG_PY_POINTER, "TermProgress", 0, 0, (void *)((int (*)(double,char const *,void *))(GDALTermProgress)), &SWIGTYPE_p_f_double_p_q_const__char_p_void__int },
39898 : {0, 0, 0, 0.0, 0, 0}};
39899 :
39900 : #ifdef __cplusplus
39901 : }
39902 : #endif
39903 : /* -----------------------------------------------------------------------------
39904 : * Type initialization:
39905 : * This problem is tough by the requirement that no dynamic
39906 : * memory is used. Also, since swig_type_info structures store pointers to
39907 : * swig_cast_info structures and swig_cast_info structures store pointers back
39908 : * to swig_type_info structures, we need some lookup code at initialization.
39909 : * The idea is that swig generates all the structures that are needed.
39910 : * The runtime then collects these partially filled structures.
39911 : * The SWIG_InitializeModule function takes these initial arrays out of
39912 : * swig_module, and does all the lookup, filling in the swig_module.types
39913 : * array with the correct data and linking the correct swig_cast_info
39914 : * structures together.
39915 : *
39916 : * The generated swig_type_info structures are assigned statically to an initial
39917 : * array. We just loop through that array, and handle each type individually.
39918 : * First we lookup if this type has been already loaded, and if so, use the
39919 : * loaded structure instead of the generated one. Then we have to fill in the
39920 : * cast linked list. The cast data is initially stored in something like a
39921 : * two-dimensional array. Each row corresponds to a type (there are the same
39922 : * number of rows as there are in the swig_type_initial array). Each entry in
39923 : * a column is one of the swig_cast_info structures for that type.
39924 : * The cast_initial array is actually an array of arrays, because each row has
39925 : * a variable number of columns. So to actually build the cast linked list,
39926 : * we find the array of casts associated with the type, and loop through it
39927 : * adding the casts to the list. The one last trick we need to do is making
39928 : * sure the type pointer in the swig_cast_info struct is correct.
39929 : *
39930 : * First off, we lookup the cast->type name to see if it is already loaded.
39931 : * There are three cases to handle:
39932 : * 1) If the cast->type has already been loaded AND the type we are adding
39933 : * casting info to has not been loaded (it is in this module), THEN we
39934 : * replace the cast->type pointer with the type pointer that has already
39935 : * been loaded.
39936 : * 2) If BOTH types (the one we are adding casting info to, and the
39937 : * cast->type) are loaded, THEN the cast info has already been loaded by
39938 : * the previous module so we just ignore it.
39939 : * 3) Finally, if cast->type has not already been loaded, then we add that
39940 : * swig_cast_info to the linked list (because the cast->type) pointer will
39941 : * be correct.
39942 : * ----------------------------------------------------------------------------- */
39943 :
39944 : #ifdef __cplusplus
39945 : extern "C" {
39946 : #if 0
39947 : } /* c-mode */
39948 : #endif
39949 : #endif
39950 :
39951 : #if 0
39952 : #define SWIGRUNTIME_DEBUG
39953 : #endif
39954 :
39955 :
39956 : SWIGRUNTIME void
39957 : SWIG_InitializeModule(void *clientdata) {
39958 : size_t i;
39959 : swig_module_info *module_head, *iter;
39960 : int init;
39961 :
39962 : /* check to see if the circular list has been setup, if not, set it up */
39963 : if (swig_module.next==0) {
39964 : /* Initialize the swig_module */
39965 : swig_module.type_initial = swig_type_initial;
39966 : swig_module.cast_initial = swig_cast_initial;
39967 : swig_module.next = &swig_module;
39968 : init = 1;
39969 : } else {
39970 : init = 0;
39971 : }
39972 :
39973 : /* Try and load any already created modules */
39974 : module_head = SWIG_GetModule(clientdata);
39975 : if (!module_head) {
39976 : /* This is the first module loaded for this interpreter */
39977 : /* so set the swig module into the interpreter */
39978 : SWIG_SetModule(clientdata, &swig_module);
39979 : } else {
39980 : /* the interpreter has loaded a SWIG module, but has it loaded this one? */
39981 : iter=module_head;
39982 : do {
39983 : if (iter==&swig_module) {
39984 : /* Our module is already in the list, so there's nothing more to do. */
39985 : return;
39986 : }
39987 : iter=iter->next;
39988 : } while (iter!= module_head);
39989 :
39990 : /* otherwise we must add our module into the list */
39991 : swig_module.next = module_head->next;
39992 : module_head->next = &swig_module;
39993 : }
39994 :
39995 : /* When multiple interpreters are used, a module could have already been initialized in
39996 : a different interpreter, but not yet have a pointer in this interpreter.
39997 : In this case, we do not want to continue adding types... everything should be
39998 : set up already */
39999 : if (init == 0) return;
40000 :
40001 : /* Now work on filling in swig_module.types */
40002 : #ifdef SWIGRUNTIME_DEBUG
40003 : printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
40004 : #endif
40005 : for (i = 0; i < swig_module.size; ++i) {
40006 : swig_type_info *type = 0;
40007 : swig_type_info *ret;
40008 : swig_cast_info *cast;
40009 :
40010 : #ifdef SWIGRUNTIME_DEBUG
40011 : printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
40012 : #endif
40013 :
40014 : /* if there is another module already loaded */
40015 : if (swig_module.next != &swig_module) {
40016 : type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
40017 : }
40018 : if (type) {
40019 : /* Overwrite clientdata field */
40020 : #ifdef SWIGRUNTIME_DEBUG
40021 : printf("SWIG_InitializeModule: found type %s\n", type->name);
40022 : #endif
40023 : if (swig_module.type_initial[i]->clientdata) {
40024 : type->clientdata = swig_module.type_initial[i]->clientdata;
40025 : #ifdef SWIGRUNTIME_DEBUG
40026 : printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
40027 : #endif
40028 : }
40029 : } else {
40030 : type = swig_module.type_initial[i];
40031 : }
40032 :
40033 : /* Insert casting types */
40034 : cast = swig_module.cast_initial[i];
40035 : while (cast->type) {
40036 : /* Don't need to add information already in the list */
40037 : ret = 0;
40038 : #ifdef SWIGRUNTIME_DEBUG
40039 : printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
40040 : #endif
40041 : if (swig_module.next != &swig_module) {
40042 : ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
40043 : #ifdef SWIGRUNTIME_DEBUG
40044 : if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
40045 : #endif
40046 : }
40047 : if (ret) {
40048 : if (type == swig_module.type_initial[i]) {
40049 : #ifdef SWIGRUNTIME_DEBUG
40050 : printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
40051 : #endif
40052 : cast->type = ret;
40053 : ret = 0;
40054 : } else {
40055 : /* Check for casting already in the list */
40056 : swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
40057 : #ifdef SWIGRUNTIME_DEBUG
40058 : if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
40059 : #endif
40060 : if (!ocast) ret = 0;
40061 : }
40062 : }
40063 :
40064 : if (!ret) {
40065 : #ifdef SWIGRUNTIME_DEBUG
40066 : printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
40067 : #endif
40068 : if (type->cast) {
40069 : type->cast->prev = cast;
40070 : cast->next = type->cast;
40071 : }
40072 : type->cast = cast;
40073 : }
40074 : cast++;
40075 : }
40076 : /* Set entry in modules->types array equal to the type */
40077 : swig_module.types[i] = type;
40078 : }
40079 : swig_module.types[i] = 0;
40080 :
40081 : #ifdef SWIGRUNTIME_DEBUG
40082 : printf("**** SWIG_InitializeModule: Cast List ******\n");
40083 : for (i = 0; i < swig_module.size; ++i) {
40084 : int j = 0;
40085 : swig_cast_info *cast = swig_module.cast_initial[i];
40086 : printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
40087 : while (cast->type) {
40088 : printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
40089 : cast++;
40090 : ++j;
40091 : }
40092 : printf("---- Total casts: %d\n",j);
40093 : }
40094 : printf("**** SWIG_InitializeModule: Cast List ******\n");
40095 : #endif
40096 : }
40097 :
40098 : /* This function will propagate the clientdata field of type to
40099 : * any new swig_type_info structures that have been added into the list
40100 : * of equivalent types. It is like calling
40101 : * SWIG_TypeClientData(type, clientdata) a second time.
40102 : */
40103 : SWIGRUNTIME void
40104 : SWIG_PropagateClientData(void) {
40105 : size_t i;
40106 : swig_cast_info *equiv;
40107 : static int init_run = 0;
40108 :
40109 : if (init_run) return;
40110 : init_run = 1;
40111 :
40112 : for (i = 0; i < swig_module.size; i++) {
40113 : if (swig_module.types[i]->clientdata) {
40114 : equiv = swig_module.types[i]->cast;
40115 : while (equiv) {
40116 : if (!equiv->converter) {
40117 : if (equiv->type && !equiv->type->clientdata)
40118 : SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
40119 : }
40120 : equiv = equiv->next;
40121 : }
40122 : }
40123 : }
40124 : }
40125 :
40126 : #ifdef __cplusplus
40127 : #if 0
40128 : {
40129 : /* c-mode */
40130 : #endif
40131 : }
40132 : #endif
40133 :
40134 :
40135 :
40136 : #ifdef __cplusplus
40137 : extern "C" {
40138 : #endif
40139 :
40140 : /* Python-specific SWIG API */
40141 : #define SWIG_newvarlink() SWIG_Python_newvarlink()
40142 : #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
40143 : #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
40144 :
40145 : /* -----------------------------------------------------------------------------
40146 : * global variable support code.
40147 : * ----------------------------------------------------------------------------- */
40148 :
40149 : typedef struct swig_globalvar {
40150 : char *name; /* Name of global variable */
40151 : PyObject *(*get_attr)(void); /* Return the current value */
40152 : int (*set_attr)(PyObject *); /* Set the value */
40153 : struct swig_globalvar *next;
40154 : } swig_globalvar;
40155 :
40156 : typedef struct swig_varlinkobject {
40157 : PyObject_HEAD
40158 : swig_globalvar *vars;
40159 : } swig_varlinkobject;
40160 :
40161 : SWIGINTERN PyObject *
40162 : swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
40163 : #if PY_VERSION_HEX >= 0x03000000
40164 : return PyUnicode_InternFromString("<Swig global variables>");
40165 : #else
40166 : return PyString_FromString("<Swig global variables>");
40167 : #endif
40168 : }
40169 :
40170 : SWIGINTERN PyObject *
40171 : swig_varlink_str(swig_varlinkobject *v) {
40172 : #if PY_VERSION_HEX >= 0x03000000
40173 : PyObject *str = PyUnicode_InternFromString("(");
40174 : PyObject *tail;
40175 : PyObject *joined;
40176 : swig_globalvar *var;
40177 : for (var = v->vars; var; var=var->next) {
40178 : tail = PyUnicode_FromString(var->name);
40179 : joined = PyUnicode_Concat(str, tail);
40180 : Py_DecRef(str);
40181 : Py_DecRef(tail);
40182 : str = joined;
40183 : if (var->next) {
40184 : tail = PyUnicode_InternFromString(", ");
40185 : joined = PyUnicode_Concat(str, tail);
40186 : Py_DecRef(str);
40187 : Py_DecRef(tail);
40188 : str = joined;
40189 : }
40190 : }
40191 : tail = PyUnicode_InternFromString(")");
40192 : joined = PyUnicode_Concat(str, tail);
40193 : Py_DecRef(str);
40194 : Py_DecRef(tail);
40195 : str = joined;
40196 : #else
40197 : PyObject *str = PyString_FromString("(");
40198 : swig_globalvar *var;
40199 : for (var = v->vars; var; var=var->next) {
40200 : PyString_ConcatAndDel(&str,PyString_FromString(var->name));
40201 : if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
40202 : }
40203 : PyString_ConcatAndDel(&str,PyString_FromString(")"));
40204 : #endif
40205 : return str;
40206 : }
40207 :
40208 : SWIGINTERN void
40209 : swig_varlink_dealloc(swig_varlinkobject *v) {
40210 : swig_globalvar *var = v->vars;
40211 : while (var) {
40212 : swig_globalvar *n = var->next;
40213 : free(var->name);
40214 : free(var);
40215 : var = n;
40216 : }
40217 : }
40218 :
40219 : SWIGINTERN PyObject *
40220 : swig_varlink_getattr(swig_varlinkobject *v, char *n) {
40221 : PyObject *res = NULL;
40222 : swig_globalvar *var = v->vars;
40223 : while (var) {
40224 : if (strcmp(var->name,n) == 0) {
40225 : res = (*var->get_attr)();
40226 : break;
40227 : }
40228 : var = var->next;
40229 : }
40230 : if (res == NULL && !PyErr_Occurred()) {
40231 : PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
40232 : }
40233 : return res;
40234 : }
40235 :
40236 : SWIGINTERN int
40237 : swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
40238 : int res = 1;
40239 : swig_globalvar *var = v->vars;
40240 : while (var) {
40241 : if (strcmp(var->name,n) == 0) {
40242 : res = (*var->set_attr)(p);
40243 : break;
40244 : }
40245 : var = var->next;
40246 : }
40247 : if (res == 1 && !PyErr_Occurred()) {
40248 : PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
40249 : }
40250 : return res;
40251 : }
40252 :
40253 : SWIGINTERN PyTypeObject*
40254 : swig_varlink_type(void) {
40255 : static char varlink__doc__[] = "Swig var link object";
40256 : static PyTypeObject varlink_type;
40257 : static int type_init = 0;
40258 : if (!type_init) {
40259 : const PyTypeObject tmp = {
40260 : #if PY_VERSION_HEX >= 0x03000000
40261 : PyVarObject_HEAD_INIT(NULL, 0)
40262 : #else
40263 : PyObject_HEAD_INIT(NULL)
40264 : 0, /* ob_size */
40265 : #endif
40266 : "swigvarlink", /* tp_name */
40267 : sizeof(swig_varlinkobject), /* tp_basicsize */
40268 : 0, /* tp_itemsize */
40269 : (destructor) swig_varlink_dealloc, /* tp_dealloc */
40270 : 0, /* tp_print */
40271 : (getattrfunc) swig_varlink_getattr, /* tp_getattr */
40272 : (setattrfunc) swig_varlink_setattr, /* tp_setattr */
40273 : 0, /* tp_compare */
40274 : (reprfunc) swig_varlink_repr, /* tp_repr */
40275 : 0, /* tp_as_number */
40276 : 0, /* tp_as_sequence */
40277 : 0, /* tp_as_mapping */
40278 : 0, /* tp_hash */
40279 : 0, /* tp_call */
40280 : (reprfunc) swig_varlink_str, /* tp_str */
40281 : 0, /* tp_getattro */
40282 : 0, /* tp_setattro */
40283 : 0, /* tp_as_buffer */
40284 : 0, /* tp_flags */
40285 : varlink__doc__, /* tp_doc */
40286 : 0, /* tp_traverse */
40287 : 0, /* tp_clear */
40288 : 0, /* tp_richcompare */
40289 : 0, /* tp_weaklistoffset */
40290 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
40291 : 0, /* tp_del */
40292 : 0, /* tp_version_tag */
40293 : #if PY_VERSION_HEX >= 0x03040000
40294 : 0, /* tp_finalize */
40295 : #endif
40296 : #ifdef COUNT_ALLOCS
40297 : 0, /* tp_allocs */
40298 : 0, /* tp_frees */
40299 : 0, /* tp_maxalloc */
40300 : 0, /* tp_prev */
40301 : 0 /* tp_next */
40302 : #endif
40303 : };
40304 : varlink_type = tmp;
40305 : type_init = 1;
40306 : if (PyType_Ready(&varlink_type) < 0)
40307 : return NULL;
40308 : }
40309 : return &varlink_type;
40310 : }
40311 :
40312 : /* Create a variable linking object for use later */
40313 : SWIGINTERN PyObject *
40314 : SWIG_Python_newvarlink(void) {
40315 : swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
40316 : if (result) {
40317 : result->vars = 0;
40318 : }
40319 : return ((PyObject*) result);
40320 : }
40321 :
40322 : SWIGINTERN void
40323 : SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
40324 : swig_varlinkobject *v = (swig_varlinkobject *) p;
40325 : swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
40326 : if (gv) {
40327 : size_t size = strlen(name)+1;
40328 : gv->name = (char *)malloc(size);
40329 : if (gv->name) {
40330 : memcpy(gv->name, name, size);
40331 : gv->get_attr = get_attr;
40332 : gv->set_attr = set_attr;
40333 : gv->next = v->vars;
40334 : }
40335 : }
40336 : v->vars = gv;
40337 : }
40338 :
40339 : SWIGINTERN PyObject *
40340 : SWIG_globals(void) {
40341 : static PyObject *globals = 0;
40342 : if (!globals) {
40343 : globals = SWIG_newvarlink();
40344 : }
40345 : return globals;
40346 : }
40347 :
40348 : /* -----------------------------------------------------------------------------
40349 : * constants/methods manipulation
40350 : * ----------------------------------------------------------------------------- */
40351 :
40352 : /* Install Constants */
40353 : SWIGINTERN void
40354 275 : SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
40355 275 : PyObject *obj = 0;
40356 275 : size_t i;
40357 550 : for (i = 0; constants[i].type; ++i) {
40358 275 : switch(constants[i].type) {
40359 275 : case SWIG_PY_POINTER:
40360 275 : obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
40361 275 : break;
40362 0 : case SWIG_PY_BINARY:
40363 0 : obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
40364 : break;
40365 : default:
40366 : obj = 0;
40367 : break;
40368 : }
40369 275 : if (obj) {
40370 275 : PyDict_SetItemString(d, constants[i].name, obj);
40371 275 : Py_DECREF(obj);
40372 : }
40373 : }
40374 275 : }
40375 :
40376 : /* -----------------------------------------------------------------------------*/
40377 : /* Fix SwigMethods to carry the callback ptrs when needed */
40378 : /* -----------------------------------------------------------------------------*/
40379 :
40380 : SWIGINTERN void
40381 275 : SWIG_Python_FixMethods(PyMethodDef *methods,
40382 : swig_const_info *const_table,
40383 : swig_type_info **types,
40384 : swig_type_info **types_initial) {
40385 275 : size_t i;
40386 119625 : for (i = 0; methods[i].ml_name; ++i) {
40387 119350 : const char *c = methods[i].ml_doc;
40388 119350 : if (!c) continue;
40389 112475 : c = strstr(c, "swig_ptr: ");
40390 112475 : if (c) {
40391 0 : int j;
40392 0 : swig_const_info *ci = 0;
40393 0 : const char *name = c + 10;
40394 0 : for (j = 0; const_table[j].type; ++j) {
40395 0 : if (strncmp(const_table[j].name, name,
40396 : strlen(const_table[j].name)) == 0) {
40397 : ci = &(const_table[j]);
40398 : break;
40399 : }
40400 : }
40401 0 : if (ci) {
40402 119350 : void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
40403 0 : if (ptr) {
40404 0 : size_t shift = (ci->ptype) - types;
40405 0 : swig_type_info *ty = types_initial[shift];
40406 0 : size_t ldoc = (c - methods[i].ml_doc);
40407 0 : size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
40408 0 : char *ndoc = (char*)malloc(ldoc + lptr + 10);
40409 0 : if (ndoc) {
40410 0 : char *buff = ndoc;
40411 0 : memcpy(buff, methods[i].ml_doc, ldoc);
40412 0 : buff += ldoc;
40413 0 : memcpy(buff, "swig_ptr: ", 10);
40414 0 : buff += 10;
40415 0 : SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
40416 0 : methods[i].ml_doc = ndoc;
40417 : }
40418 : }
40419 : }
40420 : }
40421 : }
40422 275 : }
40423 :
40424 : /* -----------------------------------------------------------------------------
40425 : * Method creation and docstring support functions
40426 : * ----------------------------------------------------------------------------- */
40427 :
40428 : /* -----------------------------------------------------------------------------
40429 : * Function to find the method definition with the correct docstring for the
40430 : * proxy module as opposed to the low-level API
40431 : * ----------------------------------------------------------------------------- */
40432 :
40433 0 : SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
40434 : /* Find the function in the modified method table */
40435 0 : size_t offset = 0;
40436 0 : int found = 0;
40437 0 : while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
40438 0 : if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
40439 : found = 1;
40440 : break;
40441 : }
40442 0 : offset++;
40443 : }
40444 : /* Use the copy with the modified docstring if available */
40445 0 : return found ? &SwigMethods_proxydocs[offset] : NULL;
40446 : }
40447 :
40448 : /* -----------------------------------------------------------------------------
40449 : * Wrapper of PyInstanceMethod_New() used in Python 3
40450 : * It is exported to the generated module, used for -fastproxy
40451 : * ----------------------------------------------------------------------------- */
40452 :
40453 0 : SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
40454 0 : if (PyCFunction_Check(func)) {
40455 0 : PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
40456 0 : PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
40457 0 : if (ml)
40458 0 : func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
40459 : }
40460 : #if PY_VERSION_HEX >= 0x03000000
40461 0 : return PyInstanceMethod_New(func);
40462 : #else
40463 : return PyMethod_New(func, NULL, NULL);
40464 : #endif
40465 : }
40466 :
40467 : /* -----------------------------------------------------------------------------
40468 : * Wrapper of PyStaticMethod_New()
40469 : * It is exported to the generated module, used for -fastproxy
40470 : * ----------------------------------------------------------------------------- */
40471 :
40472 : SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
40473 : if (PyCFunction_Check(func)) {
40474 : PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
40475 : PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
40476 : if (ml)
40477 : func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
40478 : }
40479 : return PyStaticMethod_New(func);
40480 : }
40481 :
40482 : #ifdef __cplusplus
40483 : }
40484 : #endif
40485 :
40486 : /* -----------------------------------------------------------------------------*
40487 : * Partial Init method
40488 : * -----------------------------------------------------------------------------*/
40489 :
40490 : #ifdef __cplusplus
40491 : extern "C"
40492 : #endif
40493 :
40494 : SWIGEXPORT
40495 : #if PY_VERSION_HEX >= 0x03000000
40496 : PyObject*
40497 : #else
40498 : void
40499 : #endif
40500 275 : SWIG_init(void) {
40501 275 : PyObject *m, *d, *md, *globals;
40502 :
40503 : #if PY_VERSION_HEX >= 0x03000000
40504 275 : static struct PyModuleDef SWIG_module = {
40505 : PyModuleDef_HEAD_INIT,
40506 : SWIG_name,
40507 : NULL,
40508 : -1,
40509 : SwigMethods,
40510 : NULL,
40511 : NULL,
40512 : NULL,
40513 : NULL
40514 : };
40515 : #endif
40516 :
40517 : #if defined(SWIGPYTHON_BUILTIN)
40518 : static SwigPyClientData SwigPyObject_clientdata = {
40519 : 0, 0, 0, 0, 0, 0, 0
40520 : };
40521 : static PyGetSetDef this_getset_def = {
40522 : (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
40523 : };
40524 : static SwigPyGetSet thisown_getset_closure = {
40525 : SwigPyObject_own,
40526 : SwigPyObject_own
40527 : };
40528 : static PyGetSetDef thisown_getset_def = {
40529 : (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
40530 : };
40531 : PyTypeObject *builtin_pytype;
40532 : int builtin_base_count;
40533 : swig_type_info *builtin_basetype;
40534 : PyObject *tuple;
40535 : PyGetSetDescrObject *static_getset;
40536 : PyTypeObject *metatype;
40537 : PyTypeObject *swigpyobject;
40538 : SwigPyClientData *cd;
40539 : PyObject *public_interface, *public_symbol;
40540 : PyObject *this_descr;
40541 : PyObject *thisown_descr;
40542 : PyObject *self = 0;
40543 : int i;
40544 :
40545 : (void)builtin_pytype;
40546 : (void)builtin_base_count;
40547 : (void)builtin_basetype;
40548 : (void)tuple;
40549 : (void)static_getset;
40550 : (void)self;
40551 :
40552 : /* Metaclass is used to implement static member variables */
40553 : metatype = SwigPyObjectType();
40554 : assert(metatype);
40555 : #endif
40556 :
40557 275 : (void)globals;
40558 :
40559 : /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
40560 275 : SWIG_This();
40561 275 : SWIG_Python_TypeCache();
40562 275 : SwigPyPacked_type();
40563 : #ifndef SWIGPYTHON_BUILTIN
40564 275 : SwigPyObject_type();
40565 : #endif
40566 :
40567 : /* Fix SwigMethods to carry the callback ptrs when needed */
40568 275 : SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
40569 :
40570 : #if PY_VERSION_HEX >= 0x03000000
40571 275 : m = PyModule_Create(&SWIG_module);
40572 : #else
40573 : m = Py_InitModule(SWIG_name, SwigMethods);
40574 : #endif
40575 :
40576 275 : md = d = PyModule_GetDict(m);
40577 275 : (void)md;
40578 :
40579 275 : SWIG_InitializeModule(0);
40580 :
40581 : #ifdef SWIGPYTHON_BUILTIN
40582 : swigpyobject = SwigPyObject_TypeOnce();
40583 :
40584 : SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
40585 : assert(SwigPyObject_stype);
40586 : cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
40587 : if (!cd) {
40588 : SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
40589 : SwigPyObject_clientdata.pytype = swigpyobject;
40590 : } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
40591 : PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
40592 : # if PY_VERSION_HEX >= 0x03000000
40593 : return NULL;
40594 : # else
40595 : return;
40596 : # endif
40597 : }
40598 :
40599 : /* All objects have a 'this' attribute */
40600 : this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
40601 : (void)this_descr;
40602 :
40603 : /* All objects have a 'thisown' attribute */
40604 : thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
40605 : (void)thisown_descr;
40606 :
40607 : public_interface = PyList_New(0);
40608 : public_symbol = 0;
40609 : (void)public_symbol;
40610 :
40611 : PyDict_SetItemString(md, "__all__", public_interface);
40612 : Py_DECREF(public_interface);
40613 : for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
40614 : SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
40615 : for (i = 0; swig_const_table[i].name != 0; ++i)
40616 : SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
40617 : #endif
40618 :
40619 275 : SWIG_InstallConstants(d,swig_const_table);
40620 :
40621 275 : SWIG_Python_SetConstant(d, "wkb25DBit",SWIG_From_int(static_cast< int >(0x80000000)));
40622 275 : SWIG_Python_SetConstant(d, "wkb25Bit",SWIG_From_int(static_cast< int >(0x80000000)));
40623 275 : SWIG_Python_SetConstant(d, "wkbUnknown",SWIG_From_int(static_cast< int >(0)));
40624 275 : SWIG_Python_SetConstant(d, "wkbPoint",SWIG_From_int(static_cast< int >(1)));
40625 275 : SWIG_Python_SetConstant(d, "wkbLineString",SWIG_From_int(static_cast< int >(2)));
40626 275 : SWIG_Python_SetConstant(d, "wkbPolygon",SWIG_From_int(static_cast< int >(3)));
40627 275 : SWIG_Python_SetConstant(d, "wkbMultiPoint",SWIG_From_int(static_cast< int >(4)));
40628 275 : SWIG_Python_SetConstant(d, "wkbMultiLineString",SWIG_From_int(static_cast< int >(5)));
40629 275 : SWIG_Python_SetConstant(d, "wkbMultiPolygon",SWIG_From_int(static_cast< int >(6)));
40630 275 : SWIG_Python_SetConstant(d, "wkbGeometryCollection",SWIG_From_int(static_cast< int >(7)));
40631 275 : SWIG_Python_SetConstant(d, "wkbCircularString",SWIG_From_int(static_cast< int >(8)));
40632 275 : SWIG_Python_SetConstant(d, "wkbCompoundCurve",SWIG_From_int(static_cast< int >(9)));
40633 275 : SWIG_Python_SetConstant(d, "wkbCurvePolygon",SWIG_From_int(static_cast< int >(10)));
40634 275 : SWIG_Python_SetConstant(d, "wkbMultiCurve",SWIG_From_int(static_cast< int >(11)));
40635 275 : SWIG_Python_SetConstant(d, "wkbMultiSurface",SWIG_From_int(static_cast< int >(12)));
40636 275 : SWIG_Python_SetConstant(d, "wkbCurve",SWIG_From_int(static_cast< int >(13)));
40637 275 : SWIG_Python_SetConstant(d, "wkbSurface",SWIG_From_int(static_cast< int >(14)));
40638 275 : SWIG_Python_SetConstant(d, "wkbPolyhedralSurface",SWIG_From_int(static_cast< int >(15)));
40639 275 : SWIG_Python_SetConstant(d, "wkbTIN",SWIG_From_int(static_cast< int >(16)));
40640 275 : SWIG_Python_SetConstant(d, "wkbTriangle",SWIG_From_int(static_cast< int >(17)));
40641 275 : SWIG_Python_SetConstant(d, "wkbNone",SWIG_From_int(static_cast< int >(100)));
40642 275 : SWIG_Python_SetConstant(d, "wkbLinearRing",SWIG_From_int(static_cast< int >(101)));
40643 275 : SWIG_Python_SetConstant(d, "wkbCircularStringZ",SWIG_From_int(static_cast< int >(1008)));
40644 275 : SWIG_Python_SetConstant(d, "wkbCompoundCurveZ",SWIG_From_int(static_cast< int >(1009)));
40645 275 : SWIG_Python_SetConstant(d, "wkbCurvePolygonZ",SWIG_From_int(static_cast< int >(1010)));
40646 275 : SWIG_Python_SetConstant(d, "wkbMultiCurveZ",SWIG_From_int(static_cast< int >(1011)));
40647 275 : SWIG_Python_SetConstant(d, "wkbMultiSurfaceZ",SWIG_From_int(static_cast< int >(1012)));
40648 275 : SWIG_Python_SetConstant(d, "wkbCurveZ",SWIG_From_int(static_cast< int >(1013)));
40649 275 : SWIG_Python_SetConstant(d, "wkbSurfaceZ",SWIG_From_int(static_cast< int >(1014)));
40650 275 : SWIG_Python_SetConstant(d, "wkbPolyhedralSurfaceZ",SWIG_From_int(static_cast< int >(1015)));
40651 275 : SWIG_Python_SetConstant(d, "wkbTINZ",SWIG_From_int(static_cast< int >(1016)));
40652 275 : SWIG_Python_SetConstant(d, "wkbTriangleZ",SWIG_From_int(static_cast< int >(1017)));
40653 275 : SWIG_Python_SetConstant(d, "wkbPointM",SWIG_From_int(static_cast< int >(2001)));
40654 275 : SWIG_Python_SetConstant(d, "wkbLineStringM",SWIG_From_int(static_cast< int >(2002)));
40655 275 : SWIG_Python_SetConstant(d, "wkbPolygonM",SWIG_From_int(static_cast< int >(2003)));
40656 275 : SWIG_Python_SetConstant(d, "wkbMultiPointM",SWIG_From_int(static_cast< int >(2004)));
40657 275 : SWIG_Python_SetConstant(d, "wkbMultiLineStringM",SWIG_From_int(static_cast< int >(2005)));
40658 275 : SWIG_Python_SetConstant(d, "wkbMultiPolygonM",SWIG_From_int(static_cast< int >(2006)));
40659 275 : SWIG_Python_SetConstant(d, "wkbGeometryCollectionM",SWIG_From_int(static_cast< int >(2007)));
40660 275 : SWIG_Python_SetConstant(d, "wkbCircularStringM",SWIG_From_int(static_cast< int >(2008)));
40661 275 : SWIG_Python_SetConstant(d, "wkbCompoundCurveM",SWIG_From_int(static_cast< int >(2009)));
40662 275 : SWIG_Python_SetConstant(d, "wkbCurvePolygonM",SWIG_From_int(static_cast< int >(2010)));
40663 275 : SWIG_Python_SetConstant(d, "wkbMultiCurveM",SWIG_From_int(static_cast< int >(2011)));
40664 275 : SWIG_Python_SetConstant(d, "wkbMultiSurfaceM",SWIG_From_int(static_cast< int >(2012)));
40665 275 : SWIG_Python_SetConstant(d, "wkbCurveM",SWIG_From_int(static_cast< int >(2013)));
40666 275 : SWIG_Python_SetConstant(d, "wkbSurfaceM",SWIG_From_int(static_cast< int >(2014)));
40667 275 : SWIG_Python_SetConstant(d, "wkbPolyhedralSurfaceM",SWIG_From_int(static_cast< int >(2015)));
40668 275 : SWIG_Python_SetConstant(d, "wkbTINM",SWIG_From_int(static_cast< int >(2016)));
40669 275 : SWIG_Python_SetConstant(d, "wkbTriangleM",SWIG_From_int(static_cast< int >(2017)));
40670 275 : SWIG_Python_SetConstant(d, "wkbPointZM",SWIG_From_int(static_cast< int >(3001)));
40671 275 : SWIG_Python_SetConstant(d, "wkbLineStringZM",SWIG_From_int(static_cast< int >(3002)));
40672 275 : SWIG_Python_SetConstant(d, "wkbPolygonZM",SWIG_From_int(static_cast< int >(3003)));
40673 275 : SWIG_Python_SetConstant(d, "wkbMultiPointZM",SWIG_From_int(static_cast< int >(3004)));
40674 275 : SWIG_Python_SetConstant(d, "wkbMultiLineStringZM",SWIG_From_int(static_cast< int >(3005)));
40675 275 : SWIG_Python_SetConstant(d, "wkbMultiPolygonZM",SWIG_From_int(static_cast< int >(3006)));
40676 275 : SWIG_Python_SetConstant(d, "wkbGeometryCollectionZM",SWIG_From_int(static_cast< int >(3007)));
40677 275 : SWIG_Python_SetConstant(d, "wkbCircularStringZM",SWIG_From_int(static_cast< int >(3008)));
40678 275 : SWIG_Python_SetConstant(d, "wkbCompoundCurveZM",SWIG_From_int(static_cast< int >(3009)));
40679 275 : SWIG_Python_SetConstant(d, "wkbCurvePolygonZM",SWIG_From_int(static_cast< int >(3010)));
40680 275 : SWIG_Python_SetConstant(d, "wkbMultiCurveZM",SWIG_From_int(static_cast< int >(3011)));
40681 275 : SWIG_Python_SetConstant(d, "wkbMultiSurfaceZM",SWIG_From_int(static_cast< int >(3012)));
40682 275 : SWIG_Python_SetConstant(d, "wkbCurveZM",SWIG_From_int(static_cast< int >(3013)));
40683 275 : SWIG_Python_SetConstant(d, "wkbSurfaceZM",SWIG_From_int(static_cast< int >(3014)));
40684 275 : SWIG_Python_SetConstant(d, "wkbPolyhedralSurfaceZM",SWIG_From_int(static_cast< int >(3015)));
40685 275 : SWIG_Python_SetConstant(d, "wkbTINZM",SWIG_From_int(static_cast< int >(3016)));
40686 275 : SWIG_Python_SetConstant(d, "wkbTriangleZM",SWIG_From_int(static_cast< int >(3017)));
40687 275 : SWIG_Python_SetConstant(d, "wkbPoint25D",SWIG_From_int(static_cast< int >(0x80000001)));
40688 275 : SWIG_Python_SetConstant(d, "wkbLineString25D",SWIG_From_int(static_cast< int >(0x80000002)));
40689 275 : SWIG_Python_SetConstant(d, "wkbPolygon25D",SWIG_From_int(static_cast< int >(0x80000003)));
40690 275 : SWIG_Python_SetConstant(d, "wkbMultiPoint25D",SWIG_From_int(static_cast< int >(0x80000004)));
40691 275 : SWIG_Python_SetConstant(d, "wkbMultiLineString25D",SWIG_From_int(static_cast< int >(0x80000005)));
40692 275 : SWIG_Python_SetConstant(d, "wkbMultiPolygon25D",SWIG_From_int(static_cast< int >(0x80000006)));
40693 275 : SWIG_Python_SetConstant(d, "wkbGeometryCollection25D",SWIG_From_int(static_cast< int >(0x80000007)));
40694 275 : SWIG_Python_SetConstant(d, "OFTInteger",SWIG_From_int(static_cast< int >(0)));
40695 275 : SWIG_Python_SetConstant(d, "OFTIntegerList",SWIG_From_int(static_cast< int >(1)));
40696 275 : SWIG_Python_SetConstant(d, "OFTReal",SWIG_From_int(static_cast< int >(2)));
40697 275 : SWIG_Python_SetConstant(d, "OFTRealList",SWIG_From_int(static_cast< int >(3)));
40698 275 : SWIG_Python_SetConstant(d, "OFTString",SWIG_From_int(static_cast< int >(4)));
40699 275 : SWIG_Python_SetConstant(d, "OFTStringList",SWIG_From_int(static_cast< int >(5)));
40700 275 : SWIG_Python_SetConstant(d, "OFTWideString",SWIG_From_int(static_cast< int >(6)));
40701 275 : SWIG_Python_SetConstant(d, "OFTWideStringList",SWIG_From_int(static_cast< int >(7)));
40702 275 : SWIG_Python_SetConstant(d, "OFTBinary",SWIG_From_int(static_cast< int >(8)));
40703 275 : SWIG_Python_SetConstant(d, "OFTDate",SWIG_From_int(static_cast< int >(9)));
40704 275 : SWIG_Python_SetConstant(d, "OFTTime",SWIG_From_int(static_cast< int >(10)));
40705 275 : SWIG_Python_SetConstant(d, "OFTDateTime",SWIG_From_int(static_cast< int >(11)));
40706 275 : SWIG_Python_SetConstant(d, "OFTInteger64",SWIG_From_int(static_cast< int >(12)));
40707 275 : SWIG_Python_SetConstant(d, "OFTInteger64List",SWIG_From_int(static_cast< int >(13)));
40708 275 : SWIG_Python_SetConstant(d, "OFSTNone",SWIG_From_int(static_cast< int >(0)));
40709 275 : SWIG_Python_SetConstant(d, "OFSTBoolean",SWIG_From_int(static_cast< int >(1)));
40710 275 : SWIG_Python_SetConstant(d, "OFSTInt16",SWIG_From_int(static_cast< int >(2)));
40711 275 : SWIG_Python_SetConstant(d, "OFSTFloat32",SWIG_From_int(static_cast< int >(3)));
40712 275 : SWIG_Python_SetConstant(d, "OFSTJSON",SWIG_From_int(static_cast< int >(4)));
40713 275 : SWIG_Python_SetConstant(d, "OFSTUUID",SWIG_From_int(static_cast< int >(5)));
40714 275 : SWIG_Python_SetConstant(d, "OJUndefined",SWIG_From_int(static_cast< int >(0)));
40715 275 : SWIG_Python_SetConstant(d, "OJLeft",SWIG_From_int(static_cast< int >(1)));
40716 275 : SWIG_Python_SetConstant(d, "OJRight",SWIG_From_int(static_cast< int >(2)));
40717 275 : SWIG_Python_SetConstant(d, "OFDT_CODED",SWIG_From_int(static_cast< int >(0)));
40718 275 : SWIG_Python_SetConstant(d, "OFDT_RANGE",SWIG_From_int(static_cast< int >(1)));
40719 275 : SWIG_Python_SetConstant(d, "OFDT_GLOB",SWIG_From_int(static_cast< int >(2)));
40720 275 : SWIG_Python_SetConstant(d, "OFDSP_DEFAULT_VALUE",SWIG_From_int(static_cast< int >(0)));
40721 275 : SWIG_Python_SetConstant(d, "OFDSP_DUPLICATE",SWIG_From_int(static_cast< int >(1)));
40722 275 : SWIG_Python_SetConstant(d, "OFDSP_GEOMETRY_RATIO",SWIG_From_int(static_cast< int >(2)));
40723 275 : SWIG_Python_SetConstant(d, "OFDMP_DEFAULT_VALUE",SWIG_From_int(static_cast< int >(0)));
40724 275 : SWIG_Python_SetConstant(d, "OFDMP_SUM",SWIG_From_int(static_cast< int >(1)));
40725 275 : SWIG_Python_SetConstant(d, "OFDMP_GEOMETRY_WEIGHTED",SWIG_From_int(static_cast< int >(2)));
40726 275 : SWIG_Python_SetConstant(d, "wkbXDR",SWIG_From_int(static_cast< int >(0)));
40727 275 : SWIG_Python_SetConstant(d, "wkbNDR",SWIG_From_int(static_cast< int >(1)));
40728 275 : SWIG_Python_SetConstant(d, "NullFID",SWIG_From_int(static_cast< int >(-1)));
40729 275 : SWIG_Python_SetConstant(d, "ALTER_NAME_FLAG",SWIG_From_int(static_cast< int >(1)));
40730 275 : SWIG_Python_SetConstant(d, "ALTER_TYPE_FLAG",SWIG_From_int(static_cast< int >(2)));
40731 275 : SWIG_Python_SetConstant(d, "ALTER_WIDTH_PRECISION_FLAG",SWIG_From_int(static_cast< int >(4)));
40732 275 : SWIG_Python_SetConstant(d, "ALTER_NULLABLE_FLAG",SWIG_From_int(static_cast< int >(8)));
40733 275 : SWIG_Python_SetConstant(d, "ALTER__FLAG",SWIG_From_int(static_cast< int >(8)));
40734 275 : SWIG_Python_SetConstant(d, "ALTER_DEFAULT_FLAG",SWIG_From_int(static_cast< int >(16)));
40735 275 : SWIG_Python_SetConstant(d, "ALTER_UNIQUE_FLAG",SWIG_From_int(static_cast< int >(32)));
40736 275 : SWIG_Python_SetConstant(d, "ALTER_DOMAIN_FLAG",SWIG_From_int(static_cast< int >(64)));
40737 275 : SWIG_Python_SetConstant(d, "ALTER_ALTERNATIVE_NAME_FLAG",SWIG_From_int(static_cast< int >(128)));
40738 275 : SWIG_Python_SetConstant(d, "ALTER_COMMENT_FLAG",SWIG_From_int(static_cast< int >(256)));
40739 275 : SWIG_Python_SetConstant(d, "ALTER_ALL_FLAG",SWIG_From_int(static_cast< int >(1+2+4+8+16+32+64+128+256)));
40740 275 : SWIG_Python_SetConstant(d, "ALTER_GEOM_FIELD_DEFN_NAME_FLAG",SWIG_From_int(static_cast< int >(4096)));
40741 275 : SWIG_Python_SetConstant(d, "ALTER_GEOM_FIELD_DEFN_TYPE_FLAG",SWIG_From_int(static_cast< int >(8192)));
40742 275 : SWIG_Python_SetConstant(d, "ALTER_GEOM_FIELD_DEFN_NULLABLE_FLAG",SWIG_From_int(static_cast< int >(16384)));
40743 275 : SWIG_Python_SetConstant(d, "ALTER_GEOM_FIELD_DEFN_SRS_FLAG",SWIG_From_int(static_cast< int >(32768)));
40744 275 : SWIG_Python_SetConstant(d, "ALTER_GEOM_FIELD_DEFN_SRS_COORD_EPOCH_FLAG",SWIG_From_int(static_cast< int >(65536)));
40745 275 : SWIG_Python_SetConstant(d, "ALTER_GEOM_FIELD_DEFN_ALL_FLAG",SWIG_From_int(static_cast< int >(4096+8192+16384+32768+65536)));
40746 275 : SWIG_Python_SetConstant(d, "F_VAL_NULL",SWIG_From_int(static_cast< int >(0x00000001)));
40747 275 : SWIG_Python_SetConstant(d, "F_VAL_GEOM_TYPE",SWIG_From_int(static_cast< int >(0x00000002)));
40748 275 : SWIG_Python_SetConstant(d, "F_VAL_WIDTH",SWIG_From_int(static_cast< int >(0x00000004)));
40749 275 : SWIG_Python_SetConstant(d, "F_VAL_ALLOW_NULL_WHEN_DEFAULT",SWIG_From_int(static_cast< int >(0x00000008)));
40750 275 : SWIG_Python_SetConstant(d, "F_VAL_ALL",SWIG_From_int(static_cast< int >(0xFFFFFFFF)));
40751 275 : SWIG_Python_SetConstant(d, "TZFLAG_UNKNOWN",SWIG_From_int(static_cast< int >(0)));
40752 275 : SWIG_Python_SetConstant(d, "TZFLAG_LOCALTIME",SWIG_From_int(static_cast< int >(1)));
40753 275 : SWIG_Python_SetConstant(d, "TZFLAG_MIXED_TZ",SWIG_From_int(static_cast< int >(2)));
40754 275 : SWIG_Python_SetConstant(d, "TZFLAG_UTC",SWIG_From_int(static_cast< int >(100)));
40755 275 : SWIG_Python_SetConstant(d, "GGT_COUNT_NOT_NEEDED",SWIG_From_int(static_cast< int >(0x1)));
40756 275 : SWIG_Python_SetConstant(d, "GGT_STOP_IF_MIXED",SWIG_From_int(static_cast< int >(0x2)));
40757 275 : SWIG_Python_SetConstant(d, "GGT_GEOMCOLLECTIONZ_TINZ",SWIG_From_int(static_cast< int >(0x4)));
40758 275 : SWIG_Python_SetConstant(d, "OLCRandomRead",SWIG_FromCharPtr("RandomRead"));
40759 275 : SWIG_Python_SetConstant(d, "OLCSequentialWrite",SWIG_FromCharPtr("SequentialWrite"));
40760 275 : SWIG_Python_SetConstant(d, "OLCRandomWrite",SWIG_FromCharPtr("RandomWrite"));
40761 275 : SWIG_Python_SetConstant(d, "OLCFastSpatialFilter",SWIG_FromCharPtr("FastSpatialFilter"));
40762 275 : SWIG_Python_SetConstant(d, "OLCFastFeatureCount",SWIG_FromCharPtr("FastFeatureCount"));
40763 275 : SWIG_Python_SetConstant(d, "OLCFastGetExtent",SWIG_FromCharPtr("FastGetExtent"));
40764 275 : SWIG_Python_SetConstant(d, "OLCFastGetExtent3D",SWIG_FromCharPtr("FastGetExtent3D"));
40765 275 : SWIG_Python_SetConstant(d, "OLCCreateField",SWIG_FromCharPtr("CreateField"));
40766 275 : SWIG_Python_SetConstant(d, "OLCDeleteField",SWIG_FromCharPtr("DeleteField"));
40767 275 : SWIG_Python_SetConstant(d, "OLCReorderFields",SWIG_FromCharPtr("ReorderFields"));
40768 275 : SWIG_Python_SetConstant(d, "OLCAlterFieldDefn",SWIG_FromCharPtr("AlterFieldDefn"));
40769 275 : SWIG_Python_SetConstant(d, "OLCAlterGeomFieldDefn",SWIG_FromCharPtr("AlterGeomFieldDefn"));
40770 275 : SWIG_Python_SetConstant(d, "OLCTransactions",SWIG_FromCharPtr("Transactions"));
40771 275 : SWIG_Python_SetConstant(d, "OLCDeleteFeature",SWIG_FromCharPtr("DeleteFeature"));
40772 275 : SWIG_Python_SetConstant(d, "OLCUpsertFeature",SWIG_FromCharPtr("UpsertFeature"));
40773 275 : SWIG_Python_SetConstant(d, "OLCUpdateFeature",SWIG_FromCharPtr("UpdateFeature"));
40774 275 : SWIG_Python_SetConstant(d, "OLCFastSetNextByIndex",SWIG_FromCharPtr("FastSetNextByIndex"));
40775 275 : SWIG_Python_SetConstant(d, "OLCStringsAsUTF8",SWIG_FromCharPtr("StringsAsUTF8"));
40776 275 : SWIG_Python_SetConstant(d, "OLCIgnoreFields",SWIG_FromCharPtr("IgnoreFields"));
40777 275 : SWIG_Python_SetConstant(d, "OLCCreateGeomField",SWIG_FromCharPtr("CreateGeomField"));
40778 275 : SWIG_Python_SetConstant(d, "OLCCurveGeometries",SWIG_FromCharPtr("CurveGeometries"));
40779 275 : SWIG_Python_SetConstant(d, "OLCMeasuredGeometries",SWIG_FromCharPtr("MeasuredGeometries"));
40780 275 : SWIG_Python_SetConstant(d, "OLCZGeometries",SWIG_FromCharPtr("ZGeometries"));
40781 275 : SWIG_Python_SetConstant(d, "OLCRename",SWIG_FromCharPtr("Rename"));
40782 275 : SWIG_Python_SetConstant(d, "OLCFastGetArrowStream",SWIG_FromCharPtr("FastGetArrowStream"));
40783 275 : SWIG_Python_SetConstant(d, "OLCFastWriteArrowBatch",SWIG_FromCharPtr("FastWriteArrowBatch"));
40784 275 : SWIG_Python_SetConstant(d, "ODsCCreateLayer",SWIG_FromCharPtr("CreateLayer"));
40785 275 : SWIG_Python_SetConstant(d, "ODsCDeleteLayer",SWIG_FromCharPtr("DeleteLayer"));
40786 275 : SWIG_Python_SetConstant(d, "ODsCCreateGeomFieldAfterCreateLayer",SWIG_FromCharPtr("CreateGeomFieldAfterCreateLayer"));
40787 275 : SWIG_Python_SetConstant(d, "ODsCCurveGeometries",SWIG_FromCharPtr("CurveGeometries"));
40788 275 : SWIG_Python_SetConstant(d, "ODsCTransactions",SWIG_FromCharPtr("Transactions"));
40789 275 : SWIG_Python_SetConstant(d, "ODsCEmulatedTransactions",SWIG_FromCharPtr("EmulatedTransactions"));
40790 275 : SWIG_Python_SetConstant(d, "ODsCMeasuredGeometries",SWIG_FromCharPtr("MeasuredGeometries"));
40791 275 : SWIG_Python_SetConstant(d, "ODsCZGeometries",SWIG_FromCharPtr("ZGeometries"));
40792 275 : SWIG_Python_SetConstant(d, "ODsCRandomLayerRead",SWIG_FromCharPtr("RandomLayerRead"));
40793 275 : SWIG_Python_SetConstant(d, "ODsCRandomLayerWrite",SWIG_FromCharPtr("RandomLayerWrite "));
40794 275 : SWIG_Python_SetConstant(d, "ODsCAddFieldDomain",SWIG_FromCharPtr("AddFieldDomain"));
40795 275 : SWIG_Python_SetConstant(d, "ODsCDeleteFieldDomain",SWIG_FromCharPtr("DeleteFieldDomain"));
40796 275 : SWIG_Python_SetConstant(d, "ODsCUpdateFieldDomain",SWIG_FromCharPtr("UpdateFieldDomain"));
40797 275 : SWIG_Python_SetConstant(d, "ODrCCreateDataSource",SWIG_FromCharPtr("CreateDataSource"));
40798 275 : SWIG_Python_SetConstant(d, "ODrCDeleteDataSource",SWIG_FromCharPtr("DeleteDataSource"));
40799 275 : SWIG_Python_SetConstant(d, "OLMD_FID64",SWIG_FromCharPtr("OLMD_FID64"));
40800 275 : SWIG_Python_SetConstant(d, "GEOS_PREC_NO_TOPO",SWIG_From_int(static_cast< int >(1)));
40801 275 : SWIG_Python_SetConstant(d, "GEOS_PREC_KEEP_COLLAPSED",SWIG_From_int(static_cast< int >(2)));
40802 275 : SWIG_Python_SetConstant(d, "OGRERR_NONE",SWIG_From_int(static_cast< int >(0)));
40803 275 : SWIG_Python_SetConstant(d, "OGRERR_NOT_ENOUGH_DATA",SWIG_From_int(static_cast< int >(1)));
40804 275 : SWIG_Python_SetConstant(d, "OGRERR_NOT_ENOUGH_MEMORY",SWIG_From_int(static_cast< int >(2)));
40805 275 : SWIG_Python_SetConstant(d, "OGRERR_UNSUPPORTED_GEOMETRY_TYPE",SWIG_From_int(static_cast< int >(3)));
40806 275 : SWIG_Python_SetConstant(d, "OGRERR_UNSUPPORTED_OPERATION",SWIG_From_int(static_cast< int >(4)));
40807 275 : SWIG_Python_SetConstant(d, "OGRERR_CORRUPT_DATA",SWIG_From_int(static_cast< int >(5)));
40808 275 : SWIG_Python_SetConstant(d, "OGRERR_FAILURE",SWIG_From_int(static_cast< int >(6)));
40809 275 : SWIG_Python_SetConstant(d, "OGRERR_UNSUPPORTED_SRS",SWIG_From_int(static_cast< int >(7)));
40810 275 : SWIG_Python_SetConstant(d, "OGRERR_INVALID_HANDLE",SWIG_From_int(static_cast< int >(8)));
40811 275 : SWIG_Python_SetConstant(d, "OGRERR_NON_EXISTING_FEATURE",SWIG_From_int(static_cast< int >(9)));
40812 :
40813 :
40814 275 : if ( OGRGetDriverCount() == 0 ) {
40815 0 : OGRRegisterAll();
40816 : }
40817 : // Will be turned on for GDAL 4.0
40818 : // UseExceptions();
40819 :
40820 :
40821 :
40822 :
40823 : /* Initialize threading */
40824 275 : SWIG_PYTHON_INITIALIZE_THREADS;
40825 : #if PY_VERSION_HEX >= 0x03000000
40826 275 : return m;
40827 : #else
40828 : return;
40829 : #endif
40830 : }
40831 :
|
