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 68332 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
449 68332 : if (ty) {
450 68332 : swig_cast_info *iter = ty->cast;
451 72286 : while (iter) {
452 72285 : if (strcmp(iter->type->name, c) == 0) {
453 68331 : if (iter == ty->cast)
454 : return iter;
455 : /* Move iter to the top of the linked list */
456 2832 : iter->prev->next = iter->next;
457 2832 : if (iter->next)
458 2719 : iter->next->prev = iter->prev;
459 2832 : iter->next = ty->cast;
460 2832 : iter->prev = 0;
461 2832 : if (ty->cast) ty->cast->prev = iter;
462 2832 : ty->cast = iter;
463 2832 : return iter;
464 : }
465 3954 : 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 68331 : SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
503 68331 : 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 377073 : 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 377073 : if (!type) return NULL;
539 377073 : if (type->str != NULL) {
540 : const char *last_name = type->str;
541 : const char *s;
542 8674020 : for (s = type->str; *s; s++)
543 8296950 : 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 12742 : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
571 12742 : SWIG_TypeClientData(ti, clientdata);
572 12742 : 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 53 : SWIG_MangledTypeQueryModule(swig_module_info *start,
585 : swig_module_info *end,
586 : const char *name) {
587 53 : swig_module_info *iter = start;
588 53 : do {
589 53 : if (iter->size) {
590 53 : size_t l = 0;
591 53 : size_t r = iter->size - 1;
592 265 : do {
593 : /* since l+r >= 0, we can (>> 1) instead (/ 2) */
594 265 : size_t i = (l + r) >> 1;
595 265 : const char *iname = iter->types[i]->name;
596 265 : if (iname) {
597 265 : int compare = strcmp(name, iname);
598 265 : if (compare == 0) {
599 53 : return iter->types[i];
600 212 : } else if (compare < 0) {
601 53 : if (i) {
602 53 : r = i - 1;
603 : } else {
604 : break;
605 : }
606 159 : } else if (compare > 0) {
607 159 : l = i + 1;
608 : }
609 : } else {
610 : break; /* should never happen */
611 : }
612 212 : } while (l <= r);
613 : }
614 0 : iter = iter->next;
615 0 : } 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 53 : 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 53 : swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
634 53 : 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 330 : SWIG_Python_str_FromChar(const char *c)
839 : {
840 : #if PY_VERSION_HEX >= 0x03000000
841 330 : 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 2640 : SWIG_Python_ErrorType(int code) {
868 2640 : PyObject* type = 0;
869 26 : 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 2446 : case SWIG_RuntimeError:
877 2446 : type = PyExc_RuntimeError;
878 0 : break;
879 0 : case SWIG_IndexError:
880 0 : type = PyExc_IndexError;
881 0 : break;
882 26 : case SWIG_TypeError:
883 26 : type = PyExc_TypeError;
884 26 : 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 168 : case SWIG_ValueError:
895 168 : 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 2446 : 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 1 : SWIG_Python_TypeErrorOccurred(PyObject *obj)
938 : {
939 1 : PyObject *error;
940 1 : if (obj)
941 : return 0;
942 1 : error = PyErr_Occurred();
943 1 : return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
944 : }
945 :
946 : SWIGRUNTIME void
947 1 : SWIG_Python_RaiseOrModifyTypeError(const char *message)
948 : {
949 1 : 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 1 : PyErr_SetString(PyExc_TypeError, message);
964 : }
965 1 : }
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 0 : void end() { if (status) { PyGILState_Release(state); status = false;} }
986 844018 : SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
987 31479 : ~SWIG_Python_Thread_Block() { end(); }
988 : };
989 : class SWIG_Python_Thread_Allow {
990 : bool status;
991 : PyThreadState *save;
992 : public:
993 8021300 : void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
994 8021300 : 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 2643 : SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1143 2643 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1144 2643 : PyErr_SetString(errtype, msg);
1145 2643 : SWIG_PYTHON_THREAD_END_BLOCK;
1146 2643 : }
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 10526 : SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1173 10526 : PyDict_SetItemString(d, name, obj);
1174 10526 : Py_DECREF(obj);
1175 10526 : }
1176 :
1177 : #endif
1178 :
1179 : /* Append a value to the result obj */
1180 :
1181 : SWIGINTERN PyObject*
1182 430677 : SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1183 430677 : if (!result) {
1184 : result = obj;
1185 430301 : } else if (result == Py_None) {
1186 417581 : Py_DECREF(result);
1187 : result = obj;
1188 : } else {
1189 12720 : if (!PyList_Check(result)) {
1190 11888 : PyObject *o2 = result;
1191 11888 : result = PyList_New(1);
1192 11888 : PyList_SetItem(result, 0, o2);
1193 : }
1194 12720 : PyList_Append(result,obj);
1195 12720 : Py_DECREF(obj);
1196 : }
1197 430677 : return result;
1198 : }
1199 :
1200 : /* Unpack the argument tuple */
1201 :
1202 : SWIGINTERN Py_ssize_t
1203 1482380 : SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1204 : {
1205 1482380 : if (!args) {
1206 117588 : 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 1364790 : if (!PyTuple_Check(args)) {
1215 12742 : if (min <= 1 && max >= 1) {
1216 12742 : Py_ssize_t i;
1217 12742 : objs[0] = args;
1218 12742 : 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 1352040 : Py_ssize_t l = PyTuple_GET_SIZE(args);
1227 1352040 : if (l < min) {
1228 0 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1229 : name, (min == max ? "" : "at least "), (int)min, (int)l);
1230 0 : return 0;
1231 1352040 : } 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 4806940 : for (i = 0; i < l; ++i) {
1238 3454900 : objs[i] = PyTuple_GET_ITEM(args, i);
1239 : }
1240 1746140 : for (; l < max; ++l) {
1241 394097 : objs[l] = 0;
1242 : }
1243 1352040 : 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 706430 : SWIG_Py_Void(void)
1282 : {
1283 706430 : PyObject *none = Py_None;
1284 0 : Py_INCREF(none);
1285 101081 : 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 12742 : SwigPyClientData_New(PyObject* obj)
1320 : {
1321 12742 : if (!obj) {
1322 : return 0;
1323 : } else {
1324 12742 : SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1325 : /* the klass element */
1326 12742 : data->klass = obj;
1327 12742 : Py_INCREF(data->klass);
1328 : /* the newraw method and newargs arguments used to create a new raw instance */
1329 12742 : if (PyClass_Check(obj)) {
1330 12742 : data->newraw = 0;
1331 12742 : data->newargs = obj;
1332 12742 : 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 12742 : data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
1346 12742 : if (PyErr_Occurred()) {
1347 1385 : PyErr_Clear();
1348 1385 : data->destroy = 0;
1349 : }
1350 12742 : if (data->destroy) {
1351 11357 : int flags;
1352 11357 : Py_INCREF(data->destroy);
1353 11357 : flags = PyCFunction_GET_FLAGS(data->destroy);
1354 11357 : data->delargs = !(flags & (METH_O));
1355 : } else {
1356 1385 : data->delargs = 0;
1357 : }
1358 12742 : data->implicitconv = 0;
1359 12742 : data->pytype = 0;
1360 12742 : return data;
1361 : }
1362 : }
1363 :
1364 : SWIGRUNTIME void
1365 14681 : SwigPyClientData_Del(SwigPyClientData *data) {
1366 14681 : Py_XDECREF(data->newraw);
1367 14681 : Py_XDECREF(data->newargs);
1368 14681 : Py_XDECREF(data->destroy);
1369 14681 : }
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 377073 : SwigPyObject_repr(SwigPyObject *v)
1443 : {
1444 377073 : const char *name = SWIG_TypePrettyName(v->ty);
1445 377073 : PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1446 377073 : 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 377073 : 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 2 : SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1470 : {
1471 2 : void *i = v->ptr;
1472 2 : void *j = w->ptr;
1473 2 : 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 2 : SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1479 : {
1480 2 : PyObject* res;
1481 2 : if( op != Py_EQ && op != Py_NE ) {
1482 0 : Py_INCREF(Py_NotImplemented);
1483 0 : return Py_NotImplemented;
1484 : }
1485 4 : res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1486 2 : 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 8623870 : SwigPyObject_type(void) {
1506 8623870 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1507 8623870 : 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 612626 : SwigPyObject_dealloc(PyObject *v)
1529 : {
1530 612626 : SwigPyObject *sobj = (SwigPyObject *) v;
1531 612626 : PyObject *next = sobj->next;
1532 612626 : if (sobj->own == SWIG_POINTER_OWN) {
1533 102302 : swig_type_info *ty = sobj->ty;
1534 102302 : SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1535 102302 : PyObject *destroy = data ? data->destroy : 0;
1536 102302 : if (destroy) {
1537 : /* destroy is always a VARARGS method */
1538 102302 : 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 102302 : PyObject *type = NULL, *value = NULL, *traceback = NULL;
1548 102302 : PyErr_Fetch(&type, &value, &traceback);
1549 :
1550 102302 : 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 102302 : PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1557 102302 : PyObject *mself = PyCFunction_GET_SELF(destroy);
1558 102302 : res = ((*meth)(mself, v));
1559 : }
1560 102302 : if (!res)
1561 0 : PyErr_WriteUnraisable(destroy);
1562 :
1563 102302 : PyErr_Restore(type, value, traceback);
1564 :
1565 204604 : 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 612626 : Py_XDECREF(next);
1575 612626 : PyObject_DEL(v);
1576 612626 : }
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 6292 : SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1605 : {
1606 6292 : SwigPyObject *sobj = (SwigPyObject *)v;
1607 6292 : sobj->own = 0;
1608 6292 : return SWIG_Py_Void();
1609 : }
1610 :
1611 : SWIGINTERN PyObject*
1612 619 : SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1613 : {
1614 619 : SwigPyObject *sobj = (SwigPyObject *)v;
1615 619 : sobj->own = SWIG_POINTER_OWN;
1616 619 : return SWIG_Py_Void();
1617 : }
1618 :
1619 : SWIGINTERN PyObject*
1620 10437 : SwigPyObject_own(PyObject *v, PyObject *args)
1621 : {
1622 10437 : PyObject *val = 0;
1623 10437 : if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
1624 : return NULL;
1625 : } else {
1626 10437 : SwigPyObject *sobj = (SwigPyObject *)v;
1627 10437 : PyObject *obj = PyBool_FromLong(sobj->own);
1628 10437 : if (val) {
1629 6911 : if (PyObject_IsTrue(val)) {
1630 619 : SwigPyObject_acquire(v,args);
1631 : } else {
1632 6292 : SwigPyObject_disown(v,args);
1633 : }
1634 : }
1635 10437 : 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 277 : SwigPyObject_TypeOnce(void) {
1652 277 : static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1653 :
1654 277 : 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 277 : static PyTypeObject swigpyobject_type;
1699 277 : static int type_init = 0;
1700 277 : if (!type_init) {
1701 277 : 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 277 : swigpyobject_type = tmp;
1770 277 : type_init = 1;
1771 277 : if (PyType_Ready(&swigpyobject_type) < 0)
1772 0 : return NULL;
1773 : }
1774 : return &swigpyobject_type;
1775 : }
1776 :
1777 : SWIGRUNTIME PyObject *
1778 612699 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1779 : {
1780 612699 : SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1781 612699 : if (sobj) {
1782 612699 : sobj->ptr = ptr;
1783 612699 : sobj->ty = ty;
1784 612699 : sobj->own = own;
1785 612699 : sobj->next = 0;
1786 : }
1787 612699 : 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 277 : SwigPyPacked_type(void) {
1836 277 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
1837 277 : 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 277 : SwigPyPacked_TypeOnce(void) {
1858 277 : static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1859 277 : static PyTypeObject swigpypacked_type;
1860 277 : static int type_init = 0;
1861 277 : if (!type_init) {
1862 277 : 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 277 : swigpypacked_type = tmp;
1931 277 : type_init = 1;
1932 277 : 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 3654320 : SWIG_This(void)
1978 : {
1979 3654320 : if (Swig_This_global == NULL)
1980 277 : Swig_This_global = SWIG_Python_str_FromChar("this");
1981 3654320 : 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 3755340 : SWIG_Python_GetSwigThis(PyObject *pyobj)
1993 : {
1994 3755360 : PyObject *obj;
1995 :
1996 3755360 : 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 3649360 : 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 3649360 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2039 3649360 : if (obj) {
2040 3642830 : Py_DECREF(obj);
2041 : } else {
2042 6530 : if (PyErr_Occurred()) PyErr_Clear();
2043 6530 : return 0;
2044 : }
2045 : #endif
2046 3642830 : 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 3771200 : SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2074 3771200 : int res;
2075 3771200 : SwigPyObject *sobj;
2076 3771200 : int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2077 :
2078 3771200 : if (!obj)
2079 : return SWIG_ERROR;
2080 3771200 : if (obj == Py_None && !implicit_conv) {
2081 20266 : if (ptr)
2082 20266 : *ptr = 0;
2083 40532 : return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
2084 : }
2085 :
2086 3750930 : res = SWIG_ERROR;
2087 :
2088 3750930 : sobj = SWIG_Python_GetSwigThis(obj);
2089 3750930 : if (own)
2090 0 : *own = 0;
2091 3750930 : while (sobj) {
2092 3748810 : void *vptr = sobj->ptr;
2093 3748810 : if (ty) {
2094 3748810 : swig_type_info *to = sobj->ty;
2095 3748810 : if (to == ty) {
2096 : /* no type cast needed */
2097 3680480 : if (ptr) *ptr = vptr;
2098 : break;
2099 : } else {
2100 68332 : swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2101 68332 : if (!tc) {
2102 1 : sobj = (SwigPyObject *)sobj->next;
2103 : } else {
2104 68331 : if (ptr) {
2105 68331 : int newmemory = 0;
2106 68331 : *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2107 68331 : 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 3750930 : if (sobj) {
2122 3748810 : if (own)
2123 0 : *own = *own | sobj->own;
2124 3748810 : if (flags & SWIG_POINTER_DISOWN) {
2125 108622 : sobj->own = 0;
2126 : }
2127 : res = SWIG_OK;
2128 : } else {
2129 2122 : 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 4409 : SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2281 : {
2282 4409 : 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 4409 : dict = PyObject_GetAttrString(inst, "__dict__");
2296 4409 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2297 4409 : Py_DECREF(dict);
2298 4409 : }
2299 :
2300 :
2301 : SWIGINTERN PyObject *
2302 4409 : SWIG_Python_InitShadowInstance(PyObject *args) {
2303 4409 : PyObject *obj[2];
2304 4409 : if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2305 : return NULL;
2306 : } else {
2307 4409 : SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2308 4409 : if (sthis) {
2309 0 : SwigPyObject_append((PyObject*) sthis, obj[1]);
2310 : } else {
2311 4409 : SWIG_Python_SetSwigThis(obj[0], obj[1]);
2312 : }
2313 4409 : return SWIG_Py_Void();
2314 : }
2315 : }
2316 :
2317 : /* Create a new pointer object */
2318 :
2319 : SWIGRUNTIME PyObject *
2320 630821 : SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2321 630821 : SwigPyClientData *clientdata;
2322 630821 : PyObject * robj;
2323 630821 : int own;
2324 :
2325 630821 : if (!ptr)
2326 18122 : return SWIG_Py_Void();
2327 :
2328 612699 : clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2329 612699 : own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2330 612699 : 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 612699 : assert(!(flags & SWIG_BUILTIN_TP_INIT));
2361 :
2362 612699 : robj = SwigPyObject_New(ptr, type, own);
2363 612699 : if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2364 607980 : PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2365 607980 : 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 277 : SWIG_Python_DestroyModule(PyObject *obj)
2406 : {
2407 277 : swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2408 277 : swig_type_info **types = swig_module->types;
2409 277 : size_t i;
2410 26315 : for (i =0; i < swig_module->size; ++i) {
2411 26038 : swig_type_info *ty = types[i];
2412 26038 : if (ty->owndata) {
2413 14681 : SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2414 14681 : if (data) SwigPyClientData_Del(data);
2415 : }
2416 : }
2417 277 : Py_DECREF(SWIG_This());
2418 277 : Swig_This_global = NULL;
2419 277 : }
2420 :
2421 : SWIGRUNTIME void
2422 277 : SWIG_Python_SetModule(swig_module_info *swig_module) {
2423 : #if PY_VERSION_HEX >= 0x03000000
2424 : /* Add a dummy module object into sys.modules */
2425 277 : 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 277 : PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2431 277 : if (pointer && module) {
2432 277 : PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2433 : } else {
2434 0 : Py_XDECREF(pointer);
2435 : }
2436 277 : }
2437 :
2438 : /* The python cached type query */
2439 : SWIGRUNTIME PyObject *
2440 330 : SWIG_Python_TypeCache(void) {
2441 330 : static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2442 330 : return cache;
2443 : }
2444 :
2445 : SWIGRUNTIME swig_type_info *
2446 53 : SWIG_Python_TypeQuery(const char *type)
2447 : {
2448 53 : PyObject *cache = SWIG_Python_TypeCache();
2449 53 : PyObject *key = SWIG_Python_str_FromChar(type);
2450 53 : PyObject *obj = PyDict_GetItem(cache, key);
2451 53 : swig_type_info *descriptor;
2452 53 : if (obj) {
2453 0 : descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2454 : } else {
2455 53 : swig_module_info *swig_module = SWIG_GetModule(0);
2456 53 : descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2457 53 : if (descriptor) {
2458 53 : obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2459 53 : PyDict_SetItem(cache, key, obj);
2460 53 : Py_DECREF(obj);
2461 : }
2462 : }
2463 53 : Py_DECREF(key);
2464 53 : 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_CPLErrorHandler swig_types[0]
2666 : #define SWIGTYPE_p_CPLVirtualMemShadow swig_types[1]
2667 : #define SWIGTYPE_p_CPLXMLNode swig_types[2]
2668 : #define SWIGTYPE_p_DirEntry swig_types[3]
2669 : #define SWIGTYPE_p_GByte swig_types[4]
2670 : #define SWIGTYPE_p_GDALAlgorithmArgHS swig_types[5]
2671 : #define SWIGTYPE_p_GDALAlgorithmHS swig_types[6]
2672 : #define SWIGTYPE_p_GDALAlgorithmRegistryHS swig_types[7]
2673 : #define SWIGTYPE_p_GDALArgDatasetValueHS swig_types[8]
2674 : #define SWIGTYPE_p_GDALAsyncReaderShadow swig_types[9]
2675 : #define SWIGTYPE_p_GDALAttributeHS swig_types[10]
2676 : #define SWIGTYPE_p_GDALBuildVRTOptions swig_types[11]
2677 : #define SWIGTYPE_p_GDALColorEntry swig_types[12]
2678 : #define SWIGTYPE_p_GDALColorTableShadow swig_types[13]
2679 : #define SWIGTYPE_p_GDALComputedRasterBandShadow swig_types[14]
2680 : #define SWIGTYPE_p_GDALContourOptions swig_types[15]
2681 : #define SWIGTYPE_p_GDALDEMProcessingOptions swig_types[16]
2682 : #define SWIGTYPE_p_GDALDatasetShadow swig_types[17]
2683 : #define SWIGTYPE_p_GDALDimensionHS swig_types[18]
2684 : #define SWIGTYPE_p_GDALDriverShadow swig_types[19]
2685 : #define SWIGTYPE_p_GDALEDTComponentHS swig_types[20]
2686 : #define SWIGTYPE_p_GDALExtendedDataTypeClass swig_types[21]
2687 : #define SWIGTYPE_p_GDALExtendedDataTypeHS swig_types[22]
2688 : #define SWIGTYPE_p_GDALExtendedDataTypeSubType swig_types[23]
2689 : #define SWIGTYPE_p_GDALFootprintOptions swig_types[24]
2690 : #define SWIGTYPE_p_GDALGridOptions swig_types[25]
2691 : #define SWIGTYPE_p_GDALGroupHS swig_types[26]
2692 : #define SWIGTYPE_p_GDALInfoOptions swig_types[27]
2693 : #define SWIGTYPE_p_GDALMDArrayHS swig_types[28]
2694 : #define SWIGTYPE_p_GDALMDArrayRawBlockInfo swig_types[29]
2695 : #define SWIGTYPE_p_GDALMajorObjectShadow swig_types[30]
2696 : #define SWIGTYPE_p_GDALMultiDimInfoOptions swig_types[31]
2697 : #define SWIGTYPE_p_GDALMultiDimTranslateOptions swig_types[32]
2698 : #define SWIGTYPE_p_GDALNearblackOptions swig_types[33]
2699 : #define SWIGTYPE_p_GDALProgressFunc swig_types[34]
2700 : #define SWIGTYPE_p_GDALRATDateTime swig_types[35]
2701 : #define SWIGTYPE_p_GDALRasterAlgebraBinaryOperation swig_types[36]
2702 : #define SWIGTYPE_p_GDALRasterAlgebraUnaryOperation swig_types[37]
2703 : #define SWIGTYPE_p_GDALRasterAttributeTableShadow swig_types[38]
2704 : #define SWIGTYPE_p_GDALRasterBandShadow swig_types[39]
2705 : #define SWIGTYPE_p_GDALRasterizeOptions swig_types[40]
2706 : #define SWIGTYPE_p_GDALRelationshipShadow swig_types[41]
2707 : #define SWIGTYPE_p_GDALSubdatasetInfo swig_types[42]
2708 : #define SWIGTYPE_p_GDALTileIndexOptions swig_types[43]
2709 : #define SWIGTYPE_p_GDALTransformerInfoShadow swig_types[44]
2710 : #define SWIGTYPE_p_GDALTranslateOptions swig_types[45]
2711 : #define SWIGTYPE_p_GDALVectorInfoOptions swig_types[46]
2712 : #define SWIGTYPE_p_GDALVectorTranslateOptions swig_types[47]
2713 : #define SWIGTYPE_p_GDALViewshedMode swig_types[48]
2714 : #define SWIGTYPE_p_GDALViewshedOutputType swig_types[49]
2715 : #define SWIGTYPE_p_GDALWarpAppOptions swig_types[50]
2716 : #define SWIGTYPE_p_GDAL_GCP swig_types[51]
2717 : #define SWIGTYPE_p_GIntBig swig_types[52]
2718 : #define SWIGTYPE_p_GUIntBig swig_types[53]
2719 : #define SWIGTYPE_p_OGRFeatureShadow swig_types[54]
2720 : #define SWIGTYPE_p_OGRFieldDomainShadow swig_types[55]
2721 : #define SWIGTYPE_p_OGRGeomFieldDefnShadow swig_types[56]
2722 : #define SWIGTYPE_p_OGRGeometryShadow swig_types[57]
2723 : #define SWIGTYPE_p_OGRLayerShadow swig_types[58]
2724 : #define SWIGTYPE_p_OGRStyleTableShadow swig_types[59]
2725 : #define SWIGTYPE_p_OSRSpatialReferenceShadow swig_types[60]
2726 : #define SWIGTYPE_p_StatBuf swig_types[61]
2727 : #define SWIGTYPE_p_Statistics swig_types[62]
2728 : #define SWIGTYPE_p_SuggestedWarpOutputRes swig_types[63]
2729 : #define SWIGTYPE_p_VSIDIR swig_types[64]
2730 : #define SWIGTYPE_p_VSILFILE swig_types[65]
2731 : #define SWIGTYPE_p_bool swig_types[66]
2732 : #define SWIGTYPE_p_char swig_types[67]
2733 : #define SWIGTYPE_p_double swig_types[68]
2734 : #define SWIGTYPE_p_f_double_p_q_const__char_p_void__int swig_types[69]
2735 : #define SWIGTYPE_p_int swig_types[70]
2736 : #define SWIGTYPE_p_long_long swig_types[71]
2737 : #define SWIGTYPE_p_p_GByte swig_types[72]
2738 : #define SWIGTYPE_p_p_GDALComputedRasterBandShadow swig_types[73]
2739 : #define SWIGTYPE_p_p_GDALDatasetShadow swig_types[74]
2740 : #define SWIGTYPE_p_p_GDALDimensionHS swig_types[75]
2741 : #define SWIGTYPE_p_p_GDALEDTComponentHS swig_types[76]
2742 : #define SWIGTYPE_p_p_GDALMDArrayHS swig_types[77]
2743 : #define SWIGTYPE_p_p_GDALRasterBandShadow swig_types[78]
2744 : #define SWIGTYPE_p_p_GDAL_GCP swig_types[79]
2745 : #define SWIGTYPE_p_p_GUIntBig swig_types[80]
2746 : #define SWIGTYPE_p_p_OGRLayerShadow swig_types[81]
2747 : #define SWIGTYPE_p_p_OSRSpatialReferenceShadow swig_types[82]
2748 : #define SWIGTYPE_p_p_char swig_types[83]
2749 : #define SWIGTYPE_p_p_double swig_types[84]
2750 : #define SWIGTYPE_p_p_int swig_types[85]
2751 : #define SWIGTYPE_p_p_long_long swig_types[86]
2752 : #define SWIGTYPE_p_p_p_GDALAttributeHS swig_types[87]
2753 : #define SWIGTYPE_p_p_p_GDALDimensionHS swig_types[88]
2754 : #define SWIGTYPE_p_p_p_GDALEDTComponentHS swig_types[89]
2755 : #define SWIGTYPE_p_p_p_GDALMDArrayHS swig_types[90]
2756 : #define SWIGTYPE_p_p_void swig_types[91]
2757 : #define SWIGTYPE_p_size_t swig_types[92]
2758 : #define SWIGTYPE_p_vsi_l_offset swig_types[93]
2759 : static swig_type_info *swig_types[95];
2760 : static swig_module_info swig_module = {swig_types, 94, 0, 0, 0, 0};
2761 : #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2762 : #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2763 :
2764 : /* -------- TYPES TABLE (END) -------- */
2765 :
2766 : #ifdef SWIG_TypeQuery
2767 : # undef SWIG_TypeQuery
2768 : #endif
2769 : #define SWIG_TypeQuery SWIG_Python_TypeQuery
2770 :
2771 : /*-----------------------------------------------
2772 : @(target):= _gdal.so
2773 : ------------------------------------------------*/
2774 : #if PY_VERSION_HEX >= 0x03000000
2775 : # define SWIG_init PyInit__gdal
2776 :
2777 : #else
2778 : # define SWIG_init init_gdal
2779 :
2780 : #endif
2781 : #define SWIG_name "_gdal"
2782 :
2783 : #define SWIGVERSION 0x040001
2784 : #define SWIG_VERSION SWIGVERSION
2785 :
2786 :
2787 : #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2788 : #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2789 :
2790 :
2791 : #include <stdexcept>
2792 :
2793 :
2794 : namespace swig {
2795 : class SwigPtr_PyObject {
2796 : protected:
2797 : PyObject *_obj;
2798 :
2799 : public:
2800 : SwigPtr_PyObject() :_obj(0)
2801 : {
2802 : }
2803 :
2804 : SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
2805 : {
2806 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
2807 : Py_XINCREF(_obj);
2808 : SWIG_PYTHON_THREAD_END_BLOCK;
2809 : }
2810 :
2811 : SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
2812 : {
2813 : if (initial_ref) {
2814 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
2815 : Py_XINCREF(_obj);
2816 : SWIG_PYTHON_THREAD_END_BLOCK;
2817 : }
2818 : }
2819 :
2820 : SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
2821 : {
2822 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
2823 : Py_XINCREF(item._obj);
2824 : Py_XDECREF(_obj);
2825 : _obj = item._obj;
2826 : SWIG_PYTHON_THREAD_END_BLOCK;
2827 : return *this;
2828 : }
2829 :
2830 : ~SwigPtr_PyObject()
2831 : {
2832 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
2833 : Py_XDECREF(_obj);
2834 : SWIG_PYTHON_THREAD_END_BLOCK;
2835 : }
2836 :
2837 : operator PyObject *() const
2838 : {
2839 : return _obj;
2840 : }
2841 :
2842 : PyObject *operator->() const
2843 : {
2844 : return _obj;
2845 : }
2846 : };
2847 : }
2848 :
2849 :
2850 : namespace swig {
2851 : struct SwigVar_PyObject : SwigPtr_PyObject {
2852 : SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
2853 :
2854 : SwigVar_PyObject & operator = (PyObject* obj)
2855 : {
2856 : Py_XDECREF(_obj);
2857 : _obj = obj;
2858 : return *this;
2859 : }
2860 : };
2861 : }
2862 :
2863 :
2864 : #include <iostream>
2865 : #include <vector>
2866 : using namespace std;
2867 :
2868 : #define CPL_SUPRESS_CPLUSPLUS
2869 :
2870 : // Suppress deprecation warning for GDALApplyVerticalShiftGrid
2871 : #define CPL_WARN_DEPRECATED_GDALApplyVerticalShiftGrid(x)
2872 :
2873 : #include "cpl_port.h"
2874 : #include "cpl_string.h"
2875 : #include "cpl_multiproc.h"
2876 : #include "cpl_http.h"
2877 : #include "cpl_vsi_error.h"
2878 :
2879 : #include "gdal.h"
2880 : #include "gdal_alg.h"
2881 :
2882 : #include "gdalwarper.h"
2883 : #include "ogr_srs_api.h"
2884 :
2885 : // From gdal_priv.h
2886 : void CPL_DLL GDALEnablePixelTypeSignedByteWarning(GDALRasterBandH hBand, bool b);
2887 :
2888 : typedef void GDALMajorObjectShadow;
2889 : typedef void GDALDriverShadow;
2890 : typedef void GDALDatasetShadow;
2891 : typedef void GDALRasterBandShadow;
2892 : typedef void GDALComputedRasterBandShadow;
2893 : typedef void GDALColorTableShadow;
2894 : typedef void GDALRasterAttributeTableShadow;
2895 : typedef void GDALSubdatasetInfoShadow;
2896 : typedef void GDALTransformerInfoShadow;
2897 : typedef void GDALAsyncReaderShadow;
2898 : typedef void GDALRelationshipShadow;
2899 :
2900 : typedef GDALExtendedDataTypeHS GDALExtendedDataTypeHS;
2901 : typedef GDALEDTComponentHS GDALEDTComponentHS;
2902 : typedef GDALGroupHS GDALGroupHS;
2903 : typedef GDALMDArrayHS GDALMDArrayHS;
2904 : typedef GDALAttributeHS GDALAttributeHS;
2905 : typedef GDALDimensionHS GDALDimensionHS;
2906 :
2907 :
2908 :
2909 : #ifdef DEBUG
2910 : typedef struct OGRSpatialReferenceHS OSRSpatialReferenceShadow;
2911 : typedef struct OGRLayerHS OGRLayerShadow;
2912 : typedef struct OGRFeatureHS OGRFeatureShadow;
2913 : typedef struct OGRGeometryHS OGRGeometryShadow;
2914 : #else
2915 : typedef void OSRSpatialReferenceShadow;
2916 : typedef void OGRLayerShadow;
2917 : typedef void OGRFeatureShadow;
2918 : typedef void OGRGeometryShadow;
2919 : #endif
2920 :
2921 : typedef struct OGRStyleTableHS OGRStyleTableShadow;
2922 : typedef struct OGRFieldDomainHS OGRFieldDomainShadow;
2923 : typedef struct OGRGeomFieldDefnHS OGRGeomFieldDefnShadow;
2924 :
2925 :
2926 : /* use this to not return the int returned by GDAL */
2927 : typedef int RETURN_NONE;
2928 : /* return value that is used for VSI methods that return -1 on error (and set errno) */
2929 : typedef int VSI_RETVAL;
2930 :
2931 :
2932 : SWIGINTERNINLINE PyObject*
2933 2550660 : SWIG_From_int (int value)
2934 : {
2935 2550660 : return PyInt_FromLong((long) value);
2936 : }
2937 :
2938 :
2939 65 : static int getAlignment(GDALDataType ntype)
2940 : {
2941 65 : switch(ntype)
2942 : {
2943 : case GDT_Unknown:
2944 : break; // shouldn't happen
2945 : case GDT_Byte:
2946 : case GDT_Int8:
2947 : return 1;
2948 : case GDT_Int16:
2949 : case GDT_UInt16:
2950 : case GDT_Float16:
2951 : return 2;
2952 : case GDT_Int32:
2953 : case GDT_UInt32:
2954 : case GDT_Float32:
2955 : return 4;
2956 : case GDT_Float64:
2957 : case GDT_Int64:
2958 : case GDT_UInt64:
2959 : return 8;
2960 : case GDT_CInt16:
2961 : case GDT_CFloat16:
2962 : return 2;
2963 : case GDT_CInt32:
2964 : case GDT_CFloat32:
2965 : return 4;
2966 : case GDT_CFloat64:
2967 : return 8;
2968 : case GDT_TypeCount:
2969 : break; // shouldn't happen
2970 : }
2971 : // shouldn't happen
2972 : CPLAssert(false);
2973 : return 1;
2974 : }
2975 :
2976 187007 : static bool readraster_acquirebuffer(void** buf,
2977 : void*& inputOutputBuf,
2978 : size_t buf_size,
2979 : GDALDataType ntype,
2980 : int l_bUseExceptions,
2981 : char*& data,
2982 : Py_buffer& view)
2983 : {
2984 374014 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
2985 :
2986 187007 : if( inputOutputBuf == Py_None )
2987 186867 : inputOutputBuf = NULL;
2988 :
2989 187007 : if( inputOutputBuf )
2990 : {
2991 75 : if (PyObject_GetBuffer( (PyObject*)inputOutputBuf, &view,
2992 : PyBUF_SIMPLE | PyBUF_WRITABLE) == 0)
2993 : {
2994 69 : if( static_cast<GUIntBig>(view.len) < buf_size )
2995 : {
2996 4 : PyBuffer_Release(&view);
2997 4 : SWIG_PYTHON_THREAD_END_BLOCK;
2998 4 : CPLError(CE_Failure, CPLE_AppDefined,
2999 : "buf_obj length is " CPL_FRMT_GUIB " bytes. "
3000 : "It should be at least " CPL_FRMT_GUIB,
3001 4 : static_cast<GUIntBig>(view.len),
3002 : static_cast<GUIntBig>(buf_size));
3003 : return false;
3004 : }
3005 65 : data = (char*)view.buf;
3006 124 : if( (reinterpret_cast<uintptr_t>(data) % getAlignment(ntype)) != 0 )
3007 : {
3008 29 : PyBuffer_Release(&view);
3009 29 : SWIG_PYTHON_THREAD_END_BLOCK;
3010 29 : CPLError(CE_Failure, CPLE_AppDefined,
3011 : "buffer has not the appropriate alignment");
3012 : return false;
3013 : }
3014 : }
3015 : else
3016 : {
3017 6 : PyErr_Clear();
3018 6 : SWIG_PYTHON_THREAD_END_BLOCK;
3019 6 : CPLError(CE_Failure, CPLE_AppDefined,
3020 : "buf_obj is not a simple writable buffer");
3021 : return false;
3022 : }
3023 : }
3024 : else
3025 : {
3026 186932 : *buf = (void *)PyByteArray_FromStringAndSize( NULL, buf_size );
3027 186932 : if (*buf == NULL)
3028 : {
3029 0 : *buf = Py_None;
3030 0 : if( !l_bUseExceptions )
3031 : {
3032 0 : PyErr_Clear();
3033 : }
3034 0 : SWIG_PYTHON_THREAD_END_BLOCK;
3035 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Cannot allocate result buffer");
3036 : return false;
3037 : }
3038 186932 : data = PyByteArray_AsString( (PyObject *)*buf );
3039 : }
3040 186968 : SWIG_PYTHON_THREAD_END_BLOCK;
3041 : return true;
3042 : }
3043 :
3044 186968 : static void readraster_releasebuffer(CPLErr eErr,
3045 : void** buf,
3046 : void* inputOutputBuf,
3047 : Py_buffer& view)
3048 : {
3049 186968 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3050 :
3051 186968 : if( inputOutputBuf )
3052 36 : PyBuffer_Release(&view);
3053 :
3054 186968 : if (eErr == CE_Failure)
3055 : {
3056 1335 : if( inputOutputBuf == NULL )
3057 1335 : Py_DECREF((PyObject*)*buf);
3058 1335 : *buf = NULL;
3059 : }
3060 185633 : else if( inputOutputBuf )
3061 : {
3062 36 : *buf = inputOutputBuf;
3063 36 : Py_INCREF((PyObject*)*buf);
3064 : }
3065 :
3066 186968 : SWIG_PYTHON_THREAD_END_BLOCK;
3067 186968 : }
3068 :
3069 :
3070 :
3071 : #define MODULE_NAME "gdal"
3072 :
3073 :
3074 : #include "cpl_string.h"
3075 : #include "cpl_conv.h"
3076 :
3077 : static int bUseExceptions=0;
3078 : static int bUserHasSpecifiedIfUsingExceptions = FALSE;
3079 : static thread_local int bUseExceptionsLocal = -1;
3080 :
3081 3026480 : struct PythonBindingErrorHandlerContext
3082 : {
3083 : std::string osInitialMsg{};
3084 : std::string osFailureMsg{};
3085 : CPLErrorNum nLastCode = CPLE_None;
3086 : bool bMemoryError = false;
3087 : };
3088 :
3089 : static void CPL_STDCALL
3090 22643 : PythonBindingErrorHandler(CPLErr eclass, CPLErrorNum err_no, const char *msg )
3091 : {
3092 22643 : PythonBindingErrorHandlerContext* ctxt = static_cast<
3093 22643 : PythonBindingErrorHandlerContext*>(CPLGetErrorHandlerUserData());
3094 :
3095 : /*
3096 : ** Generally we want to suppress error reporting if we have exceptions
3097 : ** enabled as the error message will be in the exception thrown in
3098 : ** Python.
3099 : */
3100 :
3101 : /* If the error class is CE_Fatal, we want to have a message issued
3102 : because the CPL support code does an abort() before any exception
3103 : can be generated */
3104 22643 : if (eclass == CE_Fatal ) {
3105 0 : CPLCallPreviousHandler(eclass, err_no, msg );
3106 : }
3107 :
3108 : /*
3109 : ** We do not want to interfere with non-failure messages since
3110 : ** they won't be translated into exceptions.
3111 : */
3112 22643 : else if (eclass != CE_Failure ) {
3113 19802 : CPLCallPreviousHandler(eclass, err_no, msg );
3114 : }
3115 : else {
3116 2841 : ctxt->nLastCode = err_no;
3117 2841 : try
3118 : {
3119 2841 : if( ctxt->osFailureMsg.empty() ) {
3120 2496 : ctxt->osFailureMsg = msg;
3121 2496 : ctxt->osInitialMsg = ctxt->osFailureMsg;
3122 : } else {
3123 345 : if( ctxt->osFailureMsg.size() < 10000 ) {
3124 690 : std::string osTmp(msg);
3125 345 : osTmp += "\nMay be caused by: ";
3126 345 : osTmp += ctxt->osFailureMsg;
3127 345 : ctxt->osFailureMsg = std::move(osTmp);
3128 345 : ctxt->osInitialMsg = ctxt->osFailureMsg;
3129 : }
3130 : else
3131 : {
3132 0 : std::string osTmp(msg);
3133 0 : osTmp += "\n[...]\nMay be caused by: ";
3134 0 : osTmp += ctxt->osInitialMsg;
3135 0 : ctxt->osFailureMsg = std::move(osTmp);
3136 : }
3137 : }
3138 : }
3139 0 : catch( const std::exception& )
3140 : {
3141 0 : ctxt->bMemoryError = true;
3142 : }
3143 : }
3144 22643 : }
3145 :
3146 :
3147 :
3148 :
3149 : static
3150 8274770 : int GetUseExceptions() {
3151 5958080 : return bUseExceptionsLocal >= 0 ? bUseExceptionsLocal : bUseExceptions;
3152 : }
3153 :
3154 11457 : static int _GetExceptionsLocal()
3155 : {
3156 11457 : return bUseExceptionsLocal;
3157 : }
3158 :
3159 22914 : static void _SetExceptionsLocal(int bVal)
3160 : {
3161 22914 : bUseExceptionsLocal = bVal;
3162 : }
3163 :
3164 : static
3165 29 : void _UseExceptions() {
3166 29 : CPLErrorReset();
3167 29 : bUserHasSpecifiedIfUsingExceptions = TRUE;
3168 29 : if( !bUseExceptions )
3169 : {
3170 26 : bUseExceptions = 1;
3171 : }
3172 : }
3173 :
3174 : static
3175 5 : void _DontUseExceptions() {
3176 5 : CPLErrorReset();
3177 5 : bUserHasSpecifiedIfUsingExceptions = TRUE;
3178 5 : if( bUseExceptions )
3179 : {
3180 0 : bUseExceptions = 0;
3181 : }
3182 : }
3183 :
3184 58651 : static int _UserHasSpecifiedIfUsingExceptions()
3185 : {
3186 1597 : return bUserHasSpecifiedIfUsingExceptions || bUseExceptionsLocal >= 0;
3187 : }
3188 :
3189 :
3190 :
3191 : #include <limits.h>
3192 : #if !defined(SWIG_NO_LLONG_MAX)
3193 : # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3194 : # define LLONG_MAX __LONG_LONG_MAX__
3195 : # define LLONG_MIN (-LLONG_MAX - 1LL)
3196 : # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3197 : # endif
3198 : #endif
3199 :
3200 :
3201 : SWIGINTERN int
3202 1058300 : SWIG_AsVal_double (PyObject *obj, double *val)
3203 : {
3204 1058300 : int res = SWIG_TypeError;
3205 1058300 : if (PyFloat_Check(obj)) {
3206 40491 : if (val) *val = PyFloat_AsDouble(obj);
3207 40491 : return SWIG_OK;
3208 : #if PY_VERSION_HEX < 0x03000000
3209 : } else if (PyInt_Check(obj)) {
3210 : if (val) *val = (double) PyInt_AsLong(obj);
3211 : return SWIG_OK;
3212 : #endif
3213 1017810 : } else if (PyLong_Check(obj)) {
3214 1017810 : double v = PyLong_AsDouble(obj);
3215 1017810 : if (!PyErr_Occurred()) {
3216 1017810 : if (val) *val = v;
3217 1017810 : return SWIG_OK;
3218 : } else {
3219 0 : PyErr_Clear();
3220 : }
3221 : }
3222 : #ifdef SWIG_PYTHON_CAST_MODE
3223 : {
3224 : int dispatch = 0;
3225 : double d = PyFloat_AsDouble(obj);
3226 : if (!PyErr_Occurred()) {
3227 : if (val) *val = d;
3228 : return SWIG_AddCast(SWIG_OK);
3229 : } else {
3230 : PyErr_Clear();
3231 : }
3232 : if (!dispatch) {
3233 : long v = PyLong_AsLong(obj);
3234 : if (!PyErr_Occurred()) {
3235 : if (val) *val = v;
3236 : return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3237 : } else {
3238 : PyErr_Clear();
3239 : }
3240 : }
3241 : }
3242 : #endif
3243 : return res;
3244 : }
3245 :
3246 :
3247 : #include <float.h>
3248 :
3249 :
3250 : #include <math.h>
3251 :
3252 :
3253 : SWIGINTERNINLINE int
3254 : SWIG_CanCastAsInteger(double *d, double min, double max) {
3255 : double x = *d;
3256 : if ((min <= x && x <= max)) {
3257 : double fx = floor(x);
3258 : double cx = ceil(x);
3259 : double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3260 : if ((errno == EDOM) || (errno == ERANGE)) {
3261 : errno = 0;
3262 : } else {
3263 : double summ, reps, diff;
3264 : if (rd < x) {
3265 : diff = x - rd;
3266 : } else if (rd > x) {
3267 : diff = rd - x;
3268 : } else {
3269 : return 1;
3270 : }
3271 : summ = rd + x;
3272 : reps = diff/summ;
3273 : if (reps < 8*DBL_EPSILON) {
3274 : *d = rd;
3275 : return 1;
3276 : }
3277 : }
3278 : }
3279 : return 0;
3280 : }
3281 :
3282 :
3283 : SWIGINTERN int
3284 2630610 : SWIG_AsVal_long (PyObject *obj, long* val)
3285 : {
3286 : #if PY_VERSION_HEX < 0x03000000
3287 : if (PyInt_Check(obj)) {
3288 : if (val) *val = PyInt_AsLong(obj);
3289 : return SWIG_OK;
3290 : } else
3291 : #endif
3292 2630610 : if (PyLong_Check(obj)) {
3293 2630600 : long v = PyLong_AsLong(obj);
3294 2630600 : if (!PyErr_Occurred()) {
3295 2630600 : if (val) *val = v;
3296 2630600 : return SWIG_OK;
3297 : } else {
3298 0 : PyErr_Clear();
3299 0 : return SWIG_OverflowError;
3300 : }
3301 : }
3302 : #ifdef SWIG_PYTHON_CAST_MODE
3303 : {
3304 : int dispatch = 0;
3305 : long v = PyInt_AsLong(obj);
3306 : if (!PyErr_Occurred()) {
3307 : if (val) *val = v;
3308 : return SWIG_AddCast(SWIG_OK);
3309 : } else {
3310 : PyErr_Clear();
3311 : }
3312 : if (!dispatch) {
3313 : double d;
3314 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3315 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3316 : if (val) *val = (long)(d);
3317 : return res;
3318 : }
3319 : }
3320 : }
3321 : #endif
3322 : return SWIG_TypeError;
3323 : }
3324 :
3325 :
3326 : SWIGINTERN int
3327 2621930 : SWIG_AsVal_int (PyObject * obj, int *val)
3328 : {
3329 2621930 : long v;
3330 5243860 : int res = SWIG_AsVal_long (obj, &v);
3331 2621930 : if (SWIG_IsOK(res)) {
3332 2621920 : if ((v < INT_MIN || v > INT_MAX)) {
3333 : return SWIG_OverflowError;
3334 : } else {
3335 2613230 : if (val) *val = static_cast< int >(v);
3336 : }
3337 : }
3338 : return res;
3339 : }
3340 :
3341 :
3342 : /* Completely unrelated: just to avoid Coverity warnings */
3343 :
3344 : static int bReturnSame = 1;
3345 :
3346 0 : void NeverCallMePlease() {
3347 0 : bReturnSame = 0;
3348 0 : }
3349 :
3350 : /* Some SWIG code generates dead code, which Coverity warns about */
3351 4539590 : template<class T> static T ReturnSame(T x)
3352 : {
3353 4539590 : if( bReturnSame )
3354 : return x;
3355 : return 0;
3356 : }
3357 :
3358 3026480 : static void pushErrorHandler()
3359 : {
3360 3026480 : CPLErrorReset();
3361 3026480 : PythonBindingErrorHandlerContext* ctxt = new PythonBindingErrorHandlerContext();
3362 3026480 : CPLPushErrorHandlerEx(PythonBindingErrorHandler, ctxt);
3363 3026480 : }
3364 :
3365 3026480 : static void popErrorHandler()
3366 : {
3367 3026480 : PythonBindingErrorHandlerContext* ctxt = static_cast<
3368 3026480 : PythonBindingErrorHandlerContext*>(CPLGetErrorHandlerUserData());
3369 3026480 : CPLPopErrorHandler();
3370 3026480 : if( ctxt->bMemoryError )
3371 : {
3372 0 : CPLErrorSetState(
3373 : CE_Failure, CPLE_OutOfMemory, "Out of memory");
3374 : }
3375 3026480 : else if( !ctxt->osFailureMsg.empty() )
3376 : {
3377 2510 : CPLErrorSetState(
3378 2496 : CPLGetLastErrorType() == CE_Failure ? CE_Failure: CE_Warning,
3379 : ctxt->nLastCode, ctxt->osFailureMsg.c_str());
3380 : }
3381 3026480 : delete ctxt;
3382 3026480 : }
3383 :
3384 :
3385 :
3386 :
3387 : /* Return a PyObject* from a NULL terminated C String */
3388 : static PyObject* GDALPythonObjectFromCStr(const char *pszStr) CPL_UNUSED;
3389 116992 : static PyObject* GDALPythonObjectFromCStr(const char *pszStr)
3390 : {
3391 116992 : const unsigned char* pszIter = (const unsigned char*) pszStr;
3392 16817600 : while(*pszIter != 0)
3393 : {
3394 16700700 : if (*pszIter > 127)
3395 : {
3396 112 : PyObject* pyObj = PyUnicode_DecodeUTF8(pszStr, strlen(pszStr), "strict");
3397 112 : if (pyObj != NULL && !PyErr_Occurred())
3398 : return pyObj;
3399 1 : PyErr_Clear();
3400 1 : return PyBytes_FromString(pszStr);
3401 : }
3402 16700600 : pszIter ++;
3403 : }
3404 116880 : return PyUnicode_FromString(pszStr);
3405 : }
3406 :
3407 : /* Return a NULL terminated c String from a PyObject */
3408 : /* Result must be freed with GDALPythonFreeCStr */
3409 : static char* GDALPythonObjectToCStr(PyObject* pyObject, int* pbToFree) CPL_UNUSED;
3410 99834 : static char* GDALPythonObjectToCStr(PyObject* pyObject, int* pbToFree)
3411 : {
3412 99834 : *pbToFree = 0;
3413 99834 : if (PyUnicode_Check(pyObject))
3414 : {
3415 99832 : char *pszStr;
3416 99832 : char *pszNewStr;
3417 99832 : Py_ssize_t nLen;
3418 99832 : PyObject* pyUTF8Str = PyUnicode_AsUTF8String(pyObject);
3419 99832 : if( pyUTF8Str == NULL )
3420 : return NULL;
3421 99832 : PyBytes_AsStringAndSize(pyUTF8Str, &pszStr, &nLen);
3422 99832 : pszNewStr = (char *) malloc(nLen+1);
3423 99832 : if( pszNewStr == NULL )
3424 : {
3425 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Failed to allocate %llu bytes",
3426 : (unsigned long long)(nLen + 1));
3427 0 : Py_XDECREF(pyUTF8Str);
3428 0 : return NULL;
3429 : }
3430 99832 : memcpy(pszNewStr, pszStr, nLen+1);
3431 99832 : Py_XDECREF(pyUTF8Str);
3432 99832 : *pbToFree = 1;
3433 99832 : return pszNewStr;
3434 : }
3435 2 : else if( PyBytes_Check(pyObject) )
3436 : {
3437 2 : char* ret = PyBytes_AsString(pyObject);
3438 :
3439 : // Check if there are \0 bytes inside the string
3440 2 : const Py_ssize_t size = PyBytes_Size(pyObject);
3441 24 : for( Py_ssize_t i = 0; i < size; i++ )
3442 : {
3443 23 : if( ret[i] == 0 )
3444 : {
3445 1 : CPLError(CE_Failure, CPLE_AppDefined,
3446 : "bytes object cast as string contains a zero-byte.");
3447 1 : return NULL;
3448 : }
3449 : }
3450 :
3451 : return ret;
3452 : }
3453 : else
3454 : {
3455 0 : CPLError(CE_Failure, CPLE_AppDefined,
3456 : "Passed object is neither of type string nor bytes");
3457 0 : return NULL;
3458 : }
3459 : }
3460 :
3461 : static char * GDALPythonPathToCStr(PyObject* pyObject, int* pbToFree) CPL_UNUSED;
3462 11503 : static char * GDALPythonPathToCStr(PyObject* pyObject, int* pbToFree)
3463 : {
3464 11503 : PyObject* os = PyImport_ImportModule("os");
3465 11503 : if (os == NULL)
3466 : {
3467 : return NULL;
3468 : }
3469 :
3470 11503 : PyObject* pathLike = PyObject_GetAttrString(os, "PathLike");
3471 11503 : if (pathLike == NULL)
3472 : {
3473 0 : Py_DECREF(os);
3474 0 : return NULL;
3475 : }
3476 :
3477 11503 : if (!PyObject_IsInstance(pyObject, pathLike))
3478 : {
3479 4 : Py_DECREF(pathLike);
3480 4 : Py_DECREF(os);
3481 4 : return NULL;
3482 : }
3483 :
3484 11499 : PyObject* str = PyObject_Str(pyObject);
3485 11499 : char* ret = NULL;
3486 11499 : if (str != NULL)
3487 : {
3488 11499 : ret = GDALPythonObjectToCStr(str, pbToFree);
3489 11499 : Py_DECREF(str);
3490 : }
3491 :
3492 11499 : Py_DECREF(pathLike);
3493 11499 : Py_DECREF(os);
3494 :
3495 : return ret;
3496 : }
3497 :
3498 :
3499 : static void GDALPythonFreeCStr(void* ptr, int bToFree) CPL_UNUSED;
3500 99838 : static void GDALPythonFreeCStr(void* ptr, int bToFree)
3501 : {
3502 99838 : if (bToFree)
3503 99832 : free(ptr);
3504 : }
3505 :
3506 :
3507 :
3508 27525 : unsigned int wrapper_VSIFReadL( void **buf, unsigned int nMembSize, unsigned int nMembCount, VSILFILE *fp)
3509 : {
3510 27525 : size_t buf_size = static_cast<size_t>(nMembSize) * nMembCount;
3511 27525 : if( buf_size > 0xFFFFFFFFU )
3512 : {
3513 0 : CPLError(CE_Failure, CPLE_AppDefined, "Too big request");
3514 0 : *buf = NULL;
3515 0 : return 0;
3516 : }
3517 :
3518 27525 : if (buf_size == 0)
3519 : {
3520 12 : *buf = NULL;
3521 12 : return 0;
3522 : }
3523 :
3524 55038 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3525 27513 : *buf = (void *)PyByteArray_FromStringAndSize( NULL, buf_size );
3526 27513 : if (*buf == NULL)
3527 : {
3528 0 : *buf = Py_None;
3529 0 : if( !GetUseExceptions() )
3530 : {
3531 0 : PyErr_Clear();
3532 : }
3533 0 : SWIG_PYTHON_THREAD_END_BLOCK;
3534 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Cannot allocate result buffer");
3535 : return 0;
3536 : }
3537 27513 : PyObject* o = (PyObject*) *buf;
3538 27513 : char *data = PyByteArray_AsString(o);
3539 27513 : SWIG_PYTHON_THREAD_END_BLOCK;
3540 27513 : size_t nRet = (size_t)VSIFReadL( data, nMembSize, nMembCount, fp );
3541 27513 : if (nRet * (size_t)nMembSize < buf_size)
3542 : {
3543 11149 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3544 11149 : PyByteArray_Resize(o, nRet * nMembSize);
3545 11149 : SWIG_PYTHON_THREAD_END_BLOCK;
3546 11149 : *buf = o;
3547 : }
3548 27513 : return static_cast<unsigned int>(nRet);
3549 : }
3550 :
3551 :
3552 : SWIGINTERN int
3553 59263 : SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3554 : {
3555 : #if PY_VERSION_HEX < 0x03000000
3556 : if (PyInt_Check(obj)) {
3557 : long v = PyInt_AsLong(obj);
3558 : if (v >= 0) {
3559 : if (val) *val = v;
3560 : return SWIG_OK;
3561 : } else {
3562 : return SWIG_OverflowError;
3563 : }
3564 : } else
3565 : #endif
3566 59263 : if (PyLong_Check(obj)) {
3567 59263 : unsigned long v = PyLong_AsUnsignedLong(obj);
3568 59263 : if (!PyErr_Occurred()) {
3569 59263 : if (val) *val = v;
3570 59263 : return SWIG_OK;
3571 : } else {
3572 0 : PyErr_Clear();
3573 0 : return SWIG_OverflowError;
3574 : }
3575 : }
3576 : #ifdef SWIG_PYTHON_CAST_MODE
3577 : {
3578 : int dispatch = 0;
3579 : unsigned long v = PyLong_AsUnsignedLong(obj);
3580 : if (!PyErr_Occurred()) {
3581 : if (val) *val = v;
3582 : return SWIG_AddCast(SWIG_OK);
3583 : } else {
3584 : PyErr_Clear();
3585 : }
3586 : if (!dispatch) {
3587 : double d;
3588 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3589 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3590 : if (val) *val = (unsigned long)(d);
3591 : return res;
3592 : }
3593 : }
3594 : }
3595 : #endif
3596 : return SWIG_TypeError;
3597 : }
3598 :
3599 :
3600 : SWIGINTERN int
3601 58991 : SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3602 : {
3603 58991 : unsigned long v;
3604 117982 : int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3605 58991 : if (SWIG_IsOK(res)) {
3606 58991 : if ((v > UINT_MAX)) {
3607 : return SWIG_OverflowError;
3608 : } else {
3609 58991 : if (val) *val = static_cast< unsigned int >(v);
3610 : }
3611 : }
3612 : return res;
3613 : }
3614 :
3615 :
3616 : SWIGINTERNINLINE PyObject*
3617 27525 : SWIG_From_unsigned_SS_int (unsigned int value)
3618 : {
3619 27525 : return PyInt_FromSize_t((size_t) value);
3620 : }
3621 :
3622 :
3623 2 : void wrapper_VSIGetMemFileBuffer(const char *utf8_path, GByte **out, vsi_l_offset *length)
3624 : {
3625 2 : *out = VSIGetMemFileBuffer(utf8_path, length, 0);
3626 2 : }
3627 :
3628 :
3629 : SWIGINTERN swig_type_info*
3630 10221 : SWIG_pchar_descriptor(void)
3631 : {
3632 10221 : static int init = 0;
3633 10221 : static swig_type_info* info = 0;
3634 10221 : if (!init) {
3635 53 : info = SWIG_TypeQuery("_p_char");
3636 53 : init = 1;
3637 : }
3638 10221 : return info;
3639 : }
3640 :
3641 :
3642 : SWIGINTERN int
3643 588409 : SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3644 : {
3645 : #if PY_VERSION_HEX>=0x03000000
3646 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3647 : if (PyBytes_Check(obj))
3648 : #else
3649 588409 : if (PyUnicode_Check(obj))
3650 : #endif
3651 : #else
3652 : if (PyString_Check(obj))
3653 : #endif
3654 : {
3655 578188 : char *cstr; Py_ssize_t len;
3656 578188 : int ret = SWIG_OK;
3657 : #if PY_VERSION_HEX>=0x03000000
3658 : #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3659 578188 : if (!alloc && cptr) {
3660 : /* We can't allow converting without allocation, since the internal
3661 : representation of string in Python 3 is UCS-2/UCS-4 but we require
3662 : a UTF-8 representation.
3663 : TODO(bhy) More detailed explanation */
3664 : return SWIG_RuntimeError;
3665 : }
3666 578188 : obj = PyUnicode_AsUTF8String(obj); if (!obj) return SWIG_TypeError;
3667 578188 : if (!obj)
3668 : return SWIG_TypeError;
3669 578188 : if (alloc)
3670 578052 : *alloc = SWIG_NEWOBJ;
3671 : #endif
3672 578188 : PyBytes_AsStringAndSize(obj, &cstr, &len);
3673 : #else
3674 : PyString_AsStringAndSize(obj, &cstr, &len);
3675 : #endif
3676 578188 : if (cptr) {
3677 578052 : if (alloc) {
3678 578052 : if (*alloc == SWIG_NEWOBJ) {
3679 578052 : *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
3680 578052 : *alloc = SWIG_NEWOBJ;
3681 : } else {
3682 0 : *cptr = cstr;
3683 0 : *alloc = SWIG_OLDOBJ;
3684 : }
3685 : } else {
3686 : #if PY_VERSION_HEX>=0x03000000
3687 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3688 : *cptr = PyBytes_AsString(obj);
3689 : #else
3690 : assert(0); /* Should never reach here with Unicode strings in Python 3 */
3691 : #endif
3692 : #else
3693 : *cptr = SWIG_Python_str_AsChar(obj);
3694 : if (!*cptr)
3695 : ret = SWIG_TypeError;
3696 : #endif
3697 : }
3698 : }
3699 578188 : if (psize) *psize = len + 1;
3700 : #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3701 578188 : Py_XDECREF(obj);
3702 : #endif
3703 578188 : return ret;
3704 : } else {
3705 : #if defined(SWIG_PYTHON_2_UNICODE)
3706 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3707 : #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3708 : #endif
3709 : #if PY_VERSION_HEX<0x03000000
3710 : if (PyUnicode_Check(obj)) {
3711 : char *cstr; Py_ssize_t len;
3712 : if (!alloc && cptr) {
3713 : return SWIG_RuntimeError;
3714 : }
3715 : obj = PyUnicode_AsUTF8String(obj); if (!obj) return SWIG_TypeError;
3716 : if (!obj)
3717 : return SWIG_TypeError;
3718 : if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3719 : if (cptr) {
3720 : if (alloc) *alloc = SWIG_NEWOBJ;
3721 : *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
3722 : }
3723 : if (psize) *psize = len + 1;
3724 :
3725 : Py_XDECREF(obj);
3726 : return SWIG_OK;
3727 : } else {
3728 : Py_XDECREF(obj);
3729 : }
3730 : }
3731 : #endif
3732 : #endif
3733 :
3734 10221 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3735 10221 : if (pchar_descriptor) {
3736 10221 : void* vptr = 0;
3737 10221 : if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3738 8378 : if (cptr) *cptr = (char *) vptr;
3739 8378 : if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3740 8378 : if (alloc) *alloc = SWIG_OLDOBJ;
3741 8378 : return SWIG_OK;
3742 : }
3743 : }
3744 : }
3745 : return SWIG_TypeError;
3746 : }
3747 :
3748 :
3749 :
3750 :
3751 :
3752 :
3753 : typedef struct {
3754 : PyObject *psPyCallback;
3755 : PyObject *psPyCallbackData;
3756 : int nLastReported;
3757 : } PyProgressData;
3758 :
3759 : /************************************************************************/
3760 : /* PyProgressProxy() */
3761 : /************************************************************************/
3762 :
3763 :
3764 : static int CPL_STDCALL
3765 : PyProgressProxy( double dfComplete, const char *pszMessage, void *pData ) CPL_UNUSED;
3766 :
3767 : static int CPL_STDCALL
3768 10323 : PyProgressProxy( double dfComplete, const char *pszMessage, void *pData )
3769 :
3770 : {
3771 10323 : PyProgressData *psInfo = (PyProgressData *) pData;
3772 10323 : PyObject *psArgs, *psResult;
3773 10323 : int bContinue = TRUE;
3774 :
3775 10323 : if( dfComplete > 0 && psInfo->nLastReported == (int) (100.0 * dfComplete) )
3776 : return TRUE;
3777 :
3778 3924 : if( psInfo->psPyCallback == NULL || psInfo->psPyCallback == Py_None )
3779 : return TRUE;
3780 :
3781 3924 : psInfo->nLastReported = (int) (100.0 * dfComplete);
3782 :
3783 3924 : if( pszMessage == NULL )
3784 805 : pszMessage = "";
3785 :
3786 14247 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3787 :
3788 3924 : if( psInfo->psPyCallbackData == NULL )
3789 2766 : psArgs = Py_BuildValue("(dsO)", dfComplete, pszMessage, Py_None );
3790 : else
3791 1158 : psArgs = Py_BuildValue("(dsO)", dfComplete, pszMessage,
3792 : psInfo->psPyCallbackData );
3793 :
3794 3924 : psResult = PyObject_CallObject( psInfo->psPyCallback, psArgs);
3795 3924 : Py_XDECREF(psArgs);
3796 :
3797 3924 : if( PyErr_Occurred() != NULL )
3798 : {
3799 1 : PyErr_Print();
3800 1 : PyErr_Clear();
3801 1 : SWIG_PYTHON_THREAD_END_BLOCK;
3802 : return FALSE;
3803 : }
3804 :
3805 3923 : if( psResult == NULL )
3806 : {
3807 0 : SWIG_PYTHON_THREAD_END_BLOCK;
3808 : return TRUE;
3809 : }
3810 :
3811 3923 : if( psResult == Py_None )
3812 : {
3813 14 : SWIG_PYTHON_THREAD_END_BLOCK;
3814 : return TRUE;
3815 : }
3816 :
3817 3909 : if( !PyArg_Parse( psResult, "i", &bContinue ) )
3818 : {
3819 1 : PyErr_Clear();
3820 1 : CPLError(CE_Failure, CPLE_AppDefined, "bad progress return value");
3821 1 : Py_XDECREF(psResult);
3822 1 : SWIG_PYTHON_THREAD_END_BLOCK;
3823 : return FALSE;
3824 : }
3825 :
3826 3908 : Py_XDECREF(psResult);
3827 3908 : SWIG_PYTHON_THREAD_END_BLOCK;
3828 :
3829 3908 : return bContinue;
3830 : }
3831 :
3832 :
3833 : typedef char retStringAndCPLFree;
3834 :
3835 :
3836 157 : void Debug( const char *msg_class, const char *message ) {
3837 157 : CPLDebug( msg_class, "%s", message );
3838 157 : }
3839 :
3840 :
3841 6 : CPLErr SetErrorHandler( CPLErrorHandler pfnErrorHandler = NULL, void* user_data = NULL )
3842 : {
3843 6 : if( pfnErrorHandler == NULL )
3844 : {
3845 0 : pfnErrorHandler = CPLDefaultErrorHandler;
3846 : }
3847 :
3848 6 : CPLSetErrorHandlerEx( pfnErrorHandler, user_data );
3849 :
3850 6 : return CE_None;
3851 : }
3852 :
3853 :
3854 : extern "C" int CPL_DLL GDALIsInGlobalDestructor();
3855 :
3856 826 : void CPL_STDCALL PyCPLErrorHandler(CPLErr eErrClass, CPLErrorNum err_no, const char* pszErrorMsg)
3857 : {
3858 826 : if( GDALIsInGlobalDestructor() )
3859 : {
3860 : // this is typically during Python interpreter shutdown, and ends up in a crash
3861 : // because error handling tries to do thread initialization.
3862 0 : return;
3863 : }
3864 :
3865 826 : void* user_data = CPLGetErrorHandlerUserData();
3866 826 : PyObject *psArgs;
3867 :
3868 1652 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3869 :
3870 826 : psArgs = Py_BuildValue("(iis)", eErrClass, err_no, pszErrorMsg );
3871 826 : PyObject_CallObject( (PyObject*)user_data, psArgs);
3872 826 : Py_XDECREF(psArgs);
3873 :
3874 826 : SWIG_PYTHON_THREAD_END_BLOCK;
3875 : }
3876 :
3877 :
3878 30160 : CPLErr PushErrorHandler( CPLErrorHandler pfnErrorHandler = NULL, void* user_data = NULL )
3879 : {
3880 30160 : if( pfnErrorHandler == NULL )
3881 76 : CPLPushErrorHandler(CPLQuietErrorHandler);
3882 : else
3883 30084 : CPLPushErrorHandlerEx(pfnErrorHandler, user_data);
3884 30160 : return CE_None;
3885 : }
3886 :
3887 :
3888 30155 : void PopErrorHandler()
3889 : {
3890 30155 : void* user_data = CPLGetErrorHandlerUserData();
3891 30155 : if( user_data != NULL )
3892 : {
3893 1578 : Py_XDECREF((PyObject*)user_data);
3894 : }
3895 30155 : CPLPopErrorHandler();
3896 30155 : }
3897 :
3898 :
3899 29 : void Error( CPLErr msg_class = CE_Failure, int err_code = 0, const char* msg = "error" ) {
3900 29 : CPLError( msg_class, err_code, "%s", msg );
3901 29 : }
3902 :
3903 :
3904 170 : retStringAndCPLFree* wrapper_EscapeString(int len, char *bin_string , int scheme=CPLES_SQL) {
3905 170 : return CPLEscapeString(bin_string, len, scheme);
3906 : }
3907 :
3908 :
3909 : static bool
3910 347102 : GetBufferAsCharPtrIntSize( PyObject* input, int *nLen, char **pBuf, int *alloc, bool *viewIsValid, Py_buffer *view ) {
3911 347102 : {
3912 347102 : if (PyObject_GetBuffer(input, view, PyBUF_SIMPLE) == 0)
3913 : {
3914 6650 : if( view->len > INT_MAX ) {
3915 0 : PyBuffer_Release(view);
3916 0 : PyErr_SetString(PyExc_RuntimeError, "too large buffer (>2GB)" );
3917 0 : return false;
3918 : }
3919 6650 : *viewIsValid = true;
3920 6650 : *nLen = (int) view->len;
3921 6650 : *pBuf = (char*) view->buf;
3922 6650 : return true;
3923 : }
3924 : else
3925 : {
3926 340452 : PyErr_Clear();
3927 : }
3928 : }
3929 340452 : if (PyUnicode_Check(input))
3930 : {
3931 340452 : size_t safeLen = 0;
3932 340452 : int ret;
3933 340452 : try {
3934 340452 : ret = SWIG_AsCharPtrAndSize(input, pBuf, &safeLen, alloc);
3935 : }
3936 0 : catch( const std::exception& )
3937 : {
3938 0 : PyErr_SetString(PyExc_MemoryError, "out of memory");
3939 0 : return false;
3940 : }
3941 340452 : if (!SWIG_IsOK(ret)) {
3942 0 : PyErr_SetString(PyExc_RuntimeError, "invalid Unicode string" );
3943 0 : return false;
3944 : }
3945 :
3946 340452 : if (safeLen) safeLen--;
3947 340452 : if( safeLen > INT_MAX ) {
3948 0 : PyErr_SetString(PyExc_RuntimeError, "too large buffer (>2GB)" );
3949 0 : return false;
3950 : }
3951 340452 : *nLen = (int) safeLen;
3952 340452 : return true;
3953 : }
3954 : else
3955 : {
3956 0 : PyErr_SetString(PyExc_RuntimeError, "not a unicode string, bytes, bytearray or memoryview");
3957 0 : return false;
3958 : }
3959 : }
3960 :
3961 :
3962 81 : void EscapeBinary(int len, char *bin_string, size_t *pnLenOut, char** pOut, int scheme=CPLES_SQL) {
3963 81 : *pOut = CPLEscapeString(bin_string, len, scheme);
3964 81 : *pnLenOut = *pOut ? strlen(*pOut) : 0;
3965 81 : }
3966 :
3967 :
3968 : SWIGINTERNINLINE PyObject *
3969 198306 : SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3970 : {
3971 198306 : if (carray) {
3972 139409 : if (size > INT_MAX) {
3973 0 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3974 0 : return pchar_descriptor ?
3975 0 : SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3976 : } else {
3977 : #if PY_VERSION_HEX >= 0x03000000
3978 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3979 : return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
3980 : #else
3981 139409 : return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
3982 : #endif
3983 : #else
3984 : return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
3985 : #endif
3986 : }
3987 : } else {
3988 58897 : return SWIG_Py_Void();
3989 : }
3990 : }
3991 :
3992 :
3993 : SWIGINTERNINLINE PyObject *
3994 198306 : SWIG_FromCharPtr(const char *cptr)
3995 : {
3996 198306 : return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3997 : }
3998 :
3999 :
4000 848 : char **wrapper_VSIReadDirEx( const char * utf8_path, int nMaxFiles = 0 )
4001 : {
4002 848 : return VSIReadDirEx(utf8_path, nMaxFiles);
4003 : }
4004 :
4005 :
4006 5078 : static PyObject* CSLToList( char** stringarray, bool *pbErr )
4007 : {
4008 5078 : PyObject* res;
4009 5078 : if ( stringarray == NULL ) {
4010 1405 : res = Py_None;
4011 1405 : Py_INCREF( res );
4012 : }
4013 : else {
4014 3673 : int len = CSLCount( stringarray );
4015 3673 : res = PyList_New( len );
4016 3673 : if( !res ) {
4017 0 : *pbErr = true;
4018 0 : return res;
4019 : }
4020 28977 : for ( int i = 0; i < len; ++i ) {
4021 25304 : PyObject *o = GDALPythonObjectFromCStr( stringarray[i] );
4022 25304 : PyList_SetItem(res, i, o );
4023 : }
4024 : }
4025 5078 : *pbErr = false;
4026 5078 : return res;
4027 : }
4028 :
4029 :
4030 35 : VSIDIR* wrapper_VSIOpenDir( const char * utf8_path,
4031 : int nRecurseDepth = -1,
4032 : char** options = NULL )
4033 : {
4034 35 : return VSIOpenDir(utf8_path, nRecurseDepth, options);
4035 : }
4036 :
4037 :
4038 : /************************************************************************/
4039 : /* CSLFromPySequence() */
4040 : /************************************************************************/
4041 18911 : static char **CSLFromPySequence( PyObject *pySeq, int *pbErr )
4042 :
4043 : {
4044 18911 : *pbErr = FALSE;
4045 : /* Check if is a list (and reject strings, that are seen as sequence of characters) */
4046 18911 : if ( ! PySequence_Check(pySeq) || PyUnicode_Check(pySeq) ) {
4047 0 : PyErr_SetString(PyExc_TypeError,"not a sequence");
4048 0 : *pbErr = TRUE;
4049 0 : return NULL;
4050 : }
4051 :
4052 18911 : Py_ssize_t size = PySequence_Size(pySeq);
4053 18911 : if( size > (Py_ssize_t)(INT_MAX - 1) ) {
4054 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
4055 0 : *pbErr = TRUE;
4056 0 : return NULL;
4057 : }
4058 18911 : if( size == 0 ) {
4059 : return NULL;
4060 : }
4061 13286 : char** papszRet = (char**) VSICalloc((int)size + 1, sizeof(char*));
4062 13286 : if( !papszRet ) {
4063 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
4064 0 : *pbErr = TRUE;
4065 0 : return NULL;
4066 : }
4067 112006 : for (int i = 0; i < (int)size; i++) {
4068 98721 : PyObject* pyObj = PySequence_GetItem(pySeq,i);
4069 98721 : if (PyUnicode_Check(pyObj))
4070 : {
4071 98717 : char *pszStr;
4072 98717 : Py_ssize_t nLen;
4073 98717 : PyObject* pyUTF8Str = PyUnicode_AsUTF8String(pyObj);
4074 98717 : if( !pyUTF8Str )
4075 : {
4076 0 : Py_DECREF(pyObj);
4077 0 : PyErr_SetString(PyExc_TypeError,"invalid Unicode sequence");
4078 0 : CSLDestroy(papszRet);
4079 0 : *pbErr = TRUE;
4080 0 : return NULL;
4081 : }
4082 98717 : PyBytes_AsStringAndSize(pyUTF8Str, &pszStr, &nLen);
4083 98717 : papszRet[i] = VSIStrdup(pszStr);
4084 194473 : Py_XDECREF(pyUTF8Str);
4085 : }
4086 4 : else if (PyBytes_Check(pyObj))
4087 3 : papszRet[i] = VSIStrdup(PyBytes_AsString(pyObj));
4088 : else
4089 : {
4090 1 : Py_DECREF(pyObj);
4091 1 : PyErr_SetString(PyExc_TypeError,"sequence must contain strings");
4092 1 : CSLDestroy(papszRet);
4093 1 : *pbErr = TRUE;
4094 1 : return NULL;
4095 : }
4096 98720 : Py_DECREF(pyObj);
4097 98720 : if( !papszRet[i] )
4098 : {
4099 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
4100 0 : CSLDestroy(papszRet);
4101 0 : *pbErr = TRUE;
4102 0 : return NULL;
4103 : }
4104 : }
4105 : return papszRet;
4106 : }
4107 :
4108 :
4109 696 : static char **CSLFromPyMapping( PyObject *pyObj, int *pbErr )
4110 :
4111 : {
4112 696 : char** retCSL = NULL;
4113 696 : Py_ssize_t size = PyMapping_Length( pyObj );
4114 696 : if ( size > 0 && size == (int)size) {
4115 286 : PyObject *item_list = PyMapping_Items( pyObj );
4116 1255 : for( int i=0; i<(int)size; i++ ) {
4117 972 : PyObject *it = PySequence_GetItem( item_list, i );
4118 :
4119 972 : PyObject *k, *v;
4120 972 : if ( ! PyArg_ParseTuple( it, "OO", &k, &v ) ) {
4121 0 : Py_DECREF(it);
4122 0 : Py_DECREF(item_list);
4123 0 : PyErr_SetString(PyExc_TypeError,"Cannot retrieve key/value");
4124 0 : CSLDestroy(retCSL);
4125 0 : *pbErr = TRUE;
4126 3 : return NULL;
4127 : }
4128 :
4129 972 : PyObject* kStr = PyObject_Str(k);
4130 972 : if( PyErr_Occurred() )
4131 : {
4132 1 : Py_DECREF(it);
4133 1 : Py_DECREF(item_list);
4134 1 : CSLDestroy(retCSL);
4135 1 : *pbErr = TRUE;
4136 1 : return NULL;
4137 : }
4138 :
4139 971 : PyObject* vStr;
4140 971 : if( PyBytes_Check(v) )
4141 : {
4142 2 : vStr = v;
4143 2 : Py_INCREF(vStr);
4144 : }
4145 : else
4146 : {
4147 969 : vStr = PyObject_Str(v);
4148 969 : if( PyErr_Occurred() )
4149 : {
4150 1 : Py_DECREF(it);
4151 1 : Py_DECREF(kStr);
4152 1 : Py_DECREF(item_list);
4153 1 : CSLDestroy(retCSL);
4154 1 : *pbErr = TRUE;
4155 1 : return NULL;
4156 : }
4157 : }
4158 :
4159 970 : int bFreeK, bFreeV;
4160 970 : char* pszK = GDALPythonObjectToCStr(kStr, &bFreeK);
4161 970 : char* pszV = GDALPythonObjectToCStr(vStr, &bFreeV);
4162 970 : if( pszK == NULL || pszV == NULL )
4163 : {
4164 1 : GDALPythonFreeCStr(pszK, bFreeK);
4165 1 : GDALPythonFreeCStr(pszV, bFreeV);
4166 1 : Py_DECREF(kStr);
4167 1 : Py_DECREF(vStr);
4168 1 : Py_DECREF(it);
4169 1 : Py_DECREF(item_list);
4170 1 : PyErr_SetString(PyExc_TypeError,"Cannot get key/value as string");
4171 1 : CSLDestroy(retCSL);
4172 1 : *pbErr = TRUE;
4173 1 : return NULL;
4174 : }
4175 969 : retCSL = CSLAddNameValue( retCSL, pszK, pszV );
4176 :
4177 969 : GDALPythonFreeCStr(pszK, bFreeK);
4178 969 : GDALPythonFreeCStr(pszV, bFreeV);
4179 969 : Py_DECREF(kStr);
4180 969 : Py_DECREF(vStr);
4181 969 : Py_DECREF(it);
4182 : }
4183 283 : Py_DECREF(item_list);
4184 : }
4185 693 : *pbErr = FALSE;
4186 693 : return retCSL;
4187 : }
4188 :
4189 :
4190 : typedef struct
4191 : {
4192 : char* name;
4193 : int mode;
4194 : GIntBig size;
4195 : GIntBig mtime;
4196 : bool modeKnown;
4197 : bool sizeKnown;
4198 : bool mtimeKnown;
4199 : char** extra;
4200 : } DirEntry;
4201 :
4202 :
4203 : SWIGINTERNINLINE PyObject*
4204 18217 : SWIG_From_bool (bool value)
4205 : {
4206 18217 : return PyBool_FromLong(value ? 1 : 0);
4207 : }
4208 :
4209 :
4210 : /* Return a PyObject* from a C String */
4211 91083 : static PyObject* GDALPythonObjectFromCStrAndSize(const char *pszStr, size_t nLen)
4212 : {
4213 91083 : const unsigned char* pszIter = (const unsigned char*) pszStr;
4214 1624750 : for( size_t i = 0; i < nLen; ++i)
4215 : {
4216 1533670 : if (pszIter[i] > 127)
4217 : {
4218 3 : PyObject* pyObj = PyUnicode_DecodeUTF8(pszStr, nLen, "strict");
4219 3 : if (pyObj != NULL && !PyErr_Occurred())
4220 : return pyObj;
4221 0 : PyErr_Clear();
4222 0 : return PyBytes_FromStringAndSize(pszStr, nLen);
4223 : }
4224 : }
4225 91080 : return PyUnicode_FromStringAndSize(pszStr, nLen);
4226 : }
4227 :
4228 :
4229 : static PyObject*
4230 7113 : GetCSLStringAsPyDict( char **stringarray, bool bFreeCSL ) {
4231 7113 : PyObject* dict = PyDict_New();
4232 7113 : if ( stringarray != NULL ) {
4233 97901 : for (char** iter = stringarray; *iter; ++iter ) {
4234 91362 : const char* pszSep = strchr( *iter, '=' );
4235 91362 : if ( pszSep != NULL) {
4236 91083 : const char* keyptr = *iter;
4237 91083 : const char* valptr = pszSep + 1;
4238 91083 : PyObject *nm = GDALPythonObjectFromCStrAndSize( keyptr, (size_t)(pszSep - keyptr) );
4239 91083 : PyObject *val = GDALPythonObjectFromCStr( valptr );
4240 91083 : PyDict_SetItem(dict, nm, val );
4241 91083 : Py_DECREF(nm);
4242 91362 : Py_DECREF(val);
4243 : }
4244 : }
4245 : }
4246 7113 : if( bFreeCSL )
4247 71 : CSLDestroy(stringarray);
4248 7113 : return dict;
4249 : }
4250 :
4251 0 : SWIGINTERN DirEntry *new_DirEntry(DirEntry const *entryIn){
4252 0 : DirEntry *self = (DirEntry*) CPLMalloc( sizeof( DirEntry ) );
4253 0 : self->name = CPLStrdup(entryIn->name);
4254 0 : self->mode = entryIn->mode;
4255 0 : self->size = entryIn->size;
4256 0 : self->mtime = entryIn->mtime;
4257 0 : self->modeKnown = entryIn->modeKnown;
4258 0 : self->sizeKnown = entryIn->sizeKnown;
4259 0 : self->mtimeKnown = entryIn->mtimeKnown;
4260 0 : self->extra = CSLDuplicate(entryIn->extra);
4261 0 : return self;
4262 : }
4263 79 : SWIGINTERN void delete_DirEntry(DirEntry *self){
4264 79 : CPLFree(self->name);
4265 79 : CSLDestroy(self->extra);
4266 79 : CPLFree(self);
4267 79 : }
4268 0 : SWIGINTERN bool DirEntry_IsDirectory(DirEntry *self){
4269 0 : return (self->mode & S_IFDIR) != 0;
4270 : }
4271 :
4272 112 : DirEntry* wrapper_VSIGetNextDirEntry(VSIDIR* dir)
4273 : {
4274 112 : const VSIDIREntry* vsiEntry = VSIGetNextDirEntry(dir);
4275 112 : if( vsiEntry == nullptr )
4276 : {
4277 : return nullptr;
4278 : }
4279 79 : DirEntry* entry = (DirEntry*) CPLMalloc( sizeof( DirEntry ) );
4280 79 : entry->name = CPLStrdup(vsiEntry->pszName);
4281 79 : entry->mode = vsiEntry->nMode;
4282 79 : entry->size = vsiEntry->nSize;
4283 79 : entry->mtime = vsiEntry->nMTime;
4284 79 : entry->modeKnown = vsiEntry->bModeKnown == TRUE;
4285 79 : entry->sizeKnown = vsiEntry->bSizeKnown == TRUE;
4286 79 : entry->mtimeKnown = vsiEntry->bMTimeKnown == TRUE;
4287 79 : entry->extra = CSLDuplicate(vsiEntry->papszExtra);
4288 79 : return entry;
4289 : }
4290 :
4291 :
4292 22724 : const char *wrapper_CPLGetConfigOption( const char * pszKey, const char * pszDefault = NULL )
4293 : {
4294 22724 : return CPLGetConfigOption( pszKey, pszDefault );
4295 : }
4296 1923 : const char *wrapper_CPLGetGlobalConfigOption( const char * pszKey, const char * pszDefault = NULL )
4297 : {
4298 1923 : return CPLGetGlobalConfigOption( pszKey, pszDefault );
4299 : }
4300 3080 : const char *wrapper_CPLGetThreadLocalConfigOption( const char * pszKey, const char * pszDefault = NULL )
4301 : {
4302 3080 : return CPLGetThreadLocalConfigOption( pszKey, pszDefault );
4303 : }
4304 :
4305 :
4306 6 : char** wrapper_GetConfigOptions() {
4307 6 : char ** papszOpts = CPLGetConfigOptions();
4308 6 : char ** papszTLOpts = CPLGetThreadLocalConfigOptions();
4309 :
4310 6 : papszOpts = CSLMerge(papszOpts, papszTLOpts);
4311 :
4312 6 : CSLDestroy(papszTLOpts);
4313 :
4314 6 : return papszOpts;
4315 : };
4316 :
4317 :
4318 56 : void wrapper_VSISetCredential( const char* pszPathPrefix, const char * pszKey, const char * pszValue )
4319 : {
4320 56 : VSISetPathSpecificOption(pszPathPrefix, pszKey, pszValue);
4321 56 : }
4322 :
4323 0 : const char *wrapper_VSIGetCredential( const char* pszPathPrefix, const char * pszKey, const char * pszDefault = NULL )
4324 : {
4325 0 : return VSIGetPathSpecificOption( pszPathPrefix, pszKey, pszDefault );
4326 : }
4327 :
4328 10 : const char *wrapper_VSIGetPathSpecificOption( const char* pszPathPrefix, const char * pszKey, const char * pszDefault = NULL )
4329 : {
4330 10 : return VSIGetPathSpecificOption( pszPathPrefix, pszKey, pszDefault );
4331 : }
4332 :
4333 :
4334 8 : void wrapper_VSIClearCredentials(const char * pszPathPrefix = NULL)
4335 : {
4336 8 : VSIClearPathSpecificOptions( pszPathPrefix );
4337 8 : }
4338 10 : void wrapper_VSIClearPathSpecificOptions(const char * pszPathPrefix = NULL)
4339 : {
4340 10 : VSIClearPathSpecificOptions( pszPathPrefix );
4341 10 : }
4342 :
4343 :
4344 3605 : VSI_RETVAL wrapper_VSIFileFromMemBuffer( const char* utf8_path, GIntBig nBytes, const char *pabyData)
4345 : {
4346 3605 : const size_t nSize = static_cast<size_t>(nBytes);
4347 3605 : void* pabyDataDup = VSIMalloc(nSize);
4348 3605 : if (pabyDataDup == NULL)
4349 : return -1;
4350 3605 : memcpy(pabyDataDup, pabyData, nSize);
4351 3605 : VSILFILE *fp = VSIFileFromMemBuffer(utf8_path, (GByte*) pabyDataDup, nSize, TRUE);
4352 :
4353 3605 : if (fp == NULL) {
4354 1 : VSIFree(pabyDataDup);
4355 1 : return -1;
4356 : } else {
4357 3604 : VSIFCloseL(fp);
4358 3604 : return 0;
4359 : }
4360 : }
4361 :
4362 :
4363 : static bool
4364 189897 : GetBufferAsCharPtrGIntBigSize( PyObject* input, GIntBig *nLen, char **pBuf, int *alloc, bool *viewIsValid, Py_buffer *view ) {
4365 189897 : {
4366 189897 : if (PyObject_GetBuffer(input, view, PyBUF_SIMPLE) == 0)
4367 : {
4368 180470 : *viewIsValid = true;
4369 180470 : *nLen = view->len;
4370 180470 : *pBuf = (char*) view->buf;
4371 180470 : return true;
4372 : }
4373 : else
4374 : {
4375 9427 : PyErr_Clear();
4376 : }
4377 : }
4378 9427 : if (PyUnicode_Check(input))
4379 : {
4380 9425 : size_t safeLen = 0;
4381 9425 : int ret;
4382 9425 : try {
4383 9425 : ret = SWIG_AsCharPtrAndSize(input, pBuf, &safeLen, alloc);
4384 : }
4385 0 : catch( const std::exception& )
4386 : {
4387 0 : PyErr_SetString(PyExc_MemoryError, "out of memory");
4388 0 : return false;
4389 : }
4390 9425 : if (!SWIG_IsOK(ret)) {
4391 0 : PyErr_SetString(PyExc_RuntimeError, "invalid Unicode string" );
4392 0 : return false;
4393 : }
4394 :
4395 9425 : if (safeLen) safeLen--;
4396 9425 : *nLen = (GIntBig)safeLen;
4397 9425 : return true;
4398 : }
4399 : else
4400 : {
4401 2 : PyErr_SetString(PyExc_RuntimeError, "not a unicode string, bytes, bytearray or memoryview");
4402 2 : return false;
4403 : }
4404 : }
4405 :
4406 :
4407 11 : bool wrapper_VSIUnlinkBatch(char** files)
4408 : {
4409 11 : int* success = VSIUnlinkBatch(files);
4410 11 : if( !success )
4411 : return false;
4412 26 : int bRet = true;
4413 26 : for( int i = 0; files && files[i]; i++ )
4414 : {
4415 18 : if( !success[i] ) {
4416 : bRet = false;
4417 : break;
4418 : }
4419 : }
4420 9 : VSIFree(success);
4421 9 : return bRet;
4422 : }
4423 :
4424 :
4425 0 : int wrapper_HasThreadSupport()
4426 : {
4427 0 : return strcmp(CPLGetThreadingModel(), "stub") != 0;
4428 : }
4429 :
4430 :
4431 7 : VSI_RETVAL wrapper_VSIMove(const char * old_path, const char *new_path, char** options = NULL,
4432 : GDALProgressFunc callback=NULL,
4433 : void* callback_data=NULL)
4434 : {
4435 7 : return VSIMove(old_path, new_path, options, callback, callback_data);
4436 : }
4437 :
4438 :
4439 42 : bool wrapper_VSISync(const char* pszSource,
4440 : const char* pszTarget,
4441 : char** options = NULL,
4442 : GDALProgressFunc callback=NULL,
4443 : void* callback_data=NULL)
4444 : {
4445 42 : return VSISync( pszSource, pszTarget, options, callback, callback_data, nullptr );
4446 : }
4447 :
4448 :
4449 29 : int wrapper_VSICopyFile(const char* pszSource,
4450 : const char* pszTarget,
4451 : VSILFILE* fpSource = NULL,
4452 : GIntBig nSourceSize = -1,
4453 : char** options = NULL,
4454 : GDALProgressFunc callback=NULL,
4455 : void* callback_data=NULL)
4456 : {
4457 29 : return VSICopyFile(
4458 : pszSource, pszTarget, fpSource,
4459 : nSourceSize < 0 ? static_cast<vsi_l_offset>(-1) : static_cast<vsi_l_offset>(nSourceSize),
4460 29 : options, callback, callback_data );
4461 : }
4462 :
4463 :
4464 20 : void CopyFileRestartable(const char* pszSource,
4465 : const char* pszTarget,
4466 : const char* pszInputPayload,
4467 : int* pnRetCode,
4468 : char** ppszOutputPayload,
4469 : char** options = NULL,
4470 : GDALProgressFunc callback=NULL,
4471 : void* callback_data=NULL)
4472 : {
4473 20 : *pnRetCode = VSICopyFileRestartable(pszSource, pszTarget, pszInputPayload,
4474 : ppszOutputPayload, options, callback,
4475 : callback_data);
4476 20 : }
4477 :
4478 :
4479 :
4480 :
4481 0 : int wrapper_MoveFile(const char* pszSource, const char* pszTarget)
4482 : {
4483 0 : return CPLMoveFile(pszTarget, pszSource);
4484 : }
4485 :
4486 :
4487 23 : retStringAndCPLFree* wrapper_VSIGetSignedURL(const char * utf8_path, char** options = NULL )
4488 : {
4489 23 : return VSIGetSignedURL( utf8_path, options );
4490 : }
4491 :
4492 :
4493 : typedef struct
4494 : {
4495 : int mode;
4496 : GIntBig size;
4497 : GIntBig mtime;
4498 : } StatBuf;
4499 :
4500 2336 : SWIGINTERN StatBuf *new_StatBuf(StatBuf *psStatBuf){
4501 4672 : StatBuf *self = (StatBuf*) CPLMalloc( sizeof( StatBuf ) );
4502 2336 : self->mode = psStatBuf->mode;
4503 2336 : self->size = psStatBuf->size;
4504 2336 : self->mtime = psStatBuf->mtime;
4505 2336 : return self;
4506 : }
4507 2336 : SWIGINTERN void delete_StatBuf(StatBuf *self){
4508 2336 : CPLFree(self);
4509 2336 : }
4510 5 : SWIGINTERN int StatBuf_IsDirectory(StatBuf *self){
4511 5 : return (self->mode & S_IFDIR) != 0;
4512 : }
4513 :
4514 3862 : int wrapper_VSIStatL( const char * utf8_path, StatBuf *psStatBufOut, int nFlags = 0 )
4515 : {
4516 3862 : VSIStatBufL sStat;
4517 3862 : memset(&sStat, 0, sizeof(sStat));
4518 3862 : memset(psStatBufOut, 0, sizeof(StatBuf));
4519 3862 : int nRet = VSIStatExL(utf8_path, &sStat, nFlags);
4520 3862 : psStatBufOut->mode = sStat.st_mode;
4521 3862 : psStatBufOut->size = (GIntBig)sStat.st_size;
4522 3862 : psStatBufOut->mtime = (GIntBig)sStat.st_mtime;
4523 3862 : return nRet;
4524 : }
4525 :
4526 :
4527 4590 : VSILFILE *wrapper_VSIFOpenL( const char *utf8_path, const char *pszMode )
4528 : {
4529 4590 : if (!pszMode) /* would lead to segfault */
4530 0 : pszMode = "r";
4531 4590 : return VSIFOpenL( utf8_path, pszMode );
4532 : }
4533 :
4534 :
4535 428 : VSILFILE *wrapper_VSIFOpenExL( const char *utf8_path, const char *pszMode, int bSetError = FALSE, char** options = NULL )
4536 : {
4537 428 : if (!pszMode) /* would lead to segfault */
4538 0 : pszMode = "r";
4539 428 : return VSIFOpenEx2L( utf8_path, pszMode, bSetError, options );
4540 : }
4541 :
4542 :
4543 :
4544 65954 : int wrapper_VSIFSeekL( VSILFILE* fp, GIntBig offset, int whence) {
4545 :
4546 :
4547 :
4548 65954 : if (offset < 0) {
4549 3 : switch (whence) {
4550 1 : case SEEK_END: VSIFSeekL(fp, 0, SEEK_END);
4551 2 : case SEEK_CUR:
4552 2 : offset = VSIFTellL(fp) + offset;
4553 2 : whence = SEEK_SET;
4554 2 : break;
4555 1 : default:
4556 1 : VSIError(VSIE_FileError, "Cannot use negative offset with SEEK_SET");
4557 1 : return -1;
4558 : }
4559 : }
4560 :
4561 65953 : return VSIFSeekL(fp, offset, whence);
4562 : }
4563 :
4564 :
4565 346837 : int wrapper_VSIFWriteL( int nLen, char *pBuf, int size, int memb, VSILFILE* fp)
4566 : {
4567 346837 : if (nLen < static_cast<GIntBig>(size) * memb)
4568 : {
4569 0 : CPLError(CE_Failure, CPLE_AppDefined, "Inconsistent buffer size with 'size' and 'memb' values");
4570 0 : return 0;
4571 : }
4572 346837 : return static_cast<int>(VSIFWriteL(pBuf, size, memb, fp));
4573 : }
4574 :
4575 :
4576 7 : void MultipartUploadGetCapabilities(
4577 : const char *pszFilename, int* pnRetCode, int *pbNonSequentialUploadSupported,
4578 : int *pbParallelUploadSupported, int *pbSupportsAbort, size_t *pnMinPartSize,
4579 : size_t *pnMaxPartSize, int *pnMaxPartCount)
4580 : {
4581 7 : *pnRetCode = VSIMultipartUploadGetCapabilities(pszFilename,
4582 : pbNonSequentialUploadSupported,
4583 : pbParallelUploadSupported,
4584 : pbSupportsAbort,
4585 : pnMinPartSize,
4586 : pnMaxPartSize,
4587 : pnMaxPartCount);
4588 7 : }
4589 :
4590 :
4591 4 : retStringAndCPLFree* MultipartUploadStart(const char *pszFilename, char** options = NULL)
4592 : {
4593 4 : return VSIMultipartUploadStart(pszFilename, options);
4594 : }
4595 :
4596 :
4597 5 : retStringAndCPLFree* MultipartUploadAddPart(const char *pszFilename,
4598 : const char *pszUploadId,
4599 : int nPartNumber,
4600 : GUIntBig nFileOffset,
4601 : size_t nDataLength, const char *pData,
4602 : char** options = NULL)
4603 : {
4604 5 : return VSIMultipartUploadAddPart(pszFilename, pszUploadId,
4605 : nPartNumber, nFileOffset,
4606 : pData, nDataLength,
4607 5 : options);
4608 : }
4609 :
4610 :
4611 : static bool
4612 7 : GetBufferAsCharPtrSizetSize( PyObject* input, size_t *nLen, char **pBuf, int *alloc, bool *viewIsValid, Py_buffer *view ) {
4613 7 : {
4614 7 : if (PyObject_GetBuffer(input, view, PyBUF_SIMPLE) == 0)
4615 : {
4616 7 : *viewIsValid = true;
4617 7 : *nLen = view->len;
4618 7 : *pBuf = (char*) view->buf;
4619 7 : return true;
4620 : }
4621 : else
4622 : {
4623 0 : PyErr_Clear();
4624 : }
4625 : }
4626 0 : if (PyUnicode_Check(input))
4627 : {
4628 0 : size_t safeLen = 0;
4629 0 : int ret;
4630 0 : try {
4631 0 : ret = SWIG_AsCharPtrAndSize(input, pBuf, &safeLen, alloc);
4632 : }
4633 0 : catch( const std::exception& )
4634 : {
4635 0 : PyErr_SetString(PyExc_MemoryError, "out of memory");
4636 0 : return false;
4637 : }
4638 0 : if (!SWIG_IsOK(ret)) {
4639 0 : PyErr_SetString(PyExc_RuntimeError, "invalid Unicode string" );
4640 0 : return false;
4641 : }
4642 :
4643 0 : if (safeLen) safeLen--;
4644 0 : *nLen = safeLen;
4645 0 : return true;
4646 : }
4647 : else
4648 : {
4649 0 : PyErr_SetString(PyExc_RuntimeError, "not a unicode string, bytes, bytearray or memoryview");
4650 0 : return false;
4651 : }
4652 : }
4653 :
4654 :
4655 : #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
4656 : # define SWIG_LONG_LONG_AVAILABLE
4657 : #endif
4658 :
4659 :
4660 : #ifdef SWIG_LONG_LONG_AVAILABLE
4661 : SWIGINTERN int
4662 : SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
4663 : {
4664 : int res = SWIG_TypeError;
4665 : if (PyLong_Check(obj)) {
4666 : unsigned long long v = PyLong_AsUnsignedLongLong(obj);
4667 : if (!PyErr_Occurred()) {
4668 : if (val) *val = v;
4669 : return SWIG_OK;
4670 : } else {
4671 : PyErr_Clear();
4672 : res = SWIG_OverflowError;
4673 : }
4674 : } else {
4675 : unsigned long v;
4676 : res = SWIG_AsVal_unsigned_SS_long (obj,&v);
4677 : if (SWIG_IsOK(res)) {
4678 : if (val) *val = v;
4679 : return res;
4680 : }
4681 : }
4682 : #ifdef SWIG_PYTHON_CAST_MODE
4683 : {
4684 : const double mant_max = 1LL << DBL_MANT_DIG;
4685 : double d;
4686 : res = SWIG_AsVal_double (obj,&d);
4687 : if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
4688 : return SWIG_OverflowError;
4689 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
4690 : if (val) *val = (unsigned long long)(d);
4691 : return SWIG_AddCast(res);
4692 : }
4693 : res = SWIG_TypeError;
4694 : }
4695 : #endif
4696 : return res;
4697 : }
4698 : #endif
4699 :
4700 :
4701 : SWIGINTERNINLINE int
4702 272 : SWIG_AsVal_size_t (PyObject * obj, size_t *val)
4703 : {
4704 272 : int res = SWIG_TypeError;
4705 : #ifdef SWIG_LONG_LONG_AVAILABLE
4706 272 : if (sizeof(size_t) <= sizeof(unsigned long)) {
4707 : #endif
4708 272 : unsigned long v;
4709 544 : res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
4710 272 : if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
4711 : #ifdef SWIG_LONG_LONG_AVAILABLE
4712 : } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
4713 : unsigned long long v;
4714 : res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
4715 : if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
4716 : }
4717 : #endif
4718 272 : return res;
4719 : }
4720 :
4721 :
4722 5 : bool MultipartUploadEnd(const char *pszFilename,
4723 : const char *pszUploadId,
4724 : char** partIds,
4725 : GUIntBig nTotalSize,
4726 : char** options = NULL)
4727 :
4728 : {
4729 5 : return VSIMultipartUploadEnd(pszFilename, pszUploadId,
4730 5 : CSLCount(partIds), partIds,
4731 : nTotalSize,
4732 5 : options);
4733 : }
4734 :
4735 :
4736 6 : bool MultipartUploadAbort(const char *pszFilename,
4737 : const char *pszUploadId,
4738 : char** options = NULL)
4739 : {
4740 6 : return VSIMultipartUploadAbort(pszFilename, pszUploadId, options);
4741 : }
4742 :
4743 2497 : SWIGINTERN char const *GDALMajorObjectShadow_GetDescription(GDALMajorObjectShadow *self){
4744 2497 : return GDALGetDescription( self );
4745 : }
4746 51 : SWIGINTERN void GDALMajorObjectShadow_SetDescription(GDALMajorObjectShadow *self,char const *pszNewDesc){
4747 51 : GDALSetDescription( self, pszNewDesc );
4748 51 : }
4749 75 : SWIGINTERN char **GDALMajorObjectShadow_GetMetadataDomainList(GDALMajorObjectShadow *self){
4750 75 : return GDALGetMetadataDomainList( self );
4751 : }
4752 7021 : SWIGINTERN char **GDALMajorObjectShadow_GetMetadata_Dict(GDALMajorObjectShadow *self,char const *pszDomain=""){
4753 7021 : return GDALGetMetadata( self, pszDomain );
4754 : }
4755 404 : SWIGINTERN char **GDALMajorObjectShadow_GetMetadata_List(GDALMajorObjectShadow *self,char const *pszDomain=""){
4756 404 : return GDALGetMetadata( self, pszDomain );
4757 : }
4758 : SWIGINTERN CPLErr GDALMajorObjectShadow_SetMetadata__SWIG_0(GDALMajorObjectShadow *self,char **papszMetadata,char const *pszDomain=""){
4759 : return GDALSetMetadata( self, papszMetadata, pszDomain );
4760 : }
4761 : SWIGINTERN CPLErr GDALMajorObjectShadow_SetMetadata__SWIG_1(GDALMajorObjectShadow *self,char *pszMetadataString,char const *pszDomain=""){
4762 : char *tmpList[2];
4763 : tmpList[0] = pszMetadataString;
4764 : tmpList[1] = 0;
4765 : return GDALSetMetadata( self, tmpList, pszDomain );
4766 : }
4767 57015 : SWIGINTERN char const *GDALMajorObjectShadow_GetMetadataItem(GDALMajorObjectShadow *self,char const *pszName,char const *pszDomain=""){
4768 57015 : return GDALGetMetadataItem( self, pszName, pszDomain);
4769 : }
4770 494 : SWIGINTERN CPLErr GDALMajorObjectShadow_SetMetadataItem(GDALMajorObjectShadow *self,char const *pszName,char const *pszValue,char const *pszDomain=""){
4771 494 : return GDALSetMetadataItem( self, pszName, pszValue, pszDomain);
4772 : }
4773 17611 : SWIGINTERN GDALDatasetShadow *GDALDriverShadow_Create(GDALDriverShadow *self,char const *utf8_path,int xsize,int ysize,int bands=1,GDALDataType eType=GDT_Byte,char **options=0){
4774 :
4775 35222 : GDALDatasetShadow* ds = (GDALDatasetShadow*) GDALCreate( self,
4776 : utf8_path,
4777 : xsize,
4778 : ysize,
4779 : bands,
4780 : eType,
4781 : options );
4782 17611 : return ds;
4783 : }
4784 310 : SWIGINTERN GDALDatasetShadow *GDALDriverShadow_CreateVector(GDALDriverShadow *self,char const *utf8_path,char **options=0){
4785 620 : GDALDatasetShadow* ds = (GDALDatasetShadow*) GDALCreate(self, utf8_path, 0, 0, 0, GDT_Unknown, options);
4786 310 : return ds;
4787 : }
4788 471 : SWIGINTERN GDALDatasetShadow *GDALDriverShadow_CreateMultiDimensional(GDALDriverShadow *self,char const *utf8_path,char **root_group_options=0,char **options=0){
4789 :
4790 942 : GDALDatasetShadow* ds = (GDALDatasetShadow*) GDALCreateMultiDimensional( self,
4791 : utf8_path,
4792 : root_group_options,
4793 : options );
4794 471 : return ds;
4795 : }
4796 3893 : SWIGINTERN GDALDatasetShadow *GDALDriverShadow_CreateCopy(GDALDriverShadow *self,char const *utf8_path,GDALDatasetShadow *src,int strict=1,char **options=0,GDALProgressFunc callback=NULL,void *callback_data=NULL){
4797 :
4798 7786 : GDALDatasetShadow *ds = (GDALDatasetShadow*) GDALCreateCopy( self,
4799 : utf8_path,
4800 : src,
4801 : strict,
4802 : options,
4803 : callback,
4804 : callback_data );
4805 3893 : return ds;
4806 : }
4807 2361 : SWIGINTERN CPLErr GDALDriverShadow_Delete(GDALDriverShadow *self,char const *utf8_path){
4808 2361 : return GDALDeleteDataset( self, utf8_path );
4809 : }
4810 173 : SWIGINTERN CPLErr GDALDriverShadow_Rename(GDALDriverShadow *self,char const *newName,char const *oldName){
4811 173 : return GDALRenameDataset( self, newName, oldName );
4812 : }
4813 3 : SWIGINTERN CPLErr GDALDriverShadow_CopyFiles(GDALDriverShadow *self,char const *newName,char const *oldName){
4814 3 : return GDALCopyDatasetFiles( self, newName, oldName );
4815 : }
4816 2 : SWIGINTERN bool GDALDriverShadow_HasOpenOption(GDALDriverShadow *self,char const *openOptionName){
4817 2 : return GDALDriverHasOpenOption( self, openOptionName );
4818 : }
4819 6 : SWIGINTERN bool GDALDriverShadow_TestCapability(GDALDriverShadow *self,char const *cap){
4820 : // TODO: should this also check DCAP entries in driver metadata?
4821 12 : return (OGR_Dr_TestCapability(self, cap) > 0);
4822 : }
4823 93 : SWIGINTERN int GDALDriverShadow_Register(GDALDriverShadow *self){
4824 93 : return GDALRegisterDriver( self );
4825 : }
4826 93 : SWIGINTERN void GDALDriverShadow_Deregister(GDALDriverShadow *self){
4827 93 : GDALDeregisterDriver( self );
4828 93 : }
4829 :
4830 98600 : char const *GDALDriverShadow_ShortName_get( GDALDriverShadow *h ) {
4831 98600 : return GDALGetDriverShortName( h );
4832 : }
4833 17 : char const *GDALDriverShadow_LongName_get( GDALDriverShadow *h ) {
4834 17 : return GDALGetDriverLongName( h );
4835 : }
4836 0 : char const *GDALDriverShadow_HelpTopic_get( GDALDriverShadow *h ) {
4837 0 : return GDALGetDriverHelpTopic( h );
4838 : }
4839 :
4840 :
4841 : SWIGINTERN int
4842 0 : SWIG_AsVal_short (PyObject * obj, short *val)
4843 : {
4844 0 : long v;
4845 0 : int res = SWIG_AsVal_long (obj, &v);
4846 0 : if (SWIG_IsOK(res)) {
4847 0 : if ((v < SHRT_MIN || v > SHRT_MAX)) {
4848 : return SWIG_OverflowError;
4849 : } else {
4850 0 : if (val) *val = static_cast< short >(v);
4851 : }
4852 : }
4853 : return res;
4854 : }
4855 :
4856 :
4857 : #define SWIG_From_long PyInt_FromLong
4858 :
4859 :
4860 : SWIGINTERNINLINE PyObject *
4861 0 : SWIG_From_short (short value)
4862 : {
4863 0 : return SWIG_From_long (value);
4864 : }
4865 :
4866 :
4867 : #define SWIG_From_double PyFloat_FromDouble
4868 :
4869 3428 : SWIGINTERN GDAL_GCP *new_GDAL_GCP(double x=0.0,double y=0.0,double z=0.0,double pixel=0.0,double line=0.0,char const *info="",char const *id=""){
4870 :
4871 3428 : GDAL_GCP *self = (GDAL_GCP*) CPLMalloc( sizeof( GDAL_GCP ) );
4872 3428 : self->dfGCPX = x;
4873 3428 : self->dfGCPY = y;
4874 3428 : self->dfGCPZ = z;
4875 3428 : self->dfGCPPixel = pixel;
4876 3428 : self->dfGCPLine = line;
4877 3428 : self->pszInfo = CPLStrdup( (info == 0) ? "" : info );
4878 3428 : self->pszId = CPLStrdup( (id==0)? "" : id );
4879 3428 : return self;
4880 : }
4881 3428 : SWIGINTERN void delete_GDAL_GCP(GDAL_GCP *self){
4882 3428 : if ( self->pszInfo )
4883 3428 : CPLFree( self->pszInfo );
4884 3428 : if ( self->pszId )
4885 3428 : CPLFree( self->pszId );
4886 3428 : CPLFree( self );
4887 3428 : }
4888 :
4889 :
4890 2205 : double GDAL_GCP_GCPX_get( GDAL_GCP *gcp ) {
4891 2205 : return gcp->dfGCPX;
4892 : }
4893 92 : void GDAL_GCP_GCPX_set( GDAL_GCP *gcp, double dfGCPX ) {
4894 92 : gcp->dfGCPX = dfGCPX;
4895 92 : }
4896 2205 : double GDAL_GCP_GCPY_get( GDAL_GCP *gcp ) {
4897 2205 : return gcp->dfGCPY;
4898 : }
4899 92 : void GDAL_GCP_GCPY_set( GDAL_GCP *gcp, double dfGCPY ) {
4900 92 : gcp->dfGCPY = dfGCPY;
4901 92 : }
4902 42 : double GDAL_GCP_GCPZ_get( GDAL_GCP *gcp ) {
4903 42 : return gcp->dfGCPZ;
4904 : }
4905 0 : void GDAL_GCP_GCPZ_set( GDAL_GCP *gcp, double dfGCPZ ) {
4906 0 : gcp->dfGCPZ = dfGCPZ;
4907 0 : }
4908 8554 : double GDAL_GCP_GCPPixel_get( GDAL_GCP *gcp ) {
4909 8554 : return gcp->dfGCPPixel;
4910 : }
4911 100 : void GDAL_GCP_GCPPixel_set( GDAL_GCP *gcp, double dfGCPPixel ) {
4912 100 : gcp->dfGCPPixel = dfGCPPixel;
4913 100 : }
4914 8554 : double GDAL_GCP_GCPLine_get( GDAL_GCP *gcp ) {
4915 8554 : return gcp->dfGCPLine;
4916 : }
4917 100 : void GDAL_GCP_GCPLine_set( GDAL_GCP *gcp, double dfGCPLine ) {
4918 100 : gcp->dfGCPLine = dfGCPLine;
4919 100 : }
4920 9 : const char * GDAL_GCP_Info_get( GDAL_GCP *gcp ) {
4921 9 : return gcp->pszInfo;
4922 : }
4923 1 : void GDAL_GCP_Info_set( GDAL_GCP *gcp, const char * pszInfo ) {
4924 1 : if ( gcp->pszInfo )
4925 1 : CPLFree( gcp->pszInfo );
4926 1 : gcp->pszInfo = CPLStrdup(pszInfo);
4927 1 : }
4928 9 : const char * GDAL_GCP_Id_get( GDAL_GCP *gcp ) {
4929 9 : return gcp->pszId;
4930 : }
4931 1 : void GDAL_GCP_Id_set( GDAL_GCP *gcp, const char * pszId ) {
4932 1 : if ( gcp->pszId )
4933 1 : CPLFree( gcp->pszId );
4934 1 : gcp->pszId = CPLStrdup(pszId);
4935 1 : }
4936 :
4937 :
4938 : static PyObject *
4939 14197 : CreateTupleFromDoubleArray( const double *first, size_t size ) {
4940 14197 : PyObject *out = PyTuple_New( size );
4941 67170 : for( unsigned int i=0; i<size; i++ ) {
4942 52973 : PyObject *val = PyFloat_FromDouble( *first );
4943 52973 : ++first;
4944 52973 : PyTuple_SetItem( out, i, val );
4945 : }
4946 14197 : return out;
4947 : }
4948 :
4949 :
4950 : #include "gdal.h"
4951 :
4952 : typedef struct
4953 : {
4954 : CPLVirtualMem *vmem;
4955 : int bAuto;
4956 : GDALDataType eBufType;
4957 : int bIsBandSequential;
4958 : int bReadOnly;
4959 : int nBufXSize;
4960 : int nBufYSize;
4961 : int nBandCount;
4962 : GDALTileOrganization eTileOrganization;
4963 : int nTileXSize;
4964 : int nTileYSize;
4965 : int nPixelSpace; /* if bAuto == TRUE */
4966 : GIntBig nLineSpace; /* if bAuto == TRUE */
4967 : } CPLVirtualMemShadow;
4968 :
4969 :
4970 0 : SWIGINTERN void delete_CPLVirtualMemShadow(CPLVirtualMemShadow *self){
4971 0 : CPLVirtualMemFree( self->vmem );
4972 0 : free(self);
4973 : }
4974 0 : SWIGINTERN void CPLVirtualMemShadow_GetAddr(CPLVirtualMemShadow *self,void **pptr,size_t *pnsize,GDALDataType *pdatatype,int *preadonly){
4975 0 : *pptr = CPLVirtualMemGetAddr( self->vmem );
4976 0 : *pnsize = CPLVirtualMemGetSize( self->vmem );
4977 0 : *pdatatype = self->eBufType;
4978 0 : *preadonly = self->bReadOnly;
4979 : }
4980 : SWIGINTERN void CPLVirtualMemShadow_Pin(CPLVirtualMemShadow *self,size_t start_offset=0,size_t nsize=0,int bWriteOp=0){
4981 : if( nsize == 0 || start_offset + nsize >= CPLVirtualMemGetSize( self->vmem ) )
4982 : nsize = CPLVirtualMemGetSize( self->vmem ) - start_offset;
4983 : char* start_addr = (char*)CPLVirtualMemGetAddr( self->vmem ) + start_offset;
4984 : CPLVirtualMemPin(self->vmem, start_addr, nsize, bWriteOp);
4985 : }
4986 :
4987 : /* Returned size is in bytes or 0 if an error occurred. */
4988 : static
4989 353180 : GIntBig ComputeDatasetRasterIOSize (int buf_xsize, int buf_ysize, int nPixelSize,
4990 : int nBands, int* bandMap, int nBandMapArrayLength,
4991 : GIntBig nPixelSpace, GIntBig nLineSpace, GIntBig nBandSpace,
4992 : int bSpacingShouldBeMultipleOfPixelSize )
4993 : {
4994 353180 : if (buf_xsize <= 0 || buf_ysize <= 0)
4995 : {
4996 2 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal values for buffer size");
4997 2 : return 0;
4998 : }
4999 :
5000 353178 : if (nPixelSpace < 0 || nLineSpace < 0 || nBandSpace < 0)
5001 : {
5002 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal values for space arguments");
5003 0 : return 0;
5004 : }
5005 :
5006 353178 : if (nPixelSize == 0)
5007 : {
5008 1 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal value for data type");
5009 1 : return 0;
5010 : }
5011 :
5012 353177 : if( nPixelSpace == 0 )
5013 352042 : nPixelSpace = nPixelSize;
5014 1135 : else if ( bSpacingShouldBeMultipleOfPixelSize && (nPixelSpace % nPixelSize) != 0 )
5015 : {
5016 0 : CPLError(CE_Failure, CPLE_IllegalArg, "nPixelSpace should be a multiple of nPixelSize");
5017 0 : return 0;
5018 : }
5019 :
5020 353177 : if( nLineSpace == 0 )
5021 : {
5022 353126 : nLineSpace = nPixelSpace * buf_xsize;
5023 : }
5024 51 : else if ( bSpacingShouldBeMultipleOfPixelSize && (nLineSpace % nPixelSize) != 0 )
5025 : {
5026 0 : CPLError(CE_Failure, CPLE_IllegalArg, "nLineSpace should be a multiple of nPixelSize");
5027 0 : return 0;
5028 : }
5029 :
5030 353177 : if( nBandSpace == 0 )
5031 : {
5032 352064 : nBandSpace = nLineSpace * buf_ysize;
5033 : }
5034 1113 : else if ( bSpacingShouldBeMultipleOfPixelSize && (nBandSpace % nPixelSize) != 0 )
5035 : {
5036 0 : CPLError(CE_Failure, CPLE_IllegalArg, "nLineSpace should be a multiple of nPixelSize");
5037 0 : return 0;
5038 : }
5039 :
5040 353177 : if (nBands <= 0 || (bandMap != NULL && nBands > nBandMapArrayLength))
5041 : {
5042 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Invalid band count");
5043 0 : return 0;
5044 : }
5045 :
5046 353177 : GIntBig nRet = (GIntBig)(buf_ysize - 1) * nLineSpace + (GIntBig)(buf_xsize - 1) * nPixelSpace + (GIntBig)(nBands - 1) * nBandSpace + nPixelSize;
5047 : #if SIZEOF_VOIDP == 4
5048 : if (nRet > INT_MAX)
5049 : {
5050 : CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
5051 : return 0;
5052 : }
5053 : #endif
5054 :
5055 353177 : return nRet;
5056 : }
5057 :
5058 :
5059 : typedef struct
5060 : {
5061 : GDALAsyncReaderH hAsyncReader;
5062 : void *pyObject;
5063 : } GDALAsyncReaderWrapper;
5064 :
5065 : typedef void* GDALAsyncReaderWrapperH;
5066 :
5067 3 : static GDALAsyncReaderH AsyncReaderWrapperGetReader(GDALAsyncReaderWrapperH hWrapper)
5068 : {
5069 3 : GDALAsyncReaderWrapper* psWrapper = (GDALAsyncReaderWrapper*)hWrapper;
5070 3 : if (psWrapper->hAsyncReader == NULL)
5071 : {
5072 0 : CPLError(CE_Failure, CPLE_AppDefined, "AsyncReader object is defunct");
5073 : }
5074 3 : return psWrapper->hAsyncReader;
5075 : }
5076 :
5077 : #if defined(SWIGPYTHON)
5078 1 : static void* AsyncReaderWrapperGetPyObject(GDALAsyncReaderWrapperH hWrapper)
5079 : {
5080 1 : GDALAsyncReaderWrapper* psWrapper = (GDALAsyncReaderWrapper*)hWrapper;
5081 1 : return psWrapper->pyObject;
5082 : }
5083 : #endif
5084 :
5085 1 : static void DeleteAsyncReaderWrapper(GDALAsyncReaderWrapperH hWrapper)
5086 : {
5087 1 : GDALAsyncReaderWrapper* psWrapper = (GDALAsyncReaderWrapper*)hWrapper;
5088 1 : if (psWrapper->hAsyncReader != NULL)
5089 : {
5090 0 : CPLError(CE_Failure, CPLE_AppDefined,
5091 : "Native AsyncReader object will leak. EndAsyncReader() should have been called before");
5092 : }
5093 1 : CPLFree(psWrapper);
5094 1 : }
5095 :
5096 :
5097 :
5098 :
5099 1 : static GDALAsyncReaderWrapper* CreateAsyncReaderWrapper(GDALAsyncReaderH hAsyncReader,
5100 : void *pyObject)
5101 : {
5102 2 : GDALAsyncReaderWrapper* psWrapper = (GDALAsyncReaderWrapper* )CPLMalloc(sizeof(GDALAsyncReaderWrapper));
5103 1 : psWrapper->hAsyncReader = hAsyncReader;
5104 1 : psWrapper->pyObject = pyObject;
5105 1 : Py_INCREF((PyObject*) psWrapper->pyObject);
5106 1 : return psWrapper;
5107 : }
5108 :
5109 1 : static void DisableAsyncReaderWrapper(GDALAsyncReaderWrapperH hWrapper)
5110 : {
5111 1 : GDALAsyncReaderWrapper* psWrapper = (GDALAsyncReaderWrapper*)hWrapper;
5112 1 : if (psWrapper->pyObject)
5113 : {
5114 1 : Py_XDECREF((PyObject*) psWrapper->pyObject);
5115 : }
5116 1 : psWrapper->pyObject = NULL;
5117 1 : psWrapper->hAsyncReader = NULL;
5118 1 : }
5119 :
5120 1 : SWIGINTERN void delete_GDALAsyncReaderShadow(GDALAsyncReaderShadow *self){
5121 1 : DeleteAsyncReaderWrapper(self);
5122 1 : }
5123 1 : SWIGINTERN GDALAsyncStatusType GDALAsyncReaderShadow_GetNextUpdatedRegion(GDALAsyncReaderShadow *self,double timeout,int *xoff,int *yoff,int *buf_xsize,int *buf_ysize){
5124 1 : GDALAsyncReaderH hReader = AsyncReaderWrapperGetReader(self);
5125 1 : if (hReader == NULL)
5126 : {
5127 0 : *xoff = 0;
5128 0 : *yoff = 0;
5129 0 : *buf_xsize = 0;
5130 0 : *buf_ysize = 0;
5131 0 : return GARIO_ERROR;
5132 : }
5133 1 : return GDALARGetNextUpdatedRegion(hReader, timeout, xoff, yoff, buf_xsize, buf_ysize );
5134 : }
5135 1 : SWIGINTERN void GDALAsyncReaderShadow_GetBuffer(GDALAsyncReaderShadow *self,void **ppRetPyObject){
5136 1 : GDALAsyncReaderH hReader = AsyncReaderWrapperGetReader(self);
5137 1 : if (hReader == NULL)
5138 : {
5139 0 : *ppRetPyObject = NULL;
5140 0 : return;
5141 : }
5142 1 : *ppRetPyObject = AsyncReaderWrapperGetPyObject(self);
5143 1 : Py_INCREF((PyObject*)*ppRetPyObject);
5144 : }
5145 0 : SWIGINTERN int GDALAsyncReaderShadow_LockBuffer(GDALAsyncReaderShadow *self,double timeout){
5146 0 : GDALAsyncReaderH hReader = AsyncReaderWrapperGetReader(self);
5147 0 : if (hReader == NULL)
5148 : {
5149 : return 0;
5150 : }
5151 0 : return GDALARLockBuffer(hReader,timeout);
5152 : }
5153 0 : SWIGINTERN void GDALAsyncReaderShadow_UnlockBuffer(GDALAsyncReaderShadow *self){
5154 0 : GDALAsyncReaderH hReader = AsyncReaderWrapperGetReader(self);
5155 0 : if (hReader == NULL)
5156 : {
5157 : return;
5158 : }
5159 0 : GDALARUnlockBuffer(hReader);
5160 : }
5161 56619 : SWIGINTERN void delete_GDALDatasetShadow(GDALDatasetShadow *self){
5162 56619 : if ( GDALDereferenceDataset( self ) <= 0 ) {
5163 49282 : if( GDALClose(self) != CE_None )
5164 : {
5165 7 : if( CPLGetLastErrorType() == CE_None )
5166 1 : CPLError(CE_Failure, CPLE_AppDefined, "Error occurred in GDALClose()");
5167 : }
5168 : }
5169 56619 : }
5170 4 : SWIGINTERN void GDALDatasetShadow_MarkSuppressOnClose(GDALDatasetShadow *self){
5171 4 : GDALDatasetMarkSuppressOnClose(self);
5172 4 : }
5173 3992 : SWIGINTERN CPLErr GDALDatasetShadow_Close(GDALDatasetShadow *self){
5174 3992 : return GDALClose(self);
5175 : }
5176 12 : SWIGINTERN CPLErr GDALDatasetShadow__RunCloseWithoutDestroying(GDALDatasetShadow *self){
5177 12 : CPLErr eErr = GDALDatasetRunCloseWithoutDestroying(self);
5178 12 : if (eErr != CE_None && CPLGetLastErrorType() == CE_None ) {
5179 0 : CPLError(CE_Failure, CPLE_AppDefined, "Error occurred in GDALDatasetRunCloseWithoutDestroying()");
5180 : }
5181 12 : return eErr;
5182 : }
5183 1329 : SWIGINTERN GDALDriverShadow *GDALDatasetShadow_GetDriver(GDALDatasetShadow *self){
5184 1329 : return (GDALDriverShadow*) GDALGetDatasetDriver( self );
5185 : }
5186 360577 : SWIGINTERN GDALRasterBandShadow *GDALDatasetShadow_GetRasterBand(GDALDatasetShadow *self,int nBand){
5187 360577 : return (GDALRasterBandShadow*) GDALGetRasterBand( self, nBand );
5188 : }
5189 5 : SWIGINTERN bool GDALDatasetShadow_IsThreadSafe(GDALDatasetShadow *self,int nScopeFlags){
5190 5 : return GDALDatasetIsThreadSafe(self, nScopeFlags, nullptr);
5191 : }
5192 8 : SWIGINTERN GDALDatasetShadow *GDALDatasetShadow_GetThreadSafeDataset(GDALDatasetShadow *self,int nScopeFlags){
5193 8 : return GDALGetThreadSafeDataset(self, nScopeFlags, nullptr);
5194 : }
5195 1265 : SWIGINTERN GDALGroupHS *GDALDatasetShadow_GetRootGroup(GDALDatasetShadow *self){
5196 1265 : return GDALDatasetGetRootGroup(self);
5197 : }
5198 454 : SWIGINTERN char const *GDALDatasetShadow_GetProjection(GDALDatasetShadow *self){
5199 454 : return GDALGetProjectionRef( self );
5200 : }
5201 858 : SWIGINTERN char const *GDALDatasetShadow_GetProjectionRef(GDALDatasetShadow *self){
5202 858 : return GDALGetProjectionRef( self );
5203 : }
5204 3999 : SWIGINTERN int GDALDatasetShadow_GetRefCount(GDALDatasetShadow *self){
5205 3999 : return OGR_DS_GetRefCount(self);
5206 : }
5207 0 : SWIGINTERN int GDALDatasetShadow_GetSummaryRefCount(GDALDatasetShadow *self){
5208 0 : return OGR_DS_GetSummaryRefCount(self);
5209 : }
5210 1250 : SWIGINTERN OSRSpatialReferenceShadow *GDALDatasetShadow_GetSpatialRef(GDALDatasetShadow *self){
5211 1250 : OGRSpatialReferenceH ref = GDALGetSpatialRef(self);
5212 1250 : if( ref )
5213 830 : ref = OSRClone( ref );
5214 1250 : return (OSRSpatialReferenceShadow*) ref;
5215 : }
5216 1630 : SWIGINTERN CPLErr GDALDatasetShadow_SetProjection(GDALDatasetShadow *self,char const *prj){
5217 1630 : return GDALSetProjection( self, prj );
5218 : }
5219 321 : SWIGINTERN CPLErr GDALDatasetShadow_SetSpatialRef(GDALDatasetShadow *self,OSRSpatialReferenceShadow *srs){
5220 321 : return GDALSetSpatialRef( self, (OGRSpatialReferenceH)srs );
5221 : }
5222 4010 : SWIGINTERN void GDALDatasetShadow_GetGeoTransform(GDALDatasetShadow *self,double argout[6],int *isvalid,int *can_return_null=0){
5223 4010 : if (can_return_null && *can_return_null)
5224 : {
5225 403 : *isvalid = (GDALGetGeoTransform( self, argout ) == CE_None );
5226 : }
5227 : else
5228 : {
5229 3607 : *isvalid = TRUE;
5230 3607 : if ( GDALGetGeoTransform( self, argout ) != CE_None ) {
5231 80 : argout[0] = 0.0;
5232 80 : argout[1] = 1.0;
5233 80 : argout[2] = 0.0;
5234 80 : argout[3] = 0.0;
5235 80 : argout[4] = 0.0;
5236 80 : argout[5] = 1.0;
5237 : }
5238 : }
5239 4010 : }
5240 3093 : SWIGINTERN CPLErr GDALDatasetShadow_SetGeoTransform(GDALDatasetShadow *self,double argin[6]){
5241 3093 : return GDALSetGeoTransform( self, argin );
5242 : }
5243 10 : SWIGINTERN void GDALDatasetShadow_GetExtent(GDALDatasetShadow *self,double argout[4],int *isvalid,OSRSpatialReferenceShadow *srs=NULL){
5244 20 : CPLErr eErr = GDALGetExtent(self, (OGREnvelope*)argout, srs);
5245 10 : *isvalid = (eErr == CE_None);
5246 10 : return;
5247 : }
5248 4 : SWIGINTERN void GDALDatasetShadow_GetExtentWGS84LongLat(GDALDatasetShadow *self,double argout[4],int *isvalid){
5249 8 : CPLErr eErr = GDALGetExtentWGS84LongLat(self, (OGREnvelope*)argout);
5250 4 : *isvalid = (eErr == CE_None);
5251 4 : return;
5252 : }
5253 :
5254 : static int*
5255 354057 : CreateCIntListFromSequence( PyObject* pySeq, int* pnSize ) {
5256 : /* check if is List */
5257 354057 : if ( !PySequence_Check(pySeq) ) {
5258 1 : PyErr_SetString(PyExc_TypeError, "not a sequence");
5259 1 : *pnSize = -1;
5260 1 : return NULL;
5261 : }
5262 354056 : Py_ssize_t size = PySequence_Size(pySeq);
5263 354056 : if( size > (Py_ssize_t)INT_MAX ) {
5264 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
5265 0 : *pnSize = -1;
5266 0 : return NULL;
5267 : }
5268 354056 : if( (size_t)size > SIZE_MAX / sizeof(int) ) {
5269 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
5270 0 : *pnSize = -1;
5271 0 : return NULL;
5272 : }
5273 354056 : *pnSize = (int)size;
5274 354056 : int* ret = (int*) malloc((*pnSize)*sizeof(int));
5275 354056 : if( !ret ) {
5276 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
5277 0 : *pnSize = -1;
5278 0 : return NULL;
5279 : }
5280 798360 : for( int i = 0; i<*pnSize; i++ ) {
5281 444305 : PyObject *o = PySequence_GetItem(pySeq,i);
5282 444305 : if ( !PyArg_Parse(o,"i",&ret[i]) ) {
5283 1 : PyErr_SetString(PyExc_TypeError, "not an integer");
5284 1 : Py_DECREF(o);
5285 1 : free(ret);
5286 1 : *pnSize = -1;
5287 1 : return NULL;
5288 : }
5289 444304 : Py_DECREF(o);
5290 : }
5291 : return ret;
5292 : }
5293 :
5294 683 : SWIGINTERN int GDALDatasetShadow_BuildOverviews(GDALDatasetShadow *self,char const *resampling="NEAREST",int overviewlist=0,int *pOverviews=0,GDALProgressFunc callback=NULL,void *callback_data=NULL,char **options=NULL){
5295 :
5296 683 : return GDALBuildOverviewsEx( self,
5297 : resampling ? resampling : "NEAREST",
5298 : overviewlist,
5299 : pOverviews,
5300 : 0,
5301 : 0,
5302 : callback,
5303 : callback_data,
5304 683 : options);
5305 : }
5306 117 : SWIGINTERN int GDALDatasetShadow_GetGCPCount(GDALDatasetShadow *self){
5307 117 : return GDALGetGCPCount( self );
5308 : }
5309 454 : SWIGINTERN char const *GDALDatasetShadow_GetGCPProjection(GDALDatasetShadow *self){
5310 454 : return GDALGetGCPProjection( self );
5311 : }
5312 426 : SWIGINTERN OSRSpatialReferenceShadow *GDALDatasetShadow_GetGCPSpatialRef(GDALDatasetShadow *self){
5313 426 : OGRSpatialReferenceH ref = GDALGetGCPSpatialRef(self);
5314 426 : if( ref )
5315 217 : ref = OSRClone( ref );
5316 426 : return (OSRSpatialReferenceShadow*) ref;
5317 : }
5318 528 : SWIGINTERN void GDALDatasetShadow_GetGCPs(GDALDatasetShadow *self,int *nGCPs,GDAL_GCP const **pGCPs){
5319 1056 : *nGCPs = GDALGetGCPCount( self );
5320 528 : *pGCPs = GDALGetGCPs( self );
5321 : }
5322 28 : SWIGINTERN CPLErr GDALDatasetShadow_SetGCPs(GDALDatasetShadow *self,int nGCPs,GDAL_GCP const *pGCPs,char const *pszGCPProjection){
5323 28 : return GDALSetGCPs( self, nGCPs, pGCPs, pszGCPProjection );
5324 : }
5325 9 : SWIGINTERN CPLErr GDALDatasetShadow_SetGCPs2(GDALDatasetShadow *self,int nGCPs,GDAL_GCP const *pGCPs,OSRSpatialReferenceShadow *hSRS){
5326 9 : return GDALSetGCPs2( self, nGCPs, pGCPs, (OGRSpatialReferenceH)hSRS );
5327 : }
5328 1623 : SWIGINTERN CPLErr GDALDatasetShadow_FlushCache(GDALDatasetShadow *self){
5329 1623 : return GDALFlushCache( self );
5330 : }
5331 32 : SWIGINTERN CPLErr GDALDatasetShadow_AddBand(GDALDatasetShadow *self,GDALDataType datatype=GDT_Byte,char **options=0){
5332 32 : return GDALAddBand( self, datatype, options );
5333 : }
5334 60 : SWIGINTERN CPLErr GDALDatasetShadow_CreateMaskBand(GDALDatasetShadow *self,int nFlags){
5335 60 : return GDALCreateDatasetMaskBand( self, nFlags );
5336 : }
5337 460 : SWIGINTERN char **GDALDatasetShadow_GetFileList(GDALDatasetShadow *self){
5338 460 : return GDALGetFileList( self );
5339 : }
5340 176515 : SWIGINTERN CPLErr GDALDatasetShadow_WriteRaster(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,GIntBig buf_len,char *buf_string,int *buf_xsize=0,int *buf_ysize=0,GDALDataType *buf_type=0,int band_list=0,int *pband_list=0,GIntBig *buf_pixel_space=0,GIntBig *buf_line_space=0,GIntBig *buf_band_space=0){
5341 176515 : CPLErr eErr;
5342 176515 : int nxsize = (buf_xsize==0) ? xsize : *buf_xsize;
5343 176515 : int nysize = (buf_ysize==0) ? ysize : *buf_ysize;
5344 176515 : GDALDataType ntype;
5345 176515 : if ( buf_type != 0 ) {
5346 176515 : ntype = (GDALDataType) *buf_type;
5347 : } else {
5348 0 : int lastband = GDALGetRasterCount( self );
5349 0 : if (lastband <= 0)
5350 : return CE_Failure;
5351 0 : ntype = GDALGetRasterDataType( GDALGetRasterBand( self, lastband ) );
5352 : }
5353 :
5354 176515 : GIntBig pixel_space = (buf_pixel_space == 0) ? 0 : *buf_pixel_space;
5355 176515 : GIntBig line_space = (buf_line_space == 0) ? 0 : *buf_line_space;
5356 176515 : GIntBig band_space = (buf_band_space == 0) ? 0 : *buf_band_space;
5357 :
5358 176515 : GIntBig min_buffer_size =
5359 176515 : ComputeDatasetRasterIOSize (nxsize, nysize, GDALGetDataTypeSizeBytes( ntype ),
5360 0 : band_list ? band_list : GDALGetRasterCount(self), pband_list, band_list,
5361 : pixel_space, line_space, band_space, FALSE);
5362 176515 : if (min_buffer_size == 0)
5363 : return CE_Failure;
5364 :
5365 176514 : if ( buf_len < min_buffer_size )
5366 : {
5367 1 : CPLError(CE_Failure, CPLE_AppDefined, "Buffer too small");
5368 1 : return CE_Failure;
5369 : }
5370 :
5371 176513 : GDALRasterIOExtraArg* psExtraArg = NULL;
5372 :
5373 176513 : eErr = GDALDatasetRasterIOEx( self, GF_Write, xoff, yoff, xsize, ysize,
5374 : (void*) buf_string, nxsize, nysize, ntype,
5375 : band_list, pband_list, pixel_space, line_space, band_space, psExtraArg );
5376 :
5377 176513 : return eErr;
5378 : }
5379 1 : SWIGINTERN CPLErr GDALDatasetShadow_AdviseRead(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int *buf_xsize=0,int *buf_ysize=0,GDALDataType *buf_type=0,int band_list=0,int *pband_list=0,char **options=NULL){
5380 1 : int nxsize = (buf_xsize==0) ? xsize : *buf_xsize;
5381 1 : int nysize = (buf_ysize==0) ? ysize : *buf_ysize;
5382 1 : GDALDataType ntype;
5383 1 : if ( buf_type != 0 ) {
5384 0 : ntype = (GDALDataType) *buf_type;
5385 : } else {
5386 1 : int lastband = GDALGetRasterCount( self );
5387 1 : if (lastband <= 0)
5388 : return CE_Failure;
5389 1 : ntype = GDALGetRasterDataType( GDALGetRasterBand( self, lastband ) );
5390 : }
5391 1 : return GDALDatasetAdviseRead(self, xoff, yoff, xsize, ysize,
5392 : nxsize, nysize, ntype,
5393 1 : band_list, pband_list, options);
5394 : }
5395 2 : SWIGINTERN GDALAsyncReaderShadow *GDALDatasetShadow_BeginAsyncReader(GDALDatasetShadow *self,int xOff,int yOff,int xSize,int ySize,size_t buf_len,char *buf_string,void *pyObject,int buf_xsize,int buf_ysize,GDALDataType bufType=(GDALDataType) 0,int band_list=0,int *pband_list=0,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0,char **options=0){
5396 :
5397 2 : if ((options != NULL) && (buf_xsize ==0) && (buf_ysize == 0))
5398 : {
5399 : // calculate an appropriate buffer size
5400 0 : const char* pszLevel = CSLFetchNameValue(options, "LEVEL");
5401 0 : if (pszLevel)
5402 : {
5403 : // round up
5404 0 : int nLevel = atoi(pszLevel);
5405 0 : if( nLevel < 0 || nLevel > 30 )
5406 : {
5407 0 : CPLError(CE_Failure, CPLE_AppDefined, "Invalid LEVEL: %d", nLevel);
5408 : }
5409 : else
5410 : {
5411 0 : int nRes = 1 << nLevel;
5412 0 : buf_xsize = static_cast<int>(ceil(xSize / (1.0 * nRes)));
5413 0 : buf_ysize = static_cast<int>(ceil(ySize / (1.0 * nRes)));
5414 : }
5415 : }
5416 : }
5417 :
5418 2 : int nxsize = (buf_xsize == 0) ? xSize : buf_xsize;
5419 2 : int nysize = (buf_ysize == 0) ? ySize : buf_ysize;
5420 :
5421 2 : GDALDataType ntype;
5422 2 : if (bufType != 0) {
5423 : ntype = (GDALDataType) bufType;
5424 : }
5425 : else {
5426 : ntype = GDT_Byte;
5427 : }
5428 :
5429 2 : int nBCount = (band_list) != 0 ? band_list : GDALGetRasterCount(self);
5430 2 : uint64_t nMinSize = (uint64_t)nxsize * nysize * nBCount * GDALGetDataTypeSizeBytes(ntype);
5431 2 : if (buf_string == NULL || buf_len < nMinSize)
5432 : {
5433 0 : CPLError(CE_Failure, CPLE_AppDefined, "Buffer is too small");
5434 0 : return NULL;
5435 : }
5436 :
5437 2 : bool myBandList = false;
5438 2 : int* pBandList;
5439 :
5440 2 : if (band_list != 0){
5441 : myBandList = false;
5442 : pBandList = pband_list;
5443 : }
5444 : else
5445 : {
5446 0 : myBandList = true;
5447 0 : pBandList = (int*)CPLMalloc(sizeof(int) * nBCount);
5448 0 : for (int i = 0; i < nBCount; ++i) {
5449 0 : pBandList[i] = i + 1;
5450 : }
5451 : }
5452 :
5453 2 : GDALAsyncReaderH hAsyncReader =
5454 2 : GDALBeginAsyncReader(self, xOff, yOff, xSize, ySize, (void*) buf_string, nxsize, nysize, ntype, nBCount, pBandList, nPixelSpace, nLineSpace,
5455 : nBandSpace, options);
5456 :
5457 2 : if ( myBandList ) {
5458 0 : CPLFree( pBandList );
5459 : }
5460 :
5461 2 : if (hAsyncReader)
5462 : {
5463 1 : return (GDALAsyncReaderShadow*) CreateAsyncReaderWrapper(hAsyncReader, pyObject);
5464 : }
5465 : else
5466 : {
5467 : return NULL;
5468 : }
5469 :
5470 : }
5471 1 : SWIGINTERN void GDALDatasetShadow_EndAsyncReader(GDALDatasetShadow *self,GDALAsyncReaderShadow *ario){
5472 1 : if( ario == NULL ) return;
5473 1 : GDALAsyncReaderH hReader = AsyncReaderWrapperGetReader(ario);
5474 1 : if (hReader == NULL)
5475 : {
5476 : return;
5477 : }
5478 1 : GDALEndAsyncReader(self, hReader);
5479 1 : DisableAsyncReaderWrapper(ario);
5480 : }
5481 3 : SWIGINTERN CPLVirtualMemShadow *GDALDatasetShadow_GetVirtualMem(GDALDatasetShadow *self,GDALRWFlag eRWFlag,int nXOff,int nYOff,int nXSize,int nYSize,int nBufXSize,int nBufYSize,GDALDataType eBufType,int band_list,int *pband_list,int bIsBandSequential,size_t nCacheSize,size_t nPageSizeHint,char **options=NULL){
5482 3 : int nPixelSpace;
5483 3 : int nBandSpace;
5484 3 : if( bIsBandSequential != 0 && bIsBandSequential != 1 )
5485 : return NULL;
5486 3 : if( band_list == 0 )
5487 : return NULL;
5488 3 : if( bIsBandSequential || band_list == 1 )
5489 : {
5490 : nPixelSpace = 0;
5491 : nBandSpace = 0;
5492 : }
5493 : else
5494 : {
5495 1 : nBandSpace = GDALGetDataTypeSizeBytes(eBufType);
5496 1 : nPixelSpace = nBandSpace * band_list;
5497 : }
5498 3 : CPLVirtualMem* vmem = GDALDatasetGetVirtualMem( self,
5499 : eRWFlag,
5500 : nXOff, nYOff,
5501 : nXSize, nYSize,
5502 : nBufXSize, nBufYSize,
5503 : eBufType,
5504 : band_list, pband_list,
5505 : nPixelSpace,
5506 : 0,
5507 : nBandSpace,
5508 : nCacheSize,
5509 : nPageSizeHint,
5510 : FALSE,
5511 : options );
5512 3 : if( vmem == NULL )
5513 : return NULL;
5514 3 : CPLVirtualMemShadow* vmemshadow = (CPLVirtualMemShadow*)calloc(1, sizeof(CPLVirtualMemShadow));
5515 3 : vmemshadow->vmem = vmem;
5516 3 : vmemshadow->eBufType = eBufType;
5517 3 : vmemshadow->bIsBandSequential = bIsBandSequential;
5518 3 : vmemshadow->bReadOnly = (eRWFlag == GF_Read);
5519 3 : vmemshadow->nBufXSize = nBufXSize;
5520 3 : vmemshadow->nBufYSize = nBufYSize;
5521 3 : vmemshadow->nBandCount = band_list;
5522 3 : return vmemshadow;
5523 : }
5524 3 : SWIGINTERN CPLVirtualMemShadow *GDALDatasetShadow_GetTiledVirtualMem(GDALDatasetShadow *self,GDALRWFlag eRWFlag,int nXOff,int nYOff,int nXSize,int nYSize,int nTileXSize,int nTileYSize,GDALDataType eBufType,int band_list,int *pband_list,GDALTileOrganization eTileOrganization,size_t nCacheSize,char **options=NULL){
5525 3 : if( band_list == 0 )
5526 : return NULL;
5527 3 : CPLVirtualMem* vmem = GDALDatasetGetTiledVirtualMem( self,
5528 : eRWFlag,
5529 : nXOff, nYOff,
5530 : nXSize, nYSize,
5531 : nTileXSize, nTileYSize,
5532 : eBufType,
5533 : band_list, pband_list,
5534 : eTileOrganization,
5535 : nCacheSize,
5536 : FALSE,
5537 : options );
5538 3 : if( vmem == NULL )
5539 : return NULL;
5540 3 : CPLVirtualMemShadow* vmemshadow = (CPLVirtualMemShadow*)calloc(1, sizeof(CPLVirtualMemShadow));
5541 3 : vmemshadow->vmem = vmem;
5542 3 : vmemshadow->eBufType = eBufType;
5543 3 : vmemshadow->bIsBandSequential = -1;
5544 3 : vmemshadow->bReadOnly = (eRWFlag == GF_Read);
5545 3 : vmemshadow->nBufXSize = nXSize;
5546 3 : vmemshadow->nBufYSize = nYSize;
5547 3 : vmemshadow->eTileOrganization = eTileOrganization;
5548 3 : vmemshadow->nTileXSize = nTileXSize;
5549 3 : vmemshadow->nTileYSize = nTileYSize;
5550 3 : vmemshadow->nBandCount = band_list;
5551 3 : return vmemshadow;
5552 : }
5553 6225 : SWIGINTERN OGRLayerShadow *GDALDatasetShadow_CreateLayer(GDALDatasetShadow *self,char const *name,OSRSpatialReferenceShadow *srs=NULL,OGRwkbGeometryType geom_type=wkbUnknown,char **options=0){
5554 12450 : OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetCreateLayer( self,
5555 : name,
5556 : srs,
5557 : geom_type,
5558 : options);
5559 6225 : return layer;
5560 : }
5561 14 : SWIGINTERN OGRLayerShadow *GDALDatasetShadow_CreateLayerFromGeomFieldDefn(GDALDatasetShadow *self,char const *name,OGRGeomFieldDefnShadow *geom_field,char **options=0){
5562 28 : OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetCreateLayerFromGeomFieldDefn( self,
5563 : name,
5564 : geom_field,
5565 : options);
5566 14 : return layer;
5567 : }
5568 18 : SWIGINTERN OGRLayerShadow *GDALDatasetShadow_CopyLayer(GDALDatasetShadow *self,OGRLayerShadow *src_layer,char const *new_name,char **options=0){
5569 36 : OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetCopyLayer( self,
5570 : src_layer,
5571 : new_name,
5572 : options);
5573 18 : return layer;
5574 : }
5575 41 : SWIGINTERN OGRErr GDALDatasetShadow_DeleteLayer(GDALDatasetShadow *self,int index){
5576 41 : return GDALDatasetDeleteLayer(self, index);
5577 : }
5578 :
5579 :
5580 : #include "ogr_core.h"
5581 : static char const *
5582 0 : OGRErrMessages( int rc ) {
5583 0 : switch( rc ) {
5584 : case OGRERR_NONE:
5585 : return "OGR Error: None";
5586 0 : case OGRERR_NOT_ENOUGH_DATA:
5587 0 : return "OGR Error: Not enough data to deserialize";
5588 0 : case OGRERR_NOT_ENOUGH_MEMORY:
5589 0 : return "OGR Error: Not enough memory";
5590 0 : case OGRERR_UNSUPPORTED_GEOMETRY_TYPE:
5591 0 : return "OGR Error: Unsupported geometry type";
5592 0 : case OGRERR_UNSUPPORTED_OPERATION:
5593 0 : return "OGR Error: Unsupported operation";
5594 0 : case OGRERR_CORRUPT_DATA:
5595 0 : return "OGR Error: Corrupt data";
5596 0 : case OGRERR_FAILURE:
5597 0 : return "OGR Error: General Error";
5598 0 : case OGRERR_UNSUPPORTED_SRS:
5599 0 : return "OGR Error: Unsupported SRS";
5600 0 : case OGRERR_INVALID_HANDLE:
5601 0 : return "OGR Error: Invalid handle";
5602 0 : case OGRERR_NON_EXISTING_FEATURE:
5603 0 : return "OGR Error: Non existing feature";
5604 0 : default:
5605 0 : return "OGR Error: Unknown";
5606 : }
5607 : }
5608 :
5609 91 : SWIGINTERN bool GDALDatasetShadow_IsLayerPrivate(GDALDatasetShadow *self,int index){
5610 182 : return GDALDatasetIsLayerPrivate(self, index);
5611 : }
5612 :
5613 : SWIGINTERN int
5614 5983 : SWIG_AsVal_bool (PyObject *obj, bool *val)
5615 : {
5616 5983 : int r;
5617 5983 : if (!PyBool_Check(obj))
5618 : return SWIG_ERROR;
5619 5982 : r = PyObject_IsTrue(obj);
5620 5982 : if (r == -1)
5621 : return SWIG_ERROR;
5622 5982 : if (val) *val = r ? true : false;
5623 : return SWIG_OK;
5624 : }
5625 :
5626 1917 : SWIGINTERN OGRFeatureShadow *GDALDatasetShadow_GetNextFeature(GDALDatasetShadow *self,bool include_layer=true,bool include_pct=false,OGRLayerShadow **ppoBelongingLayer=NULL,double *pdfProgressPct=NULL,GDALProgressFunc callback=NULL,void *callback_data=NULL){
5627 1917 : OGRLayerH hLayer = NULL;
5628 3834 : OGRFeatureShadow* feat = (OGRFeatureShadow*)GDALDatasetGetNextFeature( self, &hLayer, pdfProgressPct,
5629 : callback, callback_data );
5630 1917 : *ppoBelongingLayer = (OGRLayerShadow*)hLayer;
5631 1917 : return feat;
5632 : }
5633 127 : SWIGINTERN bool GDALDatasetShadow_TestCapability(GDALDatasetShadow *self,char const *cap){
5634 254 : return (GDALDatasetTestCapability(self, cap) > 0);
5635 : }
5636 9865 : SWIGINTERN OGRLayerShadow *GDALDatasetShadow_ExecuteSQL(GDALDatasetShadow *self,char const *statement,OGRGeometryShadow *spatialFilter=NULL,char const *dialect=""){
5637 19730 : OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetExecuteSQL(self,
5638 : statement,
5639 : spatialFilter,
5640 : dialect);
5641 9865 : return layer;
5642 : }
5643 2819 : SWIGINTERN void GDALDatasetShadow_ReleaseResultSet(GDALDatasetShadow *self,OGRLayerShadow *layer){
5644 2819 : GDALDatasetReleaseResultSet(self, layer);
5645 2819 : }
5646 6 : SWIGINTERN OGRStyleTableShadow *GDALDatasetShadow_GetStyleTable(GDALDatasetShadow *self){
5647 6 : return (OGRStyleTableShadow*) GDALDatasetGetStyleTable(self);
5648 : }
5649 7 : SWIGINTERN void GDALDatasetShadow_SetStyleTable(GDALDatasetShadow *self,OGRStyleTableShadow *table){
5650 7 : if( table != NULL )
5651 5 : GDALDatasetSetStyleTable(self, (OGRStyleTableH) table);
5652 : }
5653 9520 : SWIGINTERN OGRLayerShadow *GDALDatasetShadow_GetLayerByIndex(GDALDatasetShadow *self,int index=0){
5654 :
5655 :
5656 :
5657 19040 : OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetGetLayer(self, index);
5658 9520 : return layer;
5659 : }
5660 2729 : SWIGINTERN OGRLayerShadow *GDALDatasetShadow_GetLayerByName(GDALDatasetShadow *self,char const *layer_name){
5661 5458 : OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetGetLayerByName(self, layer_name);
5662 2729 : return layer;
5663 : }
5664 14 : SWIGINTERN void GDALDatasetShadow_ResetReading(GDALDatasetShadow *self){
5665 14 : GDALDatasetResetReading(self);
5666 14 : }
5667 1448 : SWIGINTERN int GDALDatasetShadow_GetLayerCount(GDALDatasetShadow *self){
5668 1448 : return GDALDatasetGetLayerCount(self);
5669 : }
5670 6 : SWIGINTERN OGRErr GDALDatasetShadow_AbortSQL(GDALDatasetShadow *self){
5671 6 : return GDALDatasetAbortSQL(self);
5672 : }
5673 105 : SWIGINTERN OGRErr GDALDatasetShadow_StartTransaction(GDALDatasetShadow *self,int force=FALSE){
5674 105 : return GDALDatasetStartTransaction(self, force);
5675 : }
5676 76 : SWIGINTERN OGRErr GDALDatasetShadow_CommitTransaction(GDALDatasetShadow *self){
5677 76 : return GDALDatasetCommitTransaction(self);
5678 : }
5679 44 : SWIGINTERN OGRErr GDALDatasetShadow_RollbackTransaction(GDALDatasetShadow *self){
5680 44 : return GDALDatasetRollbackTransaction(self);
5681 : }
5682 2 : SWIGINTERN void GDALDatasetShadow_ClearStatistics(GDALDatasetShadow *self){
5683 2 : GDALDatasetClearStatistics(self);
5684 2 : }
5685 34 : SWIGINTERN char **GDALDatasetShadow_GetFieldDomainNames(GDALDatasetShadow *self,char **options=0){
5686 34 : return GDALDatasetGetFieldDomainNames(self, options);
5687 : }
5688 130 : SWIGINTERN OGRFieldDomainShadow *GDALDatasetShadow_GetFieldDomain(GDALDatasetShadow *self,char const *name){
5689 130 : return (OGRFieldDomainShadow*) GDALDatasetGetFieldDomain(self, name);
5690 : }
5691 37 : SWIGINTERN bool GDALDatasetShadow_AddFieldDomain(GDALDatasetShadow *self,OGRFieldDomainShadow *fieldDomain){
5692 37 : char* pszReason = NULL;
5693 37 : if( !GDALDatasetAddFieldDomain(self, (OGRFieldDomainH)fieldDomain, &pszReason) )
5694 : {
5695 4 : CPLError(CE_Failure, CPLE_AppDefined, "%s", pszReason);
5696 4 : CPLFree(pszReason);
5697 4 : return false;
5698 : }
5699 : return true;
5700 : }
5701 25 : SWIGINTERN bool GDALDatasetShadow_DeleteFieldDomain(GDALDatasetShadow *self,char const *name){
5702 25 : return GDALDatasetDeleteFieldDomain(self, name, NULL);
5703 : }
5704 7 : SWIGINTERN bool GDALDatasetShadow_UpdateFieldDomain(GDALDatasetShadow *self,OGRFieldDomainShadow *fieldDomain){
5705 7 : return GDALDatasetUpdateFieldDomain(self, (OGRFieldDomainH)fieldDomain, NULL);
5706 : }
5707 46 : SWIGINTERN char **GDALDatasetShadow_GetRelationshipNames(GDALDatasetShadow *self,char **options=0){
5708 46 : return GDALDatasetGetRelationshipNames(self, options);
5709 : }
5710 52 : SWIGINTERN GDALRelationshipShadow *GDALDatasetShadow_GetRelationship(GDALDatasetShadow *self,char const *name){
5711 52 : return (GDALRelationshipShadow*) GDALDatasetGetRelationship(self, name);
5712 : }
5713 42 : SWIGINTERN bool GDALDatasetShadow_AddRelationship(GDALDatasetShadow *self,GDALRelationshipShadow *relationship){
5714 42 : return GDALDatasetAddRelationship(self, (GDALRelationshipH)relationship, NULL);
5715 : }
5716 6 : SWIGINTERN bool GDALDatasetShadow_DeleteRelationship(GDALDatasetShadow *self,char const *name){
5717 6 : return GDALDatasetDeleteRelationship(self, name, NULL);
5718 : }
5719 9 : SWIGINTERN bool GDALDatasetShadow_UpdateRelationship(GDALDatasetShadow *self,GDALRelationshipShadow *relationship){
5720 9 : return GDALDatasetUpdateRelationship(self, (GDALRelationshipH)relationship, NULL);
5721 : }
5722 14 : SWIGINTERN GDALMDArrayHS *GDALDatasetShadow_AsMDArray(GDALDatasetShadow *self,char **options=NULL){
5723 14 : return GDALDatasetAsMDArray(self, options);
5724 : }
5725 176665 : SWIGINTERN CPLErr GDALDatasetShadow_ReadRaster1(GDALDatasetShadow *self,double xoff,double yoff,double xsize,double ysize,void **buf,int *buf_xsize=0,int *buf_ysize=0,GDALDataType *buf_type=0,int band_list=0,int *pband_list=0,GIntBig *buf_pixel_space=0,GIntBig *buf_line_space=0,GIntBig *buf_band_space=0,GDALRIOResampleAlg resample_alg=GRIORA_NearestNeighbour,GDALProgressFunc callback=NULL,void *callback_data=NULL,void *inputOutputBuf=NULL){
5726 176665 : *buf = NULL;
5727 :
5728 176665 : int nxsize = (buf_xsize==0) ? static_cast<int>(xsize) : *buf_xsize;
5729 176665 : int nysize = (buf_ysize==0) ? static_cast<int>(ysize) : *buf_ysize;
5730 176665 : GDALDataType ntype;
5731 176665 : if ( buf_type != 0 ) {
5732 176665 : ntype = *buf_type;
5733 : } else {
5734 0 : int lastband = GDALGetRasterCount( self ) - 1;
5735 0 : if (lastband < 0)
5736 : {
5737 : return CE_Failure;
5738 : }
5739 0 : ntype = GDALGetRasterDataType( GDALGetRasterBand( self, lastband ) );
5740 : }
5741 :
5742 176665 : GIntBig pixel_space = (buf_pixel_space == 0) ? 0 : *buf_pixel_space;
5743 176665 : GIntBig line_space = (buf_line_space == 0) ? 0 : *buf_line_space;
5744 176665 : GIntBig band_space = (buf_band_space == 0) ? 0 : *buf_band_space;
5745 :
5746 176665 : int ntypesize = GDALGetDataTypeSizeBytes( ntype );
5747 176665 : size_t buf_size = static_cast<size_t>(
5748 176665 : ComputeDatasetRasterIOSize (nxsize, nysize, ntypesize,
5749 : band_list ? band_list :
5750 0 : GDALGetRasterCount(self),
5751 : pband_list, band_list,
5752 : pixel_space, line_space, band_space,
5753 176665 : FALSE));
5754 176665 : if (buf_size == 0)
5755 : {
5756 : return CE_Failure;
5757 : }
5758 :
5759 176663 : char *data;
5760 176663 : Py_buffer view;
5761 :
5762 346165 : if( !readraster_acquirebuffer(buf, inputOutputBuf, buf_size, ntype,
5763 : GetUseExceptions(), data, view) )
5764 : {
5765 : return CE_Failure;
5766 : }
5767 :
5768 176650 : if( inputOutputBuf == NULL )
5769 : {
5770 : /* Should we clear the buffer in case there are hole in it ? */
5771 176638 : if( line_space != 0 && pixel_space != 0 && line_space > pixel_space * nxsize )
5772 : {
5773 4 : memset(data, 0, buf_size);
5774 : }
5775 176634 : else if( band_list > 1 && band_space != 0 )
5776 : {
5777 1081 : if( line_space != 0 && band_space > line_space * nysize )
5778 0 : memset(data, 0, buf_size);
5779 1081 : else if( pixel_space != 0 && band_space < pixel_space &&
5780 1075 : pixel_space != (GIntBig)GDALGetRasterCount(self) * ntypesize )
5781 172 : memset(data, 0, buf_size);
5782 : }
5783 : }
5784 :
5785 176650 : GDALRasterIOExtraArg sExtraArg;
5786 176650 : INIT_RASTERIO_EXTRA_ARG(sExtraArg);
5787 176650 : sExtraArg.eResampleAlg = resample_alg;
5788 176650 : sExtraArg.pfnProgress = callback;
5789 176650 : sExtraArg.pProgressData = callback_data;
5790 :
5791 176650 : int nXOff = (int)(xoff + 0.5);
5792 176650 : int nYOff = (int)(yoff + 0.5);
5793 176650 : int nXSize = (int)(xsize + 0.5);
5794 176650 : int nYSize = (int)(ysize + 0.5);
5795 176650 : if( fabs(xoff-nXOff) > 1e-8 || fabs(yoff-nYOff) > 1e-8 ||
5796 176641 : fabs(xsize-nXSize) > 1e-8 || fabs(ysize-nYSize) > 1e-8 )
5797 : {
5798 11 : sExtraArg.bFloatingPointWindowValidity = TRUE;
5799 11 : sExtraArg.dfXOff = xoff;
5800 11 : sExtraArg.dfYOff = yoff;
5801 11 : sExtraArg.dfXSize = xsize;
5802 11 : sExtraArg.dfYSize = ysize;
5803 : }
5804 :
5805 176650 : CPLErr eErr = GDALDatasetRasterIOEx(self, GF_Read, nXOff, nYOff, nXSize, nYSize,
5806 : data, nxsize, nysize, ntype,
5807 : band_list, pband_list, pixel_space, line_space, band_space,
5808 : &sExtraArg );
5809 :
5810 176650 : readraster_releasebuffer(eErr, buf, inputOutputBuf, view);
5811 :
5812 : return eErr;
5813 : }
5814 :
5815 19935 : int GDALDatasetShadow_RasterXSize_get( GDALDatasetShadow *h ) {
5816 19935 : return GDALGetRasterXSize( h );
5817 : }
5818 20187 : int GDALDatasetShadow_RasterYSize_get( GDALDatasetShadow *h ) {
5819 20187 : return GDALGetRasterYSize( h );
5820 : }
5821 355537 : int GDALDatasetShadow_RasterCount_get( GDALDatasetShadow *h ) {
5822 355537 : return GDALGetRasterCount( h );
5823 : }
5824 :
5825 :
5826 : /* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
5827 : #ifndef SWIG_isfinite
5828 : /* isfinite() is a macro for C99 */
5829 : # if defined(isfinite)
5830 : # define SWIG_isfinite(X) (isfinite(X))
5831 : # elif defined(__cplusplus) && __cplusplus >= 201103L
5832 : /* Use a template so that this works whether isfinite() is std::isfinite() or
5833 : * in the global namespace. The reality seems to vary between compiler
5834 : * versions.
5835 : *
5836 : * Make sure namespace std exists to avoid compiler warnings.
5837 : *
5838 : * extern "C++" is required as this fragment can end up inside an extern "C" { } block
5839 : */
5840 : namespace std { }
5841 : extern "C++" template<typename T>
5842 0 : inline int SWIG_isfinite_func(T x) {
5843 : using namespace std;
5844 0 : return isfinite(x);
5845 : }
5846 : # define SWIG_isfinite(X) (SWIG_isfinite_func(X))
5847 : # elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
5848 : # define SWIG_isfinite(X) (__builtin_isfinite(X))
5849 : # elif defined(__clang__) && defined(__has_builtin)
5850 : # if __has_builtin(__builtin_isfinite)
5851 : # define SWIG_isfinite(X) (__builtin_isfinite(X))
5852 : # endif
5853 : # elif defined(_MSC_VER)
5854 : # define SWIG_isfinite(X) (_finite(X))
5855 : # elif defined(__sun) && defined(__SVR4)
5856 : # include <ieeefp.h>
5857 : # define SWIG_isfinite(X) (finite(X))
5858 : # endif
5859 : #endif
5860 :
5861 :
5862 : /* Accept infinite as a valid float value unless we are unable to check if a value is finite */
5863 : #ifdef SWIG_isfinite
5864 : # define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
5865 : #else
5866 : # define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
5867 : #endif
5868 :
5869 :
5870 : SWIGINTERN int
5871 13 : SWIG_AsVal_float (PyObject * obj, float *val)
5872 : {
5873 13 : double v;
5874 13 : int res = SWIG_AsVal_double (obj, &v);
5875 13 : if (SWIG_IsOK(res)) {
5876 13 : if (SWIG_Float_Overflow_Check(v)) {
5877 : return SWIG_OverflowError;
5878 : } else {
5879 13 : if (val) *val = static_cast< float >(v);
5880 : }
5881 : }
5882 : return res;
5883 : }
5884 :
5885 :
5886 : SWIGINTERNINLINE PyObject *
5887 6 : SWIG_From_float (float value)
5888 : {
5889 6 : return SWIG_From_double (value);
5890 : }
5891 :
5892 24 : SWIGINTERN GDALRasterAttributeTableShadow *new_GDALRasterAttributeTableShadow(){
5893 24 : return (GDALRasterAttributeTableShadow*)
5894 24 : GDALCreateRasterAttributeTable();
5895 : }
5896 32 : SWIGINTERN void delete_GDALRasterAttributeTableShadow(GDALRasterAttributeTableShadow *self){
5897 32 : GDALDestroyRasterAttributeTable(self);
5898 32 : }
5899 6 : SWIGINTERN GDALRasterAttributeTableShadow *GDALRasterAttributeTableShadow_Clone(GDALRasterAttributeTableShadow *self){
5900 6 : return (GDALRasterAttributeTableShadow*) GDALRATClone(self);
5901 : }
5902 60 : SWIGINTERN int GDALRasterAttributeTableShadow_GetColumnCount(GDALRasterAttributeTableShadow *self){
5903 60 : return GDALRATGetColumnCount( self );
5904 : }
5905 124 : SWIGINTERN char const *GDALRasterAttributeTableShadow_GetNameOfCol(GDALRasterAttributeTableShadow *self,int iCol){
5906 124 : return GDALRATGetNameOfCol( self, iCol );
5907 : }
5908 67 : SWIGINTERN GDALRATFieldUsage GDALRasterAttributeTableShadow_GetUsageOfCol(GDALRasterAttributeTableShadow *self,int iCol){
5909 67 : return GDALRATGetUsageOfCol( self, iCol );
5910 : }
5911 288 : SWIGINTERN GDALRATFieldType GDALRasterAttributeTableShadow_GetTypeOfCol(GDALRasterAttributeTableShadow *self,int iCol){
5912 288 : return GDALRATGetTypeOfCol( self, iCol );
5913 : }
5914 13 : SWIGINTERN int GDALRasterAttributeTableShadow_GetColOfUsage(GDALRasterAttributeTableShadow *self,GDALRATFieldUsage eUsage){
5915 13 : return GDALRATGetColOfUsage( self, eUsage );
5916 : }
5917 246 : SWIGINTERN int GDALRasterAttributeTableShadow_GetRowCount(GDALRasterAttributeTableShadow *self){
5918 246 : return GDALRATGetRowCount( self );
5919 : }
5920 115 : SWIGINTERN char const *GDALRasterAttributeTableShadow_GetValueAsString(GDALRasterAttributeTableShadow *self,int iRow,int iCol){
5921 115 : return GDALRATGetValueAsString( self, iRow, iCol );
5922 : }
5923 179 : SWIGINTERN int GDALRasterAttributeTableShadow_GetValueAsInt(GDALRasterAttributeTableShadow *self,int iRow,int iCol){
5924 179 : return GDALRATGetValueAsInt( self, iRow, iCol );
5925 : }
5926 105 : SWIGINTERN double GDALRasterAttributeTableShadow_GetValueAsDouble(GDALRasterAttributeTableShadow *self,int iRow,int iCol){
5927 105 : return GDALRATGetValueAsDouble( self, iRow, iCol );
5928 : }
5929 22 : SWIGINTERN bool GDALRasterAttributeTableShadow_GetValueAsBoolean(GDALRasterAttributeTableShadow *self,int iRow,int iCol){
5930 22 : return GDALRATGetValueAsBoolean( self, iRow, iCol );
5931 : }
5932 16 : SWIGINTERN GDALRATDateTime GDALRasterAttributeTableShadow_GetValueAsDateTime(GDALRasterAttributeTableShadow *self,int iRow,int iCol){
5933 16 : GDALRATDateTime dt;
5934 16 : GDALRATGetValueAsDateTime( self, iRow, iCol, &dt );
5935 16 : return dt;
5936 : }
5937 14 : SWIGINTERN CPLErr GDALRasterAttributeTableShadow_GetValueAsWKBGeometry(GDALRasterAttributeTableShadow *self,int iRow,int iCol,size_t *nLen,char **pBuf){
5938 14 : const void* pRet = GDALRATGetValueAsWKBGeometry( self, iRow, iCol, nLen );
5939 14 : *pBuf = (char*)VSIMalloc(*nLen);
5940 14 : if (*nLen)
5941 3 : memcpy(*pBuf, pRet, *nLen);
5942 14 : return CE_None;
5943 : }
5944 14 : SWIGINTERN CPLErr GDALRasterAttributeTableShadow_SetValueAsWKBGeometry(GDALRasterAttributeTableShadow *self,int iRow,int iCol,int nLen,char *pBuf){
5945 14 : return GDALRATSetValueAsWKBGeometry(self, iRow, iCol, pBuf, nLen);
5946 : }
5947 8 : SWIGINTERN CPLErr GDALRasterAttributeTableShadow_ReadValuesIOAsString(GDALRasterAttributeTableShadow *self,int iField,int iStartRow,int iLength,char **ppszData){
5948 8 : return GDALRATValuesIOAsString(self, GF_Read, iField, iStartRow, iLength, ppszData);
5949 : }
5950 10 : SWIGINTERN CPLErr GDALRasterAttributeTableShadow_ReadValuesIOAsInteger(GDALRasterAttributeTableShadow *self,int iField,int iStartRow,int iLength,int *pnData){
5951 10 : return GDALRATValuesIOAsInteger(self, GF_Read, iField, iStartRow, iLength, pnData);
5952 : }
5953 8 : SWIGINTERN CPLErr GDALRasterAttributeTableShadow_ReadValuesIOAsDouble(GDALRasterAttributeTableShadow *self,int iField,int iStartRow,int iLength,double *pdfData){
5954 8 : return GDALRATValuesIOAsDouble(self, GF_Read, iField, iStartRow, iLength, pdfData);
5955 : }
5956 7 : SWIGINTERN CPLErr GDALRasterAttributeTableShadow_ReadValuesIOAsBoolean(GDALRasterAttributeTableShadow *self,int iField,int iStartRow,int iLength,bool *pbData){
5957 7 : return GDALRATValuesIOAsBoolean(self, GF_Read, iField, iStartRow, iLength, pbData);
5958 : }
5959 66 : SWIGINTERN void GDALRasterAttributeTableShadow_SetValueAsString(GDALRasterAttributeTableShadow *self,int iRow,int iCol,char const *pszValue){
5960 66 : GDALRATSetValueAsString( self, iRow, iCol, pszValue );
5961 66 : }
5962 64 : SWIGINTERN void GDALRasterAttributeTableShadow_SetValueAsInt(GDALRasterAttributeTableShadow *self,int iRow,int iCol,int nValue){
5963 64 : GDALRATSetValueAsInt( self, iRow, iCol, nValue );
5964 64 : }
5965 50 : SWIGINTERN void GDALRasterAttributeTableShadow_SetValueAsDouble(GDALRasterAttributeTableShadow *self,int iRow,int iCol,double dfValue){
5966 50 : GDALRATSetValueAsDouble( self, iRow, iCol, dfValue );
5967 50 : }
5968 27 : SWIGINTERN void GDALRasterAttributeTableShadow_SetValueAsBoolean(GDALRasterAttributeTableShadow *self,int iRow,int iCol,bool value){
5969 27 : GDALRATSetValueAsBoolean( self, iRow, iCol, value );
5970 27 : }
5971 16 : SWIGINTERN void GDALRasterAttributeTableShadow_SetValueAsDateTime(GDALRasterAttributeTableShadow *self,int iRow,int iCol,GDALRATDateTime value){
5972 16 : GDALRATSetValueAsDateTime( self, iRow, iCol, &value );
5973 16 : }
5974 15 : SWIGINTERN void GDALRasterAttributeTableShadow_SetRowCount(GDALRasterAttributeTableShadow *self,int nCount){
5975 15 : GDALRATSetRowCount( self, nCount );
5976 15 : }
5977 74 : SWIGINTERN int GDALRasterAttributeTableShadow_CreateColumn(GDALRasterAttributeTableShadow *self,char const *pszName,GDALRATFieldType eType,GDALRATFieldUsage eUsage){
5978 148 : return GDALRATCreateColumn( self, pszName, eType, eUsage );
5979 : }
5980 1 : SWIGINTERN bool GDALRasterAttributeTableShadow_GetLinearBinning(GDALRasterAttributeTableShadow *self,double *pdfRow0Min,double *pdfBinSize){
5981 2 : return (GDALRATGetLinearBinning(self, pdfRow0Min, pdfBinSize) != 0) ? true : false;
5982 : }
5983 1 : SWIGINTERN int GDALRasterAttributeTableShadow_SetLinearBinning(GDALRasterAttributeTableShadow *self,double dfRow0Min,double dfBinSize){
5984 2 : return GDALRATSetLinearBinning(self, dfRow0Min, dfBinSize);
5985 : }
5986 3 : SWIGINTERN int GDALRasterAttributeTableShadow_GetRowOfValue(GDALRasterAttributeTableShadow *self,double dfValue){
5987 3 : return GDALRATGetRowOfValue( self, dfValue );
5988 : }
5989 2 : SWIGINTERN int GDALRasterAttributeTableShadow_ChangesAreWrittenToFile(GDALRasterAttributeTableShadow *self){
5990 2 : return GDALRATChangesAreWrittenToFile( self );
5991 : }
5992 0 : SWIGINTERN void GDALRasterAttributeTableShadow_DumpReadable(GDALRasterAttributeTableShadow *self){
5993 0 : GDALRATDumpReadable( self, NULL );
5994 0 : }
5995 3 : SWIGINTERN void GDALRasterAttributeTableShadow_SetTableType(GDALRasterAttributeTableShadow *self,GDALRATTableType eTableType){
5996 3 : GDALRATSetTableType( self, eTableType );
5997 3 : }
5998 10 : SWIGINTERN GDALRATTableType GDALRasterAttributeTableShadow_GetTableType(GDALRasterAttributeTableShadow *self){
5999 10 : return GDALRATGetTableType( self );
6000 : }
6001 1 : SWIGINTERN void GDALRasterAttributeTableShadow_RemoveStatistics(GDALRasterAttributeTableShadow *self){
6002 1 : GDALRATRemoveStatistics(self);
6003 1 : }
6004 1535 : SWIGINTERN void delete_GDALGroupHS(GDALGroupHS *self){
6005 1535 : GDALGroupRelease(self);
6006 1535 : }
6007 95 : SWIGINTERN char const *GDALGroupHS_GetName(GDALGroupHS *self){
6008 95 : return GDALGroupGetName(self);
6009 : }
6010 47 : SWIGINTERN char const *GDALGroupHS_GetFullName(GDALGroupHS *self){
6011 47 : return GDALGroupGetFullName(self);
6012 : }
6013 337 : SWIGINTERN char **GDALGroupHS_GetMDArrayNames(GDALGroupHS *self,char **options=0){
6014 337 : return GDALGroupGetMDArrayNames( self, options );
6015 : }
6016 1 : SWIGINTERN char **GDALGroupHS_GetMDArrayFullNamesRecursive(GDALGroupHS *self,char **groupOptions=0,char **arrayOptions=0){
6017 1 : return GDALGroupGetMDArrayFullNamesRecursive( self, groupOptions, arrayOptions );
6018 : }
6019 835 : SWIGINTERN GDALMDArrayHS *GDALGroupHS_OpenMDArray(GDALGroupHS *self,char const *name,char **options=0){
6020 :
6021 835 : CPLErr eLastErrorType = CPLGetLastErrorType();
6022 :
6023 835 : GDALMDArrayH hRet = GDALGroupOpenMDArray(self, name, options);
6024 :
6025 972 : if( GetUseExceptions() && hRet == NULL && eLastErrorType == CE_None && CPLGetLastErrorType() == CE_None )
6026 17 : CPLError(CE_Failure, CPLE_AppDefined, "Array %s does not exist", name);
6027 :
6028 835 : return hRet;
6029 : }
6030 18 : SWIGINTERN GDALMDArrayHS *GDALGroupHS_OpenMDArrayFromFullname(GDALGroupHS *self,char const *name,char **options=0){
6031 :
6032 18 : CPLErr eLastErrorType = CPLGetLastErrorType();
6033 :
6034 18 : GDALMDArrayH hRet = GDALGroupOpenMDArrayFromFullname(self, name, options);
6035 :
6036 26 : if( GetUseExceptions() && hRet == NULL && eLastErrorType == CE_None && CPLGetLastErrorType() == CE_None )
6037 1 : CPLError(CE_Failure, CPLE_AppDefined, "Array %s does not exist", name);
6038 :
6039 18 : return hRet;
6040 : }
6041 19 : SWIGINTERN GDALMDArrayHS *GDALGroupHS_ResolveMDArray(GDALGroupHS *self,char const *name,char const *starting_point,char **options=0){
6042 :
6043 19 : CPLErr eLastErrorType = CPLGetLastErrorType();
6044 :
6045 19 : GDALMDArrayH hRet = GDALGroupResolveMDArray(self, name, starting_point, options);
6046 :
6047 19 : if( GetUseExceptions() && hRet == NULL && eLastErrorType == CE_None && CPLGetLastErrorType() == CE_None )
6048 1 : CPLError(CE_Failure, CPLE_AppDefined, "Array %s does not exist", name);
6049 :
6050 19 : return hRet;
6051 : }
6052 98 : SWIGINTERN char **GDALGroupHS_GetGroupNames(GDALGroupHS *self,char **options=0){
6053 98 : return GDALGroupGetGroupNames( self, options );
6054 : }
6055 163 : SWIGINTERN GDALGroupHS *GDALGroupHS_OpenGroup(GDALGroupHS *self,char const *name,char **options=0){
6056 :
6057 163 : CPLErr eLastErrorType = CPLGetLastErrorType();
6058 :
6059 163 : GDALGroupH hRet = GDALGroupOpenGroup(self, name, options);
6060 :
6061 171 : if( GetUseExceptions() && hRet == NULL && eLastErrorType == CE_None && CPLGetLastErrorType() == CE_None )
6062 12 : CPLError(CE_Failure, CPLE_AppDefined, "Group %s does not exist", name);
6063 :
6064 163 : return hRet;
6065 : }
6066 3 : SWIGINTERN GDALGroupHS *GDALGroupHS_OpenGroupFromFullname(GDALGroupHS *self,char const *name,char **options=0){
6067 :
6068 3 : CPLErr eLastErrorType = CPLGetLastErrorType();
6069 :
6070 3 : GDALGroupH hRet = GDALGroupOpenGroupFromFullname(self, name, options);
6071 :
6072 3 : if( GetUseExceptions() && hRet == NULL && eLastErrorType == CE_None && CPLGetLastErrorType() == CE_None )
6073 1 : CPLError(CE_Failure, CPLE_AppDefined, "Group %s does not exist", name);
6074 :
6075 3 : return hRet;
6076 : }
6077 8 : SWIGINTERN char **GDALGroupHS_GetVectorLayerNames(GDALGroupHS *self,char **options=0){
6078 8 : return GDALGroupGetVectorLayerNames( self, options );
6079 : }
6080 12 : SWIGINTERN OGRLayerShadow *GDALGroupHS_OpenVectorLayer(GDALGroupHS *self,char const *name,char **options=0){
6081 :
6082 12 : CPLErr eLastErrorType = CPLGetLastErrorType();
6083 :
6084 12 : OGRLayerH hRet = GDALGroupOpenVectorLayer(self, name, options);
6085 :
6086 12 : if( GetUseExceptions() && hRet == NULL && eLastErrorType == CE_None && CPLGetLastErrorType() == CE_None )
6087 1 : CPLError(CE_Failure, CPLE_AppDefined, "Vector layer %s does not exist", name);
6088 :
6089 12 : return (OGRLayerShadow*) hRet;
6090 : }
6091 73 : SWIGINTERN void GDALGroupHS_GetDimensions(GDALGroupHS *self,GDALDimensionHS ***pdims,size_t *pnCount,char **options=0){
6092 146 : *pdims = GDALGroupGetDimensions(self, pnCount, options);
6093 : }
6094 80 : SWIGINTERN GDALAttributeHS *GDALGroupHS_GetAttribute(GDALGroupHS *self,char const *name){
6095 :
6096 80 : CPLErr eLastErrorType = CPLGetLastErrorType();
6097 :
6098 80 : GDALAttributeH hRet = GDALGroupGetAttribute(self, name);
6099 :
6100 85 : if( GetUseExceptions() && hRet == NULL && eLastErrorType == CE_None && CPLGetLastErrorType() == CE_None )
6101 2 : CPLError(CE_Failure, CPLE_AppDefined, "Attribute %s does not exist", name);
6102 :
6103 80 : return hRet;
6104 : }
6105 71 : SWIGINTERN void GDALGroupHS_GetAttributes(GDALGroupHS *self,GDALAttributeHS ***pattrs,size_t *pnCount,char **options=0){
6106 142 : *pattrs = GDALGroupGetAttributes(self, pnCount, options);
6107 : }
6108 4 : SWIGINTERN char **GDALGroupHS_GetStructuralInfo(GDALGroupHS *self){
6109 4 : return GDALGroupGetStructuralInfo( self );
6110 : }
6111 179 : SWIGINTERN GDALGroupHS *GDALGroupHS_CreateGroup(GDALGroupHS *self,char const *name,char **options=0){
6112 179 : return GDALGroupCreateGroup(self, name, options);
6113 : }
6114 20 : SWIGINTERN CPLErr GDALGroupHS_DeleteGroup(GDALGroupHS *self,char const *name,char **options=0){
6115 20 : return GDALGroupDeleteGroup(self, name, options) ? CE_None : CE_Failure;
6116 : }
6117 759 : SWIGINTERN GDALDimensionHS *GDALGroupHS_CreateDimension(GDALGroupHS *self,char const *name,char const *dim_type,char const *direction,GUIntBig size,char **options=0){
6118 759 : return GDALGroupCreateDimension(self, name, dim_type, direction, size, options);
6119 : }
6120 707 : SWIGINTERN GDALMDArrayHS *GDALGroupHS_CreateMDArray(GDALGroupHS *self,char const *name,int dimensions,GDALDimensionHS **dimensionsValues,GDALExtendedDataTypeHS *data_type,char **options=0){
6121 707 : return GDALGroupCreateMDArray(self, name, dimensions, dimensionsValues,
6122 : data_type, options);
6123 : }
6124 20 : SWIGINTERN CPLErr GDALGroupHS_DeleteMDArray(GDALGroupHS *self,char const *name,char **options=0){
6125 20 : return GDALGroupDeleteMDArray(self, name, options) ? CE_None : CE_Failure;
6126 : }
6127 :
6128 : static GUIntBig*
6129 5532 : CreateCGUIntBigListFromSequence( PyObject* pySeq, int* pnSize ) {
6130 : /* check if is List */
6131 5532 : if ( !PySequence_Check(pySeq) ) {
6132 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
6133 0 : *pnSize = -1;
6134 0 : return NULL;
6135 : }
6136 5532 : Py_ssize_t size = PySequence_Size(pySeq);
6137 5532 : if( size > (Py_ssize_t)INT_MAX ) {
6138 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
6139 0 : *pnSize = -1;
6140 0 : return NULL;
6141 : }
6142 5532 : if( (size_t)size > SIZE_MAX / sizeof(GUIntBig) ) {
6143 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
6144 0 : *pnSize = -1;
6145 0 : return NULL;
6146 : }
6147 5532 : *pnSize = (int)size;
6148 5532 : GUIntBig* ret = (GUIntBig*) malloc((*pnSize)*sizeof(GUIntBig));
6149 5532 : if( !ret ) {
6150 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
6151 0 : *pnSize = -1;
6152 0 : return NULL;
6153 : }
6154 15521 : for( int i = 0; i<*pnSize; i++ ) {
6155 9989 : PyObject *o = PySequence_GetItem(pySeq,i);
6156 9989 : if ( !PyArg_Parse(o,"K",&ret[i]) ) {
6157 0 : PyErr_SetString(PyExc_TypeError, "not an integer");
6158 0 : Py_DECREF(o);
6159 0 : free(ret);
6160 0 : *pnSize = -1;
6161 0 : return NULL;
6162 : }
6163 9989 : Py_DECREF(o);
6164 : }
6165 : return ret;
6166 : }
6167 :
6168 125 : SWIGINTERN GDALAttributeHS *GDALGroupHS_CreateAttribute(GDALGroupHS *self,char const *name,int dimensions,GUIntBig *sizes,GDALExtendedDataTypeHS *data_type,char **options=0){
6169 125 : return GDALGroupCreateAttribute(self, name, dimensions,
6170 : (const GUInt64*) sizes,
6171 : data_type, options);
6172 : }
6173 25 : SWIGINTERN CPLErr GDALGroupHS_DeleteAttribute(GDALGroupHS *self,char const *name,char **options=0){
6174 25 : return GDALGroupDeleteAttribute(self, name, options) ? CE_None : CE_Failure;
6175 : }
6176 45 : SWIGINTERN CPLErr GDALGroupHS_Rename(GDALGroupHS *self,char const *newName){
6177 45 : return GDALGroupRename( self, newName ) ? CE_None : CE_Failure;
6178 : }
6179 14 : SWIGINTERN GDALGroupHS *GDALGroupHS_SubsetDimensionFromSelection(GDALGroupHS *self,char const *selection,char **options=0){
6180 14 : return GDALGroupSubsetDimensionFromSelection(self, selection, options);
6181 : }
6182 2 : SWIGINTERN size_t GDALGroupHS_GetDataTypeCount(GDALGroupHS *self){
6183 2 : return GDALGroupGetDataTypeCount(self);
6184 : }
6185 :
6186 : SWIGINTERNINLINE PyObject*
6187 3783 : SWIG_From_unsigned_SS_long (unsigned long value)
6188 : {
6189 3783 : return (value > LONG_MAX) ?
6190 3783 : PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
6191 : }
6192 :
6193 :
6194 : #ifdef SWIG_LONG_LONG_AVAILABLE
6195 : SWIGINTERNINLINE PyObject*
6196 : SWIG_From_unsigned_SS_long_SS_long (unsigned long long value)
6197 : {
6198 : return (value > LONG_MAX) ?
6199 : PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
6200 : }
6201 : #endif
6202 :
6203 :
6204 : SWIGINTERNINLINE PyObject *
6205 3783 : SWIG_From_size_t (size_t value)
6206 : {
6207 : #ifdef SWIG_LONG_LONG_AVAILABLE
6208 3783 : if (sizeof(size_t) <= sizeof(unsigned long)) {
6209 : #endif
6210 3783 : return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
6211 : #ifdef SWIG_LONG_LONG_AVAILABLE
6212 : } else {
6213 : /* assume sizeof(size_t) <= sizeof(unsigned long long) */
6214 : return SWIG_From_unsigned_SS_long_SS_long (static_cast< unsigned long long >(value));
6215 : }
6216 : #endif
6217 : }
6218 :
6219 2 : SWIGINTERN GDALExtendedDataTypeHS *GDALGroupHS_GetDataType(GDALGroupHS *self,size_t idx){
6220 2 : if (idx >= GDALGroupGetDataTypeCount(self))
6221 : {
6222 1 : CPLError(CE_Failure, CPLE_AppDefined, "GetDataType(): invalid index");
6223 1 : return NULL;
6224 : }
6225 1 : return GDALGroupGetDataType(self, idx);
6226 : }
6227 :
6228 : typedef struct
6229 : {
6230 : double min;
6231 : double max;
6232 : double mean;
6233 : double std_dev;
6234 : GIntBig valid_count;
6235 : } Statistics;
6236 :
6237 0 : SWIGINTERN void delete_Statistics(Statistics *self){
6238 0 : CPLFree(self);
6239 0 : }
6240 14 : SWIGINTERN void delete_GDALMDArrayRawBlockInfo(GDALMDArrayRawBlockInfo *self){
6241 14 : GDALMDArrayRawBlockInfoRelease(self);
6242 14 : }
6243 6 : SWIGINTERN GUIntBig GDALMDArrayRawBlockInfo_GetOffset(GDALMDArrayRawBlockInfo *self){
6244 6 : return self->nOffset;
6245 : }
6246 6 : SWIGINTERN GUIntBig GDALMDArrayRawBlockInfo_GetSize(GDALMDArrayRawBlockInfo *self){
6247 6 : return self->nSize;
6248 : }
6249 6 : SWIGINTERN char const *GDALMDArrayRawBlockInfo_GetFilename(GDALMDArrayRawBlockInfo *self){
6250 6 : return self->pszFilename;
6251 : }
6252 14 : SWIGINTERN char **GDALMDArrayRawBlockInfo_GetInfo(GDALMDArrayRawBlockInfo *self){
6253 14 : return self->papszInfo;
6254 : }
6255 4 : SWIGINTERN void GDALMDArrayRawBlockInfo_GetInlineData(GDALMDArrayRawBlockInfo *self,size_t *nLen,char **pBuf){
6256 4 : if (self->pabyInlineData )
6257 : {
6258 1 : *nLen = self->nSize;
6259 1 : *pBuf = reinterpret_cast<char*>(self->pabyInlineData);
6260 1 : self->pabyInlineData = NULL;
6261 : }
6262 : else
6263 : {
6264 : *nLen = 0;
6265 : *pBuf = NULL;
6266 : }
6267 : }
6268 :
6269 : #include <limits>
6270 :
6271 2558 : static bool CheckNumericDataType(GDALExtendedDataTypeHS* dt)
6272 : {
6273 2558 : GDALExtendedDataTypeClass klass = GDALExtendedDataTypeGetClass(dt);
6274 2558 : if( klass == GEDTC_NUMERIC )
6275 : return true;
6276 32 : if( klass == GEDTC_STRING )
6277 : return false;
6278 20 : CPLAssert( klass == GEDTC_COMPOUND );
6279 20 : size_t nCount = 0;
6280 20 : GDALEDTComponentH* comps = GDALExtendedDataTypeGetComponents(dt, &nCount);
6281 : bool ret = true;
6282 56 : for( size_t i = 0; i < nCount; i++ )
6283 : {
6284 38 : GDALExtendedDataTypeH tmpType = GDALEDTComponentGetType(comps[i]);
6285 38 : ret = CheckNumericDataType(tmpType);
6286 38 : GDALExtendedDataTypeRelease(tmpType);
6287 38 : if( !ret )
6288 : break;
6289 : }
6290 20 : GDALExtendedDataTypeFreeComponents(comps, nCount);
6291 : return ret;
6292 : }
6293 :
6294 4431 : static CPLErr MDArrayReadWriteCheckArguments(GDALMDArrayHS* array,
6295 : bool bCheckOnlyDims,
6296 : int nDims1, GUIntBig* array_start_idx,
6297 : int nDims2, GUIntBig* count,
6298 : int nDims3, GIntBig* array_step,
6299 : int nDims4, GIntBig* buffer_stride,
6300 : GDALExtendedDataTypeHS* buffer_datatype,
6301 : size_t* pnBufferSize)
6302 : {
6303 4431 : const int nExpectedDims = (int)GDALMDArrayGetDimensionCount(array);
6304 4431 : if( nDims1 != nExpectedDims )
6305 : {
6306 1 : CPLError(CE_Failure, CPLE_AppDefined,
6307 : "Wrong number of values in array_start_idx");
6308 1 : return CE_Failure;
6309 : }
6310 4430 : if( nDims2 != nExpectedDims )
6311 : {
6312 1 : CPLError(CE_Failure, CPLE_AppDefined,
6313 : "Wrong number of values in count");
6314 1 : return CE_Failure;
6315 : }
6316 4429 : if( nDims3 != nExpectedDims )
6317 : {
6318 1 : CPLError(CE_Failure, CPLE_AppDefined,
6319 : "Wrong number of values in array_step");
6320 1 : return CE_Failure;
6321 : }
6322 4428 : if( nDims4!= nExpectedDims )
6323 : {
6324 1 : CPLError(CE_Failure, CPLE_AppDefined,
6325 : "Wrong number of values in buffer_stride");
6326 1 : return CE_Failure;
6327 : }
6328 4427 : if( bCheckOnlyDims )
6329 : return CE_None;
6330 2505 : if( !CheckNumericDataType(buffer_datatype) )
6331 : {
6332 8 : CPLError(CE_Failure, CPLE_NotSupported,
6333 : "non-numeric buffer data type not supported in SWIG bindings");
6334 8 : return CE_Failure;
6335 : }
6336 : GIntBig nBufferSize = 0;
6337 7126 : for( int i = 0; i < nExpectedDims; i++ )
6338 : {
6339 4631 : if( count[i] == 0 )
6340 : {
6341 1 : CPLError(CE_Failure, CPLE_AppDefined,
6342 : "count[%d] = 0 is invalid", i);
6343 1 : return CE_Failure;
6344 : }
6345 4630 : if( buffer_stride[i] < 0 )
6346 : {
6347 1 : CPLError(CE_Failure, CPLE_NotSupported,
6348 : "Negative value in buffer_stride not supported in SWIG bindings");
6349 1 : return CE_Failure;
6350 : }
6351 4629 : if( count[i] > 1 && buffer_stride[i] != 0 )
6352 : {
6353 3772 : if( (GUIntBig)buffer_stride[i] > std::numeric_limits<GIntBig>::max() / (count[i] - 1) )
6354 : {
6355 0 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
6356 0 : return CE_Failure;
6357 : }
6358 3772 : GIntBig nDelta = buffer_stride[i] * (count[i] - 1);
6359 3772 : if( nBufferSize > std::numeric_limits<GIntBig>::max() - nDelta )
6360 : {
6361 0 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
6362 0 : return CE_Failure;
6363 : }
6364 3772 : nBufferSize += nDelta;
6365 : }
6366 : }
6367 2495 : const size_t nDTSize = GDALExtendedDataTypeGetSize(buffer_datatype);
6368 2495 : if( nDTSize == 0 )
6369 : {
6370 0 : CPLError(CE_Failure, CPLE_AppDefined, "nDTSize == 0");
6371 0 : return CE_Failure;
6372 : }
6373 2495 : if( (GUIntBig)nBufferSize > (GUIntBig)std::numeric_limits<GIntBig>::max() / nDTSize )
6374 : {
6375 0 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
6376 0 : return CE_Failure;
6377 : }
6378 2495 : nBufferSize *= nDTSize;
6379 2495 : if( (GUIntBig)nBufferSize > (GUIntBig)std::numeric_limits<GIntBig>::max() - nDTSize )
6380 : {
6381 1 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
6382 1 : return CE_Failure;
6383 : }
6384 2494 : nBufferSize += nDTSize;
6385 :
6386 : #if SIZEOF_VOIDP == 4
6387 : if( nBufferSize > INT_MAX )
6388 : {
6389 : CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
6390 : return CE_Failure;
6391 : }
6392 : #endif
6393 2494 : *pnBufferSize = (size_t)nBufferSize;
6394 2494 : return CE_None;
6395 : }
6396 :
6397 2193 : SWIGINTERN void delete_GDALMDArrayHS(GDALMDArrayHS *self){
6398 2193 : GDALMDArrayRelease(self);
6399 2193 : }
6400 83 : SWIGINTERN char const *GDALMDArrayHS_GetName(GDALMDArrayHS *self){
6401 83 : return GDALMDArrayGetName(self);
6402 : }
6403 50 : SWIGINTERN char const *GDALMDArrayHS_GetFullName(GDALMDArrayHS *self){
6404 50 : return GDALMDArrayGetFullName(self);
6405 : }
6406 6 : SWIGINTERN GUIntBig GDALMDArrayHS_GetTotalElementsCount(GDALMDArrayHS *self){
6407 6 : return GDALMDArrayGetTotalElementsCount(self);
6408 : }
6409 3684 : SWIGINTERN size_t GDALMDArrayHS_GetDimensionCount(GDALMDArrayHS *self){
6410 3684 : return GDALMDArrayGetDimensionCount(self);
6411 : }
6412 2438 : SWIGINTERN void GDALMDArrayHS_GetDimensions(GDALMDArrayHS *self,GDALDimensionHS ***pdims,size_t *pnCount){
6413 4876 : *pdims = GDALMDArrayGetDimensions(self, pnCount);
6414 : }
6415 13 : SWIGINTERN void GDALMDArrayHS_GetCoordinateVariables(GDALMDArrayHS *self,GDALMDArrayHS ***parrays,size_t *pnCount){
6416 26 : *parrays = GDALMDArrayGetCoordinateVariables(self, pnCount);
6417 : }
6418 98 : SWIGINTERN void GDALMDArrayHS_GetBlockSize(GDALMDArrayHS *self,GUIntBig **psizes,size_t *pnCount){
6419 196 : *psizes = GDALMDArrayGetBlockSize(self, pnCount);
6420 : }
6421 1 : SWIGINTERN void GDALMDArrayHS_GetProcessingChunkSize(GDALMDArrayHS *self,size_t nMaxChunkMemory,GUIntBig **psizes,size_t *pnCount){
6422 1 : size_t* panTmp = GDALMDArrayGetProcessingChunkSize(self, pnCount, nMaxChunkMemory);
6423 1 : *psizes = NULL;
6424 1 : if( panTmp )
6425 : {
6426 1 : *psizes = (GUIntBig*) CPLMalloc(sizeof(GUIntBig) * (*pnCount));
6427 3 : for( size_t i = 0; i < *pnCount; ++i )
6428 : {
6429 2 : (*psizes)[i] = panTmp[i];
6430 : }
6431 1 : CPLFree(panTmp);
6432 : }
6433 1 : }
6434 2218 : SWIGINTERN GDALExtendedDataTypeHS *GDALMDArrayHS_GetDataType(GDALMDArrayHS *self){
6435 2218 : return GDALMDArrayGetDataType(self);
6436 : }
6437 15 : SWIGINTERN char **GDALMDArrayHS_GetStructuralInfo(GDALMDArrayHS *self){
6438 15 : return GDALMDArrayGetStructuralInfo( self );
6439 : }
6440 44 : SWIGINTERN CPLErr GDALMDArrayHS_Resize(GDALMDArrayHS *self,int newDimensions,GUIntBig *newSizes,char **options=NULL){
6441 44 : if( static_cast<size_t>(newDimensions) != GDALMDArrayGetDimensionCount(self) )
6442 : {
6443 2 : CPLError(CE_Failure, CPLE_IllegalArg,
6444 : "newSizes array not of expected size");
6445 2 : return CE_Failure;
6446 : }
6447 42 : return GDALMDArrayResize( self, newSizes, options ) ? CE_None : CE_Failure;
6448 : }
6449 :
6450 : static GIntBig*
6451 5092 : CreateCGIntBigListFromSequence( PyObject* pySeq, int* pnSize ) {
6452 : /* check if is List */
6453 5092 : if ( !PySequence_Check(pySeq) ) {
6454 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
6455 0 : *pnSize = -1;
6456 0 : return NULL;
6457 : }
6458 5092 : Py_ssize_t size = PySequence_Size(pySeq);
6459 5092 : if( size > (Py_ssize_t)INT_MAX ) {
6460 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
6461 0 : *pnSize = -1;
6462 0 : return NULL;
6463 : }
6464 5092 : if( (size_t)size > SIZE_MAX / sizeof(GIntBig) ) {
6465 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
6466 0 : *pnSize = -1;
6467 0 : return NULL;
6468 : }
6469 5092 : *pnSize = (int)size;
6470 5092 : GIntBig* ret = (GIntBig*) malloc((*pnSize)*sizeof(GIntBig));
6471 5092 : if( !ret ) {
6472 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
6473 0 : *pnSize = -1;
6474 0 : return NULL;
6475 : }
6476 14509 : for( int i = 0; i<*pnSize; i++ ) {
6477 9417 : PyObject *o = PySequence_GetItem(pySeq,i);
6478 9417 : if ( !PyArg_Parse(o,"L",&ret[i]) ) {
6479 0 : PyErr_SetString(PyExc_TypeError, "not an integer");
6480 0 : Py_DECREF(o);
6481 0 : free(ret);
6482 0 : *pnSize = -1;
6483 0 : return NULL;
6484 : }
6485 9417 : Py_DECREF(o);
6486 : }
6487 : return ret;
6488 : }
6489 :
6490 1926 : SWIGINTERN CPLErr GDALMDArrayHS_Read(GDALMDArrayHS *self,int nDims1,GUIntBig *array_start_idx,int nDims2,GUIntBig *count,int nDims3,GIntBig *array_step,int nDims4,GIntBig *buffer_stride,GDALExtendedDataTypeHS *buffer_datatype,void **buf){
6491 1926 : *buf = NULL;
6492 :
6493 1926 : size_t buf_size = 0;
6494 1926 : if( MDArrayReadWriteCheckArguments(self, true,
6495 : nDims1, array_start_idx,
6496 : nDims2, count,
6497 : nDims3, array_step,
6498 : nDims4, buffer_stride,
6499 : buffer_datatype,
6500 : &buf_size) != CE_None )
6501 : {
6502 : return CE_Failure;
6503 : }
6504 :
6505 1922 : const int nExpectedDims = (int)GDALMDArrayGetDimensionCount(self);
6506 3848 : std::vector<size_t> count_internal(nExpectedDims + 1);
6507 3844 : std::vector<GPtrDiff_t> buffer_stride_internal(nExpectedDims + 1);
6508 1922 : size_t nProductCount = 1;
6509 5555 : for( int i = 0; i < nExpectedDims; i++ )
6510 : {
6511 3633 : count_internal[i] = (size_t)count[i];
6512 3633 : if( count_internal[i] != count[i] )
6513 : {
6514 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
6515 : return CE_Failure;
6516 : }
6517 3633 : nProductCount *= count_internal[i];
6518 3633 : buffer_stride_internal[i] = (GPtrDiff_t)buffer_stride[i];
6519 3633 : if( buffer_stride_internal[i] != buffer_stride[i] )
6520 : {
6521 0 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
6522 : return CE_Failure;
6523 : }
6524 : }
6525 :
6526 1922 : GDALExtendedDataTypeHS* selfType = GDALMDArrayGetDataType(self);
6527 1922 : bool isSelfString = GDALExtendedDataTypeGetClass(selfType) == GEDTC_STRING;
6528 1922 : GDALExtendedDataTypeRelease(selfType);
6529 :
6530 1922 : if( GDALExtendedDataTypeGetClass(buffer_datatype) == GEDTC_STRING &&
6531 : isSelfString )
6532 : {
6533 : size_t nExpectedStride = 1;
6534 70 : for( int i = nExpectedDims; i > 0; )
6535 : {
6536 40 : --i;
6537 40 : if( (size_t)buffer_stride_internal[i] != nExpectedStride )
6538 : {
6539 0 : CPLError(CE_Failure, CPLE_AppDefined, "Unhandled stride");
6540 : return CE_Failure;
6541 : }
6542 40 : nExpectedStride *= count_internal[i];
6543 : }
6544 30 : char** ppszBuffer = (char**)VSI_CALLOC_VERBOSE(nProductCount, sizeof(char*));
6545 30 : if( !ppszBuffer )
6546 : return CE_Failure;
6547 30 : GByte* pabyBuffer = (GByte*)ppszBuffer;
6548 30 : if( !(GDALMDArrayRead( self,
6549 : array_start_idx,
6550 30 : &count_internal[0],
6551 : array_step,
6552 : NULL,
6553 : buffer_datatype,
6554 : pabyBuffer,
6555 : pabyBuffer,
6556 : nProductCount * sizeof(char*) )) )
6557 : {
6558 0 : for( size_t i = 0; i < nProductCount; i++ )
6559 0 : VSIFree(ppszBuffer[i]);
6560 0 : VSIFree(pabyBuffer);
6561 : return CE_Failure;
6562 : }
6563 :
6564 30 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6565 30 : PyObject* obj = PyList_New( nProductCount );
6566 192 : for( size_t i = 0; i < nProductCount; i++ )
6567 : {
6568 162 : if( !ppszBuffer[i] )
6569 : {
6570 3 : Py_INCREF(Py_None);
6571 3 : PyList_SetItem(obj, i, Py_None);
6572 : }
6573 : else
6574 : {
6575 159 : PyList_SetItem(obj, i, GDALPythonObjectFromCStr( ppszBuffer[i] ) );
6576 : }
6577 162 : VSIFree(ppszBuffer[i]);
6578 : }
6579 30 : SWIG_PYTHON_THREAD_END_BLOCK;
6580 30 : *buf = obj;
6581 30 : VSIFree(pabyBuffer);
6582 30 : return CE_None;
6583 : }
6584 :
6585 1892 : if( MDArrayReadWriteCheckArguments(self, false,
6586 : nDims1, array_start_idx,
6587 : nDims2, count,
6588 : nDims3, array_step,
6589 : nDims4, buffer_stride,
6590 : buffer_datatype,
6591 : &buf_size) != CE_None )
6592 : {
6593 : return CE_Failure;
6594 : }
6595 1881 : if( buf_size == 0 )
6596 : {
6597 : return CE_None;
6598 : }
6599 :
6600 :
6601 3803 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6602 1881 : *buf = (void *)PyByteArray_FromStringAndSize( NULL, buf_size );
6603 1881 : if (*buf == NULL)
6604 : {
6605 0 : *buf = Py_None;
6606 0 : if( !GetUseExceptions() )
6607 : {
6608 0 : PyErr_Clear();
6609 : }
6610 0 : SWIG_PYTHON_THREAD_END_BLOCK;
6611 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Cannot allocate result buffer");
6612 : return CE_Failure;
6613 : }
6614 1881 : char *data = PyByteArray_AsString( (PyObject *)*buf );
6615 1881 : SWIG_PYTHON_THREAD_END_BLOCK;
6616 :
6617 1881 : memset(data, 0, buf_size);
6618 :
6619 1881 : CPLErr eErr = GDALMDArrayRead( self,
6620 : array_start_idx,
6621 1881 : &count_internal[0],
6622 : array_step,
6623 1881 : &buffer_stride_internal[0],
6624 : buffer_datatype,
6625 : data,
6626 : data,
6627 1907 : buf_size ) ? CE_None : CE_Failure;
6628 26 : if (eErr == CE_Failure)
6629 : {
6630 26 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6631 26 : Py_DECREF((PyObject*)*buf);
6632 26 : SWIG_PYTHON_THREAD_END_BLOCK;
6633 26 : *buf = NULL;
6634 : }
6635 :
6636 : return eErr;
6637 : }
6638 14 : SWIGINTERN CPLErr GDALMDArrayHS_WriteStringArray(GDALMDArrayHS *self,int nDims1,GUIntBig *array_start_idx,int nDims2,GUIntBig *count,int nDims3,GIntBig *array_step,GDALExtendedDataTypeHS *buffer_datatype,char **options){
6639 :
6640 14 : const int nExpectedDims = (int)GDALMDArrayGetDimensionCount(self);
6641 28 : std::vector<size_t> count_internal(nExpectedDims + 1);
6642 14 : if( nExpectedDims > 1 )
6643 : {
6644 0 : CPLError(CE_Failure, CPLE_AppDefined,
6645 : "Unsupported number of dimensions");
6646 : return CE_Failure;
6647 : }
6648 27 : for( int i = 0; i < nExpectedDims; i++ )
6649 : {
6650 13 : count_internal[i] = (size_t)count[i];
6651 13 : if( count_internal[i] != count[i] )
6652 : {
6653 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
6654 : return CE_Failure;
6655 : }
6656 : }
6657 14 : if( nExpectedDims == 1 )
6658 : {
6659 13 : if( nDims1 != 1 )
6660 : {
6661 0 : CPLError(CE_Failure, CPLE_AppDefined,
6662 : "Wrong number of values in array_start_idx");
6663 : return CE_Failure;
6664 : }
6665 13 : if( nDims2 != 1 )
6666 : {
6667 0 : CPLError(CE_Failure, CPLE_AppDefined,
6668 : "Wrong number of values in count");
6669 : return CE_Failure;
6670 : }
6671 13 : if( nDims3 != 1 )
6672 : {
6673 0 : CPLError(CE_Failure, CPLE_AppDefined,
6674 : "Wrong number of values in array_step");
6675 : return CE_Failure;
6676 : }
6677 : }
6678 :
6679 28 : CPLErr eErr = GDALMDArrayWrite(self,
6680 : array_start_idx,
6681 14 : &count_internal[0],
6682 : array_step,
6683 : NULL,
6684 : buffer_datatype,
6685 : options,
6686 : options,
6687 14 : CSLCount(options) * sizeof(char*) ) ? CE_None : CE_Failure;
6688 : return eErr;
6689 : }
6690 613 : SWIGINTERN CPLErr GDALMDArrayHS_Write(GDALMDArrayHS *self,int nDims1,GUIntBig *array_start_idx,int nDims2,GUIntBig *count,int nDims3,GIntBig *array_step,int nDims4,GIntBig *buffer_stride,GDALExtendedDataTypeHS *buffer_datatype,GIntBig buf_len,char *buf_string){
6691 :
6692 613 : size_t buf_size = 0;
6693 613 : if( MDArrayReadWriteCheckArguments(self, false,
6694 : nDims1, array_start_idx,
6695 : nDims2, count,
6696 : nDims3, array_step,
6697 : nDims4, buffer_stride,
6698 : buffer_datatype,
6699 : &buf_size) != CE_None )
6700 : {
6701 : return CE_Failure;
6702 : }
6703 :
6704 613 : if ( (GUIntBig)buf_len < buf_size )
6705 : {
6706 2 : CPLError(CE_Failure, CPLE_AppDefined, "Buffer too small");
6707 2 : return CE_Failure;
6708 : }
6709 :
6710 611 : const int nExpectedDims = (int)GDALMDArrayGetDimensionCount(self);
6711 1224 : std::vector<size_t> count_internal(nExpectedDims+1);
6712 1222 : std::vector<GPtrDiff_t> buffer_stride_internal(nExpectedDims+1);
6713 1663 : for( int i = 0; i < nExpectedDims; i++ )
6714 : {
6715 1052 : count_internal[i] = (size_t)count[i];
6716 1052 : if( count_internal[i] != count[i] )
6717 : {
6718 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
6719 : return CE_Failure;
6720 : }
6721 1052 : buffer_stride_internal[i] = (GPtrDiff_t)buffer_stride[i];
6722 1052 : if( buffer_stride_internal[i] != buffer_stride[i] )
6723 : {
6724 0 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
6725 : return CE_Failure;
6726 : }
6727 : }
6728 :
6729 611 : CPLErr eErr = GDALMDArrayWrite( self,
6730 : array_start_idx,
6731 611 : &count_internal[0],
6732 : array_step,
6733 611 : &buffer_stride_internal[0],
6734 : buffer_datatype,
6735 : buf_string,
6736 : buf_string,
6737 614 : (size_t)buf_len ) ? CE_None : CE_Failure;
6738 : return eErr;
6739 : }
6740 22 : SWIGINTERN CPLErr GDALMDArrayHS_AdviseRead(GDALMDArrayHS *self,int nDims1,GUIntBig *array_start_idx,int nDims2,GUIntBig *count,char **options=0){
6741 :
6742 22 : const int nExpectedDims = (int)GDALMDArrayGetDimensionCount(self);
6743 22 : if( nDims1 != nExpectedDims )
6744 : {
6745 0 : CPLError(CE_Failure, CPLE_AppDefined,
6746 : "Wrong number of values in array_start_idx");
6747 0 : return CE_Failure;
6748 : }
6749 22 : if( nDims2 != nExpectedDims )
6750 : {
6751 0 : CPLError(CE_Failure, CPLE_AppDefined,
6752 : "Wrong number of values in count");
6753 0 : return CE_Failure;
6754 : }
6755 :
6756 44 : std::vector<size_t> count_internal(nExpectedDims+1);
6757 58 : for( int i = 0; i < nExpectedDims; i++ )
6758 : {
6759 36 : count_internal[i] = (size_t)count[i];
6760 36 : if( count_internal[i] != count[i] )
6761 : {
6762 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
6763 : return CE_Failure;
6764 : }
6765 : }
6766 :
6767 22 : if( !(GDALMDArrayAdviseReadEx( self, array_start_idx, count_internal.data(), options )) )
6768 : {
6769 5 : return CE_Failure;
6770 : }
6771 : return CE_None;
6772 : }
6773 120 : SWIGINTERN GDALAttributeHS *GDALMDArrayHS_GetAttribute(GDALMDArrayHS *self,char const *name){
6774 :
6775 120 : CPLErr eLastErrorType = CPLGetLastErrorType();
6776 :
6777 120 : GDALAttributeH hRet = GDALMDArrayGetAttribute(self, name);
6778 :
6779 138 : if( GetUseExceptions() && hRet == NULL && eLastErrorType == CE_None && CPLGetLastErrorType() == CE_None )
6780 2 : CPLError(CE_Failure, CPLE_AppDefined, "Attribute %s does not exist", name);
6781 :
6782 120 : return hRet;
6783 : }
6784 59 : SWIGINTERN void GDALMDArrayHS_GetAttributes(GDALMDArrayHS *self,GDALAttributeHS ***pattrs,size_t *pnCount,char **options=0){
6785 118 : *pattrs = GDALMDArrayGetAttributes(self, pnCount, options);
6786 : }
6787 188 : SWIGINTERN GDALAttributeHS *GDALMDArrayHS_CreateAttribute(GDALMDArrayHS *self,char const *name,int dimensions,GUIntBig *sizes,GDALExtendedDataTypeHS *data_type,char **options=0){
6788 188 : return GDALMDArrayCreateAttribute(self, name, dimensions,
6789 : (const GUInt64*) sizes,
6790 : data_type, options);
6791 : }
6792 24 : SWIGINTERN CPLErr GDALMDArrayHS_DeleteAttribute(GDALMDArrayHS *self,char const *name,char **options=0){
6793 24 : return GDALMDArrayDeleteAttribute(self, name, options) ? CE_None : CE_Failure;
6794 : }
6795 73 : SWIGINTERN CPLErr GDALMDArrayHS_GetNoDataValueAsRaw(GDALMDArrayHS *self,void **buf){
6796 73 : *buf = NULL;
6797 73 : const void* pabyBuf = GDALMDArrayGetRawNoDataValue(self);
6798 73 : if( pabyBuf == NULL )
6799 : {
6800 : return CE_Failure;
6801 : }
6802 36 : GDALExtendedDataTypeHS* selfType = GDALMDArrayGetDataType(self);
6803 36 : const size_t buf_size = GDALExtendedDataTypeGetSize(selfType);
6804 36 : GDALExtendedDataTypeRelease(selfType);
6805 :
6806 109 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6807 36 : *buf = (void *)PyByteArray_FromStringAndSize( NULL, buf_size );
6808 36 : if (*buf == NULL)
6809 : {
6810 0 : *buf = Py_None;
6811 0 : if( !GetUseExceptions() )
6812 : {
6813 0 : PyErr_Clear();
6814 : }
6815 0 : SWIG_PYTHON_THREAD_END_BLOCK;
6816 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Cannot allocate result buffer");
6817 : return CE_Failure;
6818 : }
6819 36 : char *data = PyByteArray_AsString( (PyObject *)*buf );
6820 36 : SWIG_PYTHON_THREAD_END_BLOCK;
6821 :
6822 36 : memcpy(data, pabyBuf, buf_size);
6823 :
6824 36 : return CE_None;
6825 : }
6826 121 : SWIGINTERN void GDALMDArrayHS_GetNoDataValueAsDouble(GDALMDArrayHS *self,double *val,int *hasval){
6827 242 : *val = GDALMDArrayGetNoDataValueAsDouble( self, hasval );
6828 : }
6829 11 : SWIGINTERN void GDALMDArrayHS_GetNoDataValueAsInt64(GDALMDArrayHS *self,GIntBig *val,int *hasval){
6830 22 : *val = GDALMDArrayGetNoDataValueAsInt64( self, hasval );
6831 : }
6832 7 : SWIGINTERN void GDALMDArrayHS_GetNoDataValueAsUInt64(GDALMDArrayHS *self,GUIntBig *val,int *hasval){
6833 14 : *val = GDALMDArrayGetNoDataValueAsUInt64( self, hasval );
6834 : }
6835 5 : SWIGINTERN retStringAndCPLFree *GDALMDArrayHS_GetNoDataValueAsString(GDALMDArrayHS *self){
6836 5 : GDALExtendedDataTypeHS* selfType = GDALMDArrayGetDataType(self);
6837 5 : const size_t typeClass = GDALExtendedDataTypeGetClass(selfType);
6838 5 : GDALExtendedDataTypeRelease(selfType);
6839 :
6840 5 : if( typeClass != GEDTC_STRING )
6841 : {
6842 1 : CPLError(CE_Failure, CPLE_IllegalArg, "Data type is not string");
6843 1 : return NULL;
6844 : }
6845 4 : const void* pabyBuf = GDALMDArrayGetRawNoDataValue(self);
6846 4 : if( pabyBuf == NULL )
6847 : {
6848 : return NULL;
6849 : }
6850 3 : const char* ret = *reinterpret_cast<const char* const*>(pabyBuf);
6851 3 : if( ret )
6852 2 : return CPLStrdup(ret);
6853 : return NULL;
6854 : }
6855 55 : SWIGINTERN CPLErr GDALMDArrayHS_SetNoDataValueDouble(GDALMDArrayHS *self,double d){
6856 55 : return GDALMDArraySetNoDataValueAsDouble( self, d ) ? CE_None : CE_Failure;
6857 : }
6858 1 : SWIGINTERN CPLErr GDALMDArrayHS_SetNoDataValueInt64(GDALMDArrayHS *self,GIntBig v){
6859 1 : return GDALMDArraySetNoDataValueAsInt64( self, v ) ? CE_None : CE_Failure;
6860 : }
6861 1 : SWIGINTERN CPLErr GDALMDArrayHS_SetNoDataValueUInt64(GDALMDArrayHS *self,GUIntBig v){
6862 1 : return GDALMDArraySetNoDataValueAsUInt64( self, v ) ? CE_None : CE_Failure;
6863 : }
6864 3 : SWIGINTERN CPLErr GDALMDArrayHS_SetNoDataValueString(GDALMDArrayHS *self,char const *nodata){
6865 3 : GDALExtendedDataTypeHS* selfType = GDALMDArrayGetDataType(self);
6866 3 : const size_t typeClass = GDALExtendedDataTypeGetClass(selfType);
6867 3 : GDALExtendedDataTypeRelease(selfType);
6868 :
6869 3 : if( typeClass != GEDTC_STRING )
6870 : {
6871 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Data type is not string");
6872 0 : return CE_Failure;
6873 : }
6874 3 : return GDALMDArraySetRawNoDataValue(self, &nodata) ? CE_None : CE_Failure;
6875 : }
6876 8 : SWIGINTERN CPLErr GDALMDArrayHS_SetNoDataValueRaw(GDALMDArrayHS *self,GIntBig nLen,char *pBuf){
6877 8 : GDALExtendedDataTypeHS* selfType = GDALMDArrayGetDataType(self);
6878 8 : const size_t selfTypeSize = GDALExtendedDataTypeGetSize(selfType);
6879 8 : GDALExtendedDataTypeRelease(selfType);
6880 :
6881 8 : if( static_cast<size_t>(nLen) != selfTypeSize )
6882 : {
6883 1 : CPLError(CE_Failure, CPLE_IllegalArg, "Argument of wrong size");
6884 1 : return CE_Failure;
6885 : }
6886 7 : return GDALMDArraySetRawNoDataValue(self, pBuf) ? CE_None : CE_Failure;
6887 : }
6888 4 : SWIGINTERN CPLErr GDALMDArrayHS_DeleteNoDataValue(GDALMDArrayHS *self){
6889 4 : return GDALMDArraySetRawNoDataValue( self, NULL ) ? CE_None : CE_Failure;
6890 : }
6891 102 : SWIGINTERN void GDALMDArrayHS_GetOffset(GDALMDArrayHS *self,double *val,int *hasval){
6892 204 : *val = GDALMDArrayGetOffset( self, hasval );
6893 : }
6894 5 : SWIGINTERN GDALDataType GDALMDArrayHS_GetOffsetStorageType(GDALMDArrayHS *self){
6895 5 : GDALDataType eDT = GDT_Unknown;
6896 5 : int hasval = FALSE;
6897 5 : GDALMDArrayGetOffsetEx( self, &hasval, &eDT );
6898 5 : return hasval ? eDT : GDT_Unknown;
6899 : }
6900 105 : SWIGINTERN void GDALMDArrayHS_GetScale(GDALMDArrayHS *self,double *val,int *hasval){
6901 210 : *val = GDALMDArrayGetScale( self, hasval );
6902 : }
6903 5 : SWIGINTERN GDALDataType GDALMDArrayHS_GetScaleStorageType(GDALMDArrayHS *self){
6904 5 : GDALDataType eDT = GDT_Unknown;
6905 5 : int hasval = FALSE;
6906 5 : GDALMDArrayGetScaleEx( self, &hasval, &eDT );
6907 5 : return hasval ? eDT : GDT_Unknown;
6908 : }
6909 21 : SWIGINTERN CPLErr GDALMDArrayHS_SetOffset(GDALMDArrayHS *self,double val,GDALDataType storageType=GDT_Unknown){
6910 21 : return GDALMDArraySetOffsetEx( self, val, storageType ) ? CE_None : CE_Failure;
6911 : }
6912 21 : SWIGINTERN CPLErr GDALMDArrayHS_SetScale(GDALMDArrayHS *self,double val,GDALDataType storageType=GDT_Unknown){
6913 21 : return GDALMDArraySetScaleEx( self, val, storageType ) ? CE_None : CE_Failure;
6914 : }
6915 15 : SWIGINTERN CPLErr GDALMDArrayHS_SetUnit(GDALMDArrayHS *self,char const *unit){
6916 15 : return GDALMDArraySetUnit(self, unit) ? CE_None : CE_Failure;
6917 : }
6918 113 : SWIGINTERN char const *GDALMDArrayHS_GetUnit(GDALMDArrayHS *self){
6919 113 : return GDALMDArrayGetUnit(self);
6920 : }
6921 30 : SWIGINTERN OGRErr GDALMDArrayHS_SetSpatialRef(GDALMDArrayHS *self,OSRSpatialReferenceShadow *srs){
6922 30 : return GDALMDArraySetSpatialRef( self, (OGRSpatialReferenceH)srs ) ? CE_None : CE_Failure;
6923 : }
6924 81 : SWIGINTERN OSRSpatialReferenceShadow *GDALMDArrayHS_GetSpatialRef(GDALMDArrayHS *self){
6925 81 : return (OSRSpatialReferenceShadow*) GDALMDArrayGetSpatialRef(self);
6926 : }
6927 438 : SWIGINTERN GDALMDArrayHS *GDALMDArrayHS_GetView(GDALMDArrayHS *self,char const *viewExpr){
6928 438 : return GDALMDArrayGetView(self, viewExpr);
6929 : }
6930 44 : SWIGINTERN GDALMDArrayHS *GDALMDArrayHS_Transpose(GDALMDArrayHS *self,int axisMap,int *mapInts){
6931 44 : return GDALMDArrayTranspose(self, axisMap, mapInts);
6932 : }
6933 13 : SWIGINTERN GDALMDArrayHS *GDALMDArrayHS_GetUnscaled(GDALMDArrayHS *self){
6934 13 : return GDALMDArrayGetUnscaled(self);
6935 : }
6936 35 : SWIGINTERN GDALMDArrayHS *GDALMDArrayHS_GetMask(GDALMDArrayHS *self,char **options=0){
6937 35 : return GDALMDArrayGetMask(self, options);
6938 : }
6939 22 : SWIGINTERN GDALMDArrayHS *GDALMDArrayHS_GetGridded(GDALMDArrayHS *self,char const *pszGridOptions,GDALMDArrayHS *xArray=NULL,GDALMDArrayHS *yArray=NULL,char **options=0){
6940 22 : return GDALMDArrayGetGridded(self, pszGridOptions, xArray, yArray, options);
6941 : }
6942 102 : SWIGINTERN GDALDatasetShadow *GDALMDArrayHS_AsClassicDataset(GDALMDArrayHS *self,size_t iXDim,size_t iYDim,GDALGroupHS *hRootGroup=NULL,char **options=0){
6943 102 : return (GDALDatasetShadow*)GDALMDArrayAsClassicDatasetEx(self, iXDim, iYDim, hRootGroup, options);
6944 : }
6945 18 : SWIGINTERN GDALMDArrayRawBlockInfo *GDALMDArrayHS_GetRawBlockInfo(GDALMDArrayHS *self,int nDims,GUIntBig *block_coordinates){
6946 18 : if (static_cast<size_t>(nDims) != GDALMDArrayGetDimensionCount(self) )
6947 : {
6948 0 : CPLError(CE_Failure, CPLE_AppDefined,
6949 : "Invalid number of values in block_coordinates argument");
6950 0 : return NULL;
6951 : }
6952 18 : GDALMDArrayRawBlockInfo* blockInfo = GDALMDArrayRawBlockInfoCreate();
6953 18 : if( !GDALMDArrayGetRawBlockInfo(self, reinterpret_cast<const uint64_t*>(block_coordinates), blockInfo) )
6954 : {
6955 4 : GDALMDArrayRawBlockInfoRelease(blockInfo);
6956 4 : blockInfo = NULL;
6957 : }
6958 : return blockInfo;
6959 : }
6960 15 : SWIGINTERN Statistics *GDALMDArrayHS_GetStatistics(GDALMDArrayHS *self,bool approx_ok=FALSE,bool force=TRUE,GDALProgressFunc callback=NULL,void *callback_data=NULL){
6961 15 : GUInt64 nValidCount = 0;
6962 15 : Statistics* psStatisticsOut = (Statistics*)CPLMalloc(sizeof(Statistics));
6963 15 : CPLErr eErr = GDALMDArrayGetStatistics(self, NULL, approx_ok, force,
6964 : &(psStatisticsOut->min),
6965 : &(psStatisticsOut->max),
6966 : &(psStatisticsOut->mean),
6967 : &(psStatisticsOut->std_dev),
6968 : &nValidCount,
6969 : callback, callback_data);
6970 15 : psStatisticsOut->valid_count = static_cast<GIntBig>(nValidCount);
6971 15 : if( eErr == CE_None )
6972 : return psStatisticsOut;
6973 5 : CPLFree(psStatisticsOut);
6974 : return NULL;
6975 : }
6976 4 : SWIGINTERN Statistics *GDALMDArrayHS_ComputeStatistics(GDALMDArrayHS *self,bool approx_ok=FALSE,GDALProgressFunc callback=NULL,void *callback_data=NULL,char **options=0){
6977 4 : GUInt64 nValidCount = 0;
6978 4 : Statistics* psStatisticsOut = (Statistics*)CPLMalloc(sizeof(Statistics));
6979 4 : int nSuccess = GDALMDArrayComputeStatisticsEx(self, NULL, approx_ok,
6980 : &(psStatisticsOut->min),
6981 : &(psStatisticsOut->max),
6982 : &(psStatisticsOut->mean),
6983 : &(psStatisticsOut->std_dev),
6984 : &nValidCount,
6985 : callback, callback_data, options);
6986 4 : psStatisticsOut->valid_count = static_cast<GIntBig>(nValidCount);
6987 4 : if( nSuccess )
6988 : return psStatisticsOut;
6989 0 : CPLFree(psStatisticsOut);
6990 : return NULL;
6991 : }
6992 34 : SWIGINTERN GDALMDArrayHS *GDALMDArrayHS_GetResampled(GDALMDArrayHS *self,int nDimensions,GDALDimensionHS **dimensions,GDALRIOResampleAlg resample_alg,OSRSpatialReferenceShadow **srs,char **options=0){
6993 34 : return GDALMDArrayGetResampled(self, nDimensions, dimensions,
6994 : resample_alg, srs ? *srs : NULL, options);
6995 : }
6996 7 : SWIGINTERN void GDALMDArrayHS_GetMeshGrid(int nInputArrays,GDALMDArrayHS **ahInputArrays,GDALMDArrayHS ***outputArrays,size_t *pnCountOutputArrays,char **options=0){
6997 14 : *outputArrays = GDALMDArrayGetMeshGrid(ahInputArrays, nInputArrays, pnCountOutputArrays, options);
6998 : }
6999 7 : SWIGINTERN bool GDALMDArrayHS_Cache(GDALMDArrayHS *self,char **options=NULL){
7000 14 : return GDALMDArrayCache(self, options);
7001 : }
7002 28 : SWIGINTERN CPLErr GDALMDArrayHS_Rename(GDALMDArrayHS *self,char const *newName){
7003 28 : return GDALMDArrayRename( self, newName ) ? CE_None : CE_Failure;
7004 : }
7005 765 : SWIGINTERN void delete_GDALAttributeHS(GDALAttributeHS *self){
7006 765 : GDALAttributeRelease(self);
7007 765 : }
7008 361 : SWIGINTERN char const *GDALAttributeHS_GetName(GDALAttributeHS *self){
7009 361 : return GDALAttributeGetName(self);
7010 : }
7011 49 : SWIGINTERN char const *GDALAttributeHS_GetFullName(GDALAttributeHS *self){
7012 49 : return GDALAttributeGetFullName(self);
7013 : }
7014 177 : SWIGINTERN GUIntBig GDALAttributeHS_GetTotalElementsCount(GDALAttributeHS *self){
7015 177 : return GDALAttributeGetTotalElementsCount(self);
7016 : }
7017 12 : SWIGINTERN size_t GDALAttributeHS_GetDimensionCount(GDALAttributeHS *self){
7018 12 : return GDALAttributeGetDimensionCount(self);
7019 : }
7020 11 : SWIGINTERN void GDALAttributeHS_GetDimensionsSize(GDALAttributeHS *self,GUIntBig **pdims,size_t *pnCount){
7021 22 : *pdims = GDALAttributeGetDimensionsSize(self, pnCount);
7022 : }
7023 419 : SWIGINTERN GDALExtendedDataTypeHS *GDALAttributeHS_GetDataType(GDALAttributeHS *self){
7024 419 : return GDALAttributeGetDataType(self);
7025 : }
7026 10 : SWIGINTERN CPLErr GDALAttributeHS_ReadAsRaw(GDALAttributeHS *self,void **buf){
7027 10 : *buf = NULL;
7028 10 : GDALExtendedDataTypeHS* dt = GDALAttributeGetDataType(self);
7029 10 : bool bIsNumeric = CheckNumericDataType(dt);
7030 10 : GDALExtendedDataTypeRelease(dt);
7031 10 : if( !bIsNumeric )
7032 : {
7033 4 : CPLError(CE_Failure, CPLE_NotSupported,
7034 : "non-numeric buffer data type not supported in SWIG bindings");
7035 4 : return CE_Failure;
7036 : }
7037 6 : size_t buf_size = 0;
7038 6 : GByte* pabyBuf = GDALAttributeReadAsRaw(self, &buf_size);
7039 6 : if( pabyBuf == NULL )
7040 : {
7041 : return CE_Failure;
7042 : }
7043 :
7044 16 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
7045 6 : *buf = (void *)PyBytes_FromStringAndSize( NULL, buf_size );
7046 6 : if (*buf == NULL)
7047 : {
7048 0 : *buf = Py_None;
7049 0 : if( !GetUseExceptions() )
7050 : {
7051 0 : PyErr_Clear();
7052 : }
7053 0 : SWIG_PYTHON_THREAD_END_BLOCK;
7054 0 : CPLError(CE_Failure, CPLE_OutOfMemory, "Cannot allocate result buffer");
7055 0 : GDALAttributeFreeRawResult(self, pabyBuf, buf_size);
7056 : return CE_Failure;
7057 : }
7058 6 : char *data = PyBytes_AsString( (PyObject *)*buf );
7059 6 : SWIG_PYTHON_THREAD_END_BLOCK;
7060 :
7061 6 : memcpy(data, pabyBuf, buf_size);
7062 6 : GDALAttributeFreeRawResult(self, pabyBuf, buf_size);
7063 :
7064 : return CE_None;
7065 : }
7066 108 : SWIGINTERN char const *GDALAttributeHS_ReadAsString(GDALAttributeHS *self){
7067 108 : return GDALAttributeReadAsString(self);
7068 : }
7069 22 : SWIGINTERN int GDALAttributeHS_ReadAsInt(GDALAttributeHS *self){
7070 22 : return GDALAttributeReadAsInt(self);
7071 : }
7072 15 : SWIGINTERN long long GDALAttributeHS_ReadAsInt64(GDALAttributeHS *self){
7073 15 : return GDALAttributeReadAsInt64(self);
7074 : }
7075 :
7076 : #ifdef SWIG_LONG_LONG_AVAILABLE
7077 : SWIGINTERNINLINE PyObject*
7078 15 : SWIG_From_long_SS_long (long long value)
7079 : {
7080 15 : return ((value < LONG_MIN) || (value > LONG_MAX)) ?
7081 : PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
7082 : }
7083 : #endif
7084 :
7085 40 : SWIGINTERN double GDALAttributeHS_ReadAsDouble(GDALAttributeHS *self){
7086 40 : return GDALAttributeReadAsDouble(self);
7087 : }
7088 19 : SWIGINTERN char **GDALAttributeHS_ReadAsStringArray(GDALAttributeHS *self){
7089 19 : return GDALAttributeReadAsStringArray(self);
7090 : }
7091 :
7092 : static PyObject *
7093 15 : CreateTupleFromIntArray( const int *first, size_t size ) {
7094 15 : PyObject *out = PyTuple_New( size );
7095 819 : for( unsigned int i=0; i<size; i++ ) {
7096 804 : PyObject *val = PyInt_FromLong( *first );
7097 804 : ++first;
7098 804 : PyTuple_SetItem( out, i, val );
7099 : }
7100 15 : return out;
7101 : }
7102 :
7103 15 : SWIGINTERN void GDALAttributeHS_ReadAsIntArray(GDALAttributeHS *self,int **pvals,size_t *pnCount){
7104 30 : *pvals = GDALAttributeReadAsIntArray(self, pnCount);
7105 : }
7106 :
7107 : static PyObject *
7108 14 : CreateTupleFromInt64Array( const long long *first, size_t size ) {
7109 14 : PyObject *out = PyTuple_New( size );
7110 69 : for( unsigned int i=0; i<size; i++ ) {
7111 55 : PyObject *val = PyLong_FromLongLong( *first );
7112 55 : ++first;
7113 55 : PyTuple_SetItem( out, i, val );
7114 : }
7115 14 : return out;
7116 : }
7117 :
7118 14 : SWIGINTERN void GDALAttributeHS_ReadAsInt64Array(GDALAttributeHS *self,long long **pvals,size_t *pnCount){
7119 28 : *pvals = (long long*)GDALAttributeReadAsInt64Array(self, pnCount);
7120 : }
7121 29 : SWIGINTERN void GDALAttributeHS_ReadAsDoubleArray(GDALAttributeHS *self,double **pvals,size_t *pnCount){
7122 58 : *pvals = GDALAttributeReadAsDoubleArray(self, pnCount);
7123 : }
7124 5 : SWIGINTERN CPLErr GDALAttributeHS_WriteRaw(GDALAttributeHS *self,GIntBig nLen,char *pBuf){
7125 5 : GDALExtendedDataTypeHS* dt = GDALAttributeGetDataType(self);
7126 5 : bool bIsNumeric = CheckNumericDataType(dt);
7127 5 : GDALExtendedDataTypeRelease(dt);
7128 5 : if( !bIsNumeric )
7129 : {
7130 0 : CPLError(CE_Failure, CPLE_NotSupported,
7131 : "non-numeric buffer data type not supported in SWIG bindings");
7132 0 : return CE_Failure;
7133 : }
7134 5 : return GDALAttributeWriteRaw(self, pBuf, nLen) ? CE_None : CE_Failure;
7135 : }
7136 207 : SWIGINTERN CPLErr GDALAttributeHS_WriteString(GDALAttributeHS *self,char const *val){
7137 207 : return GDALAttributeWriteString(self, val) ? CE_None : CE_Failure;
7138 : }
7139 8 : SWIGINTERN CPLErr GDALAttributeHS_WriteStringArray(GDALAttributeHS *self,char **vals){
7140 8 : return GDALAttributeWriteStringArray(self, vals) ? CE_None : CE_Failure;
7141 : }
7142 22 : SWIGINTERN CPLErr GDALAttributeHS_WriteInt(GDALAttributeHS *self,int val){
7143 22 : return GDALAttributeWriteInt(self, val) ? CE_None : CE_Failure;
7144 : }
7145 :
7146 : #ifdef SWIG_LONG_LONG_AVAILABLE
7147 : SWIGINTERN int
7148 11 : SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
7149 : {
7150 11 : int res = SWIG_TypeError;
7151 11 : if (PyLong_Check(obj)) {
7152 11 : long long v = PyLong_AsLongLong(obj);
7153 11 : if (!PyErr_Occurred()) {
7154 11 : if (val) *val = v;
7155 11 : return SWIG_OK;
7156 : } else {
7157 0 : PyErr_Clear();
7158 0 : res = SWIG_OverflowError;
7159 : }
7160 : } else {
7161 0 : long v;
7162 0 : res = SWIG_AsVal_long (obj,&v);
7163 0 : if (SWIG_IsOK(res)) {
7164 0 : if (val) *val = v;
7165 0 : return res;
7166 : }
7167 : }
7168 : #ifdef SWIG_PYTHON_CAST_MODE
7169 : {
7170 : const double mant_max = 1LL << DBL_MANT_DIG;
7171 : const double mant_min = -mant_max;
7172 : double d;
7173 : res = SWIG_AsVal_double (obj,&d);
7174 : if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
7175 : return SWIG_OverflowError;
7176 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
7177 : if (val) *val = (long long)(d);
7178 : return SWIG_AddCast(res);
7179 : }
7180 : res = SWIG_TypeError;
7181 : }
7182 : #endif
7183 : return res;
7184 : }
7185 : #endif
7186 :
7187 11 : SWIGINTERN CPLErr GDALAttributeHS_WriteInt64(GDALAttributeHS *self,long long val){
7188 11 : return GDALAttributeWriteInt64(self, val) ? CE_None : CE_Failure;
7189 : }
7190 11 : SWIGINTERN CPLErr GDALAttributeHS_WriteDouble(GDALAttributeHS *self,double val){
7191 11 : return GDALAttributeWriteDouble(self, val) ? CE_None : CE_Failure;
7192 : }
7193 11 : SWIGINTERN CPLErr GDALAttributeHS_WriteIntArray(GDALAttributeHS *self,int nList,int *pList){
7194 11 : return GDALAttributeWriteIntArray(self, pList, nList) ? CE_None : CE_Failure;
7195 : }
7196 :
7197 : static long long*
7198 10 : CreateCInt64ListFromSequence( PyObject* pySeq, int* pnSize ) {
7199 : /* check if is List */
7200 10 : if ( !PySequence_Check(pySeq) ) {
7201 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
7202 0 : *pnSize = -1;
7203 0 : return NULL;
7204 : }
7205 10 : Py_ssize_t size = PySequence_Size(pySeq);
7206 10 : if( size > (Py_ssize_t)INT_MAX ) {
7207 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
7208 0 : *pnSize = -1;
7209 0 : return NULL;
7210 : }
7211 10 : if( (size_t)size > SIZE_MAX / sizeof(long long) ) {
7212 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
7213 0 : *pnSize = -1;
7214 0 : return NULL;
7215 : }
7216 10 : *pnSize = (int)size;
7217 10 : long long* ret = (long long*) malloc((*pnSize)*sizeof(long long));
7218 10 : if( !ret ) {
7219 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
7220 0 : *pnSize = -1;
7221 0 : return NULL;
7222 : }
7223 30 : for( int i = 0; i<*pnSize; i++ ) {
7224 20 : PyObject *o = PySequence_GetItem(pySeq,i);
7225 20 : if ( !PyArg_Parse(o,"L",&ret[i]) ) {
7226 0 : PyErr_SetString(PyExc_TypeError, "not an integer");
7227 0 : Py_DECREF(o);
7228 0 : free(ret);
7229 0 : *pnSize = -1;
7230 0 : return NULL;
7231 : }
7232 20 : Py_DECREF(o);
7233 : }
7234 : return ret;
7235 : }
7236 :
7237 10 : SWIGINTERN CPLErr GDALAttributeHS_WriteInt64Array(GDALAttributeHS *self,int nList,long long *pList){
7238 10 : return GDALAttributeWriteInt64Array(self, (int64_t*)pList, nList) ? CE_None : CE_Failure;
7239 : }
7240 :
7241 : static double*
7242 179 : CreateCDoubleListFromSequence( PyObject* pySeq, int* pnSize ) {
7243 : /* check if is List */
7244 179 : if ( !PySequence_Check(pySeq) ) {
7245 1 : PyErr_SetString(PyExc_TypeError, "not a sequence");
7246 1 : *pnSize = -1;
7247 1 : return NULL;
7248 : }
7249 178 : Py_ssize_t size = PySequence_Size(pySeq);
7250 178 : if( size > (Py_ssize_t)INT_MAX ) {
7251 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
7252 0 : *pnSize = -1;
7253 0 : return NULL;
7254 : }
7255 178 : if( (size_t)size > SIZE_MAX / sizeof(double) ) {
7256 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
7257 0 : *pnSize = -1;
7258 0 : return NULL;
7259 : }
7260 178 : *pnSize = (int)size;
7261 178 : double* ret = (double*) malloc((*pnSize)*sizeof(double));
7262 178 : if( !ret ) {
7263 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
7264 0 : *pnSize = -1;
7265 0 : return NULL;
7266 : }
7267 575 : for( int i = 0; i<*pnSize; i++ ) {
7268 398 : PyObject *o = PySequence_GetItem(pySeq,i);
7269 398 : if ( !PyArg_Parse(o,"d",&ret[i]) ) {
7270 1 : PyErr_SetString(PyExc_TypeError, "not an number");
7271 1 : Py_DECREF(o);
7272 1 : free(ret);
7273 1 : *pnSize = -1;
7274 1 : return NULL;
7275 : }
7276 397 : Py_DECREF(o);
7277 : }
7278 : return ret;
7279 : }
7280 :
7281 7 : SWIGINTERN CPLErr GDALAttributeHS_WriteDoubleArray(GDALAttributeHS *self,int nList,double *pList){
7282 7 : return GDALAttributeWriteDoubleArray(self, pList, nList) ? CE_None : CE_Failure;
7283 : }
7284 27 : SWIGINTERN CPLErr GDALAttributeHS_Rename(GDALAttributeHS *self,char const *newName){
7285 27 : return GDALAttributeRename( self, newName ) ? CE_None : CE_Failure;
7286 : }
7287 5324 : SWIGINTERN void delete_GDALDimensionHS(GDALDimensionHS *self){
7288 5324 : GDALDimensionRelease(self);
7289 5324 : }
7290 286 : SWIGINTERN char const *GDALDimensionHS_GetName(GDALDimensionHS *self){
7291 286 : return GDALDimensionGetName(self);
7292 : }
7293 82 : SWIGINTERN char const *GDALDimensionHS_GetFullName(GDALDimensionHS *self){
7294 82 : return GDALDimensionGetFullName(self);
7295 : }
7296 60 : SWIGINTERN char const *GDALDimensionHS_GetType(GDALDimensionHS *self){
7297 60 : return GDALDimensionGetType(self);
7298 : }
7299 28 : SWIGINTERN char const *GDALDimensionHS_GetDirection(GDALDimensionHS *self){
7300 28 : return GDALDimensionGetDirection(self);
7301 : }
7302 3952 : SWIGINTERN GUIntBig GDALDimensionHS_GetSize(GDALDimensionHS *self){
7303 3952 : return GDALDimensionGetSize(self);
7304 : }
7305 140 : SWIGINTERN GDALMDArrayHS *GDALDimensionHS_GetIndexingVariable(GDALDimensionHS *self){
7306 140 : return GDALDimensionGetIndexingVariable(self);
7307 : }
7308 23 : SWIGINTERN bool GDALDimensionHS_SetIndexingVariable(GDALDimensionHS *self,GDALMDArrayHS *array){
7309 46 : return GDALDimensionSetIndexingVariable(self, array);
7310 : }
7311 31 : SWIGINTERN CPLErr GDALDimensionHS_Rename(GDALDimensionHS *self,char const *newName){
7312 31 : return GDALDimensionRename( self, newName ) ? CE_None : CE_Failure;
7313 : }
7314 5012 : SWIGINTERN void delete_GDALExtendedDataTypeHS(GDALExtendedDataTypeHS *self){
7315 5012 : GDALExtendedDataTypeRelease(self);
7316 5012 : }
7317 2108 : SWIGINTERN GDALExtendedDataTypeHS *GDALExtendedDataTypeHS_Create(GDALDataType dt){
7318 2108 : return GDALExtendedDataTypeCreate(dt);
7319 : }
7320 222 : SWIGINTERN GDALExtendedDataTypeHS *GDALExtendedDataTypeHS_CreateString(size_t nMaxStringLength=0,GDALExtendedDataTypeSubType eSubType=GEDTST_NONE){
7321 222 : return GDALExtendedDataTypeCreateStringEx(nMaxStringLength, eSubType);
7322 : }
7323 22 : SWIGINTERN GDALExtendedDataTypeHS *GDALExtendedDataTypeHS_CreateCompound(char const *name,size_t nTotalSize,int nComps,GDALEDTComponentHS **comps){
7324 22 : return GDALExtendedDataTypeCreateCompound(name, nTotalSize, nComps, comps);
7325 : }
7326 8 : SWIGINTERN char const *GDALExtendedDataTypeHS_GetName(GDALExtendedDataTypeHS *self){
7327 8 : return GDALExtendedDataTypeGetName(self);
7328 : }
7329 3119 : SWIGINTERN GDALExtendedDataTypeClass GDALExtendedDataTypeHS_GetClass(GDALExtendedDataTypeHS *self){
7330 3119 : return GDALExtendedDataTypeGetClass(self);
7331 : }
7332 2142 : SWIGINTERN GDALDataType GDALExtendedDataTypeHS_GetNumericDataType(GDALExtendedDataTypeHS *self){
7333 2142 : return GDALExtendedDataTypeGetNumericDataType(self);
7334 : }
7335 51 : SWIGINTERN size_t GDALExtendedDataTypeHS_GetSize(GDALExtendedDataTypeHS *self){
7336 51 : return GDALExtendedDataTypeGetSize(self);
7337 : }
7338 3 : SWIGINTERN size_t GDALExtendedDataTypeHS_GetMaxStringLength(GDALExtendedDataTypeHS *self){
7339 3 : return GDALExtendedDataTypeGetMaxStringLength(self);
7340 : }
7341 105 : SWIGINTERN GDALExtendedDataTypeSubType GDALExtendedDataTypeHS_GetSubType(GDALExtendedDataTypeHS *self){
7342 105 : return GDALExtendedDataTypeGetSubType(self);
7343 : }
7344 1 : SWIGINTERN GDALRasterAttributeTableShadow *GDALExtendedDataTypeHS_GetRAT(GDALExtendedDataTypeHS *self){
7345 1 : return GDALExtendedDataTypeGetRAT(self);
7346 : }
7347 21 : SWIGINTERN void GDALExtendedDataTypeHS_GetComponents(GDALExtendedDataTypeHS *self,GDALEDTComponentHS ***pcomps,size_t *pnCount){
7348 42 : *pcomps = GDALExtendedDataTypeGetComponents(self, pnCount);
7349 : }
7350 7 : SWIGINTERN bool GDALExtendedDataTypeHS_CanConvertTo(GDALExtendedDataTypeHS *self,GDALExtendedDataTypeHS *other){
7351 14 : return GDALExtendedDataTypeCanConvertTo(self, other);
7352 : }
7353 100 : SWIGINTERN bool GDALExtendedDataTypeHS_Equals(GDALExtendedDataTypeHS *self,GDALExtendedDataTypeHS *other){
7354 200 : return GDALExtendedDataTypeEquals(self, other);
7355 : }
7356 61 : SWIGINTERN void delete_GDALEDTComponentHS(GDALEDTComponentHS *self){
7357 61 : GDALEDTComponentRelease(self);
7358 61 : }
7359 20 : SWIGINTERN GDALEDTComponentHS *GDALEDTComponentHS_Create(char const *name,size_t offset,GDALExtendedDataTypeHS *type){
7360 20 : return GDALEDTComponentCreate(name, offset, type);
7361 : }
7362 33 : SWIGINTERN char const *GDALEDTComponentHS_GetName(GDALEDTComponentHS *self){
7363 33 : return GDALEDTComponentGetName(self);
7364 : }
7365 31 : SWIGINTERN size_t GDALEDTComponentHS_GetOffset(GDALEDTComponentHS *self){
7366 31 : return GDALEDTComponentGetOffset(self);
7367 : }
7368 49 : SWIGINTERN GDALExtendedDataTypeHS *GDALEDTComponentHS_GetType(GDALEDTComponentHS *self){
7369 49 : return GDALEDTComponentGetType(self);
7370 : }
7371 :
7372 6 : GDALRasterAttributeTableShadow* CreateRasterAttributeTableFromMDArrays(
7373 : GDALRATTableType eTableType, int nArrays, GDALMDArrayHS **ahArrays,
7374 : int nUsages = 0, GDALRATFieldUsage *paeUsages = NULL )
7375 : {
7376 6 : if( nUsages != 0 && nUsages != nArrays )
7377 : {
7378 1 : CPLError(CE_Failure, CPLE_AppDefined, "nUsages != nArrays");
7379 1 : return NULL;
7380 : }
7381 5 : return GDALCreateRasterAttributeTableFromMDArrays( eTableType, nArrays, (const GDALMDArrayH *)ahArrays, paeUsages );
7382 : }
7383 :
7384 :
7385 : /* Returned size is in bytes or 0 if an error occurred. */
7386 : static
7387 19405 : GIntBig ComputeBandRasterIOSize (int buf_xsize, int buf_ysize, int nPixelSize,
7388 : GIntBig nPixelSpace, GIntBig nLineSpace,
7389 : int bSpacingShouldBeMultipleOfPixelSize )
7390 : {
7391 19405 : if (buf_xsize <= 0 || buf_ysize <= 0)
7392 : {
7393 2 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal values for buffer size");
7394 2 : return 0;
7395 : }
7396 :
7397 19403 : if (nPixelSpace < 0 || nLineSpace < 0)
7398 : {
7399 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal values for space arguments");
7400 0 : return 0;
7401 : }
7402 :
7403 19403 : if (nPixelSize == 0)
7404 : {
7405 1 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal value for data type");
7406 1 : return 0;
7407 : }
7408 :
7409 19402 : if( nPixelSpace == 0 )
7410 19205 : nPixelSpace = nPixelSize;
7411 197 : else if ( bSpacingShouldBeMultipleOfPixelSize && (nPixelSpace % nPixelSize) != 0 )
7412 : {
7413 0 : CPLError(CE_Failure, CPLE_IllegalArg, "nPixelSpace should be a multiple of nPixelSize");
7414 0 : return 0;
7415 : }
7416 :
7417 19402 : if( nLineSpace == 0 )
7418 : {
7419 19354 : nLineSpace = nPixelSpace * buf_xsize;
7420 : }
7421 48 : else if ( bSpacingShouldBeMultipleOfPixelSize && (nLineSpace % nPixelSize) != 0 )
7422 : {
7423 0 : CPLError(CE_Failure, CPLE_IllegalArg, "nLineSpace should be a multiple of nPixelSize");
7424 0 : return 0;
7425 : }
7426 :
7427 19402 : GIntBig nRet = (GIntBig)(buf_ysize - 1) * nLineSpace + (GIntBig)(buf_xsize - 1) * nPixelSpace + nPixelSize;
7428 : #if SIZEOF_VOIDP == 4
7429 : if (nRet > INT_MAX)
7430 : {
7431 : CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
7432 : return 0;
7433 : }
7434 : #endif
7435 :
7436 19402 : return nRet;
7437 : }
7438 :
7439 :
7440 : static
7441 9149 : CPLErr WriteRaster_internal( GDALRasterBandShadow *obj,
7442 : int xoff, int yoff, int xsize, int ysize,
7443 : int buf_xsize, int buf_ysize,
7444 : GDALDataType buf_type,
7445 : GIntBig buf_size, char *buffer,
7446 : GIntBig pixel_space, GIntBig line_space,
7447 : GDALRasterIOExtraArg* psExtraArg )
7448 : {
7449 9149 : GIntBig min_buffer_size = ComputeBandRasterIOSize (buf_xsize, buf_ysize, GDALGetDataTypeSizeBytes( buf_type ),
7450 : pixel_space, line_space, FALSE );
7451 9149 : if ( min_buffer_size == 0 )
7452 : return CE_Failure;
7453 :
7454 9148 : if ( buf_size < min_buffer_size ) {
7455 1 : CPLError(CE_Failure, CPLE_AppDefined, "Buffer too small");
7456 1 : return CE_Failure;
7457 : }
7458 :
7459 9147 : return GDALRasterIOEx( obj, GF_Write, xoff, yoff, xsize, ysize,
7460 9147 : (void *) buffer, buf_xsize, buf_ysize, buf_type, pixel_space, line_space, psExtraArg );
7461 : }
7462 :
7463 68 : SWIGINTERN GDALDatasetShadow *GDALRasterBandShadow_GetDataset(GDALRasterBandShadow *self){
7464 68 : return (GDALDatasetShadow*) GDALGetBandDataset(self);
7465 : }
7466 8 : SWIGINTERN int GDALRasterBandShadow_GetBand(GDALRasterBandShadow *self){
7467 8 : return GDALGetBandNumber(self);
7468 : }
7469 472 : SWIGINTERN void GDALRasterBandShadow_GetBlockSize(GDALRasterBandShadow *self,int *pnBlockXSize,int *pnBlockYSize){
7470 472 : GDALGetBlockSize(self, pnBlockXSize, pnBlockYSize);
7471 472 : }
7472 6 : SWIGINTERN void GDALRasterBandShadow_GetActualBlockSize(GDALRasterBandShadow *self,int nXBlockOff,int nYBlockOff,int *pnxvalid,int *pnyvalid,int *pisvalid){
7473 12 : *pisvalid = (GDALGetActualBlockSize(self, nXBlockOff, nYBlockOff, pnxvalid, pnyvalid) == CE_None);
7474 : }
7475 840 : SWIGINTERN GDALColorInterp GDALRasterBandShadow_GetColorInterpretation(GDALRasterBandShadow *self){
7476 840 : return GDALGetRasterColorInterpretation(self);
7477 : }
7478 182 : SWIGINTERN GDALColorInterp GDALRasterBandShadow_GetRasterColorInterpretation(GDALRasterBandShadow *self){
7479 182 : return GDALGetRasterColorInterpretation(self);
7480 : }
7481 693 : SWIGINTERN CPLErr GDALRasterBandShadow_SetColorInterpretation(GDALRasterBandShadow *self,GDALColorInterp val){
7482 693 : return GDALSetRasterColorInterpretation( self, val );
7483 : }
7484 409 : SWIGINTERN CPLErr GDALRasterBandShadow_SetRasterColorInterpretation(GDALRasterBandShadow *self,GDALColorInterp val){
7485 409 : return GDALSetRasterColorInterpretation( self, val );
7486 : }
7487 410206 : SWIGINTERN void GDALRasterBandShadow_GetNoDataValue(GDALRasterBandShadow *self,double *val,int *hasval){
7488 820412 : *val = GDALGetRasterNoDataValue( self, hasval );
7489 : }
7490 31 : SWIGINTERN void GDALRasterBandShadow_GetNoDataValueAsInt64(GDALRasterBandShadow *self,GIntBig *val,int *hasval){
7491 62 : *val = GDALGetRasterNoDataValueAsInt64( self, hasval );
7492 : }
7493 22 : SWIGINTERN void GDALRasterBandShadow_GetNoDataValueAsUInt64(GDALRasterBandShadow *self,GUIntBig *val,int *hasval){
7494 44 : *val = GDALGetRasterNoDataValueAsUInt64( self, hasval );
7495 : }
7496 686 : SWIGINTERN CPLErr GDALRasterBandShadow_SetNoDataValue(GDALRasterBandShadow *self,double d){
7497 686 : return GDALSetRasterNoDataValue( self, d );
7498 : }
7499 21 : SWIGINTERN CPLErr GDALRasterBandShadow_SetNoDataValueAsInt64(GDALRasterBandShadow *self,GIntBig v){
7500 21 : return GDALSetRasterNoDataValueAsInt64( self, v );
7501 : }
7502 20 : SWIGINTERN CPLErr GDALRasterBandShadow_SetNoDataValueAsUInt64(GDALRasterBandShadow *self,GUIntBig v){
7503 20 : return GDALSetRasterNoDataValueAsUInt64( self, v );
7504 : }
7505 53 : SWIGINTERN CPLErr GDALRasterBandShadow_DeleteNoDataValue(GDALRasterBandShadow *self){
7506 53 : return GDALDeleteRasterNoDataValue(self);
7507 : }
7508 69 : SWIGINTERN char const *GDALRasterBandShadow_GetUnitType(GDALRasterBandShadow *self){
7509 69 : return GDALGetRasterUnitType(self);
7510 : }
7511 38 : SWIGINTERN CPLErr GDALRasterBandShadow_SetUnitType(GDALRasterBandShadow *self,char const *val){
7512 38 : return GDALSetRasterUnitType( self, val );
7513 : }
7514 17 : SWIGINTERN char **GDALRasterBandShadow_GetRasterCategoryNames(GDALRasterBandShadow *self){
7515 17 : return GDALGetRasterCategoryNames(self);
7516 : }
7517 0 : SWIGINTERN CPLErr GDALRasterBandShadow_SetRasterCategoryNames(GDALRasterBandShadow *self,char **names){
7518 0 : return GDALSetRasterCategoryNames( self, names );
7519 : }
7520 97 : SWIGINTERN void GDALRasterBandShadow_GetMinimum(GDALRasterBandShadow *self,double *val,int *hasval){
7521 194 : *val = GDALGetRasterMinimum( self, hasval );
7522 : }
7523 87 : SWIGINTERN void GDALRasterBandShadow_GetMaximum(GDALRasterBandShadow *self,double *val,int *hasval){
7524 174 : *val = GDALGetRasterMaximum( self, hasval );
7525 : }
7526 151 : SWIGINTERN void GDALRasterBandShadow_GetOffset(GDALRasterBandShadow *self,double *val,int *hasval){
7527 302 : *val = GDALGetRasterOffset( self, hasval );
7528 : }
7529 149 : SWIGINTERN void GDALRasterBandShadow_GetScale(GDALRasterBandShadow *self,double *val,int *hasval){
7530 298 : *val = GDALGetRasterScale( self, hasval );
7531 : }
7532 86 : SWIGINTERN CPLErr GDALRasterBandShadow_SetOffset(GDALRasterBandShadow *self,double val){
7533 86 : return GDALSetRasterOffset( self, val );
7534 : }
7535 87 : SWIGINTERN CPLErr GDALRasterBandShadow_SetScale(GDALRasterBandShadow *self,double val){
7536 87 : return GDALSetRasterScale( self, val );
7537 : }
7538 140 : SWIGINTERN CPLErr GDALRasterBandShadow_GetStatistics(GDALRasterBandShadow *self,int approx_ok,int force,double *min,double *max,double *mean,double *stddev){
7539 140 : if (min) *min = 0;
7540 140 : if (max) *max = 0;
7541 140 : if (mean) *mean = 0;
7542 140 : if (stddev) *stddev = -1; /* This is the only way to recognize from Python if GetRasterStatistics() has updated the values */
7543 140 : return GDALGetRasterStatistics( self, approx_ok, force,
7544 140 : min, max, mean, stddev );
7545 : }
7546 168 : SWIGINTERN CPLErr GDALRasterBandShadow_ComputeStatistics(GDALRasterBandShadow *self,bool approx_ok,double *min,double *max,double *mean,double *stddev,GDALProgressFunc callback=NULL,void *callback_data=NULL){
7547 168 : return GDALComputeRasterStatistics( self, approx_ok, min, max, mean, stddev, callback, callback_data );
7548 : }
7549 2 : SWIGINTERN CPLErr GDALRasterBandShadow_SetStatistics(GDALRasterBandShadow *self,double min,double max,double mean,double stddev){
7550 2 : return GDALSetRasterStatistics( self, min, max, mean, stddev );
7551 : }
7552 536 : SWIGINTERN int GDALRasterBandShadow_GetOverviewCount(GDALRasterBandShadow *self){
7553 536 : return GDALGetOverviewCount(self);
7554 : }
7555 5597 : SWIGINTERN GDALRasterBandShadow *GDALRasterBandShadow_GetOverview(GDALRasterBandShadow *self,int i){
7556 5597 : return (GDALRasterBandShadow*) GDALGetOverview( self, i );
7557 : }
7558 2000 : SWIGINTERN GDALRasterBandShadow *GDALRasterBandShadow_GetSampleOverview(GDALRasterBandShadow *self,GUIntBig nDesiredSamples){
7559 2000 : return (GDALRasterBandShadow*) GDALGetRasterSampleOverviewEx( self, nDesiredSamples );
7560 : }
7561 38748 : SWIGINTERN int GDALRasterBandShadow_Checksum(GDALRasterBandShadow *self,int xoff=0,int yoff=0,int *xsize=0,int *ysize=0){
7562 38748 : int nxsize = (xsize!=0) ? *xsize : GDALGetRasterBandXSize( self );
7563 38748 : int nysize = (ysize!=0) ? *ysize : GDALGetRasterBandYSize( self );
7564 38748 : return GDALChecksumImage( self, xoff, yoff, nxsize, nysize );
7565 : }
7566 1515 : SWIGINTERN void GDALRasterBandShadow_ComputeRasterMinMax(GDALRasterBandShadow *self,double argout[2],int *isvalid,bool approx_ok=false,bool can_return_none=false){
7567 1515 : *isvalid = GDALComputeRasterMinMax( self, approx_ok, argout ) == CE_None;
7568 1515 : if( !can_return_none && !*isvalid )
7569 : {
7570 5 : *isvalid = true;
7571 5 : argout[0] = CPLAtof("nan");
7572 5 : argout[1] = CPLAtof("nan");
7573 : }
7574 1515 : }
7575 18 : SWIGINTERN void GDALRasterBandShadow_ComputeBandStats(GDALRasterBandShadow *self,double argout[2],int samplestep=1){
7576 18 : GDALComputeBandStats( self, samplestep, argout+0, argout+1,
7577 : NULL, NULL );
7578 18 : }
7579 268618 : SWIGINTERN CPLErr GDALRasterBandShadow_Fill(GDALRasterBandShadow *self,double real_fill,double imag_fill=0.0){
7580 268618 : return GDALFillRaster( self, real_fill, imag_fill );
7581 : }
7582 9149 : SWIGINTERN CPLErr GDALRasterBandShadow_WriteRaster(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,GIntBig buf_len,char *buf_string,int *buf_xsize=0,int *buf_ysize=0,GDALDataType *buf_type=0,GIntBig *buf_pixel_space=0,GIntBig *buf_line_space=0){
7583 9149 : int nxsize = (buf_xsize==0) ? xsize : *buf_xsize;
7584 9149 : int nysize = (buf_ysize==0) ? ysize : *buf_ysize;
7585 9149 : GDALDataType ntype = (buf_type==0) ? GDALGetRasterDataType(self)
7586 9149 : : *buf_type;
7587 9149 : GIntBig pixel_space = (buf_pixel_space == 0) ? 0 : *buf_pixel_space;
7588 9149 : GIntBig line_space = (buf_line_space == 0) ? 0 : *buf_line_space;
7589 9149 : GDALRasterIOExtraArg* psExtraArg = NULL;
7590 9149 : return WriteRaster_internal( self, xoff, yoff, xsize, ysize,
7591 9149 : nxsize, nysize, ntype, buf_len, buf_string, pixel_space, line_space, psExtraArg );
7592 : }
7593 391 : SWIGINTERN void GDALRasterBandShadow_FlushCache(GDALRasterBandShadow *self){
7594 391 : GDALFlushRasterCache( self );
7595 391 : }
7596 130 : SWIGINTERN GDALColorTableShadow *GDALRasterBandShadow_GetRasterColorTable(GDALRasterBandShadow *self){
7597 130 : return (GDALColorTableShadow*) GDALGetRasterColorTable( self );
7598 : }
7599 131 : SWIGINTERN GDALColorTableShadow *GDALRasterBandShadow_GetColorTable(GDALRasterBandShadow *self){
7600 131 : return (GDALColorTableShadow*) GDALGetRasterColorTable( self );
7601 : }
7602 46 : SWIGINTERN int GDALRasterBandShadow_SetRasterColorTable(GDALRasterBandShadow *self,GDALColorTableShadow *arg){
7603 92 : return GDALSetRasterColorTable( self, arg );
7604 : }
7605 30 : SWIGINTERN int GDALRasterBandShadow_SetColorTable(GDALRasterBandShadow *self,GDALColorTableShadow *arg){
7606 60 : return GDALSetRasterColorTable( self, arg );
7607 : }
7608 81 : SWIGINTERN GDALRasterAttributeTableShadow *GDALRasterBandShadow_GetDefaultRAT(GDALRasterBandShadow *self){
7609 81 : return (GDALRasterAttributeTableShadow*) GDALGetDefaultRAT(self);
7610 : }
7611 25 : SWIGINTERN int GDALRasterBandShadow_SetDefaultRAT(GDALRasterBandShadow *self,GDALRasterAttributeTableShadow *table){
7612 50 : return GDALSetDefaultRAT(self, table);
7613 : }
7614 10826 : SWIGINTERN GDALRasterBandShadow *GDALRasterBandShadow_GetMaskBand(GDALRasterBandShadow *self){
7615 10826 : return (GDALRasterBandShadow *) GDALGetMaskBand( self );
7616 : }
7617 454 : SWIGINTERN int GDALRasterBandShadow_GetMaskFlags(GDALRasterBandShadow *self){
7618 454 : return GDALGetMaskFlags( self );
7619 : }
7620 34 : SWIGINTERN CPLErr GDALRasterBandShadow_CreateMaskBand(GDALRasterBandShadow *self,int nFlags){
7621 34 : return GDALCreateMaskBand( self, nFlags );
7622 : }
7623 37 : SWIGINTERN bool GDALRasterBandShadow_IsMaskBand(GDALRasterBandShadow *self){
7624 37 : return GDALIsMaskBand( self );
7625 : }
7626 26 : SWIGINTERN CPLErr GDALRasterBandShadow_GetHistogram(GDALRasterBandShadow *self,double min=-0.5,double max=255.5,int buckets=256,GUIntBig *panHistogram=NULL,int include_out_of_range=0,int approx_ok=1,GDALProgressFunc callback=NULL,void *callback_data=NULL){
7627 26 : CPLErrorReset();
7628 26 : CPLErr err = GDALGetRasterHistogramEx( self, min, max, buckets, panHistogram,
7629 : include_out_of_range, approx_ok,
7630 : callback, callback_data );
7631 26 : return err;
7632 : }
7633 13 : SWIGINTERN CPLErr GDALRasterBandShadow_GetDefaultHistogram(GDALRasterBandShadow *self,double *min_ret=NULL,double *max_ret=NULL,int *buckets_ret=NULL,GUIntBig **ppanHistogram=NULL,int force=1,GDALProgressFunc callback=NULL,void *callback_data=NULL){
7634 13 : return GDALGetDefaultHistogramEx( self, min_ret, max_ret, buckets_ret,
7635 : ppanHistogram, force,
7636 : callback, callback_data );
7637 : }
7638 5 : SWIGINTERN CPLErr GDALRasterBandShadow_SetDefaultHistogram(GDALRasterBandShadow *self,double min,double max,int buckets_in,GUIntBig *panHistogram_in){
7639 5 : return GDALSetDefaultHistogramEx( self, min, max,
7640 : buckets_in, panHistogram_in );
7641 : }
7642 17 : SWIGINTERN bool GDALRasterBandShadow_HasArbitraryOverviews(GDALRasterBandShadow *self){
7643 34 : return (GDALHasArbitraryOverviews( self ) != 0) ? true : false;
7644 : }
7645 10 : SWIGINTERN char **GDALRasterBandShadow_GetCategoryNames(GDALRasterBandShadow *self){
7646 10 : return GDALGetRasterCategoryNames( self );
7647 : }
7648 2 : SWIGINTERN CPLErr GDALRasterBandShadow_SetCategoryNames(GDALRasterBandShadow *self,char **papszCategoryNames){
7649 2 : return GDALSetRasterCategoryNames( self, papszCategoryNames );
7650 : }
7651 1 : SWIGINTERN CPLVirtualMemShadow *GDALRasterBandShadow_GetVirtualMem(GDALRasterBandShadow *self,GDALRWFlag eRWFlag,int nXOff,int nYOff,int nXSize,int nYSize,int nBufXSize,int nBufYSize,GDALDataType eBufType,size_t nCacheSize,size_t nPageSizeHint,char **options=NULL){
7652 1 : CPLVirtualMem* vmem = GDALRasterBandGetVirtualMem( self,
7653 : eRWFlag,
7654 : nXOff, nYOff,
7655 : nXSize, nYSize,
7656 : nBufXSize, nBufYSize,
7657 : eBufType,
7658 : 0,
7659 : 0,
7660 : nCacheSize,
7661 : nPageSizeHint,
7662 : FALSE,
7663 : options );
7664 1 : if( vmem == NULL )
7665 : return NULL;
7666 1 : CPLVirtualMemShadow* vmemshadow = (CPLVirtualMemShadow*)calloc(1, sizeof(CPLVirtualMemShadow));
7667 1 : vmemshadow->vmem = vmem;
7668 1 : vmemshadow->eBufType = eBufType;
7669 1 : vmemshadow->bIsBandSequential = TRUE;
7670 1 : vmemshadow->bReadOnly = (eRWFlag == GF_Read);
7671 1 : vmemshadow->nBufXSize = nBufXSize;
7672 1 : vmemshadow->nBufYSize = nBufYSize;
7673 1 : vmemshadow->nBandCount = 1;
7674 1 : return vmemshadow;
7675 : }
7676 21 : SWIGINTERN CPLVirtualMemShadow *GDALRasterBandShadow_GetVirtualMemAuto(GDALRasterBandShadow *self,GDALRWFlag eRWFlag,char **options=NULL){
7677 21 : int nPixelSpace;
7678 21 : GIntBig nLineSpace;
7679 21 : CPLVirtualMem* vmem = GDALGetVirtualMemAuto( self,
7680 : eRWFlag,
7681 : &nPixelSpace,
7682 : &nLineSpace,
7683 : options );
7684 21 : if( vmem == NULL )
7685 : return NULL;
7686 20 : CPLVirtualMemShadow* vmemshadow = (CPLVirtualMemShadow*)calloc(1, sizeof(CPLVirtualMemShadow));
7687 20 : vmemshadow->vmem = vmem;
7688 20 : vmemshadow->eBufType = GDALGetRasterDataType( self );
7689 20 : vmemshadow->bAuto = TRUE;
7690 20 : vmemshadow->bReadOnly = (eRWFlag == GF_Read);
7691 20 : vmemshadow->nBandCount = 1;
7692 20 : vmemshadow->nPixelSpace = nPixelSpace;
7693 20 : vmemshadow->nLineSpace = nLineSpace;
7694 20 : vmemshadow->nBufXSize = GDALGetRasterBandXSize(self);
7695 20 : vmemshadow->nBufYSize = GDALGetRasterBandYSize(self);
7696 20 : return vmemshadow;
7697 : }
7698 1 : SWIGINTERN CPLVirtualMemShadow *GDALRasterBandShadow_GetTiledVirtualMem(GDALRasterBandShadow *self,GDALRWFlag eRWFlag,int nXOff,int nYOff,int nXSize,int nYSize,int nTileXSize,int nTileYSize,GDALDataType eBufType,size_t nCacheSize,char **options=NULL){
7699 1 : CPLVirtualMem* vmem = GDALRasterBandGetTiledVirtualMem( self,
7700 : eRWFlag,
7701 : nXOff, nYOff,
7702 : nXSize, nYSize,
7703 : nTileXSize, nTileYSize,
7704 : eBufType,
7705 : nCacheSize,
7706 : FALSE,
7707 : options );
7708 1 : if( vmem == NULL )
7709 : return NULL;
7710 1 : CPLVirtualMemShadow* vmemshadow = (CPLVirtualMemShadow*)calloc(1, sizeof(CPLVirtualMemShadow));
7711 1 : vmemshadow->vmem = vmem;
7712 1 : vmemshadow->eBufType = eBufType;
7713 1 : vmemshadow->bIsBandSequential = -1;
7714 1 : vmemshadow->bReadOnly = (eRWFlag == GF_Read);
7715 1 : vmemshadow->nBufXSize = nXSize;
7716 1 : vmemshadow->nBufYSize = nYSize;
7717 1 : vmemshadow->eTileOrganization = GTO_BSQ;
7718 1 : vmemshadow->nTileXSize = nTileXSize;
7719 1 : vmemshadow->nTileYSize = nTileYSize;
7720 1 : vmemshadow->nBandCount = 1;
7721 1 : return vmemshadow;
7722 : }
7723 29 : SWIGINTERN int GDALRasterBandShadow_GetDataCoverageStatus(GDALRasterBandShadow *self,int nXOff,int nYOff,int nXSize,int nYSize,int nMaskFlagStop=0,double *pdfDataPct=NULL){
7724 29 : return GDALGetDataCoverageStatus(self, nXOff, nYOff,
7725 : nXSize, nYSize,
7726 : nMaskFlagStop,
7727 : pdfDataPct);
7728 : }
7729 2 : SWIGINTERN CPLErr GDALRasterBandShadow_AdviseRead(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int *buf_xsize=0,int *buf_ysize=0,GDALDataType *buf_type=0,char **options=NULL){
7730 2 : int nxsize = (buf_xsize==0) ? xsize : *buf_xsize;
7731 2 : int nysize = (buf_ysize==0) ? ysize : *buf_ysize;
7732 2 : GDALDataType ntype;
7733 2 : if ( buf_type != 0 ) {
7734 0 : ntype = (GDALDataType) *buf_type;
7735 : } else {
7736 2 : ntype = GDALGetRasterDataType( self );
7737 : }
7738 2 : return GDALRasterAdviseRead(self, xoff, yoff, xsize, ysize,
7739 2 : nxsize, nysize, ntype, options);
7740 : }
7741 69 : SWIGINTERN CPLErr GDALRasterBandShadow_InterpolateAtPoint(GDALRasterBandShadow *self,double pixel,double line,GDALRIOResampleAlg interpolation,double *pdfRealValue,double *pdfImagValue){
7742 69 : if (pdfRealValue) *pdfRealValue = 0;
7743 69 : if (pdfImagValue) *pdfImagValue = 0;
7744 69 : return GDALRasterInterpolateAtPoint( self, pixel, line, interpolation, pdfRealValue, pdfImagValue );
7745 : }
7746 15 : SWIGINTERN CPLErr GDALRasterBandShadow_InterpolateAtGeolocation(GDALRasterBandShadow *self,double geolocX,double geolocY,OSRSpatialReferenceShadow *srs,GDALRIOResampleAlg interpolation,double *pdfRealValue,double *pdfImagValue,char **transformerOptions=NULL){
7747 15 : if (pdfRealValue) *pdfRealValue = 0;
7748 15 : if (pdfImagValue) *pdfImagValue = 0;
7749 15 : return GDALRasterInterpolateAtGeolocation( self, geolocX, geolocY,
7750 : (OGRSpatialReferenceH)srs, interpolation,
7751 : pdfRealValue, pdfImagValue, transformerOptions );
7752 : }
7753 2 : SWIGINTERN CPLErr GDALRasterBandShadow_ComputeMinMaxLocation(GDALRasterBandShadow *self,double *pdfMin,double *pdfMax,int *pnMinX,int *pnMinY,int *pnMaxX,int *pnMaxY){
7754 2 : return GDALComputeRasterMinMaxLocation( self, pdfMin, pdfMax,
7755 : pnMinX, pnMinY,
7756 : pnMaxX, pnMaxY );
7757 : }
7758 24 : SWIGINTERN GDALMDArrayHS *GDALRasterBandShadow_AsMDArray(GDALRasterBandShadow *self){
7759 24 : return GDALRasterBandAsMDArray(self);
7760 : }
7761 4902 : SWIGINTERN void GDALRasterBandShadow__EnablePixelTypeSignedByteWarning(GDALRasterBandShadow *self,bool b){
7762 4902 : GDALEnablePixelTypeSignedByteWarning(self, b);
7763 4902 : }
7764 6 : SWIGINTERN GDALComputedRasterBandShadow *GDALRasterBandShadow_UnaryOp(GDALRasterBandShadow *self,GDALRasterAlgebraUnaryOperation op){
7765 6 : return GDALRasterBandUnaryOp(self, op);
7766 : }
7767 57 : SWIGINTERN GDALComputedRasterBandShadow *GDALRasterBandShadow_BinaryOpBand(GDALRasterBandShadow *self,GDALRasterAlgebraBinaryOperation op,GDALRasterBandShadow *other){
7768 57 : return GDALRasterBandBinaryOpBand(self, op, other);
7769 : }
7770 59 : SWIGINTERN GDALComputedRasterBandShadow *GDALRasterBandShadow_BinaryOpDouble(GDALRasterBandShadow *self,GDALRasterAlgebraBinaryOperation op,double constant){
7771 59 : return GDALRasterBandBinaryOpDouble(self, op, constant);
7772 : }
7773 18 : SWIGINTERN GDALComputedRasterBandShadow *GDALRasterBandShadow_BinaryOpDoubleToBand(double constant,GDALRasterAlgebraBinaryOperation op,GDALRasterBandShadow *band){
7774 18 : return GDALRasterBandBinaryOpDoubleToBand(constant, op, band);
7775 : }
7776 12 : SWIGINTERN GDALComputedRasterBandShadow *GDALRasterBandShadow_IfThenElse(GDALRasterBandShadow *condBand,GDALRasterBandShadow *thenBand,GDALRasterBandShadow *elseBand){
7777 12 : return GDALRasterBandIfThenElse(condBand, thenBand, elseBand);
7778 : }
7779 16 : SWIGINTERN GDALComputedRasterBandShadow *GDALRasterBandShadow_AsType(GDALRasterBandShadow *self,GDALDataType dt){
7780 16 : return GDALRasterBandAsDataType(self, dt);
7781 : }
7782 4 : SWIGINTERN GDALComputedRasterBandShadow *GDALRasterBandShadow_MaximumOfNBands(int band_count,GDALRasterBandShadow **bands){
7783 4 : return GDALMaximumOfNBands(band_count, bands);
7784 : }
7785 2 : SWIGINTERN GDALComputedRasterBandShadow *GDALRasterBandShadow_MaxConstant(GDALRasterBandShadow *self,double constant){
7786 2 : return GDALRasterBandMaxConstant(self, constant);
7787 : }
7788 4 : SWIGINTERN GDALComputedRasterBandShadow *GDALRasterBandShadow_MinimumOfNBands(int band_count,GDALRasterBandShadow **bands){
7789 4 : return GDALMinimumOfNBands(band_count, bands);
7790 : }
7791 2 : SWIGINTERN GDALComputedRasterBandShadow *GDALRasterBandShadow_MinConstant(GDALRasterBandShadow *self,double constant){
7792 2 : return GDALRasterBandMinConstant(self, constant);
7793 : }
7794 3 : SWIGINTERN GDALComputedRasterBandShadow *GDALRasterBandShadow_MeanOfNBands(int band_count,GDALRasterBandShadow **bands){
7795 3 : return GDALMeanOfNBands(band_count, bands);
7796 : }
7797 10256 : SWIGINTERN CPLErr GDALRasterBandShadow_ReadRaster1(GDALRasterBandShadow *self,double xoff,double yoff,double xsize,double ysize,void **buf,int *buf_xsize=0,int *buf_ysize=0,GDALDataType *buf_type=0,GIntBig *buf_pixel_space=0,GIntBig *buf_line_space=0,GDALRIOResampleAlg resample_alg=GRIORA_NearestNeighbour,GDALProgressFunc callback=NULL,void *callback_data=NULL,void *inputOutputBuf=NULL){
7798 :
7799 10256 : *buf = NULL;
7800 :
7801 10256 : int nxsize = (buf_xsize==0) ? static_cast<int>(xsize) : *buf_xsize;
7802 10256 : int nysize = (buf_ysize==0) ? static_cast<int>(ysize) : *buf_ysize;
7803 10256 : GDALDataType ntype = (buf_type==0) ? GDALGetRasterDataType(self)
7804 10256 : : *buf_type;
7805 10256 : GIntBig pixel_space = (buf_pixel_space == 0) ? 0 : *buf_pixel_space;
7806 10256 : GIntBig line_space = (buf_line_space == 0) ? 0 : *buf_line_space;
7807 :
7808 10256 : size_t buf_size = static_cast<size_t>(
7809 10256 : ComputeBandRasterIOSize( nxsize, nysize,
7810 : GDALGetDataTypeSizeBytes( ntype ),
7811 10256 : pixel_space, line_space, FALSE ) );
7812 10256 : if (buf_size == 0)
7813 : {
7814 : return CE_Failure;
7815 : }
7816 :
7817 10254 : char *data;
7818 10254 : Py_buffer view;
7819 14541 : if( !readraster_acquirebuffer(buf, inputOutputBuf, buf_size, ntype,
7820 : GetUseExceptions(), data, view) )
7821 : {
7822 : return CE_Failure;
7823 : }
7824 :
7825 : /* Should we clear the buffer in case there are hole in it ? */
7826 10241 : if( inputOutputBuf == NULL &&
7827 10229 : line_space != 0 && pixel_space != 0 && line_space > pixel_space * nxsize )
7828 : {
7829 4 : memset(data, 0, buf_size);
7830 : }
7831 :
7832 10241 : GDALRasterIOExtraArg sExtraArg;
7833 10241 : INIT_RASTERIO_EXTRA_ARG(sExtraArg);
7834 10241 : sExtraArg.eResampleAlg = resample_alg;
7835 10241 : sExtraArg.pfnProgress = callback;
7836 10241 : sExtraArg.pProgressData = callback_data;
7837 10241 : int nXOff = (int)(xoff + 0.5);
7838 10241 : int nYOff = (int)(yoff + 0.5);
7839 10241 : int nXSize = (int)(xsize + 0.5);
7840 10241 : int nYSize = (int)(ysize + 0.5);
7841 10241 : if( fabs(xoff-nXOff) > 1e-8 || fabs(yoff-nYOff) > 1e-8 ||
7842 10235 : fabs(xsize-nXSize) > 1e-8 || fabs(ysize-nYSize) > 1e-8 )
7843 : {
7844 8 : sExtraArg.bFloatingPointWindowValidity = TRUE;
7845 8 : sExtraArg.dfXOff = xoff;
7846 8 : sExtraArg.dfYOff = yoff;
7847 8 : sExtraArg.dfXSize = xsize;
7848 8 : sExtraArg.dfYSize = ysize;
7849 : }
7850 :
7851 10241 : CPLErr eErr = GDALRasterIOEx( self, GF_Read, nXOff, nYOff, nXSize, nYSize,
7852 : data, nxsize, nysize, ntype,
7853 : pixel_space, line_space, &sExtraArg );
7854 :
7855 10241 : readraster_releasebuffer(eErr, buf, inputOutputBuf, view);
7856 :
7857 : return eErr;
7858 : }
7859 90 : SWIGINTERN CPLErr GDALRasterBandShadow_ReadBlock(GDALRasterBandShadow *self,int xoff,int yoff,void **buf,void *buf_obj=NULL){
7860 :
7861 90 : int nBlockXSize, nBlockYSize;
7862 90 : GDALGetBlockSize(self, &nBlockXSize, &nBlockYSize);
7863 90 : GDALDataType ntype = GDALGetRasterDataType(self);
7864 90 : int nDataTypeSize = GDALGetDataTypeSizeBytes(ntype);
7865 90 : size_t buf_size = static_cast<size_t>(nBlockXSize) *
7866 90 : nBlockYSize * nDataTypeSize;
7867 :
7868 90 : *buf = NULL;
7869 :
7870 90 : char *data;
7871 90 : Py_buffer view;
7872 :
7873 124 : if( !readraster_acquirebuffer(buf, buf_obj, buf_size, ntype,
7874 : GetUseExceptions(), data, view) )
7875 : {
7876 : return CE_Failure;
7877 : }
7878 :
7879 77 : CPLErr eErr = GDALReadBlock( self, xoff, yoff, data);
7880 :
7881 77 : readraster_releasebuffer(eErr, buf, buf_obj, view);
7882 :
7883 : return eErr;
7884 : }
7885 :
7886 849953 : GDALDataType GDALRasterBandShadow_DataType_get( GDALRasterBandShadow *h ) {
7887 849953 : return GDALGetRasterDataType( h );
7888 : }
7889 18112 : int GDALRasterBandShadow_XSize_get( GDALRasterBandShadow *h ) {
7890 18112 : return GDALGetRasterBandXSize( h );
7891 : }
7892 16977 : int GDALRasterBandShadow_YSize_get( GDALRasterBandShadow *h ) {
7893 16977 : return GDALGetRasterBandYSize( h );
7894 : }
7895 :
7896 163 : SWIGINTERN void delete_GDALComputedRasterBandShadow(GDALComputedRasterBandShadow *self){
7897 163 : GDALComputedRasterBandRelease(self);
7898 163 : }
7899 56 : SWIGINTERN GDALColorTableShadow *new_GDALColorTableShadow(GDALPaletteInterp palette=GPI_RGB){
7900 56 : return (GDALColorTableShadow*) GDALCreateColorTable(palette);
7901 : }
7902 68 : SWIGINTERN void delete_GDALColorTableShadow(GDALColorTableShadow *self){
7903 68 : GDALDestroyColorTable(self);
7904 68 : }
7905 12 : SWIGINTERN GDALColorTableShadow *GDALColorTableShadow_Clone(GDALColorTableShadow *self){
7906 12 : return (GDALColorTableShadow*) GDALCloneColorTable (self);
7907 : }
7908 2 : SWIGINTERN GDALPaletteInterp GDALColorTableShadow_GetPaletteInterpretation(GDALColorTableShadow *self){
7909 2 : return GDALGetPaletteInterpretation(self);
7910 : }
7911 73 : SWIGINTERN int GDALColorTableShadow_GetColorEntryCount(GDALColorTableShadow *self){
7912 73 : return GDALGetColorEntryCount(self);
7913 : }
7914 4719 : SWIGINTERN GDALColorEntry *GDALColorTableShadow_GetColorEntry(GDALColorTableShadow *self,int entry){
7915 4719 : return (GDALColorEntry*) GDALGetColorEntry(self, entry);
7916 : }
7917 0 : SWIGINTERN int GDALColorTableShadow_GetColorEntryAsRGB(GDALColorTableShadow *self,int entry,GDALColorEntry *centry){
7918 0 : return GDALGetColorEntryAsRGB(self, entry, centry);
7919 : }
7920 1379 : SWIGINTERN void GDALColorTableShadow_SetColorEntry(GDALColorTableShadow *self,int entry,GDALColorEntry const *centry){
7921 1379 : GDALSetColorEntry(self, entry, centry);
7922 1379 : }
7923 1 : SWIGINTERN void GDALColorTableShadow_CreateColorRamp(GDALColorTableShadow *self,int nStartIndex,GDALColorEntry const *startcolor,int nEndIndex,GDALColorEntry const *endcolor){
7924 1 : GDALCreateColorRamp(self, nStartIndex, startcolor, nEndIndex, endcolor);
7925 1 : }
7926 :
7927 : #include "gdalsubdatasetinfo.h"
7928 :
7929 60 : SWIGINTERN void delete_GDALSubdatasetInfoShadow(GDALSubdatasetInfoShadow *self){
7930 60 : GDALDestroySubdatasetInfo(reinterpret_cast<GDALSubdatasetInfoH>(self));
7931 60 : }
7932 35 : SWIGINTERN retStringAndCPLFree *GDALSubdatasetInfoShadow_GetPathComponent(GDALSubdatasetInfoShadow *self){
7933 35 : return GDALSubdatasetInfoGetPathComponent(reinterpret_cast<GDALSubdatasetInfoH>(self) );
7934 : }
7935 39 : SWIGINTERN retStringAndCPLFree *GDALSubdatasetInfoShadow_GetSubdatasetComponent(GDALSubdatasetInfoShadow *self){
7936 39 : return GDALSubdatasetInfoGetSubdatasetComponent(reinterpret_cast<GDALSubdatasetInfoH>(self) );
7937 : }
7938 21 : SWIGINTERN retStringAndCPLFree *GDALSubdatasetInfoShadow_ModifyPathComponent(GDALSubdatasetInfoShadow *self,char const *pszNewFileName){
7939 21 : return GDALSubdatasetInfoModifyPathComponent(reinterpret_cast<GDALSubdatasetInfoH>(self), pszNewFileName );
7940 : }
7941 :
7942 83 : GDALSubdatasetInfoShadow* GetSubdatasetInfo(const char *pszFileName)
7943 : {
7944 83 : GDALSubdatasetInfoH info { GDALGetSubdatasetInfo(pszFileName) };
7945 :
7946 83 : if( ! info )
7947 : {
7948 23 : return nullptr;
7949 : }
7950 :
7951 : return (GDALSubdatasetInfoShadow*)( info );
7952 : };
7953 :
7954 29 : SWIGINTERN GDALRelationshipShadow *new_GDALRelationshipShadow(char const *name,char const *leftTableName,char const *rightTableName,GDALRelationshipCardinality cardinality){
7955 29 : return (GDALRelationshipShadow*)
7956 29 : GDALRelationshipCreate(name,
7957 : leftTableName,
7958 : rightTableName,
7959 : cardinality);
7960 : }
7961 29 : SWIGINTERN void delete_GDALRelationshipShadow(GDALRelationshipShadow *self){
7962 29 : GDALDestroyRelationship(self);
7963 29 : }
7964 31 : SWIGINTERN char const *GDALRelationshipShadow_GetName(GDALRelationshipShadow *self){
7965 31 : return GDALRelationshipGetName( self );
7966 : }
7967 47 : SWIGINTERN GDALRelationshipCardinality GDALRelationshipShadow_GetCardinality(GDALRelationshipShadow *self){
7968 47 : return GDALRelationshipGetCardinality( self );
7969 : }
7970 49 : SWIGINTERN char const *GDALRelationshipShadow_GetLeftTableName(GDALRelationshipShadow *self){
7971 49 : return GDALRelationshipGetLeftTableName( self );
7972 : }
7973 49 : SWIGINTERN char const *GDALRelationshipShadow_GetRightTableName(GDALRelationshipShadow *self){
7974 49 : return GDALRelationshipGetRightTableName( self );
7975 : }
7976 34 : SWIGINTERN char const *GDALRelationshipShadow_GetMappingTableName(GDALRelationshipShadow *self){
7977 34 : return GDALRelationshipGetMappingTableName( self );
7978 : }
7979 14 : SWIGINTERN void GDALRelationshipShadow_SetMappingTableName(GDALRelationshipShadow *self,char const *pszName){
7980 14 : GDALRelationshipSetMappingTableName( self, pszName );
7981 14 : }
7982 48 : SWIGINTERN char **GDALRelationshipShadow_GetLeftTableFields(GDALRelationshipShadow *self){
7983 48 : return GDALRelationshipGetLeftTableFields(self);
7984 : }
7985 48 : SWIGINTERN char **GDALRelationshipShadow_GetRightTableFields(GDALRelationshipShadow *self){
7986 48 : return GDALRelationshipGetRightTableFields(self);
7987 : }
7988 37 : SWIGINTERN void GDALRelationshipShadow_SetLeftTableFields(GDALRelationshipShadow *self,char **pFields){
7989 37 : GDALRelationshipSetLeftTableFields(self, pFields);
7990 37 : }
7991 38 : SWIGINTERN void GDALRelationshipShadow_SetRightTableFields(GDALRelationshipShadow *self,char **pFields){
7992 38 : GDALRelationshipSetRightTableFields(self, pFields);
7993 38 : }
7994 23 : SWIGINTERN char **GDALRelationshipShadow_GetLeftMappingTableFields(GDALRelationshipShadow *self){
7995 23 : return GDALRelationshipGetLeftMappingTableFields(self);
7996 : }
7997 23 : SWIGINTERN char **GDALRelationshipShadow_GetRightMappingTableFields(GDALRelationshipShadow *self){
7998 23 : return GDALRelationshipGetRightMappingTableFields(self);
7999 : }
8000 9 : SWIGINTERN void GDALRelationshipShadow_SetLeftMappingTableFields(GDALRelationshipShadow *self,char **pFields){
8001 9 : GDALRelationshipSetLeftMappingTableFields(self, pFields);
8002 9 : }
8003 9 : SWIGINTERN void GDALRelationshipShadow_SetRightMappingTableFields(GDALRelationshipShadow *self,char **pFields){
8004 9 : GDALRelationshipSetRightMappingTableFields(self, pFields);
8005 9 : }
8006 47 : SWIGINTERN GDALRelationshipType GDALRelationshipShadow_GetType(GDALRelationshipShadow *self){
8007 47 : return GDALRelationshipGetType( self );
8008 : }
8009 10 : SWIGINTERN void GDALRelationshipShadow_SetType(GDALRelationshipShadow *self,GDALRelationshipType type){
8010 10 : return GDALRelationshipSetType( self, type );
8011 : }
8012 14 : SWIGINTERN char const *GDALRelationshipShadow_GetForwardPathLabel(GDALRelationshipShadow *self){
8013 14 : return GDALRelationshipGetForwardPathLabel( self );
8014 : }
8015 9 : SWIGINTERN void GDALRelationshipShadow_SetForwardPathLabel(GDALRelationshipShadow *self,char const *pszLabel){
8016 9 : GDALRelationshipSetForwardPathLabel( self, pszLabel );
8017 9 : }
8018 14 : SWIGINTERN char const *GDALRelationshipShadow_GetBackwardPathLabel(GDALRelationshipShadow *self){
8019 14 : return GDALRelationshipGetBackwardPathLabel( self );
8020 : }
8021 9 : SWIGINTERN void GDALRelationshipShadow_SetBackwardPathLabel(GDALRelationshipShadow *self,char const *pszLabel){
8022 9 : GDALRelationshipSetBackwardPathLabel( self, pszLabel );
8023 9 : }
8024 44 : SWIGINTERN char const *GDALRelationshipShadow_GetRelatedTableType(GDALRelationshipShadow *self){
8025 44 : return GDALRelationshipGetRelatedTableType( self );
8026 : }
8027 20 : SWIGINTERN void GDALRelationshipShadow_SetRelatedTableType(GDALRelationshipShadow *self,char const *pszType){
8028 20 : GDALRelationshipSetRelatedTableType( self, pszType );
8029 20 : }
8030 :
8031 : #include "gdalgrid.h"
8032 :
8033 : #ifdef DEBUG
8034 : typedef struct OGRLayerHS OGRLayerShadow;
8035 : typedef struct OGRGeometryHS OGRGeometryShadow;
8036 : #else
8037 : typedef void OGRLayerShadow;
8038 : typedef void OGRGeometryShadow;
8039 : #endif
8040 :
8041 :
8042 : static int
8043 3713 : GDALTermProgress_nocb( double dfProgress, const char * pszMessage=NULL, void *pData=NULL ) {
8044 3713 : return GDALTermProgress( dfProgress, pszMessage, pData);
8045 : }
8046 :
8047 :
8048 4 : int ComputeMedianCutPCT ( GDALRasterBandShadow *red,
8049 : GDALRasterBandShadow *green,
8050 : GDALRasterBandShadow *blue,
8051 : int num_colors,
8052 : GDALColorTableShadow* colors,
8053 : GDALProgressFunc callback = NULL,
8054 : void* callback_data=NULL) {
8055 :
8056 4 : CPLErrorReset();
8057 :
8058 4 : int err = GDALComputeMedianCutPCT( red,
8059 : green,
8060 : blue,
8061 : NULL,
8062 : num_colors,
8063 : colors,
8064 : callback,
8065 : callback_data);
8066 :
8067 4 : return err;
8068 : }
8069 :
8070 :
8071 7 : int DitherRGB2PCT ( GDALRasterBandShadow *red,
8072 : GDALRasterBandShadow *green,
8073 : GDALRasterBandShadow *blue,
8074 : GDALRasterBandShadow *target,
8075 : GDALColorTableShadow *colors,
8076 : GDALProgressFunc callback = NULL,
8077 : void* callback_data=NULL) {
8078 :
8079 7 : CPLErrorReset();
8080 7 : int err;
8081 7 : err = GDALDitherRGB2PCT( red,
8082 : green,
8083 : blue,
8084 : target,
8085 : colors,
8086 : callback,
8087 : callback_data);
8088 :
8089 7 : return err;
8090 : }
8091 :
8092 :
8093 62 : CPLErr ReprojectImage ( GDALDatasetShadow *src_ds,
8094 : GDALDatasetShadow *dst_ds,
8095 : const char *src_wkt=NULL,
8096 : const char *dst_wkt=NULL,
8097 : GDALResampleAlg eResampleAlg=GRA_NearestNeighbour,
8098 : double WarpMemoryLimit=0.0,
8099 : double maxerror = 0.0,
8100 : GDALProgressFunc callback = NULL,
8101 : void* callback_data=NULL,
8102 : char** options = NULL ) {
8103 :
8104 62 : CPLErrorReset();
8105 :
8106 62 : GDALWarpOptions* psOptions = NULL;
8107 62 : if( options != NULL )
8108 : {
8109 1 : psOptions = GDALCreateWarpOptions();
8110 1 : psOptions->papszWarpOptions = CSLDuplicate(options);
8111 : }
8112 :
8113 62 : CPLErr err = GDALReprojectImage( src_ds,
8114 : src_wkt,
8115 : dst_ds,
8116 : dst_wkt,
8117 : eResampleAlg,
8118 : WarpMemoryLimit,
8119 : maxerror,
8120 : callback,
8121 : callback_data,
8122 : psOptions);
8123 :
8124 62 : if( psOptions != NULL )
8125 1 : GDALDestroyWarpOptions(psOptions);
8126 :
8127 62 : return err;
8128 : }
8129 :
8130 :
8131 6 : int ComputeProximity( GDALRasterBandShadow *srcBand,
8132 : GDALRasterBandShadow *proximityBand,
8133 : char **options = NULL,
8134 : GDALProgressFunc callback=NULL,
8135 : void* callback_data=NULL) {
8136 :
8137 6 : CPLErrorReset();
8138 :
8139 6 : return GDALComputeProximity( srcBand, proximityBand, options,
8140 6 : callback, callback_data );
8141 : }
8142 :
8143 :
8144 42 : int RasterizeLayer( GDALDatasetShadow *dataset,
8145 : int bands, int *band_list,
8146 : OGRLayerShadow *layer,
8147 : void *pfnTransformer = NULL,
8148 : void *pTransformArg = NULL,
8149 : int burn_values = 0, double *burn_values_list = NULL,
8150 : char **options = NULL,
8151 : GDALProgressFunc callback=NULL,
8152 : void* callback_data=NULL) {
8153 :
8154 42 : CPLErr eErr;
8155 :
8156 42 : CPLErrorReset();
8157 :
8158 42 : if( burn_values == 0 )
8159 : {
8160 1 : burn_values_list = (double *) CPLMalloc(sizeof(double)*bands);
8161 4 : for( int i = 0; i < bands; i++ )
8162 3 : burn_values_list[i] = 255.0;
8163 : }
8164 41 : else if( burn_values != bands )
8165 : {
8166 0 : CPLError( CE_Failure, CPLE_AppDefined,
8167 : "Did not get the expected number of burn values in RasterizeLayer()" );
8168 0 : return CE_Failure;
8169 : }
8170 :
8171 42 : OGRLayerH hLayer = (OGRLayerH)layer;
8172 42 : eErr = GDALRasterizeLayers( dataset, bands, band_list,
8173 : 1, &hLayer,
8174 : (GDALTransformerFunc) pfnTransformer,
8175 : pTransformArg,
8176 : burn_values_list, options,
8177 : callback, callback_data );
8178 :
8179 42 : if( burn_values == 0 )
8180 1 : CPLFree( burn_values_list );
8181 :
8182 42 : return eErr;
8183 : }
8184 :
8185 :
8186 21 : int Polygonize( GDALRasterBandShadow *srcBand,
8187 : GDALRasterBandShadow *maskBand,
8188 : OGRLayerShadow *outLayer,
8189 : int iPixValField,
8190 : char **options = NULL,
8191 : GDALProgressFunc callback=NULL,
8192 : void* callback_data=NULL) {
8193 :
8194 21 : CPLErrorReset();
8195 :
8196 21 : return GDALPolygonize( srcBand, maskBand, outLayer, iPixValField,
8197 21 : options, callback, callback_data );
8198 : }
8199 :
8200 :
8201 1 : int FPolygonize( GDALRasterBandShadow *srcBand,
8202 : GDALRasterBandShadow *maskBand,
8203 : OGRLayerShadow *outLayer,
8204 : int iPixValField,
8205 : char **options = NULL,
8206 : GDALProgressFunc callback=NULL,
8207 : void* callback_data=NULL) {
8208 :
8209 1 : CPLErrorReset();
8210 :
8211 1 : return GDALFPolygonize( srcBand, maskBand, outLayer, iPixValField,
8212 1 : options, callback, callback_data );
8213 : }
8214 :
8215 :
8216 29 : int FillNodata( GDALRasterBandShadow *targetBand,
8217 : GDALRasterBandShadow *maskBand,
8218 : double maxSearchDist,
8219 : int smoothingIterations,
8220 : char **options = NULL,
8221 : GDALProgressFunc callback=NULL,
8222 : void* callback_data=NULL) {
8223 :
8224 29 : CPLErrorReset();
8225 :
8226 29 : return GDALFillNodata( targetBand, maskBand, maxSearchDist,
8227 : 0, smoothingIterations, options,
8228 29 : callback, callback_data );
8229 : }
8230 :
8231 :
8232 12 : int SieveFilter( GDALRasterBandShadow *srcBand,
8233 : GDALRasterBandShadow *maskBand,
8234 : GDALRasterBandShadow *dstBand,
8235 : int threshold, int connectedness=4,
8236 : char **options = NULL,
8237 : GDALProgressFunc callback=NULL,
8238 : void* callback_data=NULL) {
8239 :
8240 12 : CPLErrorReset();
8241 :
8242 12 : return GDALSieveFilter( srcBand, maskBand, dstBand,
8243 : threshold, connectedness,
8244 12 : options, callback, callback_data );
8245 : }
8246 :
8247 :
8248 2 : int RegenerateOverviews( GDALRasterBandShadow *srcBand,
8249 : int overviewBandCount,
8250 : GDALRasterBandShadow **overviewBands,
8251 : const char *resampling = "average",
8252 : GDALProgressFunc callback=NULL,
8253 : void* callback_data=NULL) {
8254 :
8255 2 : CPLErrorReset();
8256 :
8257 2 : return GDALRegenerateOverviews( srcBand, overviewBandCount, overviewBands,
8258 2 : resampling ? resampling : "average", callback, callback_data );
8259 : }
8260 :
8261 :
8262 248 : int RegenerateOverview( GDALRasterBandShadow *srcBand,
8263 : GDALRasterBandShadow *overviewBand,
8264 : const char *resampling = "average",
8265 : GDALProgressFunc callback=NULL,
8266 : void* callback_data=NULL) {
8267 :
8268 248 : CPLErrorReset();
8269 :
8270 248 : return GDALRegenerateOverviews( srcBand, 1, &overviewBand,
8271 248 : resampling ? resampling : "average", callback, callback_data );
8272 : }
8273 :
8274 :
8275 3 : int ContourGenerate( GDALRasterBandShadow *srcBand,
8276 : double contourInterval,
8277 : double contourBase,
8278 : int fixedLevelCount,
8279 : double *fixedLevels,
8280 : int useNoData,
8281 : double noDataValue,
8282 : OGRLayerShadow* dstLayer,
8283 : int idField,
8284 : int elevField,
8285 : GDALProgressFunc callback = NULL,
8286 : void* callback_data = NULL)
8287 : {
8288 3 : CPLErr eErr;
8289 :
8290 3 : CPLErrorReset();
8291 :
8292 3 : eErr = GDALContourGenerate( srcBand,
8293 : contourInterval,
8294 : contourBase,
8295 : fixedLevelCount,
8296 : fixedLevels,
8297 : useNoData,
8298 : noDataValue,
8299 : dstLayer,
8300 : idField,
8301 : elevField,
8302 : callback,
8303 : callback_data);
8304 :
8305 3 : return eErr;
8306 : }
8307 :
8308 :
8309 25 : int ContourGenerateEx( GDALRasterBandShadow *srcBand,
8310 : OGRLayerShadow* dstLayer,
8311 : char** options = NULL,
8312 : GDALProgressFunc callback = NULL,
8313 : void* callback_data = NULL )
8314 : {
8315 25 : CPLErr eErr;
8316 :
8317 25 : CPLErrorReset();
8318 :
8319 25 : eErr = GDALContourGenerateEx( srcBand,
8320 : dstLayer,
8321 : options,
8322 : callback,
8323 : callback_data);
8324 :
8325 25 : return eErr;
8326 : }
8327 :
8328 :
8329 0 : GDALDatasetShadow *ViewshedGenerate( GDALRasterBandShadow *srcBand,
8330 : const char* driverName,
8331 : const char* targetRasterName,
8332 : char** creationOptions,
8333 : double observerX, double observerY, double observerHeight,
8334 : double targetHeight, double visibleVal, double invisibleVal,
8335 : double outOfRangeVal, double noDataVal, double dfCurvCoeff,
8336 : GDALViewshedMode mode, double maxDistance,
8337 : GDALProgressFunc callback = NULL, void* callback_data = NULL,
8338 : GDALViewshedOutputType heightMode = GVOT_NORMAL,
8339 : char** options = NULL)
8340 : {
8341 0 : GDALDatasetShadow* ds = GDALViewshedGenerate( srcBand,
8342 : driverName,
8343 : targetRasterName,
8344 : creationOptions,
8345 : observerX,
8346 : observerY,
8347 : observerHeight,
8348 : targetHeight,
8349 : visibleVal,
8350 : invisibleVal,
8351 : outOfRangeVal,
8352 : noDataVal,
8353 : dfCurvCoeff,
8354 : mode,
8355 : maxDistance,
8356 : callback,
8357 : callback_data,
8358 : heightMode,
8359 : options);
8360 0 : if (ds == 0) {
8361 : /*throw CPLGetLastErrorMsg(); causes a SWIG_exception later*/
8362 : }
8363 0 : return ds;
8364 : }
8365 :
8366 :
8367 5 : void IsLineOfSightVisible(GDALRasterBandShadow *band,
8368 : int xA, int yA, double zA,
8369 : int xB, int yB, double zB,
8370 : bool *pbVisible, int *pnXIntersection, int *pnYIntersection,
8371 : char** options = NULL)
8372 : {
8373 5 : *pbVisible = GDALIsLineOfSightVisible(band, xA, yA, zA, xB, yB, zB, pnXIntersection, pnYIntersection, options);
8374 5 : }
8375 :
8376 :
8377 24 : GDALDatasetShadow *AutoCreateWarpedVRT( GDALDatasetShadow *src_ds,
8378 : const char *src_wkt = 0,
8379 : const char *dst_wkt = 0,
8380 : GDALResampleAlg eResampleAlg = GRA_NearestNeighbour,
8381 : double maxerror = 0.0 ) {
8382 24 : GDALDatasetShadow *ds = GDALAutoCreateWarpedVRT( src_ds, src_wkt,
8383 : dst_wkt,
8384 : eResampleAlg,
8385 : maxerror,
8386 : 0 );
8387 24 : if (ds == 0) {
8388 : /*throw CPLGetLastErrorMsg(); causes a SWIG_exception later*/
8389 : }
8390 24 : return ds;
8391 :
8392 : }
8393 :
8394 :
8395 8 : GDALDatasetShadow* CreatePansharpenedVRT( const char* pszXML,
8396 : GDALRasterBandShadow* panchroBand,
8397 : int nInputSpectralBands,
8398 : GDALRasterBandShadow** ahInputSpectralBands )
8399 : {
8400 8 : CPLErrorReset();
8401 :
8402 8 : return (GDALDatasetShadow*)GDALCreatePansharpenedVRT( pszXML, panchroBand,
8403 8 : nInputSpectralBands, ahInputSpectralBands );
8404 : }
8405 :
8406 71 : SWIGINTERN void delete_GDALTransformerInfoShadow(GDALTransformerInfoShadow *self){
8407 71 : GDALDestroyTransformer( self );
8408 71 : }
8409 0 : SWIGINTERN int GDALTransformerInfoShadow_TransformPoint__SWIG_0(GDALTransformerInfoShadow *self,int bDstToSrc,double inout[3]){
8410 0 : int nRet, nSuccess = TRUE;
8411 :
8412 0 : nRet = GDALUseTransformer( self, bDstToSrc,
8413 : 1, &inout[0], &inout[1], &inout[2],
8414 : &nSuccess );
8415 :
8416 0 : return nRet && nSuccess;
8417 : }
8418 8677 : SWIGINTERN int GDALTransformerInfoShadow_TransformPoint__SWIG_1(GDALTransformerInfoShadow *self,double argout[3],int bDstToSrc,double x,double y,double z=0.0){
8419 8677 : int nRet, nSuccess = TRUE;
8420 :
8421 8677 : argout[0] = x;
8422 8677 : argout[1] = y;
8423 8677 : argout[2] = z;
8424 8677 : nRet = GDALUseTransformer( self, bDstToSrc,
8425 : 1, &argout[0], &argout[1], &argout[2],
8426 : &nSuccess );
8427 :
8428 8677 : return nRet && nSuccess;
8429 : }
8430 :
8431 : static int
8432 4 : DecomposeSequenceOfCoordinates( PyObject *seq, int nCount, double *x, double *y, double *z )
8433 : {
8434 35 : for( int i = 0; i<nCount; ++i )
8435 : {
8436 :
8437 31 : PyObject *o = PySequence_GetItem(seq, i);
8438 31 : if ( !PySequence_Check(o) )
8439 : {
8440 0 : Py_DECREF(o);
8441 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
8442 :
8443 0 : return FALSE;
8444 : }
8445 :
8446 31 : Py_ssize_t len = PySequence_Size(o);
8447 :
8448 31 : if (len == 2 || len == 3)
8449 : {
8450 31 : PyObject *o1 = PySequence_GetItem(o, 0);
8451 31 : if (!PyNumber_Check(o1))
8452 : {
8453 0 : Py_DECREF(o); Py_DECREF(o1);
8454 0 : PyErr_SetString(PyExc_TypeError, "not a number");
8455 :
8456 0 : return FALSE;
8457 : }
8458 31 : x[i] = PyFloat_AsDouble(o1);
8459 31 : Py_DECREF(o1);
8460 :
8461 31 : o1 = PySequence_GetItem(o, 1);
8462 31 : if (!PyNumber_Check(o1))
8463 : {
8464 0 : Py_DECREF(o); Py_DECREF(o1);
8465 0 : PyErr_SetString(PyExc_TypeError, "not a number");
8466 :
8467 0 : return FALSE;
8468 : }
8469 31 : y[i] = PyFloat_AsDouble(o1);
8470 31 : Py_DECREF(o1);
8471 :
8472 : /* The 3rd coordinate is optional, default 0.0 */
8473 31 : if (len == 3)
8474 : {
8475 0 : o1 = PySequence_GetItem(o, 2);
8476 0 : if (!PyNumber_Check(o1))
8477 : {
8478 0 : Py_DECREF(o); Py_DECREF(o1);
8479 0 : PyErr_SetString(PyExc_TypeError, "not a number");
8480 :
8481 0 : return FALSE;
8482 : }
8483 0 : z[i] = PyFloat_AsDouble(o1);
8484 0 : Py_DECREF(o1);
8485 : }
8486 : else
8487 : {
8488 31 : z[i] = 0.0;
8489 : }
8490 : }
8491 : else
8492 : {
8493 0 : Py_DECREF(o);
8494 0 : PyErr_SetString(PyExc_TypeError, "invalid coordinate");
8495 :
8496 0 : return FALSE;
8497 : }
8498 :
8499 31 : Py_DECREF(o);
8500 : }
8501 :
8502 : return TRUE;
8503 : }
8504 :
8505 4 : SWIGINTERN int GDALTransformerInfoShadow_TransformPoints(GDALTransformerInfoShadow *self,int bDstToSrc,int nCount,double *x,double *y,double *z,int *panSuccess){
8506 4 : int nRet;
8507 :
8508 8 : nRet = GDALUseTransformer( self, bDstToSrc, nCount, x, y, z, panSuccess );
8509 :
8510 4 : return nRet;
8511 : }
8512 1 : SWIGINTERN int GDALTransformerInfoShadow_TransformGeolocations(GDALTransformerInfoShadow *self,GDALRasterBandShadow *xBand,GDALRasterBandShadow *yBand,GDALRasterBandShadow *zBand,GDALProgressFunc callback=NULL,void *callback_data=NULL,char **options=NULL){
8513 :
8514 1 : CPLErrorReset();
8515 :
8516 1 : return GDALTransformGeolocations( xBand, yBand, zBand,
8517 : GDALUseTransformer, self,
8518 1 : callback, callback_data, options );
8519 : }
8520 :
8521 79 : GDALTransformerInfoShadow* Transformer( GDALDatasetShadow *src, GDALDatasetShadow *dst,
8522 : char **options ) {
8523 79 : GDALTransformerInfoShadow *obj = (GDALTransformerInfoShadow*)
8524 79 : GDALCreateGenImgProjTransformer2( (GDALDatasetH)src, (GDALDatasetH)dst,
8525 : options );
8526 79 : return obj;
8527 : }
8528 :
8529 :
8530 : typedef struct
8531 : {
8532 : int width;
8533 : int height;
8534 : double xmin;
8535 : double ymin;
8536 : double xmax;
8537 : double ymax;
8538 : double geotransform[6];
8539 : } SuggestedWarpOutputRes;
8540 :
8541 3 : SWIGINTERN void delete_SuggestedWarpOutputRes(SuggestedWarpOutputRes *self){
8542 3 : CPLFree(self);
8543 3 : }
8544 2 : SWIGINTERN void SuggestedWarpOutputRes_GetGeotransform(SuggestedWarpOutputRes *self,double geotransform[6]){
8545 2 : memcpy(geotransform, self->geotransform, 6 * sizeof(double));
8546 : }
8547 :
8548 : #ifdef SWIGPYTHON
8549 1 : SuggestedWarpOutputRes* SuggestedWarpOutputFromTransformer(
8550 : GDALDatasetShadow *src,
8551 : GDALTransformerInfoShadow* transformer )
8552 : #else
8553 : SuggestedWarpOutputRes* SuggestedWarpOutput( GDALDatasetShadow *src,
8554 : GDALTransformerInfoShadow* transformer )
8555 : #endif
8556 : {
8557 1 : SuggestedWarpOutputRes* res = (SuggestedWarpOutputRes*)CPLMalloc(sizeof(SuggestedWarpOutputRes));
8558 1 : double extent[4];
8559 1 : if( GDALSuggestedWarpOutput2(src, GDALGenImgProjTransform, transformer,
8560 1 : res->geotransform,&(res->width), &(res->height),
8561 : extent, 0) != CE_None )
8562 : {
8563 0 : CPLFree(res);
8564 0 : return NULL;
8565 : }
8566 1 : res->xmin = extent[0];
8567 1 : res->ymin = extent[1];
8568 1 : res->xmax = extent[2];
8569 1 : res->ymax = extent[3];
8570 1 : return res;
8571 : }
8572 :
8573 :
8574 : #ifdef SWIGPYTHON
8575 2 : SuggestedWarpOutputRes* SuggestedWarpOutputFromOptions( GDALDatasetShadow *src,
8576 : char** options )
8577 : #else
8578 : SuggestedWarpOutputRes* SuggestedWarpOutput( GDALDatasetShadow *src,
8579 : char** options )
8580 : #endif
8581 : {
8582 2 : SuggestedWarpOutputRes* res = (SuggestedWarpOutputRes*)CPLMalloc(sizeof(SuggestedWarpOutputRes));
8583 2 : double extent[4];
8584 2 : void* pTransformArg = GDALCreateGenImgProjTransformer2( src, NULL, options );
8585 2 : if( GDALSuggestedWarpOutput2(src, GDALGenImgProjTransform, pTransformArg,
8586 2 : res->geotransform,&(res->width), &(res->height),
8587 : extent, 0) != CE_None )
8588 : {
8589 0 : GDALDestroyTransformer(pTransformArg);
8590 0 : CPLFree(res);
8591 0 : return NULL;
8592 : }
8593 2 : GDALDestroyTransformer(pTransformArg);
8594 2 : res->xmin = extent[0];
8595 2 : res->ymin = extent[1];
8596 2 : res->xmax = extent[2];
8597 2 : res->ymax = extent[3];
8598 2 : return res;
8599 : }
8600 :
8601 :
8602 23 : GDALDatasetShadow* ApplyVerticalShiftGrid( GDALDatasetShadow *src_ds,
8603 : GDALDatasetShadow *grid_ds,
8604 : bool inverse = false,
8605 : double srcUnitToMeter = 1.0,
8606 : double dstUnitToMeter = 1.0,
8607 : char** options = NULL ) {
8608 23 : GDALDatasetShadow *ds = GDALApplyVerticalShiftGrid( src_ds, grid_ds,
8609 : inverse,
8610 : srcUnitToMeter,
8611 : dstUnitToMeter,
8612 : options );
8613 23 : return ds;
8614 :
8615 : }
8616 :
8617 :
8618 : #include "gdalalgorithm.h"
8619 :
8620 : typedef GDALAlgorithmRegistryHS GDALAlgorithmRegistryHS;
8621 : typedef GDALAlgorithmHS GDALAlgorithmHS;
8622 : typedef GDALAlgorithmArgHS GDALAlgorithmArgHS;
8623 : typedef GDALArgDatasetValueHS GDALArgDatasetValueHS;
8624 :
8625 14330 : SWIGINTERN void delete_GDALAlgorithmArgHS(GDALAlgorithmArgHS *self){
8626 14330 : GDALAlgorithmArgRelease( self );
8627 14330 : }
8628 480 : SWIGINTERN char const *GDALAlgorithmArgHS_GetName(GDALAlgorithmArgHS *self){
8629 480 : return GDALAlgorithmArgGetName(self);
8630 : }
8631 8438 : SWIGINTERN GDALAlgorithmArgType GDALAlgorithmArgHS_GetType(GDALAlgorithmArgHS *self){
8632 8438 : return GDALAlgorithmArgGetType(self);
8633 : }
8634 1 : SWIGINTERN char const *GDALAlgorithmArgHS_GetDescription(GDALAlgorithmArgHS *self){
8635 1 : return GDALAlgorithmArgGetDescription(self);
8636 : }
8637 1 : SWIGINTERN char const *GDALAlgorithmArgHS_GetShortName(GDALAlgorithmArgHS *self){
8638 1 : return GDALAlgorithmArgGetShortName(self);
8639 : }
8640 1 : SWIGINTERN char **GDALAlgorithmArgHS_GetAliases(GDALAlgorithmArgHS *self){
8641 1 : return GDALAlgorithmArgGetAliases( self );
8642 : }
8643 1 : SWIGINTERN char const *GDALAlgorithmArgHS_GetMetaVar(GDALAlgorithmArgHS *self){
8644 1 : return GDALAlgorithmArgGetMetaVar(self);
8645 : }
8646 1 : SWIGINTERN char const *GDALAlgorithmArgHS_GetCategory(GDALAlgorithmArgHS *self){
8647 1 : return GDALAlgorithmArgGetCategory(self);
8648 : }
8649 1 : SWIGINTERN bool GDALAlgorithmArgHS_IsPositional(GDALAlgorithmArgHS *self){
8650 1 : return GDALAlgorithmArgIsPositional(self);
8651 : }
8652 1 : SWIGINTERN bool GDALAlgorithmArgHS_IsRequired(GDALAlgorithmArgHS *self){
8653 1 : return GDALAlgorithmArgIsRequired(self);
8654 : }
8655 1 : SWIGINTERN int GDALAlgorithmArgHS_GetMinCount(GDALAlgorithmArgHS *self){
8656 1 : return GDALAlgorithmArgGetMinCount(self);
8657 : }
8658 1 : SWIGINTERN int GDALAlgorithmArgHS_GetMaxCount(GDALAlgorithmArgHS *self){
8659 1 : return GDALAlgorithmArgGetMaxCount(self);
8660 : }
8661 1 : SWIGINTERN bool GDALAlgorithmArgHS_GetPackedValuesAllowed(GDALAlgorithmArgHS *self){
8662 1 : return GDALAlgorithmArgGetPackedValuesAllowed(self);
8663 : }
8664 1 : SWIGINTERN bool GDALAlgorithmArgHS_GetRepeatedArgAllowed(GDALAlgorithmArgHS *self){
8665 1 : return GDALAlgorithmArgGetRepeatedArgAllowed(self);
8666 : }
8667 1 : SWIGINTERN char **GDALAlgorithmArgHS_GetChoices(GDALAlgorithmArgHS *self){
8668 1 : return GDALAlgorithmArgGetChoices( self );
8669 : }
8670 28 : SWIGINTERN char **GDALAlgorithmArgHS_GetMetadataItem(GDALAlgorithmArgHS *self,char const *item){
8671 28 : return GDALAlgorithmArgGetMetadataItem( self, item );
8672 : }
8673 321 : SWIGINTERN bool GDALAlgorithmArgHS_IsExplicitlySet(GDALAlgorithmArgHS *self){
8674 321 : return GDALAlgorithmArgIsExplicitlySet(self);
8675 : }
8676 1 : SWIGINTERN bool GDALAlgorithmArgHS_HasDefaultValue(GDALAlgorithmArgHS *self){
8677 1 : return GDALAlgorithmArgHasDefaultValue(self);
8678 : }
8679 1 : SWIGINTERN bool GDALAlgorithmArgHS_GetDefaultAsBoolean(GDALAlgorithmArgHS *self){
8680 1 : return GDALAlgorithmArgGetDefaultAsBoolean(self);
8681 : }
8682 1 : SWIGINTERN char const *GDALAlgorithmArgHS_GetDefaultAsString(GDALAlgorithmArgHS *self){
8683 1 : return GDALAlgorithmArgGetDefaultAsString(self);
8684 : }
8685 1 : SWIGINTERN int GDALAlgorithmArgHS_GetDefaultAsInteger(GDALAlgorithmArgHS *self){
8686 1 : return GDALAlgorithmArgGetDefaultAsInteger(self);
8687 : }
8688 1 : SWIGINTERN double GDALAlgorithmArgHS_GetDefaultAsDouble(GDALAlgorithmArgHS *self){
8689 1 : return GDALAlgorithmArgGetDefaultAsDouble(self);
8690 : }
8691 1 : SWIGINTERN char **GDALAlgorithmArgHS_GetDefaultAsStringList(GDALAlgorithmArgHS *self){
8692 1 : return GDALAlgorithmArgGetDefaultAsStringList( self );
8693 : }
8694 1 : SWIGINTERN void GDALAlgorithmArgHS_GetDefaultAsIntegerList(GDALAlgorithmArgHS *self,int *nLen,int const **pList){
8695 1 : size_t nLenSizet = 0;
8696 2 : *pList = GDALAlgorithmArgGetDefaultAsIntegerList(self, &nLenSizet);
8697 1 : *nLen = (int)nLenSizet;
8698 : }
8699 1 : SWIGINTERN void GDALAlgorithmArgHS_GetDefaultAsDoubleList(GDALAlgorithmArgHS *self,int *nLen,double const **pList){
8700 1 : size_t nLenSizet = 0;
8701 2 : *pList = GDALAlgorithmArgGetDefaultAsDoubleList(self, &nLenSizet);
8702 1 : *nLen = (int)nLenSizet;
8703 : }
8704 1 : SWIGINTERN bool GDALAlgorithmArgHS_IsHidden(GDALAlgorithmArgHS *self){
8705 1 : return GDALAlgorithmArgIsHidden(self);
8706 : }
8707 1 : SWIGINTERN bool GDALAlgorithmArgHS_IsHiddenForCLI(GDALAlgorithmArgHS *self){
8708 1 : return GDALAlgorithmArgIsHiddenForCLI(self);
8709 : }
8710 1 : SWIGINTERN bool GDALAlgorithmArgHS_IsHiddenForAPI(GDALAlgorithmArgHS *self){
8711 1 : return GDALAlgorithmArgIsHiddenForAPI(self);
8712 : }
8713 1 : SWIGINTERN bool GDALAlgorithmArgHS_IsInput(GDALAlgorithmArgHS *self){
8714 1 : return GDALAlgorithmArgIsInput(self);
8715 : }
8716 6728 : SWIGINTERN bool GDALAlgorithmArgHS_IsOutput(GDALAlgorithmArgHS *self){
8717 6728 : return GDALAlgorithmArgIsOutput(self);
8718 : }
8719 1 : SWIGINTERN int GDALAlgorithmArgHS_GetDatasetType(GDALAlgorithmArgHS *self){
8720 1 : return GDALAlgorithmArgGetDatasetType(self);
8721 : }
8722 1 : SWIGINTERN int GDALAlgorithmArgHS_GetDatasetInputFlags(GDALAlgorithmArgHS *self){
8723 1 : return GDALAlgorithmArgGetDatasetInputFlags(self);
8724 : }
8725 1 : SWIGINTERN int GDALAlgorithmArgHS_GetDatasetOutputFlags(GDALAlgorithmArgHS *self){
8726 1 : return GDALAlgorithmArgGetDatasetOutputFlags(self);
8727 : }
8728 1 : SWIGINTERN char const *GDALAlgorithmArgHS_GetMutualExclusionGroup(GDALAlgorithmArgHS *self){
8729 1 : return GDALAlgorithmArgGetMutualExclusionGroup(self);
8730 : }
8731 7 : SWIGINTERN bool GDALAlgorithmArgHS_GetAsBoolean(GDALAlgorithmArgHS *self){
8732 7 : return GDALAlgorithmArgGetAsBoolean(self);
8733 : }
8734 292 : SWIGINTERN char const *GDALAlgorithmArgHS_GetAsString(GDALAlgorithmArgHS *self){
8735 292 : return GDALAlgorithmArgGetAsString(self);
8736 : }
8737 7 : SWIGINTERN int GDALAlgorithmArgHS_GetAsInteger(GDALAlgorithmArgHS *self){
8738 7 : return GDALAlgorithmArgGetAsInteger(self);
8739 : }
8740 7 : SWIGINTERN double GDALAlgorithmArgHS_GetAsDouble(GDALAlgorithmArgHS *self){
8741 7 : return GDALAlgorithmArgGetAsDouble(self);
8742 : }
8743 2314 : SWIGINTERN GDALArgDatasetValueHS *GDALAlgorithmArgHS_GetAsDatasetValue(GDALAlgorithmArgHS *self){
8744 2314 : return GDALAlgorithmArgGetAsDatasetValue(self);
8745 : }
8746 1 : SWIGINTERN char **GDALAlgorithmArgHS_GetAsStringList(GDALAlgorithmArgHS *self){
8747 1 : return GDALAlgorithmArgGetAsStringList( self );
8748 : }
8749 7 : SWIGINTERN void GDALAlgorithmArgHS_GetAsIntegerList(GDALAlgorithmArgHS *self,int *nLen,int const **pList){
8750 7 : size_t nLenSizet = 0;
8751 14 : *pList = GDALAlgorithmArgGetAsIntegerList(self, &nLenSizet);
8752 7 : *nLen = (int)nLenSizet;
8753 : }
8754 7 : SWIGINTERN void GDALAlgorithmArgHS_GetAsDoubleList(GDALAlgorithmArgHS *self,int *nLen,double const **pList){
8755 7 : size_t nLenSizet = 0;
8756 14 : *pList = GDALAlgorithmArgGetAsDoubleList(self, &nLenSizet);
8757 7 : *nLen = (int)nLenSizet;
8758 : }
8759 515 : SWIGINTERN bool GDALAlgorithmArgHS_SetAsBoolean(GDALAlgorithmArgHS *self,bool value){
8760 515 : return GDALAlgorithmArgSetAsBoolean(self, value);
8761 : }
8762 2030 : SWIGINTERN bool GDALAlgorithmArgHS_SetAsString(GDALAlgorithmArgHS *self,char const *value){
8763 2030 : return GDALAlgorithmArgSetAsString(self, value);
8764 : }
8765 260 : SWIGINTERN bool GDALAlgorithmArgHS_SetAsInteger(GDALAlgorithmArgHS *self,int value){
8766 260 : return GDALAlgorithmArgSetAsInteger(self, value);
8767 : }
8768 215 : SWIGINTERN bool GDALAlgorithmArgHS_SetAsDouble(GDALAlgorithmArgHS *self,double value){
8769 215 : return GDALAlgorithmArgSetAsDouble(self, value);
8770 : }
8771 1 : SWIGINTERN bool GDALAlgorithmArgHS_SetAsDatasetValue(GDALAlgorithmArgHS *self,GDALArgDatasetValueHS *value){
8772 1 : return GDALAlgorithmArgSetAsDatasetValue(self, value);
8773 : }
8774 533 : SWIGINTERN bool GDALAlgorithmArgHS_SetAsStringList(GDALAlgorithmArgHS *self,char **value){
8775 533 : return GDALAlgorithmArgSetAsStringList(self, value);
8776 : }
8777 84 : SWIGINTERN bool GDALAlgorithmArgHS_SetAsIntegerList(GDALAlgorithmArgHS *self,int nList,int *pList){
8778 84 : return GDALAlgorithmArgSetAsIntegerList(self, nList, pList);
8779 : }
8780 126 : SWIGINTERN bool GDALAlgorithmArgHS_SetAsDoubleList(GDALAlgorithmArgHS *self,int nList,double *pList){
8781 126 : return GDALAlgorithmArgSetAsDoubleList(self, nList, pList);
8782 : }
8783 0 : SWIGINTERN bool GDALAlgorithmArgHS_SetDataset(GDALAlgorithmArgHS *self,GDALDatasetShadow *ds){
8784 0 : return GDALAlgorithmArgSetDataset(self, ds);
8785 : }
8786 929 : SWIGINTERN bool GDALAlgorithmArgHS_SetDatasets(GDALAlgorithmArgHS *self,int object_list_count,GDALDatasetShadow **poObjects){
8787 929 : return GDALAlgorithmArgSetDatasets(self, object_list_count, poObjects);
8788 : }
8789 530 : SWIGINTERN bool GDALAlgorithmArgHS_SetDatasetNames(GDALAlgorithmArgHS *self,char **names){
8790 530 : return GDALAlgorithmArgSetDatasetNames(self, names);
8791 : }
8792 5113 : SWIGINTERN void delete_GDALAlgorithmHS(GDALAlgorithmHS *self){
8793 5113 : GDALAlgorithmRelease( self );
8794 5113 : }
8795 32 : SWIGINTERN char const *GDALAlgorithmHS_GetName(GDALAlgorithmHS *self){
8796 32 : return GDALAlgorithmGetName(self);
8797 : }
8798 1 : SWIGINTERN char const *GDALAlgorithmHS_GetDescription(GDALAlgorithmHS *self){
8799 1 : return GDALAlgorithmGetDescription(self);
8800 : }
8801 1 : SWIGINTERN char const *GDALAlgorithmHS_GetLongDescription(GDALAlgorithmHS *self){
8802 1 : return GDALAlgorithmGetLongDescription(self);
8803 : }
8804 1 : SWIGINTERN char const *GDALAlgorithmHS_GetHelpFullURL(GDALAlgorithmHS *self){
8805 1 : return GDALAlgorithmGetHelpFullURL(self);
8806 : }
8807 2642 : SWIGINTERN bool GDALAlgorithmHS_HasSubAlgorithms(GDALAlgorithmHS *self){
8808 2642 : return GDALAlgorithmHasSubAlgorithms(self);
8809 : }
8810 6 : SWIGINTERN char **GDALAlgorithmHS_GetSubAlgorithmNames(GDALAlgorithmHS *self){
8811 6 : return GDALAlgorithmGetSubAlgorithmNames( self );
8812 : }
8813 2217 : SWIGINTERN GDALAlgorithmHS *GDALAlgorithmHS_InstantiateSubAlgorithm(GDALAlgorithmHS *self,char const *algName){
8814 2217 : return GDALAlgorithmInstantiateSubAlgorithm(self, algName);
8815 : }
8816 85 : SWIGINTERN bool GDALAlgorithmHS_ParseCommandLineArguments(GDALAlgorithmHS *self,char **args){
8817 85 : return GDALAlgorithmParseCommandLineArguments(self, args);
8818 : }
8819 791 : SWIGINTERN GDALAlgorithmHS *GDALAlgorithmHS_GetActualAlgorithm(GDALAlgorithmHS *self){
8820 791 : return GDALAlgorithmGetActualAlgorithm(self);
8821 : }
8822 1802 : SWIGINTERN bool GDALAlgorithmHS_Run(GDALAlgorithmHS *self,GDALProgressFunc callback=NULL,void *callback_data=NULL){
8823 1802 : return GDALAlgorithmRun(self, callback, callback_data);
8824 : }
8825 477 : SWIGINTERN bool GDALAlgorithmHS_Finalize(GDALAlgorithmHS *self){
8826 477 : return GDALAlgorithmFinalize(self);
8827 : }
8828 253 : SWIGINTERN bool GDALAlgorithmHS_ParseRunAndFinalize(GDALAlgorithmHS *self,char **args,GDALProgressFunc callback=NULL,void *callback_data=NULL){
8829 448 : return GDALAlgorithmParseCommandLineArguments(self, args) &&
8830 425 : GDALAlgorithmRun(self, callback, callback_data) &&
8831 172 : GDALAlgorithmFinalize(self);
8832 : }
8833 3 : SWIGINTERN retStringAndCPLFree *GDALAlgorithmHS_GetUsageAsJSON(GDALAlgorithmHS *self){
8834 3 : return GDALAlgorithmGetUsageAsJSON(self);
8835 : }
8836 281 : SWIGINTERN char **GDALAlgorithmHS_GetArgNames(GDALAlgorithmHS *self){
8837 281 : return GDALAlgorithmGetArgNames( self );
8838 : }
8839 7524 : SWIGINTERN GDALAlgorithmArgHS *GDALAlgorithmHS_GetArg(GDALAlgorithmHS *self,char const *argName){
8840 7524 : return GDALAlgorithmGetArg(self, argName);
8841 : }
8842 6809 : SWIGINTERN GDALAlgorithmArgHS *GDALAlgorithmHS_GetArgNonConst(GDALAlgorithmHS *self,char const *argName){
8843 6809 : return GDALAlgorithmGetArgNonConst(self, argName);
8844 : }
8845 2121 : SWIGINTERN void delete_GDALAlgorithmRegistryHS(GDALAlgorithmRegistryHS *self){
8846 2121 : GDALAlgorithmRegistryRelease( self );
8847 2121 : }
8848 1 : SWIGINTERN char **GDALAlgorithmRegistryHS_GetAlgNames(GDALAlgorithmRegistryHS *self){
8849 1 : return GDALAlgorithmRegistryGetAlgNames( self );
8850 : }
8851 2122 : SWIGINTERN GDALAlgorithmHS *GDALAlgorithmRegistryHS_InstantiateAlg(GDALAlgorithmRegistryHS *self,char const *algName){
8852 2122 : return GDALAlgorithmRegistryInstantiateAlg(self, algName);
8853 : }
8854 2313 : SWIGINTERN void delete_GDALArgDatasetValueHS(GDALArgDatasetValueHS *self){
8855 2313 : GDALArgDatasetValueRelease( self );
8856 2313 : }
8857 2 : SWIGINTERN char const *GDALArgDatasetValueHS_GetName(GDALArgDatasetValueHS *self){
8858 2 : return GDALArgDatasetValueGetName(self);
8859 : }
8860 745 : SWIGINTERN GDALDatasetShadow *GDALArgDatasetValueHS_GetDataset(GDALArgDatasetValueHS *self){
8861 745 : return GDALArgDatasetValueGetDatasetIncreaseRefCount(self);
8862 : }
8863 1032 : SWIGINTERN void GDALArgDatasetValueHS_SetName(GDALArgDatasetValueHS *self,char const *name){
8864 1032 : GDALArgDatasetValueSetName(self, name);
8865 1032 : }
8866 529 : SWIGINTERN void GDALArgDatasetValueHS_SetDataset(GDALArgDatasetValueHS *self,GDALDatasetShadow *ds){
8867 529 : GDALArgDatasetValueSetDataset(self, ds);
8868 529 : }
8869 :
8870 56 : GIntBig wrapper_GDALGetCacheMax()
8871 : {
8872 56 : return GDALGetCacheMax64();
8873 : }
8874 :
8875 :
8876 2 : GIntBig wrapper_GDALGetCacheUsed()
8877 : {
8878 2 : return GDALGetCacheUsed64();
8879 : }
8880 :
8881 :
8882 76 : void wrapper_GDALSetCacheMax(GIntBig nBytes)
8883 : {
8884 76 : return GDALSetCacheMax64(nBytes);
8885 : }
8886 :
8887 :
8888 43 : int wrapper_GDALGetDataTypeSizeBits( GDALDataType eDataType )
8889 : {
8890 43 : return GDALGetDataTypeSizeBits(eDataType);
8891 : }
8892 :
8893 :
8894 : /************************************************************************/
8895 : /* XMLTreeToPyList() */
8896 : /************************************************************************/
8897 26996 : static PyObject *XMLTreeToPyList( CPLXMLNode *psTree )
8898 : {
8899 26996 : PyObject *pyList;
8900 26996 : int nChildCount = 0, iChild;
8901 26996 : CPLXMLNode *psChild;
8902 :
8903 26996 : if( psTree == NULL )
8904 : return Py_None;
8905 :
8906 26983 : for( psChild = psTree->psChild;
8907 53900 : psChild != NULL;
8908 26917 : psChild = psChild->psNext )
8909 26917 : nChildCount++;
8910 :
8911 26983 : pyList = PyList_New(nChildCount+2);
8912 :
8913 26983 : PyList_SetItem( pyList, 0, Py_BuildValue( "i", (int) psTree->eType ) );
8914 26983 : PyList_SetItem( pyList, 1, Py_BuildValue( "s", psTree->pszValue ) );
8915 :
8916 26983 : for( psChild = psTree->psChild, iChild = 2;
8917 53900 : psChild != NULL;
8918 26917 : psChild = psChild->psNext, iChild++ )
8919 : {
8920 26917 : PyList_SetItem( pyList, iChild, XMLTreeToPyList( psChild ) );
8921 : }
8922 :
8923 : return pyList;
8924 : }
8925 :
8926 :
8927 : /************************************************************************/
8928 : /* PyListToXMLTree() */
8929 : /************************************************************************/
8930 339 : static CPLXMLNode *PyListToXMLTree( PyObject *pyList )
8931 :
8932 : {
8933 339 : int nChildCount = 0, iChild, nType = 0;
8934 339 : CPLXMLNode *psThisNode;
8935 339 : CPLXMLNode *psChild;
8936 339 : char *pszText = NULL;
8937 :
8938 339 : if( PyList_Size(pyList) > INT_MAX )
8939 : {
8940 0 : PyErr_SetString(PyExc_TypeError,"Error in input XMLTree." );
8941 0 : return NULL;
8942 : }
8943 339 : nChildCount = static_cast<int>(PyList_Size(pyList)) - 2;
8944 339 : if( nChildCount < 0 )
8945 : {
8946 0 : PyErr_SetString(PyExc_TypeError,"Error in input XMLTree." );
8947 0 : return NULL;
8948 : }
8949 :
8950 339 : CPL_IGNORE_RET_VAL(PyArg_Parse( PyList_GET_ITEM(pyList,0), "i", &nType ));
8951 339 : CPL_IGNORE_RET_VAL(PyArg_Parse( PyList_GET_ITEM(pyList,1), "s", &pszText ));
8952 :
8953 : /* Detect "pseudo" root */
8954 339 : if (nType == CXT_Element && pszText != NULL && strlen(pszText) == 0 && nChildCount == 2)
8955 : {
8956 2 : PyObject *pyFirst = PyList_GET_ITEM(pyList, 2);
8957 2 : if (PyList_Size(pyFirst) < 2)
8958 : {
8959 0 : PyErr_SetString(PyExc_TypeError,"Error in input XMLTree." );
8960 2 : return NULL;
8961 : }
8962 2 : int nTypeFirst = 0;
8963 2 : char* pszTextFirst = NULL;
8964 2 : CPL_IGNORE_RET_VAL(PyArg_Parse( PyList_GET_ITEM(pyFirst,0), "i", &nTypeFirst ));
8965 2 : CPL_IGNORE_RET_VAL(PyArg_Parse( PyList_GET_ITEM(pyFirst,1), "s", &pszTextFirst ));
8966 2 : if (nTypeFirst == CXT_Element && pszTextFirst != NULL && pszTextFirst[0] == '?')
8967 : {
8968 2 : psThisNode = PyListToXMLTree( PyList_GET_ITEM(pyList,2) );
8969 2 : psThisNode->psNext = PyListToXMLTree( PyList_GET_ITEM(pyList,3) );
8970 2 : return psThisNode;
8971 : }
8972 : }
8973 :
8974 337 : psThisNode = CPLCreateXMLNode( NULL, (CPLXMLNodeType) nType, pszText );
8975 :
8976 659 : for( iChild = 0; iChild < nChildCount; iChild++ )
8977 : {
8978 322 : psChild = PyListToXMLTree( PyList_GET_ITEM(pyList,iChild+2) );
8979 322 : CPLAddXMLChild( psThisNode, psChild );
8980 : }
8981 :
8982 : return psThisNode;
8983 : }
8984 :
8985 :
8986 9 : retStringAndCPLFree *GetJPEG2000StructureAsString( const char* pszFilename, char** options = NULL )
8987 : {
8988 9 : CPLXMLNode* psNode = GDALGetJPEG2000Structure(pszFilename, options);
8989 9 : if( psNode == NULL )
8990 : return NULL;
8991 9 : char* pszXML = CPLSerializeXMLTree(psNode);
8992 9 : CPLDestroyXMLNode(psNode);
8993 9 : return pszXML;
8994 : }
8995 :
8996 :
8997 373 : int GetDriverCount() {
8998 373 : return GDALGetDriverCount();
8999 : }
9000 :
9001 :
9002 : static
9003 16285 : GDALDriverShadow* GetDriverByName( char const *name ) {
9004 16285 : return (GDALDriverShadow*) GDALGetDriverByName( name );
9005 : }
9006 :
9007 :
9008 82228 : GDALDriverShadow* GetDriver( int i ) {
9009 82228 : return (GDALDriverShadow*) GDALGetDriver( i );
9010 : }
9011 :
9012 :
9013 23470 : GDALDatasetShadow* Open( char const* utf8_path, GDALAccess eAccess = GA_ReadOnly ) {
9014 23470 : CPLErrorReset();
9015 23470 : GDALDatasetShadow *ds = GDALOpen( utf8_path, eAccess );
9016 : #ifndef SWIGPYTHON
9017 : if( ds != NULL && CPLGetLastErrorType() == CE_Failure )
9018 : {
9019 : if ( GDALDereferenceDataset( ds ) <= 0 )
9020 : GDALClose(ds);
9021 : ds = NULL;
9022 : }
9023 : #endif
9024 23470 : return (GDALDatasetShadow*) ds;
9025 : }
9026 :
9027 :
9028 6658 : GDALDatasetShadow* OpenEx( char const* utf8_path, unsigned int nOpenFlags = 0,
9029 : char** allowed_drivers = NULL, char** open_options = NULL,
9030 : char** sibling_files = NULL ) {
9031 6658 : CPLErrorReset();
9032 : #ifdef SWIGPYTHON
9033 9197 : if( GetUseExceptions() )
9034 3015 : nOpenFlags |= GDAL_OF_VERBOSE_ERROR;
9035 : #endif
9036 6658 : GDALDatasetShadow *ds = GDALOpenEx( utf8_path, nOpenFlags, allowed_drivers,
9037 : open_options, sibling_files );
9038 : #ifndef SWIGPYTHON
9039 : if( ds != NULL && CPLGetLastErrorType() == CE_Failure )
9040 : {
9041 : if ( GDALDereferenceDataset( ds ) <= 0 )
9042 : GDALClose(ds);
9043 : ds = NULL;
9044 : }
9045 : #endif
9046 6658 : return (GDALDatasetShadow*) ds;
9047 : }
9048 :
9049 :
9050 5053 : GDALDatasetShadow* OpenShared( char const* utf8_path, GDALAccess eAccess = GA_ReadOnly ) {
9051 5053 : CPLErrorReset();
9052 5053 : GDALDatasetShadow *ds = GDALOpenShared( utf8_path, eAccess );
9053 : #ifndef SWIGPYTHON
9054 : if( ds != NULL && CPLGetLastErrorType() == CE_Failure )
9055 : {
9056 : if ( GDALDereferenceDataset( ds ) <= 0 )
9057 : GDALClose(ds);
9058 : ds = NULL;
9059 : }
9060 : #endif
9061 5053 : return (GDALDatasetShadow*) ds;
9062 : }
9063 :
9064 :
9065 11 : GDALDriverShadow *IdentifyDriver( const char *utf8_path,
9066 : char **papszSiblings = NULL ) {
9067 11 : return (GDALDriverShadow *) GDALIdentifyDriver( utf8_path,
9068 11 : papszSiblings );
9069 : }
9070 :
9071 :
9072 50 : GDALDriverShadow *IdentifyDriverEx( const char* utf8_path,
9073 : unsigned int nIdentifyFlags = 0,
9074 : char** allowed_drivers = NULL,
9075 : char** sibling_files = NULL )
9076 : {
9077 50 : return (GDALDriverShadow *) GDALIdentifyDriverEx( utf8_path,
9078 : nIdentifyFlags,
9079 : allowed_drivers,
9080 50 : sibling_files );
9081 : }
9082 :
9083 :
9084 188 : char **GeneralCmdLineProcessor( char **papszArgv, int nOptions = 0 ) {
9085 188 : int nResArgCount;
9086 :
9087 188 : if( papszArgv == NULL )
9088 : return NULL;
9089 :
9090 376 : bool bReloadDrivers = ( CSLFindString(papszArgv, "GDAL_SKIP") >= 0 ||
9091 188 : CSLFindString(papszArgv, "OGR_SKIP") >= 0 );
9092 :
9093 188 : nResArgCount =
9094 188 : GDALGeneralCmdLineProcessor( CSLCount(papszArgv), &papszArgv, nOptions );
9095 :
9096 188 : if( bReloadDrivers )
9097 : {
9098 0 : GDALAllRegister();
9099 : }
9100 :
9101 188 : if( nResArgCount <= 0 )
9102 : return NULL;
9103 : else
9104 173 : return papszArgv;
9105 : }
9106 :
9107 :
9108 : #include "gdal_utils.h"
9109 :
9110 :
9111 :
9112 : #include <vector>
9113 :
9114 : class ErrorStruct
9115 : {
9116 : public:
9117 : CPLErr type;
9118 : CPLErrorNum no;
9119 : char* msg;
9120 :
9121 : ErrorStruct() = delete;
9122 282 : ErrorStruct(CPLErr eErrIn, CPLErrorNum noIn, const char* msgIn) :
9123 282 : type(eErrIn), no(noIn), msg(msgIn ? CPLStrdup(msgIn) : nullptr) {}
9124 70 : ErrorStruct(const ErrorStruct& other):
9125 70 : type(other.type), no(other.no),
9126 70 : msg(other.msg ? CPLStrdup(other.msg) : nullptr) {}
9127 352 : ~ErrorStruct() { CPLFree(msg); }
9128 : };
9129 :
9130 282 : static void CPL_STDCALL StackingErrorHandler( CPLErr eErr, CPLErrorNum no,
9131 : const char* msg )
9132 : {
9133 282 : std::vector<ErrorStruct>* paoErrors =
9134 : static_cast<std::vector<ErrorStruct> *>(
9135 282 : CPLGetErrorHandlerUserData());
9136 282 : paoErrors->emplace_back(eErr, no, msg);
9137 282 : }
9138 :
9139 2608 : static void PushStackingErrorHandler(std::vector<ErrorStruct>* paoErrors)
9140 : {
9141 2608 : CPLPushErrorHandlerEx(StackingErrorHandler, paoErrors);
9142 2608 : CPLSetCurrentErrorHandlerCatchDebug(false);
9143 2608 : }
9144 :
9145 2608 : static void PopStackingErrorHandler(std::vector<ErrorStruct>* paoErrors, bool bSuccess)
9146 : {
9147 2608 : CPLPopErrorHandler();
9148 :
9149 : // If the operation was successful, do not emit regular CPLError()
9150 : // of CE_Failure type that would be caught by the PythonBindingErrorHandler
9151 : // and turned into
9152 : // Python exceptions. Just emit them with the previous error handler
9153 :
9154 2890 : for( size_t iError = 0; iError < paoErrors->size(); ++iError )
9155 : {
9156 282 : CPLErr eErrClass = (*paoErrors)[iError].type;
9157 282 : if( bSuccess && eErrClass == CE_Failure )
9158 : {
9159 13 : CPLCallPreviousHandler( eErrClass,
9160 13 : (*paoErrors)[iError].no,
9161 13 : (*paoErrors)[iError].msg );
9162 : }
9163 : else
9164 : {
9165 269 : CPLError( eErrClass,
9166 269 : (*paoErrors)[iError].no,
9167 : "%s",
9168 269 : (*paoErrors)[iError].msg );
9169 : }
9170 : }
9171 :
9172 2608 : if( bSuccess )
9173 : {
9174 2492 : CPLErrorReset();
9175 : }
9176 2608 : }
9177 :
9178 60 : SWIGINTERN GDALInfoOptions *new_GDALInfoOptions(char **options){
9179 60 : return GDALInfoOptionsNew(options, NULL);
9180 : }
9181 60 : SWIGINTERN void delete_GDALInfoOptions(GDALInfoOptions *self){
9182 60 : GDALInfoOptionsFree( self );
9183 60 : }
9184 36 : SWIGINTERN GDALVectorInfoOptions *new_GDALVectorInfoOptions(char **options){
9185 36 : return GDALVectorInfoOptionsNew(options, NULL);
9186 : }
9187 36 : SWIGINTERN void delete_GDALVectorInfoOptions(GDALVectorInfoOptions *self){
9188 36 : GDALVectorInfoOptionsFree( self );
9189 36 : }
9190 28 : SWIGINTERN GDALMultiDimInfoOptions *new_GDALMultiDimInfoOptions(char **options){
9191 28 : return GDALMultiDimInfoOptionsNew(options, NULL);
9192 : }
9193 28 : SWIGINTERN void delete_GDALMultiDimInfoOptions(GDALMultiDimInfoOptions *self){
9194 28 : GDALMultiDimInfoOptionsFree( self );
9195 28 : }
9196 2038 : SWIGINTERN GDALTranslateOptions *new_GDALTranslateOptions(char **options){
9197 2038 : return GDALTranslateOptionsNew(options, NULL);
9198 : }
9199 2034 : SWIGINTERN void delete_GDALTranslateOptions(GDALTranslateOptions *self){
9200 2034 : GDALTranslateOptionsFree( self );
9201 2034 : }
9202 :
9203 2036 : GDALDatasetShadow* wrapper_GDALTranslate( const char* dest,
9204 : GDALDatasetShadow* dataset,
9205 : GDALTranslateOptions* translateOptions,
9206 : GDALProgressFunc callback=NULL,
9207 : void* callback_data=NULL)
9208 : {
9209 2036 : int usageError; /* ignored */
9210 2036 : bool bFreeOptions = false;
9211 2036 : if( callback )
9212 : {
9213 3 : if( translateOptions == NULL )
9214 : {
9215 1 : bFreeOptions = true;
9216 1 : translateOptions = GDALTranslateOptionsNew(NULL, NULL);
9217 : }
9218 3 : GDALTranslateOptionsSetProgress(translateOptions, callback, callback_data);
9219 : }
9220 : #ifdef SWIGPYTHON
9221 2036 : std::vector<ErrorStruct> aoErrors;
9222 2923 : if( GetUseExceptions() )
9223 : {
9224 904 : PushStackingErrorHandler(&aoErrors);
9225 : }
9226 : #endif
9227 2036 : GDALDatasetH hDSRet = GDALTranslate(dest, dataset, translateOptions, &usageError);
9228 2036 : if( bFreeOptions )
9229 1 : GDALTranslateOptionsFree(translateOptions);
9230 : #ifdef SWIGPYTHON
9231 2923 : if( GetUseExceptions() )
9232 : {
9233 904 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
9234 : }
9235 : #endif
9236 2036 : return hDSRet;
9237 : }
9238 :
9239 810 : SWIGINTERN GDALWarpAppOptions *new_GDALWarpAppOptions(char **options){
9240 810 : return GDALWarpAppOptionsNew(options, NULL);
9241 : }
9242 808 : SWIGINTERN void delete_GDALWarpAppOptions(GDALWarpAppOptions *self){
9243 808 : GDALWarpAppOptionsFree( self );
9244 808 : }
9245 :
9246 :
9247 86 : int wrapper_GDALWarpDestDS( GDALDatasetShadow* dstDS,
9248 : int object_list_count, GDALDatasetShadow** poObjects,
9249 : GDALWarpAppOptions* warpAppOptions,
9250 : GDALProgressFunc callback=NULL,
9251 : void* callback_data=NULL)
9252 : {
9253 86 : int usageError; /* ignored */
9254 86 : bool bFreeOptions = false;
9255 86 : if( callback )
9256 : {
9257 1 : if( warpAppOptions == NULL )
9258 : {
9259 1 : bFreeOptions = true;
9260 1 : warpAppOptions = GDALWarpAppOptionsNew(NULL, NULL);
9261 : }
9262 1 : GDALWarpAppOptionsSetProgress(warpAppOptions, callback, callback_data);
9263 : }
9264 : #ifdef SWIGPYTHON
9265 86 : std::vector<ErrorStruct> aoErrors;
9266 166 : if( GetUseExceptions() )
9267 : {
9268 86 : PushStackingErrorHandler(&aoErrors);
9269 : }
9270 : #endif
9271 86 : bool bRet = (GDALWarp(NULL, dstDS, object_list_count, poObjects, warpAppOptions, &usageError) != NULL);
9272 86 : if( bFreeOptions )
9273 1 : GDALWarpAppOptionsFree(warpAppOptions);
9274 : #ifdef SWIGPYTHON
9275 166 : if( GetUseExceptions() )
9276 : {
9277 86 : PopStackingErrorHandler(&aoErrors, bRet);
9278 : }
9279 : #endif
9280 86 : return bRet;
9281 : }
9282 :
9283 :
9284 725 : GDALDatasetShadow* wrapper_GDALWarpDestName( const char* dest,
9285 : int object_list_count, GDALDatasetShadow** poObjects,
9286 : GDALWarpAppOptions* warpAppOptions,
9287 : GDALProgressFunc callback=NULL,
9288 : void* callback_data=NULL)
9289 : {
9290 725 : int usageError; /* ignored */
9291 725 : bool bFreeOptions = false;
9292 725 : if( callback )
9293 : {
9294 2 : if( warpAppOptions == NULL )
9295 : {
9296 1 : bFreeOptions = true;
9297 1 : warpAppOptions = GDALWarpAppOptionsNew(NULL, NULL);
9298 : }
9299 2 : GDALWarpAppOptionsSetProgress(warpAppOptions, callback, callback_data);
9300 : }
9301 : #ifdef SWIGPYTHON
9302 725 : std::vector<ErrorStruct> aoErrors;
9303 1385 : if( GetUseExceptions() )
9304 : {
9305 701 : PushStackingErrorHandler(&aoErrors);
9306 : }
9307 : #endif
9308 725 : GDALDatasetH hDSRet = GDALWarp(dest, NULL, object_list_count, poObjects, warpAppOptions, &usageError);
9309 725 : if( bFreeOptions )
9310 1 : GDALWarpAppOptionsFree(warpAppOptions);
9311 : #ifdef SWIGPYTHON
9312 1385 : if( GetUseExceptions() )
9313 : {
9314 701 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
9315 : }
9316 : #endif
9317 725 : return hDSRet;
9318 : }
9319 :
9320 656 : SWIGINTERN GDALVectorTranslateOptions *new_GDALVectorTranslateOptions(char **options){
9321 656 : return GDALVectorTranslateOptionsNew(options, NULL);
9322 : }
9323 629 : SWIGINTERN void delete_GDALVectorTranslateOptions(GDALVectorTranslateOptions *self){
9324 629 : GDALVectorTranslateOptionsFree( self );
9325 629 : }
9326 :
9327 12 : int wrapper_GDALVectorTranslateDestDS( GDALDatasetShadow* dstDS,
9328 : GDALDatasetShadow* srcDS,
9329 : GDALVectorTranslateOptions* options,
9330 : GDALProgressFunc callback=NULL,
9331 : void* callback_data=NULL)
9332 : {
9333 12 : int usageError; /* ignored */
9334 12 : bool bFreeOptions = false;
9335 12 : if( callback )
9336 : {
9337 0 : if( options == NULL )
9338 : {
9339 0 : bFreeOptions = true;
9340 0 : options = GDALVectorTranslateOptionsNew(NULL, NULL);
9341 : }
9342 0 : GDALVectorTranslateOptionsSetProgress(options, callback, callback_data);
9343 : }
9344 : #ifdef SWIGPYTHON
9345 12 : std::vector<ErrorStruct> aoErrors;
9346 19 : if( GetUseExceptions() )
9347 : {
9348 11 : PushStackingErrorHandler(&aoErrors);
9349 : }
9350 : #endif
9351 12 : bool bRet = (GDALVectorTranslate(NULL, dstDS, 1, &srcDS, options, &usageError) != NULL);
9352 12 : if( bFreeOptions )
9353 0 : GDALVectorTranslateOptionsFree(options);
9354 : #ifdef SWIGPYTHON
9355 19 : if( GetUseExceptions() )
9356 : {
9357 11 : PopStackingErrorHandler(&aoErrors, bRet);
9358 : }
9359 : #endif
9360 12 : return bRet;
9361 : }
9362 :
9363 :
9364 605 : GDALDatasetShadow* wrapper_GDALVectorTranslateDestName( const char* dest,
9365 : GDALDatasetShadow* srcDS,
9366 : GDALVectorTranslateOptions* options,
9367 : GDALProgressFunc callback=NULL,
9368 : void* callback_data=NULL)
9369 : {
9370 605 : int usageError; /* ignored */
9371 605 : bool bFreeOptions = false;
9372 605 : if( callback )
9373 : {
9374 3 : if( options == NULL )
9375 : {
9376 0 : bFreeOptions = true;
9377 0 : options = GDALVectorTranslateOptionsNew(NULL, NULL);
9378 : }
9379 3 : GDALVectorTranslateOptionsSetProgress(options, callback, callback_data);
9380 : }
9381 : #ifdef SWIGPYTHON
9382 605 : std::vector<ErrorStruct> aoErrors;
9383 997 : if( GetUseExceptions() )
9384 : {
9385 455 : PushStackingErrorHandler(&aoErrors);
9386 : }
9387 : #endif
9388 605 : GDALDatasetH hDSRet = GDALVectorTranslate(dest, NULL, 1, &srcDS, options, &usageError);
9389 605 : if( bFreeOptions )
9390 0 : GDALVectorTranslateOptionsFree(options);
9391 : #ifdef SWIGPYTHON
9392 997 : if( GetUseExceptions() )
9393 : {
9394 455 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
9395 : }
9396 : #endif
9397 605 : return hDSRet;
9398 : }
9399 :
9400 93 : SWIGINTERN GDALDEMProcessingOptions *new_GDALDEMProcessingOptions(char **options){
9401 93 : return GDALDEMProcessingOptionsNew(options, NULL);
9402 : }
9403 89 : SWIGINTERN void delete_GDALDEMProcessingOptions(GDALDEMProcessingOptions *self){
9404 89 : GDALDEMProcessingOptionsFree( self );
9405 89 : }
9406 :
9407 89 : GDALDatasetShadow* wrapper_GDALDEMProcessing( const char* dest,
9408 : GDALDatasetShadow* dataset,
9409 : const char* pszProcessing,
9410 : const char* pszColorFilename,
9411 : GDALDEMProcessingOptions* options,
9412 : GDALProgressFunc callback=NULL,
9413 : void* callback_data=NULL)
9414 : {
9415 89 : int usageError; /* ignored */
9416 89 : bool bFreeOptions = false;
9417 89 : if( callback )
9418 : {
9419 0 : if( options == NULL )
9420 : {
9421 0 : bFreeOptions = true;
9422 0 : options = GDALDEMProcessingOptionsNew(NULL, NULL);
9423 : }
9424 0 : GDALDEMProcessingOptionsSetProgress(options, callback, callback_data);
9425 : }
9426 : #ifdef SWIGPYTHON
9427 89 : std::vector<ErrorStruct> aoErrors;
9428 178 : if( GetUseExceptions() )
9429 : {
9430 89 : PushStackingErrorHandler(&aoErrors);
9431 : }
9432 : #endif
9433 89 : GDALDatasetH hDSRet = GDALDEMProcessing(dest, dataset, pszProcessing, pszColorFilename, options, &usageError);
9434 89 : if( bFreeOptions )
9435 0 : GDALDEMProcessingOptionsFree(options);
9436 : #ifdef SWIGPYTHON
9437 178 : if( GetUseExceptions() )
9438 : {
9439 89 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
9440 : }
9441 : #endif
9442 89 : return hDSRet;
9443 : }
9444 :
9445 45 : SWIGINTERN GDALNearblackOptions *new_GDALNearblackOptions(char **options){
9446 45 : return GDALNearblackOptionsNew(options, NULL);
9447 : }
9448 45 : SWIGINTERN void delete_GDALNearblackOptions(GDALNearblackOptions *self){
9449 45 : GDALNearblackOptionsFree( self );
9450 45 : }
9451 :
9452 2 : int wrapper_GDALNearblackDestDS( GDALDatasetShadow* dstDS,
9453 : GDALDatasetShadow* srcDS,
9454 : GDALNearblackOptions* options,
9455 : GDALProgressFunc callback=NULL,
9456 : void* callback_data=NULL)
9457 : {
9458 2 : int usageError; /* ignored */
9459 2 : bool bFreeOptions = false;
9460 2 : if( callback )
9461 : {
9462 0 : if( options == NULL )
9463 : {
9464 0 : bFreeOptions = true;
9465 0 : options = GDALNearblackOptionsNew(NULL, NULL);
9466 : }
9467 0 : GDALNearblackOptionsSetProgress(options, callback, callback_data);
9468 : }
9469 : #ifdef SWIGPYTHON
9470 2 : std::vector<ErrorStruct> aoErrors;
9471 4 : if( GetUseExceptions() )
9472 : {
9473 2 : PushStackingErrorHandler(&aoErrors);
9474 : }
9475 : #endif
9476 2 : bool bRet = (GDALNearblack(NULL, dstDS, srcDS, options, &usageError) != NULL);
9477 2 : if( bFreeOptions )
9478 0 : GDALNearblackOptionsFree(options);
9479 : #ifdef SWIGPYTHON
9480 4 : if( GetUseExceptions() )
9481 : {
9482 2 : PopStackingErrorHandler(&aoErrors, bRet);
9483 : }
9484 : #endif
9485 2 : return bRet;
9486 : }
9487 :
9488 :
9489 43 : GDALDatasetShadow* wrapper_GDALNearblackDestName( const char* dest,
9490 : GDALDatasetShadow* srcDS,
9491 : GDALNearblackOptions* options,
9492 : GDALProgressFunc callback=NULL,
9493 : void* callback_data=NULL)
9494 : {
9495 43 : int usageError; /* ignored */
9496 43 : bool bFreeOptions = false;
9497 43 : if( callback )
9498 : {
9499 0 : if( options == NULL )
9500 : {
9501 0 : bFreeOptions = true;
9502 0 : options = GDALNearblackOptionsNew(NULL, NULL);
9503 : }
9504 0 : GDALNearblackOptionsSetProgress(options, callback, callback_data);
9505 : }
9506 : #ifdef SWIGPYTHON
9507 43 : std::vector<ErrorStruct> aoErrors;
9508 86 : if( GetUseExceptions() )
9509 : {
9510 43 : PushStackingErrorHandler(&aoErrors);
9511 : }
9512 : #endif
9513 43 : GDALDatasetH hDSRet = GDALNearblack(dest, NULL, srcDS, options, &usageError);
9514 43 : if( bFreeOptions )
9515 0 : GDALNearblackOptionsFree(options);
9516 : #ifdef SWIGPYTHON
9517 86 : if( GetUseExceptions() )
9518 : {
9519 43 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
9520 : }
9521 : #endif
9522 43 : return hDSRet;
9523 : }
9524 :
9525 52 : SWIGINTERN GDALGridOptions *new_GDALGridOptions(char **options){
9526 52 : return GDALGridOptionsNew(options, NULL);
9527 : }
9528 52 : SWIGINTERN void delete_GDALGridOptions(GDALGridOptions *self){
9529 52 : GDALGridOptionsFree( self );
9530 52 : }
9531 :
9532 52 : GDALDatasetShadow* wrapper_GDALGrid( const char* dest,
9533 : GDALDatasetShadow* dataset,
9534 : GDALGridOptions* options,
9535 : GDALProgressFunc callback=NULL,
9536 : void* callback_data=NULL)
9537 : {
9538 52 : int usageError; /* ignored */
9539 52 : bool bFreeOptions = false;
9540 52 : if( callback )
9541 : {
9542 0 : if( options == NULL )
9543 : {
9544 0 : bFreeOptions = true;
9545 0 : options = GDALGridOptionsNew(NULL, NULL);
9546 : }
9547 0 : GDALGridOptionsSetProgress(options, callback, callback_data);
9548 : }
9549 : #ifdef SWIGPYTHON
9550 52 : std::vector<ErrorStruct> aoErrors;
9551 103 : if( GetUseExceptions() )
9552 : {
9553 51 : PushStackingErrorHandler(&aoErrors);
9554 : }
9555 : #endif
9556 52 : GDALDatasetH hDSRet = GDALGrid(dest, dataset, options, &usageError);
9557 52 : if( bFreeOptions )
9558 0 : GDALGridOptionsFree(options);
9559 : #ifdef SWIGPYTHON
9560 103 : if( GetUseExceptions() )
9561 : {
9562 51 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
9563 : }
9564 : #endif
9565 52 : return hDSRet;
9566 : }
9567 :
9568 12 : SWIGINTERN GDALContourOptions *new_GDALContourOptions(char **options){
9569 12 : return GDALContourOptionsNew(options, NULL);
9570 : }
9571 12 : SWIGINTERN void delete_GDALContourOptions(GDALContourOptions *self){
9572 12 : GDALContourOptionsFree( self );
9573 12 : }
9574 :
9575 :
9576 6 : int wrapper_GDALContourDestDS( GDALDatasetShadow* dstDS,
9577 : GDALDatasetShadow* srcDS,
9578 : GDALContourOptions* options,
9579 : GDALProgressFunc callback=NULL,
9580 : void* callback_data=NULL)
9581 : {
9582 6 : bool bFreeOptions = false;
9583 6 : if( callback )
9584 : {
9585 0 : if( options == NULL )
9586 : {
9587 0 : bFreeOptions = true;
9588 0 : options = GDALContourOptionsNew(NULL, NULL);
9589 : }
9590 0 : GDALContourOptionsSetProgress(options, callback, callback_data);
9591 : }
9592 :
9593 : #ifdef SWIGPYTHON
9594 6 : std::vector<ErrorStruct> aoErrors;
9595 12 : if( GetUseExceptions() )
9596 : {
9597 6 : PushStackingErrorHandler(&aoErrors);
9598 : }
9599 : #endif
9600 :
9601 6 : char** papszStringOptions = NULL;
9602 6 : GDALRasterBandH hBand = NULL;
9603 6 : OGRLayerH hLayer = NULL;
9604 6 : const CPLErr err = GDALContourProcessOptions(options, &papszStringOptions, &srcDS, &hBand, &dstDS, &hLayer);
9605 6 : bool bRet = (err == CE_None && GDALContourGenerateEx(hBand, hLayer, papszStringOptions, callback, callback_data) == CE_None);
9606 6 : if( bFreeOptions )
9607 0 : GDALContourOptionsFree(options);
9608 : #ifdef SWIGPYTHON
9609 12 : if( GetUseExceptions() )
9610 : {
9611 6 : PopStackingErrorHandler(&aoErrors, bRet);
9612 : }
9613 : #endif
9614 6 : CSLDestroy(papszStringOptions);
9615 6 : return bRet;
9616 : }
9617 :
9618 :
9619 6 : GDALDatasetShadow* wrapper_GDALContourDestName( const char* dest,
9620 : GDALDatasetShadow* srcDS,
9621 : GDALContourOptions* options,
9622 : GDALProgressFunc callback=NULL,
9623 : void* callback_data=NULL)
9624 : {
9625 6 : bool bFreeOptions = false;
9626 6 : if( callback )
9627 : {
9628 0 : if( options == NULL )
9629 : {
9630 0 : bFreeOptions = true;
9631 0 : options = GDALContourOptionsNew(NULL, NULL);
9632 : }
9633 0 : GDALContourOptionsSetProgress(options, callback, callback_data);
9634 : }
9635 :
9636 : #ifdef SWIGPYTHON
9637 6 : std::vector<ErrorStruct> aoErrors;
9638 12 : if( GetUseExceptions() )
9639 : {
9640 6 : PushStackingErrorHandler(&aoErrors);
9641 : }
9642 : #endif
9643 :
9644 6 : GDALContourOptionsSetDestDataSource(options, dest);
9645 6 : char** papszStringOptions = NULL;
9646 6 : GDALRasterBandH hBand = NULL;
9647 6 : OGRLayerH hLayer = NULL;
9648 6 : GDALDatasetH dstDS = NULL;
9649 6 : CPLErr err = GDALContourProcessOptions(options, &papszStringOptions, &srcDS, &hBand, &dstDS, &hLayer);
9650 6 : if (err == CE_None )
9651 : {
9652 6 : err = GDALContourGenerateEx(hBand, hLayer, papszStringOptions, callback, callback_data);
9653 : }
9654 :
9655 6 : if( bFreeOptions )
9656 0 : GDALContourOptionsFree(options);
9657 : #ifdef SWIGPYTHON
9658 12 : if( GetUseExceptions() )
9659 : {
9660 6 : PopStackingErrorHandler(&aoErrors, dstDS != NULL);
9661 : }
9662 : #endif
9663 6 : CSLDestroy(papszStringOptions);
9664 6 : return dstDS;
9665 : }
9666 :
9667 23 : SWIGINTERN GDALRasterizeOptions *new_GDALRasterizeOptions(char **options){
9668 23 : return GDALRasterizeOptionsNew(options, NULL);
9669 : }
9670 23 : SWIGINTERN void delete_GDALRasterizeOptions(GDALRasterizeOptions *self){
9671 23 : GDALRasterizeOptionsFree( self );
9672 23 : }
9673 :
9674 13 : int wrapper_GDALRasterizeDestDS( GDALDatasetShadow* dstDS,
9675 : GDALDatasetShadow* srcDS,
9676 : GDALRasterizeOptions* options,
9677 : GDALProgressFunc callback=NULL,
9678 : void* callback_data=NULL)
9679 : {
9680 13 : int usageError; /* ignored */
9681 13 : bool bFreeOptions = false;
9682 13 : if( callback )
9683 : {
9684 0 : if( options == NULL )
9685 : {
9686 0 : bFreeOptions = true;
9687 0 : options = GDALRasterizeOptionsNew(NULL, NULL);
9688 : }
9689 0 : GDALRasterizeOptionsSetProgress(options, callback, callback_data);
9690 : }
9691 : #ifdef SWIGPYTHON
9692 13 : std::vector<ErrorStruct> aoErrors;
9693 26 : if( GetUseExceptions() )
9694 : {
9695 13 : PushStackingErrorHandler(&aoErrors);
9696 : }
9697 : #endif
9698 13 : bool bRet = (GDALRasterize(NULL, dstDS, srcDS, options, &usageError) != NULL);
9699 13 : if( bFreeOptions )
9700 0 : GDALRasterizeOptionsFree(options);
9701 : #ifdef SWIGPYTHON
9702 26 : if( GetUseExceptions() )
9703 : {
9704 13 : PopStackingErrorHandler(&aoErrors, bRet);
9705 : }
9706 : #endif
9707 13 : return bRet;
9708 : }
9709 :
9710 :
9711 10 : GDALDatasetShadow* wrapper_GDALRasterizeDestName( const char* dest,
9712 : GDALDatasetShadow* srcDS,
9713 : GDALRasterizeOptions* options,
9714 : GDALProgressFunc callback=NULL,
9715 : void* callback_data=NULL)
9716 : {
9717 10 : int usageError; /* ignored */
9718 10 : bool bFreeOptions = false;
9719 10 : if( callback )
9720 : {
9721 0 : if( options == NULL )
9722 : {
9723 0 : bFreeOptions = true;
9724 0 : options = GDALRasterizeOptionsNew(NULL, NULL);
9725 : }
9726 0 : GDALRasterizeOptionsSetProgress(options, callback, callback_data);
9727 : }
9728 : #ifdef SWIGPYTHON
9729 10 : std::vector<ErrorStruct> aoErrors;
9730 17 : if( GetUseExceptions() )
9731 : {
9732 10 : PushStackingErrorHandler(&aoErrors);
9733 : }
9734 : #endif
9735 10 : GDALDatasetH hDSRet = GDALRasterize(dest, NULL, srcDS, options, &usageError);
9736 10 : if( bFreeOptions )
9737 0 : GDALRasterizeOptionsFree(options);
9738 : #ifdef SWIGPYTHON
9739 17 : if( GetUseExceptions() )
9740 : {
9741 10 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
9742 : }
9743 : #endif
9744 10 : return hDSRet;
9745 : }
9746 :
9747 39 : SWIGINTERN GDALFootprintOptions *new_GDALFootprintOptions(char **options){
9748 39 : return GDALFootprintOptionsNew(options, NULL);
9749 : }
9750 37 : SWIGINTERN void delete_GDALFootprintOptions(GDALFootprintOptions *self){
9751 37 : GDALFootprintOptionsFree( self );
9752 37 : }
9753 :
9754 3 : int wrapper_GDALFootprintDestDS( GDALDatasetShadow* dstDS,
9755 : GDALDatasetShadow* srcDS,
9756 : GDALFootprintOptions* options,
9757 : GDALProgressFunc callback=NULL,
9758 : void* callback_data=NULL)
9759 : {
9760 3 : int usageError; /* ignored */
9761 3 : bool bFreeOptions = false;
9762 3 : if( callback )
9763 : {
9764 0 : if( options == NULL )
9765 : {
9766 0 : bFreeOptions = true;
9767 0 : options = GDALFootprintOptionsNew(NULL, NULL);
9768 : }
9769 0 : GDALFootprintOptionsSetProgress(options, callback, callback_data);
9770 : }
9771 : #ifdef SWIGPYTHON
9772 3 : std::vector<ErrorStruct> aoErrors;
9773 6 : if( GetUseExceptions() )
9774 : {
9775 3 : PushStackingErrorHandler(&aoErrors);
9776 : }
9777 : #endif
9778 3 : bool bRet = (GDALFootprint(NULL, dstDS, srcDS, options, &usageError) != NULL);
9779 3 : if( bFreeOptions )
9780 0 : GDALFootprintOptionsFree(options);
9781 : #ifdef SWIGPYTHON
9782 6 : if( GetUseExceptions() )
9783 : {
9784 3 : PopStackingErrorHandler(&aoErrors, bRet);
9785 : }
9786 : #endif
9787 3 : return bRet;
9788 : }
9789 :
9790 :
9791 34 : GDALDatasetShadow* wrapper_GDALFootprintDestName( const char* dest,
9792 : GDALDatasetShadow* srcDS,
9793 : GDALFootprintOptions* options,
9794 : GDALProgressFunc callback=NULL,
9795 : void* callback_data=NULL)
9796 : {
9797 34 : int usageError; /* ignored */
9798 34 : bool bFreeOptions = false;
9799 34 : if( callback )
9800 : {
9801 0 : if( options == NULL )
9802 : {
9803 0 : bFreeOptions = true;
9804 0 : options = GDALFootprintOptionsNew(NULL, NULL);
9805 : }
9806 0 : GDALFootprintOptionsSetProgress(options, callback, callback_data);
9807 : }
9808 : #ifdef SWIGPYTHON
9809 34 : std::vector<ErrorStruct> aoErrors;
9810 68 : if( GetUseExceptions() )
9811 : {
9812 34 : PushStackingErrorHandler(&aoErrors);
9813 : }
9814 : #endif
9815 34 : GDALDatasetH hDSRet = GDALFootprint(dest, NULL, srcDS, options, &usageError);
9816 34 : if( bFreeOptions )
9817 0 : GDALFootprintOptionsFree(options);
9818 : #ifdef SWIGPYTHON
9819 68 : if( GetUseExceptions() )
9820 : {
9821 34 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
9822 : }
9823 : #endif
9824 34 : return hDSRet;
9825 : }
9826 :
9827 172 : SWIGINTERN GDALBuildVRTOptions *new_GDALBuildVRTOptions(char **options){
9828 172 : return GDALBuildVRTOptionsNew(options, NULL);
9829 : }
9830 169 : SWIGINTERN void delete_GDALBuildVRTOptions(GDALBuildVRTOptions *self){
9831 169 : GDALBuildVRTOptionsFree( self );
9832 169 : }
9833 :
9834 69 : GDALDatasetShadow* wrapper_GDALBuildVRT_objects( const char* dest,
9835 : int object_list_count, GDALDatasetShadow** poObjects,
9836 : GDALBuildVRTOptions* options,
9837 : GDALProgressFunc callback=NULL,
9838 : void* callback_data=NULL)
9839 : {
9840 69 : int usageError; /* ignored */
9841 69 : bool bFreeOptions = false;
9842 69 : if( callback )
9843 : {
9844 0 : if( options == NULL )
9845 : {
9846 0 : bFreeOptions = true;
9847 0 : options = GDALBuildVRTOptionsNew(NULL, NULL);
9848 : }
9849 0 : GDALBuildVRTOptionsSetProgress(options, callback, callback_data);
9850 : }
9851 : #ifdef SWIGPYTHON
9852 69 : std::vector<ErrorStruct> aoErrors;
9853 116 : if( GetUseExceptions() )
9854 : {
9855 56 : PushStackingErrorHandler(&aoErrors);
9856 : }
9857 : #endif
9858 69 : GDALDatasetH hDSRet = GDALBuildVRT(dest, object_list_count, poObjects, NULL, options, &usageError);
9859 69 : if( bFreeOptions )
9860 0 : GDALBuildVRTOptionsFree(options);
9861 : #ifdef SWIGPYTHON
9862 116 : if( GetUseExceptions() )
9863 : {
9864 56 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
9865 : }
9866 : #endif
9867 69 : return hDSRet;
9868 : }
9869 :
9870 :
9871 100 : GDALDatasetShadow* wrapper_GDALBuildVRT_names( const char* dest,
9872 : char ** source_filenames,
9873 : GDALBuildVRTOptions* options,
9874 : GDALProgressFunc callback=NULL,
9875 : void* callback_data=NULL)
9876 : {
9877 100 : int usageError; /* ignored */
9878 100 : bool bFreeOptions = false;
9879 100 : if( callback )
9880 : {
9881 1 : if( options == NULL )
9882 : {
9883 0 : bFreeOptions = true;
9884 0 : options = GDALBuildVRTOptionsNew(NULL, NULL);
9885 : }
9886 1 : GDALBuildVRTOptionsSetProgress(options, callback, callback_data);
9887 : }
9888 : #ifdef SWIGPYTHON
9889 100 : std::vector<ErrorStruct> aoErrors;
9890 173 : if( GetUseExceptions() )
9891 : {
9892 85 : PushStackingErrorHandler(&aoErrors);
9893 : }
9894 : #endif
9895 100 : GDALDatasetH hDSRet = GDALBuildVRT(dest, CSLCount(source_filenames), NULL, source_filenames, options, &usageError);
9896 100 : if( bFreeOptions )
9897 0 : GDALBuildVRTOptionsFree(options);
9898 : #ifdef SWIGPYTHON
9899 173 : if( GetUseExceptions() )
9900 : {
9901 85 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
9902 : }
9903 : #endif
9904 100 : return hDSRet;
9905 : }
9906 :
9907 23 : SWIGINTERN GDALTileIndexOptions *new_GDALTileIndexOptions(char **options){
9908 23 : return GDALTileIndexOptionsNew(options, NULL);
9909 : }
9910 23 : SWIGINTERN void delete_GDALTileIndexOptions(GDALTileIndexOptions *self){
9911 23 : GDALTileIndexOptionsFree( self );
9912 23 : }
9913 :
9914 23 : GDALDatasetShadow* wrapper_TileIndex_names( const char* dest,
9915 : char ** source_filenames,
9916 : GDALTileIndexOptions* options,
9917 : GDALProgressFunc callback=NULL,
9918 : void* callback_data=NULL)
9919 : {
9920 23 : int usageError; /* ignored */
9921 : #if 0
9922 : bool bFreeOptions = false;
9923 : if( callback )
9924 : {
9925 : if( options == NULL )
9926 : {
9927 : bFreeOptions = true;
9928 : options = GDALTileIndexOptionsNew(NULL, NULL);
9929 : }
9930 : GDALTileIndexOptionsSetProgress(options, callback, callback_data);
9931 : }
9932 : #endif
9933 :
9934 : #ifdef SWIGPYTHON
9935 23 : std::vector<ErrorStruct> aoErrors;
9936 46 : if( GetUseExceptions() )
9937 : {
9938 23 : PushStackingErrorHandler(&aoErrors);
9939 : }
9940 : #endif
9941 23 : GDALDatasetH hDSRet = GDALTileIndex(dest, CSLCount(source_filenames), source_filenames, options, &usageError);
9942 : #if 0
9943 : if( bFreeOptions )
9944 : GDALTileIndexOptionsFree(options);
9945 : #endif
9946 : #ifdef SWIGPYTHON
9947 46 : if( GetUseExceptions() )
9948 : {
9949 23 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
9950 : }
9951 : #endif
9952 23 : return hDSRet;
9953 : }
9954 :
9955 109 : SWIGINTERN GDALMultiDimTranslateOptions *new_GDALMultiDimTranslateOptions(char **options){
9956 109 : return GDALMultiDimTranslateOptionsNew(options, NULL);
9957 : }
9958 109 : SWIGINTERN void delete_GDALMultiDimTranslateOptions(GDALMultiDimTranslateOptions *self){
9959 109 : GDALMultiDimTranslateOptionsFree( self );
9960 109 : }
9961 :
9962 109 : GDALDatasetShadow* wrapper_GDALMultiDimTranslateDestName( const char* dest,
9963 : int object_list_count, GDALDatasetShadow** poObjects,
9964 : GDALMultiDimTranslateOptions* multiDimTranslateOptions,
9965 : GDALProgressFunc callback=NULL,
9966 : void* callback_data=NULL)
9967 : {
9968 109 : int usageError; /* ignored */
9969 109 : bool bFreeOptions = false;
9970 109 : if( callback )
9971 : {
9972 0 : if( multiDimTranslateOptions == NULL )
9973 : {
9974 0 : bFreeOptions = true;
9975 0 : multiDimTranslateOptions = GDALMultiDimTranslateOptionsNew(NULL, NULL);
9976 : }
9977 0 : GDALMultiDimTranslateOptionsSetProgress(multiDimTranslateOptions, callback, callback_data);
9978 : }
9979 : #ifdef SWIGPYTHON
9980 109 : std::vector<ErrorStruct> aoErrors;
9981 136 : if( GetUseExceptions() )
9982 : {
9983 30 : PushStackingErrorHandler(&aoErrors);
9984 : }
9985 : #endif
9986 109 : GDALDatasetH hDSRet = GDALMultiDimTranslate(dest, NULL, object_list_count, poObjects, multiDimTranslateOptions, &usageError);
9987 109 : if( bFreeOptions )
9988 0 : GDALMultiDimTranslateOptionsFree(multiDimTranslateOptions);
9989 : #ifdef SWIGPYTHON
9990 136 : if( GetUseExceptions() )
9991 : {
9992 30 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
9993 : }
9994 : #endif
9995 109 : return hDSRet;
9996 : }
9997 :
9998 : #ifdef __cplusplus
9999 : extern "C" {
10000 : #endif
10001 10015 : SWIGINTERN PyObject *_wrap_GetUseExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10002 10015 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10003 10015 : int result;
10004 :
10005 10015 : if (!SWIG_Python_UnpackTuple(args, "GetUseExceptions", 0, 0, 0)) SWIG_fail;
10006 10015 : {
10007 : #ifdef SED_HACKS
10008 10015 : if( ReturnSame(TRUE) ) bLocalUseExceptionsCode = FALSE;
10009 : #endif
10010 10015 : result = GetUseExceptions();
10011 : }
10012 10015 : resultobj = SWIG_From_int(static_cast< int >(result));
10013 10015 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10014 : return resultobj;
10015 0 : fail:
10016 0 : return NULL;
10017 : }
10018 :
10019 :
10020 11457 : SWIGINTERN PyObject *_wrap__GetExceptionsLocal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10021 11457 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10022 11457 : int result;
10023 :
10024 11457 : if (!SWIG_Python_UnpackTuple(args, "_GetExceptionsLocal", 0, 0, 0)) SWIG_fail;
10025 11457 : {
10026 : #ifdef SED_HACKS
10027 11457 : if( ReturnSame(TRUE) ) bLocalUseExceptionsCode = FALSE;
10028 : #endif
10029 11457 : {
10030 11457 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10031 11457 : result = (int)_GetExceptionsLocal();
10032 11457 : SWIG_PYTHON_THREAD_END_ALLOW;
10033 : }
10034 : }
10035 11457 : resultobj = SWIG_From_int(static_cast< int >(result));
10036 11457 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10037 : return resultobj;
10038 0 : fail:
10039 0 : return NULL;
10040 : }
10041 :
10042 :
10043 22914 : SWIGINTERN PyObject *_wrap__SetExceptionsLocal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10044 22914 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10045 22914 : int arg1 ;
10046 22914 : int val1 ;
10047 22914 : int ecode1 = 0 ;
10048 22914 : PyObject *swig_obj[1] ;
10049 :
10050 22914 : if (!args) SWIG_fail;
10051 22914 : swig_obj[0] = args;
10052 22914 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10053 22914 : if (!SWIG_IsOK(ecode1)) {
10054 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_SetExceptionsLocal" "', argument " "1"" of type '" "int""'");
10055 : }
10056 22914 : arg1 = static_cast< int >(val1);
10057 22914 : {
10058 : #ifdef SED_HACKS
10059 22914 : if( ReturnSame(TRUE) ) bLocalUseExceptionsCode = FALSE;
10060 : #endif
10061 22914 : {
10062 22914 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10063 22914 : _SetExceptionsLocal(arg1);
10064 22914 : SWIG_PYTHON_THREAD_END_ALLOW;
10065 : }
10066 : }
10067 22914 : resultobj = SWIG_Py_Void();
10068 22914 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10069 : return resultobj;
10070 : fail:
10071 : return NULL;
10072 : }
10073 :
10074 :
10075 29 : SWIGINTERN PyObject *_wrap__UseExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10076 29 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10077 :
10078 29 : if (!SWIG_Python_UnpackTuple(args, "_UseExceptions", 0, 0, 0)) SWIG_fail;
10079 29 : {
10080 29 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10081 29 : _UseExceptions();
10082 29 : SWIG_PYTHON_THREAD_END_ALLOW;
10083 : }
10084 29 : resultobj = SWIG_Py_Void();
10085 29 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10086 : return resultobj;
10087 0 : fail:
10088 0 : return NULL;
10089 : }
10090 :
10091 :
10092 5 : SWIGINTERN PyObject *_wrap__DontUseExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10093 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10094 :
10095 5 : if (!SWIG_Python_UnpackTuple(args, "_DontUseExceptions", 0, 0, 0)) SWIG_fail;
10096 5 : {
10097 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10098 5 : _DontUseExceptions();
10099 5 : SWIG_PYTHON_THREAD_END_ALLOW;
10100 : }
10101 5 : resultobj = SWIG_Py_Void();
10102 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10103 : return resultobj;
10104 0 : fail:
10105 0 : return NULL;
10106 : }
10107 :
10108 :
10109 58651 : SWIGINTERN PyObject *_wrap__UserHasSpecifiedIfUsingExceptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10110 58651 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10111 58651 : int result;
10112 :
10113 58651 : if (!SWIG_Python_UnpackTuple(args, "_UserHasSpecifiedIfUsingExceptions", 0, 0, 0)) SWIG_fail;
10114 58651 : {
10115 : #ifdef SED_HACKS
10116 58651 : if( ReturnSame(TRUE) ) bLocalUseExceptionsCode = FALSE;
10117 : #endif
10118 58651 : {
10119 58651 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10120 58651 : result = (int)_UserHasSpecifiedIfUsingExceptions();
10121 58651 : SWIG_PYTHON_THREAD_END_ALLOW;
10122 : }
10123 : }
10124 58651 : resultobj = SWIG_From_int(static_cast< int >(result));
10125 58651 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10126 : return resultobj;
10127 0 : fail:
10128 0 : return NULL;
10129 : }
10130 :
10131 :
10132 27526 : SWIGINTERN PyObject *_wrap_VSIFReadL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10133 27526 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10134 27526 : void **arg1 = (void **) 0 ;
10135 27526 : unsigned int arg2 ;
10136 27526 : unsigned int arg3 ;
10137 27526 : VSILFILE *arg4 = (VSILFILE *) 0 ;
10138 27526 : void *pyObject1 = NULL ;
10139 27526 : unsigned int val2 ;
10140 27526 : int ecode2 = 0 ;
10141 27526 : unsigned int val3 ;
10142 27526 : int ecode3 = 0 ;
10143 27526 : void *argp4 = 0 ;
10144 27526 : int res4 = 0 ;
10145 27526 : PyObject *swig_obj[3] ;
10146 27526 : unsigned int result;
10147 :
10148 27526 : {
10149 : /* %typemap(in,numinputs=0) ( void **outPythonObject ) ( void *pyObject1 = NULL ) */
10150 27526 : arg1 = &pyObject1;
10151 : }
10152 27526 : if (!SWIG_Python_UnpackTuple(args, "VSIFReadL", 3, 3, swig_obj)) SWIG_fail;
10153 27526 : ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
10154 27526 : if (!SWIG_IsOK(ecode2)) {
10155 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VSIFReadL" "', argument " "2"" of type '" "unsigned int""'");
10156 : }
10157 27526 : arg2 = static_cast< unsigned int >(val2);
10158 27526 : ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val3);
10159 27526 : if (!SWIG_IsOK(ecode3)) {
10160 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VSIFReadL" "', argument " "3"" of type '" "unsigned int""'");
10161 : }
10162 27526 : arg3 = static_cast< unsigned int >(val3);
10163 27526 : res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_VSILFILE, 0 | 0 );
10164 27526 : if (!SWIG_IsOK(res4)) {
10165 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VSIFReadL" "', argument " "4"" of type '" "VSILFILE *""'");
10166 : }
10167 27526 : arg4 = reinterpret_cast< VSILFILE * >(argp4);
10168 27526 : {
10169 27526 : if (!arg4) {
10170 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10171 : }
10172 : }
10173 27525 : {
10174 27525 : const int bLocalUseExceptions = GetUseExceptions();
10175 27525 : if ( bLocalUseExceptions ) {
10176 1668 : pushErrorHandler();
10177 : }
10178 27525 : {
10179 27525 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10180 27525 : result = (unsigned int)wrapper_VSIFReadL(arg1,arg2,arg3,arg4);
10181 27525 : SWIG_PYTHON_THREAD_END_ALLOW;
10182 : }
10183 27525 : if ( bLocalUseExceptions ) {
10184 1668 : popErrorHandler();
10185 : }
10186 : #ifndef SED_HACKS
10187 : if ( bLocalUseExceptions ) {
10188 : CPLErr eclass = CPLGetLastErrorType();
10189 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10190 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10191 : }
10192 : }
10193 : #endif
10194 : }
10195 27525 : resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
10196 27525 : {
10197 : /* %typemap(argout) ( void **outPythonObject ) */
10198 27525 : Py_XDECREF(resultobj);
10199 27525 : if (*arg1)
10200 : {
10201 : resultobj = (PyObject*)*arg1;
10202 : }
10203 : else
10204 : {
10205 12 : resultobj = Py_None;
10206 12 : Py_INCREF(resultobj);
10207 : }
10208 : }
10209 27526 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10210 : return resultobj;
10211 : fail:
10212 : return NULL;
10213 : }
10214 :
10215 :
10216 2 : SWIGINTERN PyObject *_wrap_VSIGetMemFileBuffer_unsafe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10217 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10218 2 : char *arg1 = (char *) 0 ;
10219 2 : GByte **arg2 = (GByte **) 0 ;
10220 2 : vsi_l_offset *arg3 = (vsi_l_offset *) 0 ;
10221 2 : int bToFree1 = 0 ;
10222 2 : GByte *out2 = NULL ;
10223 2 : vsi_l_offset length2 ;
10224 2 : PyObject *swig_obj[1] ;
10225 :
10226 2 : {
10227 2 : arg2 = &out2;
10228 2 : arg3 = &length2;
10229 : }
10230 2 : if (!args) SWIG_fail;
10231 2 : swig_obj[0] = args;
10232 2 : {
10233 : /* %typemap(in) (const char *utf8_path) */
10234 2 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
10235 : {
10236 2 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
10237 : }
10238 : else
10239 : {
10240 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
10241 :
10242 : }
10243 2 : if (arg1 == NULL)
10244 : {
10245 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
10246 0 : SWIG_fail;
10247 : }
10248 : }
10249 2 : {
10250 2 : const int bLocalUseExceptions = GetUseExceptions();
10251 2 : if ( bLocalUseExceptions ) {
10252 0 : pushErrorHandler();
10253 : }
10254 2 : {
10255 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10256 2 : wrapper_VSIGetMemFileBuffer((char const *)arg1,arg2,arg3);
10257 2 : SWIG_PYTHON_THREAD_END_ALLOW;
10258 : }
10259 2 : if ( bLocalUseExceptions ) {
10260 0 : popErrorHandler();
10261 : }
10262 : #ifndef SED_HACKS
10263 : if ( bLocalUseExceptions ) {
10264 : CPLErr eclass = CPLGetLastErrorType();
10265 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10266 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10267 : }
10268 : }
10269 : #endif
10270 : }
10271 2 : resultobj = SWIG_Py_Void();
10272 2 : {
10273 2 : if (*arg2 == NULL) {
10274 1 : if( GetUseExceptions() ) {
10275 0 : PyErr_SetString(PyExc_RuntimeError, "Could not find path");
10276 : resultobj = NULL;
10277 : } else {
10278 1 : CPLError(CE_Failure, CPLE_AppDefined, "Could not find path");
10279 1 : resultobj = Py_None;
10280 1 : Py_INCREF(resultobj);
10281 : }
10282 : } else {
10283 1 : do {
10284 1 : resultobj = PyMemoryView_FromMemory(reinterpret_cast<char *>(*arg2), *arg3, PyBUF_READ);
10285 1 : if (resultobj == NULL) {
10286 0 : if( GetUseExceptions() ) {
10287 0 : PyErr_SetString(PyExc_RuntimeError, "Could not allocate result buffer");
10288 : resultobj = NULL;
10289 : } else {
10290 0 : CPLError(CE_Failure, CPLE_AppDefined, "Could not allocate result buffer");
10291 0 : resultobj = Py_None;
10292 0 : Py_INCREF(resultobj);
10293 : }
10294 : }
10295 : } while(0);
10296 : }
10297 : }
10298 2 : {
10299 : /* %typemap(freearg) (const char *utf8_path) */
10300 2 : GDALPythonFreeCStr(arg1, bToFree1);
10301 : }
10302 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10303 : return resultobj;
10304 0 : fail:
10305 0 : {
10306 : /* %typemap(freearg) (const char *utf8_path) */
10307 2 : GDALPythonFreeCStr(arg1, bToFree1);
10308 : }
10309 : return NULL;
10310 : }
10311 :
10312 :
10313 157 : SWIGINTERN PyObject *_wrap_Debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10314 157 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10315 157 : char *arg1 = (char *) 0 ;
10316 157 : char *arg2 = (char *) 0 ;
10317 157 : int res1 ;
10318 157 : char *buf1 = 0 ;
10319 157 : int alloc1 = 0 ;
10320 157 : int res2 ;
10321 157 : char *buf2 = 0 ;
10322 157 : int alloc2 = 0 ;
10323 157 : PyObject *swig_obj[2] ;
10324 :
10325 157 : if (!SWIG_Python_UnpackTuple(args, "Debug", 2, 2, swig_obj)) SWIG_fail;
10326 157 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
10327 157 : if (!SWIG_IsOK(res1)) {
10328 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Debug" "', argument " "1"" of type '" "char const *""'");
10329 : }
10330 157 : arg1 = reinterpret_cast< char * >(buf1);
10331 157 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
10332 157 : if (!SWIG_IsOK(res2)) {
10333 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Debug" "', argument " "2"" of type '" "char const *""'");
10334 : }
10335 157 : arg2 = reinterpret_cast< char * >(buf2);
10336 157 : {
10337 157 : if (!arg2) {
10338 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10339 : }
10340 : }
10341 157 : {
10342 157 : const int bLocalUseExceptions = GetUseExceptions();
10343 157 : if ( bLocalUseExceptions ) {
10344 98 : pushErrorHandler();
10345 : }
10346 157 : {
10347 157 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10348 157 : Debug((char const *)arg1,(char const *)arg2);
10349 157 : SWIG_PYTHON_THREAD_END_ALLOW;
10350 : }
10351 157 : if ( bLocalUseExceptions ) {
10352 98 : popErrorHandler();
10353 : }
10354 : #ifndef SED_HACKS
10355 : if ( bLocalUseExceptions ) {
10356 : CPLErr eclass = CPLGetLastErrorType();
10357 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10358 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10359 : }
10360 : }
10361 : #endif
10362 : }
10363 157 : resultobj = SWIG_Py_Void();
10364 157 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
10365 157 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10366 157 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10367 : return resultobj;
10368 0 : fail:
10369 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
10370 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10371 : return NULL;
10372 : }
10373 :
10374 :
10375 6 : SWIGINTERN PyObject *_wrap_SetErrorHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10376 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10377 6 : CPLErrorHandler arg1 = (CPLErrorHandler) NULL ;
10378 6 : void *arg2 = (void *) NULL ;
10379 6 : PyObject *swig_obj[1] ;
10380 6 : CPLErr result;
10381 :
10382 6 : if (!SWIG_Python_UnpackTuple(args, "SetErrorHandler", 0, 1, swig_obj)) SWIG_fail;
10383 6 : if (swig_obj[0]) {
10384 6 : {
10385 : /* %typemap(in) (CPLErrorHandler pfnErrorHandler = NULL, void* user_data = NULL) */
10386 6 : int alloc = 0;
10387 6 : char* pszCallbackName = NULL;
10388 6 : arg2 = NULL;
10389 6 : if( SWIG_IsOK(SWIG_AsCharPtrAndSize(swig_obj[0], &pszCallbackName, NULL, &alloc)) )
10390 : {
10391 3 : if( pszCallbackName == NULL || EQUAL(pszCallbackName,"CPLQuietErrorHandler") )
10392 : arg1 = CPLQuietErrorHandler;
10393 3 : else if( EQUAL(pszCallbackName,"CPLQuietWarningsErrorHandler") )
10394 : arg1 = CPLQuietWarningsErrorHandler;
10395 3 : else if( EQUAL(pszCallbackName,"CPLDefaultErrorHandler") )
10396 : arg1 = CPLDefaultErrorHandler;
10397 0 : else if( EQUAL(pszCallbackName,"CPLLoggingErrorHandler") )
10398 : arg1 = CPLLoggingErrorHandler;
10399 : else
10400 : {
10401 0 : if (alloc == SWIG_NEWOBJ) delete[] pszCallbackName;
10402 0 : PyErr_SetString( PyExc_RuntimeError, "Unhandled value for passed string" );
10403 0 : SWIG_fail;
10404 : }
10405 :
10406 3 : if (alloc == SWIG_NEWOBJ) delete[] pszCallbackName;
10407 : }
10408 3 : else if (!PyCallable_Check(swig_obj[0]))
10409 : {
10410 0 : PyErr_SetString( PyExc_RuntimeError,
10411 : "Object given is not a String or a Python function" );
10412 0 : SWIG_fail;
10413 : }
10414 : else
10415 : {
10416 3 : Py_INCREF(swig_obj[0]);
10417 3 : arg1 = PyCPLErrorHandler;
10418 3 : arg2 = swig_obj[0];
10419 : }
10420 : }
10421 : }
10422 6 : {
10423 6 : const int bLocalUseExceptions = GetUseExceptions();
10424 6 : if ( bLocalUseExceptions ) {
10425 0 : pushErrorHandler();
10426 : }
10427 6 : {
10428 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10429 6 : result = (CPLErr)SetErrorHandler(arg1,arg2);
10430 6 : SWIG_PYTHON_THREAD_END_ALLOW;
10431 : }
10432 6 : if ( bLocalUseExceptions ) {
10433 0 : popErrorHandler();
10434 : }
10435 : #ifndef SED_HACKS
10436 : if ( bLocalUseExceptions ) {
10437 : CPLErr eclass = CPLGetLastErrorType();
10438 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10439 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10440 : }
10441 : }
10442 : #endif
10443 : }
10444 6 : resultobj = SWIG_From_int(static_cast< int >(result));
10445 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10446 : return resultobj;
10447 : fail:
10448 : return NULL;
10449 : }
10450 :
10451 :
10452 1 : SWIGINTERN PyObject *_wrap_SetCurrentErrorHandlerCatchDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10453 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10454 1 : int arg1 ;
10455 1 : int val1 ;
10456 1 : int ecode1 = 0 ;
10457 1 : PyObject *swig_obj[1] ;
10458 :
10459 1 : if (!args) SWIG_fail;
10460 1 : swig_obj[0] = args;
10461 1 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10462 1 : if (!SWIG_IsOK(ecode1)) {
10463 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SetCurrentErrorHandlerCatchDebug" "', argument " "1"" of type '" "int""'");
10464 : }
10465 1 : arg1 = static_cast< int >(val1);
10466 1 : {
10467 1 : const int bLocalUseExceptions = GetUseExceptions();
10468 1 : if ( bLocalUseExceptions ) {
10469 0 : pushErrorHandler();
10470 : }
10471 1 : {
10472 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10473 1 : CPLSetCurrentErrorHandlerCatchDebug(arg1);
10474 1 : SWIG_PYTHON_THREAD_END_ALLOW;
10475 : }
10476 1 : if ( bLocalUseExceptions ) {
10477 0 : popErrorHandler();
10478 : }
10479 : #ifndef SED_HACKS
10480 : if ( bLocalUseExceptions ) {
10481 : CPLErr eclass = CPLGetLastErrorType();
10482 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10483 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10484 : }
10485 : }
10486 : #endif
10487 : }
10488 1 : resultobj = SWIG_Py_Void();
10489 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10490 : return resultobj;
10491 : fail:
10492 : return NULL;
10493 : }
10494 :
10495 :
10496 30160 : SWIGINTERN PyObject *_wrap_PushErrorHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10497 30160 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10498 30160 : CPLErrorHandler arg1 = (CPLErrorHandler) NULL ;
10499 30160 : void *arg2 = (void *) NULL ;
10500 30160 : PyObject *swig_obj[1] ;
10501 30160 : CPLErr result;
10502 :
10503 30160 : if (!SWIG_Python_UnpackTuple(args, "PushErrorHandler", 0, 1, swig_obj)) SWIG_fail;
10504 30160 : if (swig_obj[0]) {
10505 30084 : {
10506 : /* %typemap(in) (CPLErrorHandler pfnErrorHandler = NULL, void* user_data = NULL) */
10507 30084 : int alloc = 0;
10508 30084 : char* pszCallbackName = NULL;
10509 30084 : arg2 = NULL;
10510 30084 : if( SWIG_IsOK(SWIG_AsCharPtrAndSize(swig_obj[0], &pszCallbackName, NULL, &alloc)) )
10511 : {
10512 28506 : if( pszCallbackName == NULL || EQUAL(pszCallbackName,"CPLQuietErrorHandler") )
10513 : arg1 = CPLQuietErrorHandler;
10514 7 : else if( EQUAL(pszCallbackName,"CPLQuietWarningsErrorHandler") )
10515 : arg1 = CPLQuietWarningsErrorHandler;
10516 0 : else if( EQUAL(pszCallbackName,"CPLDefaultErrorHandler") )
10517 : arg1 = CPLDefaultErrorHandler;
10518 0 : else if( EQUAL(pszCallbackName,"CPLLoggingErrorHandler") )
10519 : arg1 = CPLLoggingErrorHandler;
10520 : else
10521 : {
10522 0 : if (alloc == SWIG_NEWOBJ) delete[] pszCallbackName;
10523 0 : PyErr_SetString( PyExc_RuntimeError, "Unhandled value for passed string" );
10524 0 : SWIG_fail;
10525 : }
10526 :
10527 28506 : if (alloc == SWIG_NEWOBJ) delete[] pszCallbackName;
10528 : }
10529 1578 : else if (!PyCallable_Check(swig_obj[0]))
10530 : {
10531 0 : PyErr_SetString( PyExc_RuntimeError,
10532 : "Object given is not a String or a Python function" );
10533 0 : SWIG_fail;
10534 : }
10535 : else
10536 : {
10537 1578 : Py_INCREF(swig_obj[0]);
10538 1578 : arg1 = PyCPLErrorHandler;
10539 1578 : arg2 = swig_obj[0];
10540 : }
10541 : }
10542 : }
10543 30160 : {
10544 30746 : if( GetUseExceptions() ) bLocalUseExceptionsCode = FALSE;
10545 30160 : result = (CPLErr)PushErrorHandler(arg1,arg2);
10546 : }
10547 30160 : resultobj = SWIG_From_int(static_cast< int >(result));
10548 30160 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10549 : return resultobj;
10550 : fail:
10551 : return NULL;
10552 : }
10553 :
10554 :
10555 30155 : SWIGINTERN PyObject *_wrap_PopErrorHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10556 30155 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10557 :
10558 30155 : if (!SWIG_Python_UnpackTuple(args, "PopErrorHandler", 0, 0, 0)) SWIG_fail;
10559 30155 : {
10560 30741 : if( GetUseExceptions() ) bLocalUseExceptionsCode = FALSE;
10561 30155 : PopErrorHandler();
10562 : }
10563 30155 : resultobj = SWIG_Py_Void();
10564 30155 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10565 : return resultobj;
10566 0 : fail:
10567 0 : return NULL;
10568 : }
10569 :
10570 :
10571 29 : SWIGINTERN PyObject *_wrap_Error(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10572 29 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10573 29 : CPLErr arg1 = (CPLErr) CE_Failure ;
10574 29 : int arg2 = (int) 0 ;
10575 29 : char *arg3 = (char *) "error" ;
10576 29 : int val1 ;
10577 29 : int ecode1 = 0 ;
10578 29 : int val2 ;
10579 29 : int ecode2 = 0 ;
10580 29 : int res3 ;
10581 29 : char *buf3 = 0 ;
10582 29 : int alloc3 = 0 ;
10583 29 : PyObject *swig_obj[3] ;
10584 :
10585 29 : if (!SWIG_Python_UnpackTuple(args, "Error", 0, 3, swig_obj)) SWIG_fail;
10586 29 : if (swig_obj[0]) {
10587 29 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10588 29 : if (!SWIG_IsOK(ecode1)) {
10589 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Error" "', argument " "1"" of type '" "CPLErr""'");
10590 : }
10591 29 : arg1 = static_cast< CPLErr >(val1);
10592 : }
10593 29 : if (swig_obj[1]) {
10594 29 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10595 29 : if (!SWIG_IsOK(ecode2)) {
10596 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Error" "', argument " "2"" of type '" "int""'");
10597 : }
10598 : arg2 = static_cast< int >(val2);
10599 : }
10600 29 : if (swig_obj[2]) {
10601 29 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
10602 29 : if (!SWIG_IsOK(res3)) {
10603 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Error" "', argument " "3"" of type '" "char const *""'");
10604 : }
10605 29 : arg3 = reinterpret_cast< char * >(buf3);
10606 : }
10607 29 : {
10608 29 : const int bLocalUseExceptions = GetUseExceptions();
10609 29 : if ( bLocalUseExceptions ) {
10610 2 : pushErrorHandler();
10611 : }
10612 29 : {
10613 29 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10614 29 : Error(arg1,arg2,(char const *)arg3);
10615 29 : SWIG_PYTHON_THREAD_END_ALLOW;
10616 : }
10617 29 : if ( bLocalUseExceptions ) {
10618 2 : popErrorHandler();
10619 : }
10620 : #ifndef SED_HACKS
10621 : if ( bLocalUseExceptions ) {
10622 : CPLErr eclass = CPLGetLastErrorType();
10623 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10624 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10625 : }
10626 : }
10627 : #endif
10628 : }
10629 29 : resultobj = SWIG_Py_Void();
10630 29 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
10631 30 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10632 : return resultobj;
10633 0 : fail:
10634 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
10635 : return NULL;
10636 : }
10637 :
10638 :
10639 0 : SWIGINTERN PyObject *_wrap_GOA2GetAuthorizationURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10640 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10641 0 : char *arg1 = (char *) 0 ;
10642 0 : int res1 ;
10643 0 : char *buf1 = 0 ;
10644 0 : int alloc1 = 0 ;
10645 0 : PyObject *swig_obj[1] ;
10646 0 : retStringAndCPLFree *result = 0 ;
10647 :
10648 0 : if (!args) SWIG_fail;
10649 0 : swig_obj[0] = args;
10650 0 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
10651 0 : if (!SWIG_IsOK(res1)) {
10652 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GOA2GetAuthorizationURL" "', argument " "1"" of type '" "char const *""'");
10653 : }
10654 0 : arg1 = reinterpret_cast< char * >(buf1);
10655 0 : {
10656 0 : if (!arg1) {
10657 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10658 : }
10659 : }
10660 0 : {
10661 0 : const int bLocalUseExceptions = GetUseExceptions();
10662 0 : if ( bLocalUseExceptions ) {
10663 0 : pushErrorHandler();
10664 : }
10665 0 : {
10666 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10667 0 : result = (retStringAndCPLFree *)GOA2GetAuthorizationURL((char const *)arg1);
10668 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10669 : }
10670 0 : if ( bLocalUseExceptions ) {
10671 0 : popErrorHandler();
10672 : }
10673 : #ifndef SED_HACKS
10674 : if ( bLocalUseExceptions ) {
10675 : CPLErr eclass = CPLGetLastErrorType();
10676 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10677 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10678 : }
10679 : }
10680 : #endif
10681 : }
10682 0 : {
10683 : /* %typemap(out) (retStringAndCPLFree*) */
10684 0 : Py_XDECREF(resultobj);
10685 0 : if(result)
10686 : {
10687 0 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
10688 0 : CPLFree(result);
10689 : }
10690 : else
10691 : {
10692 0 : resultobj = Py_None;
10693 0 : Py_INCREF(resultobj);
10694 : }
10695 : }
10696 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
10697 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10698 : return resultobj;
10699 0 : fail:
10700 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
10701 : return NULL;
10702 : }
10703 :
10704 :
10705 0 : SWIGINTERN PyObject *_wrap_GOA2GetRefreshToken(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10706 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10707 0 : char *arg1 = (char *) 0 ;
10708 0 : char *arg2 = (char *) 0 ;
10709 0 : int res1 ;
10710 0 : char *buf1 = 0 ;
10711 0 : int alloc1 = 0 ;
10712 0 : int res2 ;
10713 0 : char *buf2 = 0 ;
10714 0 : int alloc2 = 0 ;
10715 0 : PyObject *swig_obj[2] ;
10716 0 : retStringAndCPLFree *result = 0 ;
10717 :
10718 0 : if (!SWIG_Python_UnpackTuple(args, "GOA2GetRefreshToken", 2, 2, swig_obj)) SWIG_fail;
10719 0 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
10720 0 : if (!SWIG_IsOK(res1)) {
10721 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GOA2GetRefreshToken" "', argument " "1"" of type '" "char const *""'");
10722 : }
10723 0 : arg1 = reinterpret_cast< char * >(buf1);
10724 0 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
10725 0 : if (!SWIG_IsOK(res2)) {
10726 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GOA2GetRefreshToken" "', argument " "2"" of type '" "char const *""'");
10727 : }
10728 0 : arg2 = reinterpret_cast< char * >(buf2);
10729 0 : {
10730 0 : if (!arg1) {
10731 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10732 : }
10733 : }
10734 0 : {
10735 0 : const int bLocalUseExceptions = GetUseExceptions();
10736 0 : if ( bLocalUseExceptions ) {
10737 0 : pushErrorHandler();
10738 : }
10739 0 : {
10740 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10741 0 : result = (retStringAndCPLFree *)GOA2GetRefreshToken((char const *)arg1,(char const *)arg2);
10742 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10743 : }
10744 0 : if ( bLocalUseExceptions ) {
10745 0 : popErrorHandler();
10746 : }
10747 : #ifndef SED_HACKS
10748 : if ( bLocalUseExceptions ) {
10749 : CPLErr eclass = CPLGetLastErrorType();
10750 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10751 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10752 : }
10753 : }
10754 : #endif
10755 : }
10756 0 : {
10757 : /* %typemap(out) (retStringAndCPLFree*) */
10758 0 : Py_XDECREF(resultobj);
10759 0 : if(result)
10760 : {
10761 0 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
10762 0 : CPLFree(result);
10763 : }
10764 : else
10765 : {
10766 0 : resultobj = Py_None;
10767 0 : Py_INCREF(resultobj);
10768 : }
10769 : }
10770 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
10771 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10772 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10773 : return resultobj;
10774 0 : fail:
10775 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
10776 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10777 : return NULL;
10778 : }
10779 :
10780 :
10781 0 : SWIGINTERN PyObject *_wrap_GOA2GetAccessToken(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10782 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10783 0 : char *arg1 = (char *) 0 ;
10784 0 : char *arg2 = (char *) 0 ;
10785 0 : int res1 ;
10786 0 : char *buf1 = 0 ;
10787 0 : int alloc1 = 0 ;
10788 0 : int res2 ;
10789 0 : char *buf2 = 0 ;
10790 0 : int alloc2 = 0 ;
10791 0 : PyObject *swig_obj[2] ;
10792 0 : retStringAndCPLFree *result = 0 ;
10793 :
10794 0 : if (!SWIG_Python_UnpackTuple(args, "GOA2GetAccessToken", 2, 2, swig_obj)) SWIG_fail;
10795 0 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
10796 0 : if (!SWIG_IsOK(res1)) {
10797 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GOA2GetAccessToken" "', argument " "1"" of type '" "char const *""'");
10798 : }
10799 0 : arg1 = reinterpret_cast< char * >(buf1);
10800 0 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
10801 0 : if (!SWIG_IsOK(res2)) {
10802 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GOA2GetAccessToken" "', argument " "2"" of type '" "char const *""'");
10803 : }
10804 0 : arg2 = reinterpret_cast< char * >(buf2);
10805 0 : {
10806 0 : if (!arg1) {
10807 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
10808 : }
10809 : }
10810 0 : {
10811 0 : const int bLocalUseExceptions = GetUseExceptions();
10812 0 : if ( bLocalUseExceptions ) {
10813 0 : pushErrorHandler();
10814 : }
10815 0 : {
10816 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10817 0 : result = (retStringAndCPLFree *)GOA2GetAccessToken((char const *)arg1,(char const *)arg2);
10818 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10819 : }
10820 0 : if ( bLocalUseExceptions ) {
10821 0 : popErrorHandler();
10822 : }
10823 : #ifndef SED_HACKS
10824 : if ( bLocalUseExceptions ) {
10825 : CPLErr eclass = CPLGetLastErrorType();
10826 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10827 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10828 : }
10829 : }
10830 : #endif
10831 : }
10832 0 : {
10833 : /* %typemap(out) (retStringAndCPLFree*) */
10834 0 : Py_XDECREF(resultobj);
10835 0 : if(result)
10836 : {
10837 0 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
10838 0 : CPLFree(result);
10839 : }
10840 : else
10841 : {
10842 0 : resultobj = Py_None;
10843 0 : Py_INCREF(resultobj);
10844 : }
10845 : }
10846 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
10847 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10848 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10849 : return resultobj;
10850 0 : fail:
10851 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
10852 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10853 : return NULL;
10854 : }
10855 :
10856 :
10857 1783 : SWIGINTERN PyObject *_wrap_ErrorReset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10858 1783 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10859 :
10860 1783 : if (!SWIG_Python_UnpackTuple(args, "ErrorReset", 0, 0, 0)) SWIG_fail;
10861 1783 : {
10862 1783 : const int bLocalUseExceptions = GetUseExceptions();
10863 1783 : if ( bLocalUseExceptions ) {
10864 306 : pushErrorHandler();
10865 : }
10866 1783 : {
10867 1783 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10868 1783 : CPLErrorReset();
10869 1783 : SWIG_PYTHON_THREAD_END_ALLOW;
10870 : }
10871 1783 : if ( bLocalUseExceptions ) {
10872 306 : popErrorHandler();
10873 : }
10874 : #ifndef SED_HACKS
10875 : if ( bLocalUseExceptions ) {
10876 : CPLErr eclass = CPLGetLastErrorType();
10877 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10878 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10879 : }
10880 : }
10881 : #endif
10882 : }
10883 1783 : resultobj = SWIG_Py_Void();
10884 1783 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10885 : return resultobj;
10886 0 : fail:
10887 0 : return NULL;
10888 : }
10889 :
10890 :
10891 170 : SWIGINTERN PyObject *_wrap_wrapper_EscapeString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10892 170 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10893 170 : int arg1 ;
10894 170 : char *arg2 = (char *) 0 ;
10895 170 : int arg3 = (int) CPLES_SQL ;
10896 170 : int alloc1 = 0 ;
10897 170 : bool viewIsValid1 = false ;
10898 170 : Py_buffer view1 ;
10899 170 : int val3 ;
10900 170 : int ecode3 = 0 ;
10901 170 : PyObject * obj0 = 0 ;
10902 170 : PyObject * obj1 = 0 ;
10903 170 : char * kwnames[] = {
10904 : (char *)"len", (char *)"scheme", NULL
10905 : };
10906 170 : retStringAndCPLFree *result = 0 ;
10907 :
10908 170 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:wrapper_EscapeString", kwnames, &obj0, &obj1)) SWIG_fail;
10909 170 : {
10910 : /* %typemap(in,numinputs=1) (int nLen, char *pBuf ) */
10911 170 : char* ptr = NULL;
10912 170 : if( !GetBufferAsCharPtrIntSize(obj0, &arg1, &ptr, &alloc1, &viewIsValid1, &view1) ) {
10913 0 : SWIG_fail;
10914 : }
10915 170 : arg2 = (char *)ptr;
10916 : }
10917 170 : if (obj1) {
10918 170 : ecode3 = SWIG_AsVal_int(obj1, &val3);
10919 170 : if (!SWIG_IsOK(ecode3)) {
10920 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "wrapper_EscapeString" "', argument " "3"" of type '" "int""'");
10921 : }
10922 : arg3 = static_cast< int >(val3);
10923 : }
10924 170 : {
10925 170 : const int bLocalUseExceptions = GetUseExceptions();
10926 170 : if ( bLocalUseExceptions ) {
10927 137 : pushErrorHandler();
10928 : }
10929 170 : {
10930 170 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10931 170 : result = (retStringAndCPLFree *)wrapper_EscapeString(arg1,arg2,arg3);
10932 170 : SWIG_PYTHON_THREAD_END_ALLOW;
10933 : }
10934 170 : if ( bLocalUseExceptions ) {
10935 137 : popErrorHandler();
10936 : }
10937 : #ifndef SED_HACKS
10938 : if ( bLocalUseExceptions ) {
10939 : CPLErr eclass = CPLGetLastErrorType();
10940 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10941 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
10942 : }
10943 : }
10944 : #endif
10945 : }
10946 170 : {
10947 : /* %typemap(out) (retStringAndCPLFree*) */
10948 170 : Py_XDECREF(resultobj);
10949 170 : if(result)
10950 : {
10951 170 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
10952 170 : CPLFree(result);
10953 : }
10954 : else
10955 : {
10956 0 : resultobj = Py_None;
10957 0 : Py_INCREF(resultobj);
10958 : }
10959 : }
10960 170 : {
10961 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
10962 170 : if( viewIsValid1 ) {
10963 0 : PyBuffer_Release(&view1);
10964 : }
10965 170 : else if (ReturnSame(alloc1) == SWIG_NEWOBJ ) {
10966 170 : delete[] arg2;
10967 : }
10968 : }
10969 170 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
10970 : return resultobj;
10971 0 : fail:
10972 0 : {
10973 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
10974 0 : if( viewIsValid1 ) {
10975 0 : PyBuffer_Release(&view1);
10976 : }
10977 170 : else if (ReturnSame(alloc1) == SWIG_NEWOBJ ) {
10978 0 : delete[] arg2;
10979 : }
10980 : }
10981 : return NULL;
10982 : }
10983 :
10984 :
10985 81 : SWIGINTERN PyObject *_wrap_EscapeBinary(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10986 81 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
10987 81 : int arg1 ;
10988 81 : char *arg2 = (char *) 0 ;
10989 81 : size_t *arg3 = (size_t *) 0 ;
10990 81 : char **arg4 = (char **) 0 ;
10991 81 : int arg5 = (int) CPLES_SQL ;
10992 81 : int alloc1 = 0 ;
10993 81 : bool viewIsValid1 = false ;
10994 81 : Py_buffer view1 ;
10995 81 : size_t nLen3 = 0 ;
10996 81 : char *pBuf3 = 0 ;
10997 81 : int val5 ;
10998 81 : int ecode5 = 0 ;
10999 81 : PyObject * obj0 = 0 ;
11000 81 : PyObject * obj1 = 0 ;
11001 81 : char * kwnames[] = {
11002 : (char *)"len", (char *)"scheme", NULL
11003 : };
11004 :
11005 81 : {
11006 : /* %typemap(in,numinputs=0) (size_t *nLen3, char **pBuf3 ) */
11007 81 : arg3 = &nLen3;
11008 81 : arg4 = &pBuf3;
11009 : }
11010 81 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:EscapeBinary", kwnames, &obj0, &obj1)) SWIG_fail;
11011 81 : {
11012 : /* %typemap(in,numinputs=1) (int nLen, char *pBuf ) */
11013 81 : char* ptr = NULL;
11014 81 : if( !GetBufferAsCharPtrIntSize(obj0, &arg1, &ptr, &alloc1, &viewIsValid1, &view1) ) {
11015 0 : SWIG_fail;
11016 : }
11017 81 : arg2 = (char *)ptr;
11018 : }
11019 81 : if (obj1) {
11020 81 : ecode5 = SWIG_AsVal_int(obj1, &val5);
11021 81 : if (!SWIG_IsOK(ecode5)) {
11022 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "EscapeBinary" "', argument " "5"" of type '" "int""'");
11023 : }
11024 : arg5 = static_cast< int >(val5);
11025 : }
11026 81 : {
11027 81 : const int bLocalUseExceptions = GetUseExceptions();
11028 81 : if ( bLocalUseExceptions ) {
11029 72 : pushErrorHandler();
11030 : }
11031 81 : {
11032 81 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11033 81 : EscapeBinary(arg1,arg2,arg3,arg4,arg5);
11034 81 : SWIG_PYTHON_THREAD_END_ALLOW;
11035 : }
11036 81 : if ( bLocalUseExceptions ) {
11037 72 : popErrorHandler();
11038 : }
11039 : #ifndef SED_HACKS
11040 : if ( bLocalUseExceptions ) {
11041 : CPLErr eclass = CPLGetLastErrorType();
11042 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11043 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11044 : }
11045 : }
11046 : #endif
11047 : }
11048 81 : resultobj = SWIG_Py_Void();
11049 81 : {
11050 : /* %typemap(argout) (size_t *nLen, char **pBuf ) */
11051 81 : Py_XDECREF(resultobj);
11052 81 : if( *arg4 ) {
11053 81 : resultobj = PyByteArray_FromStringAndSize( *arg4, *arg3 );
11054 : }
11055 : else {
11056 0 : resultobj = Py_None;
11057 0 : Py_INCREF(Py_None);
11058 : }
11059 : }
11060 81 : {
11061 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
11062 81 : if( viewIsValid1 ) {
11063 81 : PyBuffer_Release(&view1);
11064 : }
11065 0 : else if (ReturnSame(alloc1) == SWIG_NEWOBJ ) {
11066 0 : delete[] arg2;
11067 : }
11068 : }
11069 81 : {
11070 : /* %typemap(freearg) (size_t *nLen, char **pBuf ) */
11071 81 : VSIFree( *arg4 );
11072 : }
11073 81 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11074 : return resultobj;
11075 0 : fail:
11076 0 : {
11077 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
11078 0 : if( viewIsValid1 ) {
11079 0 : PyBuffer_Release(&view1);
11080 : }
11081 0 : else if (ReturnSame(alloc1) == SWIG_NEWOBJ ) {
11082 0 : delete[] arg2;
11083 : }
11084 : }
11085 0 : {
11086 : /* %typemap(freearg) (size_t *nLen, char **pBuf ) */
11087 0 : VSIFree( *arg4 );
11088 : }
11089 : return NULL;
11090 : }
11091 :
11092 :
11093 2 : SWIGINTERN PyObject *_wrap_GetLastErrorNo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11094 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11095 2 : int result;
11096 :
11097 2 : if (!SWIG_Python_UnpackTuple(args, "GetLastErrorNo", 0, 0, 0)) SWIG_fail;
11098 2 : {
11099 : #ifdef SED_HACKS
11100 2 : if( GetUseExceptions() ) bLocalUseExceptionsCode = FALSE;
11101 : #endif
11102 :
11103 2 : result = CPLGetLastErrorNo();
11104 : }
11105 2 : resultobj = SWIG_From_int(static_cast< int >(result));
11106 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11107 : return resultobj;
11108 0 : fail:
11109 0 : return NULL;
11110 : }
11111 :
11112 :
11113 75 : SWIGINTERN PyObject *_wrap_GetLastErrorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11114 75 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11115 75 : int result;
11116 :
11117 75 : if (!SWIG_Python_UnpackTuple(args, "GetLastErrorType", 0, 0, 0)) SWIG_fail;
11118 75 : {
11119 : #ifdef SED_HACKS
11120 87 : if( GetUseExceptions() ) bLocalUseExceptionsCode = FALSE;
11121 : #endif
11122 :
11123 75 : result = CPLGetLastErrorType();
11124 : }
11125 75 : resultobj = SWIG_From_int(static_cast< int >(result));
11126 75 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11127 : return resultobj;
11128 0 : fail:
11129 0 : return NULL;
11130 : }
11131 :
11132 :
11133 2091 : SWIGINTERN PyObject *_wrap_GetLastErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11134 2091 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11135 2091 : char *result = 0 ;
11136 :
11137 2091 : if (!SWIG_Python_UnpackTuple(args, "GetLastErrorMsg", 0, 0, 0)) SWIG_fail;
11138 2091 : {
11139 : #ifdef SED_HACKS
11140 2322 : if( GetUseExceptions() ) bLocalUseExceptionsCode = FALSE;
11141 : #endif
11142 :
11143 2091 : result = (char*)CPLGetLastErrorMsg();
11144 : }
11145 2091 : resultobj = SWIG_FromCharPtr((const char *)result);
11146 2091 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11147 : return resultobj;
11148 0 : fail:
11149 0 : return NULL;
11150 : }
11151 :
11152 :
11153 0 : SWIGINTERN PyObject *_wrap_GetErrorCounter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11154 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11155 0 : unsigned int result;
11156 :
11157 0 : if (!SWIG_Python_UnpackTuple(args, "GetErrorCounter", 0, 0, 0)) SWIG_fail;
11158 0 : {
11159 : #ifdef SED_HACKS
11160 0 : if( GetUseExceptions() ) bLocalUseExceptionsCode = FALSE;
11161 : #endif
11162 :
11163 0 : result = CPLGetErrorCounter();
11164 : }
11165 0 : resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
11166 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11167 : return resultobj;
11168 0 : fail:
11169 0 : return NULL;
11170 : }
11171 :
11172 :
11173 4 : SWIGINTERN PyObject *_wrap_VSIGetLastErrorNo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11174 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11175 4 : int result;
11176 :
11177 4 : if (!SWIG_Python_UnpackTuple(args, "VSIGetLastErrorNo", 0, 0, 0)) SWIG_fail;
11178 4 : {
11179 4 : const int bLocalUseExceptions = GetUseExceptions();
11180 4 : if ( bLocalUseExceptions ) {
11181 0 : pushErrorHandler();
11182 : }
11183 4 : {
11184 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11185 4 : result = (int)VSIGetLastErrorNo();
11186 4 : SWIG_PYTHON_THREAD_END_ALLOW;
11187 : }
11188 4 : if ( bLocalUseExceptions ) {
11189 0 : popErrorHandler();
11190 : }
11191 : #ifndef SED_HACKS
11192 : if ( bLocalUseExceptions ) {
11193 : CPLErr eclass = CPLGetLastErrorType();
11194 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11195 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11196 : }
11197 : }
11198 : #endif
11199 : }
11200 4 : resultobj = SWIG_From_int(static_cast< int >(result));
11201 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11202 : return resultobj;
11203 0 : fail:
11204 0 : return NULL;
11205 : }
11206 :
11207 :
11208 42 : SWIGINTERN PyObject *_wrap_VSIGetLastErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11209 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11210 42 : char *result = 0 ;
11211 :
11212 42 : if (!SWIG_Python_UnpackTuple(args, "VSIGetLastErrorMsg", 0, 0, 0)) SWIG_fail;
11213 42 : {
11214 42 : const int bLocalUseExceptions = GetUseExceptions();
11215 42 : if ( bLocalUseExceptions ) {
11216 11 : pushErrorHandler();
11217 : }
11218 42 : {
11219 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11220 42 : result = (char *)VSIGetLastErrorMsg();
11221 42 : SWIG_PYTHON_THREAD_END_ALLOW;
11222 : }
11223 42 : if ( bLocalUseExceptions ) {
11224 11 : popErrorHandler();
11225 : }
11226 : #ifndef SED_HACKS
11227 : if ( bLocalUseExceptions ) {
11228 : CPLErr eclass = CPLGetLastErrorType();
11229 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11230 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11231 : }
11232 : }
11233 : #endif
11234 : }
11235 42 : resultobj = SWIG_FromCharPtr((const char *)result);
11236 42 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11237 : return resultobj;
11238 0 : fail:
11239 0 : return NULL;
11240 : }
11241 :
11242 :
11243 3 : SWIGINTERN PyObject *_wrap_VSIErrorReset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11244 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11245 :
11246 3 : if (!SWIG_Python_UnpackTuple(args, "VSIErrorReset", 0, 0, 0)) SWIG_fail;
11247 3 : {
11248 3 : const int bLocalUseExceptions = GetUseExceptions();
11249 3 : if ( bLocalUseExceptions ) {
11250 1 : pushErrorHandler();
11251 : }
11252 3 : {
11253 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11254 3 : VSIErrorReset();
11255 3 : SWIG_PYTHON_THREAD_END_ALLOW;
11256 : }
11257 3 : if ( bLocalUseExceptions ) {
11258 1 : popErrorHandler();
11259 : }
11260 : #ifndef SED_HACKS
11261 : if ( bLocalUseExceptions ) {
11262 : CPLErr eclass = CPLGetLastErrorType();
11263 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11264 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11265 : }
11266 : }
11267 : #endif
11268 : }
11269 3 : resultobj = SWIG_Py_Void();
11270 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11271 : return resultobj;
11272 0 : fail:
11273 0 : return NULL;
11274 : }
11275 :
11276 :
11277 0 : SWIGINTERN PyObject *_wrap_PushFinderLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11278 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11279 0 : char *arg1 = (char *) 0 ;
11280 0 : int bToFree1 = 0 ;
11281 0 : PyObject *swig_obj[1] ;
11282 :
11283 0 : if (!args) SWIG_fail;
11284 0 : swig_obj[0] = args;
11285 0 : {
11286 : /* %typemap(in) (const char *utf8_path) */
11287 0 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
11288 : {
11289 0 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
11290 : }
11291 : else
11292 : {
11293 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
11294 :
11295 : }
11296 0 : if (arg1 == NULL)
11297 : {
11298 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
11299 0 : SWIG_fail;
11300 : }
11301 : }
11302 0 : {
11303 0 : if (!arg1) {
11304 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
11305 : }
11306 : }
11307 0 : {
11308 0 : const int bLocalUseExceptions = GetUseExceptions();
11309 0 : if ( bLocalUseExceptions ) {
11310 0 : pushErrorHandler();
11311 : }
11312 0 : {
11313 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11314 0 : CPLPushFinderLocation((char const *)arg1);
11315 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11316 : }
11317 0 : if ( bLocalUseExceptions ) {
11318 0 : popErrorHandler();
11319 : }
11320 : #ifndef SED_HACKS
11321 : if ( bLocalUseExceptions ) {
11322 : CPLErr eclass = CPLGetLastErrorType();
11323 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11324 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11325 : }
11326 : }
11327 : #endif
11328 : }
11329 0 : resultobj = SWIG_Py_Void();
11330 0 : {
11331 : /* %typemap(freearg) (const char *utf8_path) */
11332 0 : GDALPythonFreeCStr(arg1, bToFree1);
11333 : }
11334 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11335 : return resultobj;
11336 0 : fail:
11337 0 : {
11338 : /* %typemap(freearg) (const char *utf8_path) */
11339 0 : GDALPythonFreeCStr(arg1, bToFree1);
11340 : }
11341 : return NULL;
11342 : }
11343 :
11344 :
11345 0 : SWIGINTERN PyObject *_wrap_PopFinderLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11346 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11347 :
11348 0 : if (!SWIG_Python_UnpackTuple(args, "PopFinderLocation", 0, 0, 0)) SWIG_fail;
11349 0 : {
11350 0 : const int bLocalUseExceptions = GetUseExceptions();
11351 0 : if ( bLocalUseExceptions ) {
11352 0 : pushErrorHandler();
11353 : }
11354 0 : {
11355 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11356 0 : CPLPopFinderLocation();
11357 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11358 : }
11359 0 : if ( bLocalUseExceptions ) {
11360 0 : popErrorHandler();
11361 : }
11362 : #ifndef SED_HACKS
11363 : if ( bLocalUseExceptions ) {
11364 : CPLErr eclass = CPLGetLastErrorType();
11365 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11366 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11367 : }
11368 : }
11369 : #endif
11370 : }
11371 0 : resultobj = SWIG_Py_Void();
11372 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11373 : return resultobj;
11374 0 : fail:
11375 0 : return NULL;
11376 : }
11377 :
11378 :
11379 0 : SWIGINTERN PyObject *_wrap_FinderClean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11380 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11381 :
11382 0 : if (!SWIG_Python_UnpackTuple(args, "FinderClean", 0, 0, 0)) SWIG_fail;
11383 0 : {
11384 0 : const int bLocalUseExceptions = GetUseExceptions();
11385 0 : if ( bLocalUseExceptions ) {
11386 0 : pushErrorHandler();
11387 : }
11388 0 : {
11389 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11390 0 : CPLFinderClean();
11391 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11392 : }
11393 0 : if ( bLocalUseExceptions ) {
11394 0 : popErrorHandler();
11395 : }
11396 : #ifndef SED_HACKS
11397 : if ( bLocalUseExceptions ) {
11398 : CPLErr eclass = CPLGetLastErrorType();
11399 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11400 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11401 : }
11402 : }
11403 : #endif
11404 : }
11405 0 : resultobj = SWIG_Py_Void();
11406 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11407 : return resultobj;
11408 0 : fail:
11409 0 : return NULL;
11410 : }
11411 :
11412 :
11413 47 : SWIGINTERN PyObject *_wrap_FindFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11414 47 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11415 47 : char *arg1 = (char *) 0 ;
11416 47 : char *arg2 = (char *) 0 ;
11417 47 : int res1 ;
11418 47 : char *buf1 = 0 ;
11419 47 : int alloc1 = 0 ;
11420 47 : int bToFree2 = 0 ;
11421 47 : PyObject *swig_obj[2] ;
11422 47 : char *result = 0 ;
11423 :
11424 47 : if (!SWIG_Python_UnpackTuple(args, "FindFile", 2, 2, swig_obj)) SWIG_fail;
11425 47 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11426 47 : if (!SWIG_IsOK(res1)) {
11427 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FindFile" "', argument " "1"" of type '" "char const *""'");
11428 : }
11429 47 : arg1 = reinterpret_cast< char * >(buf1);
11430 47 : {
11431 : /* %typemap(in) (const char *utf8_path) */
11432 47 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
11433 : {
11434 47 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
11435 : }
11436 : else
11437 : {
11438 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
11439 :
11440 : }
11441 47 : if (arg2 == NULL)
11442 : {
11443 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
11444 0 : SWIG_fail;
11445 : }
11446 : }
11447 47 : {
11448 47 : if (!arg2) {
11449 47 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
11450 : }
11451 : }
11452 47 : {
11453 47 : const int bLocalUseExceptions = GetUseExceptions();
11454 47 : if ( bLocalUseExceptions ) {
11455 47 : pushErrorHandler();
11456 : }
11457 47 : {
11458 47 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11459 47 : result = (char *)CPLFindFile((char const *)arg1,(char const *)arg2);
11460 47 : SWIG_PYTHON_THREAD_END_ALLOW;
11461 : }
11462 47 : if ( bLocalUseExceptions ) {
11463 47 : popErrorHandler();
11464 : }
11465 : #ifndef SED_HACKS
11466 : if ( bLocalUseExceptions ) {
11467 : CPLErr eclass = CPLGetLastErrorType();
11468 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11469 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11470 : }
11471 : }
11472 : #endif
11473 : }
11474 47 : resultobj = SWIG_FromCharPtr((const char *)result);
11475 47 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
11476 47 : {
11477 : /* %typemap(freearg) (const char *utf8_path) */
11478 47 : GDALPythonFreeCStr(arg2, bToFree2);
11479 : }
11480 47 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11481 : return resultobj;
11482 0 : fail:
11483 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
11484 0 : {
11485 : /* %typemap(freearg) (const char *utf8_path) */
11486 47 : GDALPythonFreeCStr(arg2, bToFree2);
11487 : }
11488 : return NULL;
11489 : }
11490 :
11491 :
11492 848 : SWIGINTERN PyObject *_wrap_ReadDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11493 848 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11494 848 : char *arg1 = (char *) 0 ;
11495 848 : int arg2 = (int) 0 ;
11496 848 : int bToFree1 = 0 ;
11497 848 : int val2 ;
11498 848 : int ecode2 = 0 ;
11499 848 : PyObject *swig_obj[2] ;
11500 848 : char **result = 0 ;
11501 :
11502 848 : if (!SWIG_Python_UnpackTuple(args, "ReadDir", 1, 2, swig_obj)) SWIG_fail;
11503 848 : {
11504 : /* %typemap(in) (const char *utf8_path) */
11505 848 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
11506 : {
11507 826 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
11508 : }
11509 : else
11510 : {
11511 22 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
11512 :
11513 : }
11514 848 : if (arg1 == NULL)
11515 : {
11516 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
11517 0 : SWIG_fail;
11518 : }
11519 : }
11520 848 : if (swig_obj[1]) {
11521 6 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11522 6 : if (!SWIG_IsOK(ecode2)) {
11523 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReadDir" "', argument " "2"" of type '" "int""'");
11524 : }
11525 : arg2 = static_cast< int >(val2);
11526 : }
11527 848 : {
11528 848 : if (!arg1) {
11529 848 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
11530 : }
11531 : }
11532 848 : {
11533 848 : const int bLocalUseExceptions = GetUseExceptions();
11534 848 : if ( bLocalUseExceptions ) {
11535 96 : pushErrorHandler();
11536 : }
11537 848 : {
11538 848 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11539 848 : result = (char **)wrapper_VSIReadDirEx((char const *)arg1,arg2);
11540 848 : SWIG_PYTHON_THREAD_END_ALLOW;
11541 : }
11542 848 : if ( bLocalUseExceptions ) {
11543 96 : popErrorHandler();
11544 : }
11545 : #ifndef SED_HACKS
11546 : if ( bLocalUseExceptions ) {
11547 : CPLErr eclass = CPLGetLastErrorType();
11548 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11549 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11550 : }
11551 : }
11552 : #endif
11553 : }
11554 848 : {
11555 : /* %typemap(out) char **CSL -> ( string ) */
11556 848 : bool bErr = false;
11557 848 : resultobj = CSLToList(result, &bErr);
11558 848 : CSLDestroy(result);
11559 848 : if( bErr ) {
11560 0 : SWIG_fail;
11561 : }
11562 : }
11563 848 : {
11564 : /* %typemap(freearg) (const char *utf8_path) */
11565 848 : GDALPythonFreeCStr(arg1, bToFree1);
11566 : }
11567 880 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11568 : return resultobj;
11569 0 : fail:
11570 0 : {
11571 : /* %typemap(freearg) (const char *utf8_path) */
11572 848 : GDALPythonFreeCStr(arg1, bToFree1);
11573 : }
11574 : return NULL;
11575 : }
11576 :
11577 :
11578 1133 : SWIGINTERN PyObject *_wrap_ReadDirRecursive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11579 1133 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11580 1133 : char *arg1 = (char *) 0 ;
11581 1133 : int bToFree1 = 0 ;
11582 1133 : PyObject *swig_obj[1] ;
11583 1133 : char **result = 0 ;
11584 :
11585 1133 : if (!args) SWIG_fail;
11586 1133 : swig_obj[0] = args;
11587 1133 : {
11588 : /* %typemap(in) (const char *utf8_path) */
11589 1133 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
11590 : {
11591 1068 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
11592 : }
11593 : else
11594 : {
11595 65 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
11596 :
11597 : }
11598 1133 : if (arg1 == NULL)
11599 : {
11600 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
11601 0 : SWIG_fail;
11602 : }
11603 : }
11604 1133 : {
11605 1133 : if (!arg1) {
11606 1133 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
11607 : }
11608 : }
11609 1133 : {
11610 1133 : const int bLocalUseExceptions = GetUseExceptions();
11611 1133 : if ( bLocalUseExceptions ) {
11612 300 : pushErrorHandler();
11613 : }
11614 1133 : {
11615 1133 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11616 1133 : result = (char **)VSIReadDirRecursive((char const *)arg1);
11617 1133 : SWIG_PYTHON_THREAD_END_ALLOW;
11618 : }
11619 1133 : if ( bLocalUseExceptions ) {
11620 300 : popErrorHandler();
11621 : }
11622 : #ifndef SED_HACKS
11623 : if ( bLocalUseExceptions ) {
11624 : CPLErr eclass = CPLGetLastErrorType();
11625 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11626 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11627 : }
11628 : }
11629 : #endif
11630 : }
11631 1133 : {
11632 : /* %typemap(out) char **CSL -> ( string ) */
11633 1133 : bool bErr = false;
11634 1133 : resultobj = CSLToList(result, &bErr);
11635 1133 : CSLDestroy(result);
11636 1133 : if( bErr ) {
11637 0 : SWIG_fail;
11638 : }
11639 : }
11640 1133 : {
11641 : /* %typemap(freearg) (const char *utf8_path) */
11642 1133 : GDALPythonFreeCStr(arg1, bToFree1);
11643 : }
11644 1133 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11645 : return resultobj;
11646 0 : fail:
11647 0 : {
11648 : /* %typemap(freearg) (const char *utf8_path) */
11649 1133 : GDALPythonFreeCStr(arg1, bToFree1);
11650 : }
11651 : return NULL;
11652 : }
11653 :
11654 :
11655 35 : SWIGINTERN PyObject *_wrap_OpenDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11656 35 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11657 35 : char *arg1 = (char *) 0 ;
11658 35 : int arg2 = (int) -1 ;
11659 35 : char **arg3 = (char **) NULL ;
11660 35 : int bToFree1 = 0 ;
11661 35 : int val2 ;
11662 35 : int ecode2 = 0 ;
11663 35 : PyObject *swig_obj[3] ;
11664 35 : VSIDIR *result = 0 ;
11665 :
11666 35 : if (!SWIG_Python_UnpackTuple(args, "OpenDir", 1, 3, swig_obj)) SWIG_fail;
11667 35 : {
11668 : /* %typemap(in) (const char *utf8_path) */
11669 35 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
11670 : {
11671 35 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
11672 : }
11673 : else
11674 : {
11675 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
11676 :
11677 : }
11678 35 : if (arg1 == NULL)
11679 : {
11680 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
11681 0 : SWIG_fail;
11682 : }
11683 : }
11684 35 : if (swig_obj[1]) {
11685 22 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11686 22 : if (!SWIG_IsOK(ecode2)) {
11687 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OpenDir" "', argument " "2"" of type '" "int""'");
11688 : }
11689 : arg2 = static_cast< int >(val2);
11690 : }
11691 35 : if (swig_obj[2]) {
11692 18 : {
11693 : /* %typemap(in) char **dict */
11694 18 : arg3 = NULL;
11695 18 : if ( PySequence_Check( swig_obj[2] ) ) {
11696 18 : int bErr = FALSE;
11697 18 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
11698 18 : if ( bErr )
11699 : {
11700 0 : SWIG_fail;
11701 : }
11702 : }
11703 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
11704 0 : int bErr = FALSE;
11705 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
11706 0 : if ( bErr )
11707 : {
11708 0 : SWIG_fail;
11709 : }
11710 : }
11711 : else {
11712 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
11713 0 : SWIG_fail;
11714 : }
11715 : }
11716 : }
11717 35 : {
11718 35 : if (!arg1) {
11719 35 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
11720 : }
11721 : }
11722 35 : {
11723 35 : const int bLocalUseExceptions = GetUseExceptions();
11724 35 : if ( bLocalUseExceptions ) {
11725 0 : pushErrorHandler();
11726 : }
11727 35 : {
11728 35 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11729 35 : result = (VSIDIR *)wrapper_VSIOpenDir((char const *)arg1,arg2,arg3);
11730 35 : SWIG_PYTHON_THREAD_END_ALLOW;
11731 : }
11732 35 : if ( bLocalUseExceptions ) {
11733 0 : popErrorHandler();
11734 : }
11735 : #ifndef SED_HACKS
11736 : if ( bLocalUseExceptions ) {
11737 : CPLErr eclass = CPLGetLastErrorType();
11738 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
11739 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
11740 : }
11741 : }
11742 : #endif
11743 : }
11744 35 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VSIDIR, 0 | 0 );
11745 35 : {
11746 : /* %typemap(freearg) (const char *utf8_path) */
11747 35 : GDALPythonFreeCStr(arg1, bToFree1);
11748 : }
11749 35 : {
11750 : /* %typemap(freearg) char **dict */
11751 35 : CSLDestroy( arg3 );
11752 : }
11753 35 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11754 : return resultobj;
11755 0 : fail:
11756 0 : {
11757 : /* %typemap(freearg) (const char *utf8_path) */
11758 0 : GDALPythonFreeCStr(arg1, bToFree1);
11759 : }
11760 0 : {
11761 : /* %typemap(freearg) char **dict */
11762 0 : CSLDestroy( arg3 );
11763 : }
11764 : return NULL;
11765 : }
11766 :
11767 :
11768 81 : SWIGINTERN PyObject *_wrap_DirEntry_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11769 81 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11770 81 : DirEntry *arg1 = (DirEntry *) 0 ;
11771 81 : void *argp1 = 0 ;
11772 81 : int res1 = 0 ;
11773 81 : PyObject *swig_obj[1] ;
11774 81 : char *result = 0 ;
11775 :
11776 81 : if (!args) SWIG_fail;
11777 81 : swig_obj[0] = args;
11778 81 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DirEntry, 0 | 0 );
11779 81 : if (!SWIG_IsOK(res1)) {
11780 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_name_get" "', argument " "1"" of type '" "DirEntry *""'");
11781 : }
11782 81 : arg1 = reinterpret_cast< DirEntry * >(argp1);
11783 81 : {
11784 81 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11785 81 : result = (char *) ((arg1)->name);
11786 81 : SWIG_PYTHON_THREAD_END_ALLOW;
11787 : }
11788 81 : resultobj = SWIG_FromCharPtr((const char *)result);
11789 81 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11790 : return resultobj;
11791 : fail:
11792 : return NULL;
11793 : }
11794 :
11795 :
11796 42 : SWIGINTERN PyObject *_wrap_DirEntry_mode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11797 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11798 42 : DirEntry *arg1 = (DirEntry *) 0 ;
11799 42 : void *argp1 = 0 ;
11800 42 : int res1 = 0 ;
11801 42 : PyObject *swig_obj[1] ;
11802 42 : int result;
11803 :
11804 42 : if (!args) SWIG_fail;
11805 42 : swig_obj[0] = args;
11806 42 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DirEntry, 0 | 0 );
11807 42 : if (!SWIG_IsOK(res1)) {
11808 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_mode_get" "', argument " "1"" of type '" "DirEntry *""'");
11809 : }
11810 42 : arg1 = reinterpret_cast< DirEntry * >(argp1);
11811 42 : {
11812 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11813 42 : result = (int) ((arg1)->mode);
11814 42 : SWIG_PYTHON_THREAD_END_ALLOW;
11815 : }
11816 42 : resultobj = SWIG_From_int(static_cast< int >(result));
11817 42 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11818 : return resultobj;
11819 : fail:
11820 : return NULL;
11821 : }
11822 :
11823 :
11824 15 : SWIGINTERN PyObject *_wrap_DirEntry_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11825 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11826 15 : DirEntry *arg1 = (DirEntry *) 0 ;
11827 15 : void *argp1 = 0 ;
11828 15 : int res1 = 0 ;
11829 15 : PyObject *swig_obj[1] ;
11830 15 : GIntBig result;
11831 :
11832 15 : if (!args) SWIG_fail;
11833 15 : swig_obj[0] = args;
11834 15 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DirEntry, 0 | 0 );
11835 15 : if (!SWIG_IsOK(res1)) {
11836 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_size_get" "', argument " "1"" of type '" "DirEntry *""'");
11837 : }
11838 15 : arg1 = reinterpret_cast< DirEntry * >(argp1);
11839 15 : {
11840 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11841 15 : result = ((arg1)->size);
11842 15 : SWIG_PYTHON_THREAD_END_ALLOW;
11843 : }
11844 15 : {
11845 15 : resultobj = PyLong_FromLongLong(result);
11846 : }
11847 15 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11848 : return resultobj;
11849 : fail:
11850 : return NULL;
11851 : }
11852 :
11853 :
11854 12 : SWIGINTERN PyObject *_wrap_DirEntry_mtime_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11855 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11856 12 : DirEntry *arg1 = (DirEntry *) 0 ;
11857 12 : void *argp1 = 0 ;
11858 12 : int res1 = 0 ;
11859 12 : PyObject *swig_obj[1] ;
11860 12 : GIntBig result;
11861 :
11862 12 : if (!args) SWIG_fail;
11863 12 : swig_obj[0] = args;
11864 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DirEntry, 0 | 0 );
11865 12 : if (!SWIG_IsOK(res1)) {
11866 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_mtime_get" "', argument " "1"" of type '" "DirEntry *""'");
11867 : }
11868 12 : arg1 = reinterpret_cast< DirEntry * >(argp1);
11869 12 : {
11870 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11871 12 : result = ((arg1)->mtime);
11872 12 : SWIG_PYTHON_THREAD_END_ALLOW;
11873 : }
11874 12 : {
11875 12 : resultobj = PyLong_FromLongLong(result);
11876 : }
11877 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11878 : return resultobj;
11879 : fail:
11880 : return NULL;
11881 : }
11882 :
11883 :
11884 2 : SWIGINTERN PyObject *_wrap_DirEntry_modeKnown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11885 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11886 2 : DirEntry *arg1 = (DirEntry *) 0 ;
11887 2 : void *argp1 = 0 ;
11888 2 : int res1 = 0 ;
11889 2 : PyObject *swig_obj[1] ;
11890 2 : bool result;
11891 :
11892 2 : if (!args) SWIG_fail;
11893 2 : swig_obj[0] = args;
11894 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DirEntry, 0 | 0 );
11895 2 : if (!SWIG_IsOK(res1)) {
11896 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_modeKnown_get" "', argument " "1"" of type '" "DirEntry *""'");
11897 : }
11898 2 : arg1 = reinterpret_cast< DirEntry * >(argp1);
11899 2 : {
11900 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11901 2 : result = (bool) ((arg1)->modeKnown);
11902 2 : SWIG_PYTHON_THREAD_END_ALLOW;
11903 : }
11904 2 : resultobj = SWIG_From_bool(static_cast< bool >(result));
11905 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11906 : return resultobj;
11907 : fail:
11908 : return NULL;
11909 : }
11910 :
11911 :
11912 2 : SWIGINTERN PyObject *_wrap_DirEntry_sizeKnown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11913 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11914 2 : DirEntry *arg1 = (DirEntry *) 0 ;
11915 2 : void *argp1 = 0 ;
11916 2 : int res1 = 0 ;
11917 2 : PyObject *swig_obj[1] ;
11918 2 : bool result;
11919 :
11920 2 : if (!args) SWIG_fail;
11921 2 : swig_obj[0] = args;
11922 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DirEntry, 0 | 0 );
11923 2 : if (!SWIG_IsOK(res1)) {
11924 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_sizeKnown_get" "', argument " "1"" of type '" "DirEntry *""'");
11925 : }
11926 2 : arg1 = reinterpret_cast< DirEntry * >(argp1);
11927 2 : {
11928 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11929 2 : result = (bool) ((arg1)->sizeKnown);
11930 2 : SWIG_PYTHON_THREAD_END_ALLOW;
11931 : }
11932 2 : resultobj = SWIG_From_bool(static_cast< bool >(result));
11933 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11934 : return resultobj;
11935 : fail:
11936 : return NULL;
11937 : }
11938 :
11939 :
11940 2 : SWIGINTERN PyObject *_wrap_DirEntry_mtimeKnown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11941 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11942 2 : DirEntry *arg1 = (DirEntry *) 0 ;
11943 2 : void *argp1 = 0 ;
11944 2 : int res1 = 0 ;
11945 2 : PyObject *swig_obj[1] ;
11946 2 : bool result;
11947 :
11948 2 : if (!args) SWIG_fail;
11949 2 : swig_obj[0] = args;
11950 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DirEntry, 0 | 0 );
11951 2 : if (!SWIG_IsOK(res1)) {
11952 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_mtimeKnown_get" "', argument " "1"" of type '" "DirEntry *""'");
11953 : }
11954 2 : arg1 = reinterpret_cast< DirEntry * >(argp1);
11955 2 : {
11956 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11957 2 : result = (bool) ((arg1)->mtimeKnown);
11958 2 : SWIG_PYTHON_THREAD_END_ALLOW;
11959 : }
11960 2 : resultobj = SWIG_From_bool(static_cast< bool >(result));
11961 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11962 : return resultobj;
11963 : fail:
11964 : return NULL;
11965 : }
11966 :
11967 :
11968 2 : SWIGINTERN PyObject *_wrap_DirEntry_extra_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11969 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
11970 2 : DirEntry *arg1 = (DirEntry *) 0 ;
11971 2 : void *argp1 = 0 ;
11972 2 : int res1 = 0 ;
11973 2 : PyObject *swig_obj[1] ;
11974 2 : char **result = 0 ;
11975 :
11976 2 : if (!args) SWIG_fail;
11977 2 : swig_obj[0] = args;
11978 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DirEntry, 0 | 0 );
11979 2 : if (!SWIG_IsOK(res1)) {
11980 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_extra_get" "', argument " "1"" of type '" "DirEntry *""'");
11981 : }
11982 2 : arg1 = reinterpret_cast< DirEntry * >(argp1);
11983 2 : {
11984 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11985 2 : result = (char **) ((arg1)->extra);
11986 2 : SWIG_PYTHON_THREAD_END_ALLOW;
11987 : }
11988 2 : {
11989 : /* %typemap(out) char **dict */
11990 2 : resultobj = GetCSLStringAsPyDict(result, false);
11991 : }
11992 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
11993 : return resultobj;
11994 : fail:
11995 : return NULL;
11996 : }
11997 :
11998 :
11999 0 : SWIGINTERN PyObject *_wrap_new_DirEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12000 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12001 0 : DirEntry *arg1 = (DirEntry *) 0 ;
12002 0 : void *argp1 = 0 ;
12003 0 : int res1 = 0 ;
12004 0 : PyObject *swig_obj[1] ;
12005 0 : DirEntry *result = 0 ;
12006 :
12007 0 : if (!args) SWIG_fail;
12008 0 : swig_obj[0] = args;
12009 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DirEntry, 0 | 0 );
12010 0 : if (!SWIG_IsOK(res1)) {
12011 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DirEntry" "', argument " "1"" of type '" "DirEntry const *""'");
12012 : }
12013 0 : arg1 = reinterpret_cast< DirEntry * >(argp1);
12014 0 : {
12015 0 : const int bLocalUseExceptions = GetUseExceptions();
12016 0 : if ( bLocalUseExceptions ) {
12017 0 : pushErrorHandler();
12018 : }
12019 0 : {
12020 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12021 0 : result = (DirEntry *)new_DirEntry((DirEntry const *)arg1);
12022 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12023 : }
12024 0 : if ( bLocalUseExceptions ) {
12025 0 : popErrorHandler();
12026 : }
12027 : #ifndef SED_HACKS
12028 : if ( bLocalUseExceptions ) {
12029 : CPLErr eclass = CPLGetLastErrorType();
12030 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12031 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12032 : }
12033 : }
12034 : #endif
12035 : }
12036 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DirEntry, SWIG_POINTER_NEW | 0 );
12037 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12038 : return resultobj;
12039 : fail:
12040 : return NULL;
12041 : }
12042 :
12043 :
12044 79 : SWIGINTERN PyObject *_wrap_delete_DirEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12045 79 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12046 79 : DirEntry *arg1 = (DirEntry *) 0 ;
12047 79 : void *argp1 = 0 ;
12048 79 : int res1 = 0 ;
12049 79 : PyObject *swig_obj[1] ;
12050 :
12051 79 : if (!args) SWIG_fail;
12052 79 : swig_obj[0] = args;
12053 79 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DirEntry, SWIG_POINTER_DISOWN | 0 );
12054 79 : if (!SWIG_IsOK(res1)) {
12055 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DirEntry" "', argument " "1"" of type '" "DirEntry *""'");
12056 : }
12057 79 : arg1 = reinterpret_cast< DirEntry * >(argp1);
12058 79 : {
12059 79 : const int bLocalUseExceptions = GetUseExceptions();
12060 79 : if ( bLocalUseExceptions ) {
12061 0 : pushErrorHandler();
12062 : }
12063 79 : {
12064 79 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12065 79 : delete_DirEntry(arg1);
12066 79 : SWIG_PYTHON_THREAD_END_ALLOW;
12067 : }
12068 79 : if ( bLocalUseExceptions ) {
12069 0 : popErrorHandler();
12070 : }
12071 : #ifndef SED_HACKS
12072 : if ( bLocalUseExceptions ) {
12073 : CPLErr eclass = CPLGetLastErrorType();
12074 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12075 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12076 : }
12077 : }
12078 : #endif
12079 : }
12080 79 : resultobj = SWIG_Py_Void();
12081 79 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12082 : return resultobj;
12083 : fail:
12084 : return NULL;
12085 : }
12086 :
12087 :
12088 0 : SWIGINTERN PyObject *_wrap_DirEntry_IsDirectory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12089 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12090 0 : DirEntry *arg1 = (DirEntry *) 0 ;
12091 0 : void *argp1 = 0 ;
12092 0 : int res1 = 0 ;
12093 0 : PyObject *swig_obj[1] ;
12094 0 : bool result;
12095 :
12096 0 : if (!args) SWIG_fail;
12097 0 : swig_obj[0] = args;
12098 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DirEntry, 0 | 0 );
12099 0 : if (!SWIG_IsOK(res1)) {
12100 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_IsDirectory" "', argument " "1"" of type '" "DirEntry *""'");
12101 : }
12102 0 : arg1 = reinterpret_cast< DirEntry * >(argp1);
12103 0 : {
12104 0 : const int bLocalUseExceptions = GetUseExceptions();
12105 0 : if ( bLocalUseExceptions ) {
12106 0 : pushErrorHandler();
12107 : }
12108 0 : {
12109 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12110 0 : result = (bool)DirEntry_IsDirectory(arg1);
12111 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12112 : }
12113 0 : if ( bLocalUseExceptions ) {
12114 0 : popErrorHandler();
12115 : }
12116 : #ifndef SED_HACKS
12117 : if ( bLocalUseExceptions ) {
12118 : CPLErr eclass = CPLGetLastErrorType();
12119 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12120 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12121 : }
12122 : }
12123 : #endif
12124 : }
12125 0 : resultobj = SWIG_From_bool(static_cast< bool >(result));
12126 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12127 : return resultobj;
12128 : fail:
12129 : return NULL;
12130 : }
12131 :
12132 :
12133 277 : SWIGINTERN PyObject *DirEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12134 277 : PyObject *obj;
12135 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
12136 277 : SWIG_TypeNewClientData(SWIGTYPE_p_DirEntry, SWIG_NewClientData(obj));
12137 277 : return SWIG_Py_Void();
12138 : }
12139 :
12140 0 : SWIGINTERN PyObject *DirEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12141 0 : return SWIG_Python_InitShadowInstance(args);
12142 : }
12143 :
12144 112 : SWIGINTERN PyObject *_wrap_GetNextDirEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12145 112 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12146 112 : VSIDIR *arg1 = (VSIDIR *) 0 ;
12147 112 : void *argp1 = 0 ;
12148 112 : int res1 = 0 ;
12149 112 : PyObject *swig_obj[1] ;
12150 112 : DirEntry *result = 0 ;
12151 :
12152 112 : if (!args) SWIG_fail;
12153 112 : swig_obj[0] = args;
12154 112 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_VSIDIR, 0 | 0 );
12155 112 : if (!SWIG_IsOK(res1)) {
12156 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetNextDirEntry" "', argument " "1"" of type '" "VSIDIR *""'");
12157 : }
12158 112 : arg1 = reinterpret_cast< VSIDIR * >(argp1);
12159 112 : {
12160 112 : if (!arg1) {
12161 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12162 : }
12163 : }
12164 112 : {
12165 112 : const int bLocalUseExceptions = GetUseExceptions();
12166 112 : if ( bLocalUseExceptions ) {
12167 0 : pushErrorHandler();
12168 : }
12169 112 : {
12170 112 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12171 112 : result = (DirEntry *)wrapper_VSIGetNextDirEntry(arg1);
12172 112 : SWIG_PYTHON_THREAD_END_ALLOW;
12173 : }
12174 112 : if ( bLocalUseExceptions ) {
12175 0 : popErrorHandler();
12176 : }
12177 : #ifndef SED_HACKS
12178 : if ( bLocalUseExceptions ) {
12179 : CPLErr eclass = CPLGetLastErrorType();
12180 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12181 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12182 : }
12183 : }
12184 : #endif
12185 : }
12186 112 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DirEntry, SWIG_POINTER_OWN | 0 );
12187 112 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12188 : return resultobj;
12189 : fail:
12190 : return NULL;
12191 : }
12192 :
12193 :
12194 33 : SWIGINTERN PyObject *_wrap_CloseDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12195 33 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12196 33 : VSIDIR *arg1 = (VSIDIR *) 0 ;
12197 33 : void *argp1 = 0 ;
12198 33 : int res1 = 0 ;
12199 33 : PyObject *swig_obj[1] ;
12200 :
12201 33 : if (!args) SWIG_fail;
12202 33 : swig_obj[0] = args;
12203 33 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_VSIDIR, 0 | 0 );
12204 33 : if (!SWIG_IsOK(res1)) {
12205 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseDir" "', argument " "1"" of type '" "VSIDIR *""'");
12206 : }
12207 33 : arg1 = reinterpret_cast< VSIDIR * >(argp1);
12208 33 : {
12209 33 : if (!arg1) {
12210 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12211 : }
12212 : }
12213 33 : {
12214 33 : const int bLocalUseExceptions = GetUseExceptions();
12215 33 : if ( bLocalUseExceptions ) {
12216 0 : pushErrorHandler();
12217 : }
12218 33 : {
12219 33 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12220 33 : VSICloseDir(arg1);
12221 33 : SWIG_PYTHON_THREAD_END_ALLOW;
12222 : }
12223 33 : if ( bLocalUseExceptions ) {
12224 0 : popErrorHandler();
12225 : }
12226 : #ifndef SED_HACKS
12227 : if ( bLocalUseExceptions ) {
12228 : CPLErr eclass = CPLGetLastErrorType();
12229 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12230 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12231 : }
12232 : }
12233 : #endif
12234 : }
12235 33 : resultobj = SWIG_Py_Void();
12236 33 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12237 : return resultobj;
12238 : fail:
12239 : return NULL;
12240 : }
12241 :
12242 :
12243 4211 : SWIGINTERN PyObject *_wrap_SetConfigOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12244 4211 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12245 4211 : char *arg1 = (char *) 0 ;
12246 4211 : char *arg2 = (char *) 0 ;
12247 4211 : int res1 ;
12248 4211 : char *buf1 = 0 ;
12249 4211 : int alloc1 = 0 ;
12250 4211 : int res2 ;
12251 4211 : char *buf2 = 0 ;
12252 4211 : int alloc2 = 0 ;
12253 4211 : PyObject *swig_obj[2] ;
12254 :
12255 4211 : if (!SWIG_Python_UnpackTuple(args, "SetConfigOption", 2, 2, swig_obj)) SWIG_fail;
12256 4211 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12257 4211 : if (!SWIG_IsOK(res1)) {
12258 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetConfigOption" "', argument " "1"" of type '" "char const *""'");
12259 : }
12260 4211 : arg1 = reinterpret_cast< char * >(buf1);
12261 4211 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
12262 4211 : if (!SWIG_IsOK(res2)) {
12263 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetConfigOption" "', argument " "2"" of type '" "char const *""'");
12264 : }
12265 4211 : arg2 = reinterpret_cast< char * >(buf2);
12266 4211 : {
12267 4211 : if (!arg1) {
12268 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12269 : }
12270 : }
12271 4211 : {
12272 4211 : const int bLocalUseExceptions = GetUseExceptions();
12273 4211 : if ( bLocalUseExceptions ) {
12274 227 : pushErrorHandler();
12275 : }
12276 4211 : {
12277 4211 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12278 4211 : CPLSetConfigOption((char const *)arg1,(char const *)arg2);
12279 4211 : SWIG_PYTHON_THREAD_END_ALLOW;
12280 : }
12281 4211 : if ( bLocalUseExceptions ) {
12282 227 : popErrorHandler();
12283 : }
12284 : #ifndef SED_HACKS
12285 : if ( bLocalUseExceptions ) {
12286 : CPLErr eclass = CPLGetLastErrorType();
12287 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12288 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12289 : }
12290 : }
12291 : #endif
12292 : }
12293 4211 : resultobj = SWIG_Py_Void();
12294 4211 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12295 4211 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12296 4211 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12297 : return resultobj;
12298 0 : fail:
12299 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12300 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12301 : return NULL;
12302 : }
12303 :
12304 :
12305 6150 : SWIGINTERN PyObject *_wrap_SetThreadLocalConfigOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12306 6150 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12307 6150 : char *arg1 = (char *) 0 ;
12308 6150 : char *arg2 = (char *) 0 ;
12309 6150 : int res1 ;
12310 6150 : char *buf1 = 0 ;
12311 6150 : int alloc1 = 0 ;
12312 6150 : int res2 ;
12313 6150 : char *buf2 = 0 ;
12314 6150 : int alloc2 = 0 ;
12315 6150 : PyObject *swig_obj[2] ;
12316 :
12317 6150 : if (!SWIG_Python_UnpackTuple(args, "SetThreadLocalConfigOption", 2, 2, swig_obj)) SWIG_fail;
12318 6150 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12319 6150 : if (!SWIG_IsOK(res1)) {
12320 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetThreadLocalConfigOption" "', argument " "1"" of type '" "char const *""'");
12321 : }
12322 6150 : arg1 = reinterpret_cast< char * >(buf1);
12323 6150 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
12324 6150 : if (!SWIG_IsOK(res2)) {
12325 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetThreadLocalConfigOption" "', argument " "2"" of type '" "char const *""'");
12326 : }
12327 6150 : arg2 = reinterpret_cast< char * >(buf2);
12328 6150 : {
12329 6150 : if (!arg1) {
12330 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12331 : }
12332 : }
12333 6150 : {
12334 6150 : const int bLocalUseExceptions = GetUseExceptions();
12335 6150 : if ( bLocalUseExceptions ) {
12336 3090 : pushErrorHandler();
12337 : }
12338 6150 : {
12339 6150 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12340 6150 : CPLSetThreadLocalConfigOption((char const *)arg1,(char const *)arg2);
12341 6150 : SWIG_PYTHON_THREAD_END_ALLOW;
12342 : }
12343 6150 : if ( bLocalUseExceptions ) {
12344 3090 : popErrorHandler();
12345 : }
12346 : #ifndef SED_HACKS
12347 : if ( bLocalUseExceptions ) {
12348 : CPLErr eclass = CPLGetLastErrorType();
12349 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12350 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12351 : }
12352 : }
12353 : #endif
12354 : }
12355 6150 : resultobj = SWIG_Py_Void();
12356 6150 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12357 6150 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12358 6150 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12359 : return resultobj;
12360 0 : fail:
12361 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12362 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12363 : return NULL;
12364 : }
12365 :
12366 :
12367 22724 : SWIGINTERN PyObject *_wrap_GetConfigOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12368 22724 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12369 22724 : char *arg1 = (char *) 0 ;
12370 22724 : char *arg2 = (char *) NULL ;
12371 22724 : int res1 ;
12372 22724 : char *buf1 = 0 ;
12373 22724 : int alloc1 = 0 ;
12374 22724 : int res2 ;
12375 22724 : char *buf2 = 0 ;
12376 22724 : int alloc2 = 0 ;
12377 22724 : PyObject *swig_obj[2] ;
12378 22724 : char *result = 0 ;
12379 :
12380 22724 : if (!SWIG_Python_UnpackTuple(args, "GetConfigOption", 1, 2, swig_obj)) SWIG_fail;
12381 22724 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12382 22724 : if (!SWIG_IsOK(res1)) {
12383 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetConfigOption" "', argument " "1"" of type '" "char const *""'");
12384 : }
12385 22724 : arg1 = reinterpret_cast< char * >(buf1);
12386 22724 : if (swig_obj[1]) {
12387 1020 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
12388 1020 : if (!SWIG_IsOK(res2)) {
12389 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetConfigOption" "', argument " "2"" of type '" "char const *""'");
12390 : }
12391 1020 : arg2 = reinterpret_cast< char * >(buf2);
12392 : }
12393 22724 : {
12394 22724 : if (!arg1) {
12395 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12396 : }
12397 : }
12398 22724 : {
12399 22724 : const int bLocalUseExceptions = GetUseExceptions();
12400 22724 : if ( bLocalUseExceptions ) {
12401 22215 : pushErrorHandler();
12402 : }
12403 22724 : {
12404 22724 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12405 22724 : result = (char *)wrapper_CPLGetConfigOption((char const *)arg1,(char const *)arg2);
12406 22724 : SWIG_PYTHON_THREAD_END_ALLOW;
12407 : }
12408 22724 : if ( bLocalUseExceptions ) {
12409 22215 : popErrorHandler();
12410 : }
12411 : #ifndef SED_HACKS
12412 : if ( bLocalUseExceptions ) {
12413 : CPLErr eclass = CPLGetLastErrorType();
12414 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12415 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12416 : }
12417 : }
12418 : #endif
12419 : }
12420 22724 : resultobj = SWIG_FromCharPtr((const char *)result);
12421 22724 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12422 22724 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12423 22724 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12424 : return resultobj;
12425 0 : fail:
12426 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12427 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12428 : return NULL;
12429 : }
12430 :
12431 :
12432 1923 : SWIGINTERN PyObject *_wrap_GetGlobalConfigOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12433 1923 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12434 1923 : char *arg1 = (char *) 0 ;
12435 1923 : char *arg2 = (char *) NULL ;
12436 1923 : int res1 ;
12437 1923 : char *buf1 = 0 ;
12438 1923 : int alloc1 = 0 ;
12439 1923 : int res2 ;
12440 1923 : char *buf2 = 0 ;
12441 1923 : int alloc2 = 0 ;
12442 1923 : PyObject *swig_obj[2] ;
12443 1923 : char *result = 0 ;
12444 :
12445 1923 : if (!SWIG_Python_UnpackTuple(args, "GetGlobalConfigOption", 1, 2, swig_obj)) SWIG_fail;
12446 1923 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12447 1923 : if (!SWIG_IsOK(res1)) {
12448 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetGlobalConfigOption" "', argument " "1"" of type '" "char const *""'");
12449 : }
12450 1923 : arg1 = reinterpret_cast< char * >(buf1);
12451 1923 : if (swig_obj[1]) {
12452 0 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
12453 0 : if (!SWIG_IsOK(res2)) {
12454 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetGlobalConfigOption" "', argument " "2"" of type '" "char const *""'");
12455 : }
12456 0 : arg2 = reinterpret_cast< char * >(buf2);
12457 : }
12458 1923 : {
12459 1923 : if (!arg1) {
12460 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12461 : }
12462 : }
12463 1923 : {
12464 1923 : const int bLocalUseExceptions = GetUseExceptions();
12465 1923 : if ( bLocalUseExceptions ) {
12466 68 : pushErrorHandler();
12467 : }
12468 1923 : {
12469 1923 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12470 1923 : result = (char *)wrapper_CPLGetGlobalConfigOption((char const *)arg1,(char const *)arg2);
12471 1923 : SWIG_PYTHON_THREAD_END_ALLOW;
12472 : }
12473 1923 : if ( bLocalUseExceptions ) {
12474 68 : popErrorHandler();
12475 : }
12476 : #ifndef SED_HACKS
12477 : if ( bLocalUseExceptions ) {
12478 : CPLErr eclass = CPLGetLastErrorType();
12479 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12480 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12481 : }
12482 : }
12483 : #endif
12484 : }
12485 1923 : resultobj = SWIG_FromCharPtr((const char *)result);
12486 1923 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12487 1923 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12488 1923 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12489 : return resultobj;
12490 0 : fail:
12491 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12492 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12493 : return NULL;
12494 : }
12495 :
12496 :
12497 3080 : SWIGINTERN PyObject *_wrap_GetThreadLocalConfigOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12498 3080 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12499 3080 : char *arg1 = (char *) 0 ;
12500 3080 : char *arg2 = (char *) NULL ;
12501 3080 : int res1 ;
12502 3080 : char *buf1 = 0 ;
12503 3080 : int alloc1 = 0 ;
12504 3080 : int res2 ;
12505 3080 : char *buf2 = 0 ;
12506 3080 : int alloc2 = 0 ;
12507 3080 : PyObject *swig_obj[2] ;
12508 3080 : char *result = 0 ;
12509 :
12510 3080 : if (!SWIG_Python_UnpackTuple(args, "GetThreadLocalConfigOption", 1, 2, swig_obj)) SWIG_fail;
12511 3080 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12512 3080 : if (!SWIG_IsOK(res1)) {
12513 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetThreadLocalConfigOption" "', argument " "1"" of type '" "char const *""'");
12514 : }
12515 3080 : arg1 = reinterpret_cast< char * >(buf1);
12516 3080 : if (swig_obj[1]) {
12517 0 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
12518 0 : if (!SWIG_IsOK(res2)) {
12519 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetThreadLocalConfigOption" "', argument " "2"" of type '" "char const *""'");
12520 : }
12521 0 : arg2 = reinterpret_cast< char * >(buf2);
12522 : }
12523 3080 : {
12524 3080 : if (!arg1) {
12525 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12526 : }
12527 : }
12528 3080 : {
12529 3080 : const int bLocalUseExceptions = GetUseExceptions();
12530 3080 : if ( bLocalUseExceptions ) {
12531 1545 : pushErrorHandler();
12532 : }
12533 3080 : {
12534 3080 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12535 3080 : result = (char *)wrapper_CPLGetThreadLocalConfigOption((char const *)arg1,(char const *)arg2);
12536 3080 : SWIG_PYTHON_THREAD_END_ALLOW;
12537 : }
12538 3080 : if ( bLocalUseExceptions ) {
12539 1545 : popErrorHandler();
12540 : }
12541 : #ifndef SED_HACKS
12542 : if ( bLocalUseExceptions ) {
12543 : CPLErr eclass = CPLGetLastErrorType();
12544 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12545 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12546 : }
12547 : }
12548 : #endif
12549 : }
12550 3080 : resultobj = SWIG_FromCharPtr((const char *)result);
12551 3080 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12552 3080 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12553 3080 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12554 : return resultobj;
12555 0 : fail:
12556 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12557 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12558 : return NULL;
12559 : }
12560 :
12561 :
12562 6 : SWIGINTERN PyObject *_wrap_GetConfigOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12563 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12564 6 : char **result = 0 ;
12565 :
12566 6 : if (!SWIG_Python_UnpackTuple(args, "GetConfigOptions", 0, 0, 0)) SWIG_fail;
12567 6 : {
12568 6 : const int bLocalUseExceptions = GetUseExceptions();
12569 6 : if ( bLocalUseExceptions ) {
12570 0 : pushErrorHandler();
12571 : }
12572 6 : {
12573 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12574 6 : result = (char **)wrapper_GetConfigOptions();
12575 6 : SWIG_PYTHON_THREAD_END_ALLOW;
12576 : }
12577 6 : if ( bLocalUseExceptions ) {
12578 0 : popErrorHandler();
12579 : }
12580 : #ifndef SED_HACKS
12581 : if ( bLocalUseExceptions ) {
12582 : CPLErr eclass = CPLGetLastErrorType();
12583 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12584 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12585 : }
12586 : }
12587 : #endif
12588 : }
12589 6 : {
12590 : /* %typemap(out) char **dict */
12591 6 : resultobj = GetCSLStringAsPyDict(result, true);
12592 : }
12593 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12594 : return resultobj;
12595 0 : fail:
12596 0 : return NULL;
12597 : }
12598 :
12599 :
12600 31 : SWIGINTERN PyObject *_wrap_SetPathSpecificOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12601 31 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12602 31 : char *arg1 = (char *) 0 ;
12603 31 : char *arg2 = (char *) 0 ;
12604 31 : char *arg3 = (char *) 0 ;
12605 31 : int res1 ;
12606 31 : char *buf1 = 0 ;
12607 31 : int alloc1 = 0 ;
12608 31 : int res2 ;
12609 31 : char *buf2 = 0 ;
12610 31 : int alloc2 = 0 ;
12611 31 : int res3 ;
12612 31 : char *buf3 = 0 ;
12613 31 : int alloc3 = 0 ;
12614 31 : PyObject *swig_obj[3] ;
12615 :
12616 31 : if (!SWIG_Python_UnpackTuple(args, "SetPathSpecificOption", 3, 3, swig_obj)) SWIG_fail;
12617 31 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12618 31 : if (!SWIG_IsOK(res1)) {
12619 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetPathSpecificOption" "', argument " "1"" of type '" "char const *""'");
12620 : }
12621 31 : arg1 = reinterpret_cast< char * >(buf1);
12622 31 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
12623 31 : if (!SWIG_IsOK(res2)) {
12624 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetPathSpecificOption" "', argument " "2"" of type '" "char const *""'");
12625 : }
12626 31 : arg2 = reinterpret_cast< char * >(buf2);
12627 31 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
12628 31 : if (!SWIG_IsOK(res3)) {
12629 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SetPathSpecificOption" "', argument " "3"" of type '" "char const *""'");
12630 : }
12631 31 : arg3 = reinterpret_cast< char * >(buf3);
12632 31 : {
12633 31 : if (!arg1) {
12634 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12635 : }
12636 : }
12637 30 : {
12638 30 : if (!arg2) {
12639 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12640 : }
12641 : }
12642 29 : {
12643 29 : const int bLocalUseExceptions = GetUseExceptions();
12644 29 : if ( bLocalUseExceptions ) {
12645 19 : pushErrorHandler();
12646 : }
12647 29 : {
12648 29 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12649 29 : VSISetPathSpecificOption((char const *)arg1,(char const *)arg2,(char const *)arg3);
12650 29 : SWIG_PYTHON_THREAD_END_ALLOW;
12651 : }
12652 29 : if ( bLocalUseExceptions ) {
12653 19 : popErrorHandler();
12654 : }
12655 : #ifndef SED_HACKS
12656 : if ( bLocalUseExceptions ) {
12657 : CPLErr eclass = CPLGetLastErrorType();
12658 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12659 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12660 : }
12661 : }
12662 : #endif
12663 : }
12664 29 : resultobj = SWIG_Py_Void();
12665 29 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12666 29 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12667 29 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
12668 31 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12669 : return resultobj;
12670 2 : fail:
12671 2 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12672 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12673 2 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
12674 : return NULL;
12675 : }
12676 :
12677 :
12678 56 : SWIGINTERN PyObject *_wrap_SetCredential(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12679 56 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12680 56 : char *arg1 = (char *) 0 ;
12681 56 : char *arg2 = (char *) 0 ;
12682 56 : char *arg3 = (char *) 0 ;
12683 56 : int res1 ;
12684 56 : char *buf1 = 0 ;
12685 56 : int alloc1 = 0 ;
12686 56 : int res2 ;
12687 56 : char *buf2 = 0 ;
12688 56 : int alloc2 = 0 ;
12689 56 : int res3 ;
12690 56 : char *buf3 = 0 ;
12691 56 : int alloc3 = 0 ;
12692 56 : PyObject *swig_obj[3] ;
12693 :
12694 56 : if (!SWIG_Python_UnpackTuple(args, "SetCredential", 3, 3, swig_obj)) SWIG_fail;
12695 56 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12696 56 : if (!SWIG_IsOK(res1)) {
12697 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCredential" "', argument " "1"" of type '" "char const *""'");
12698 : }
12699 56 : arg1 = reinterpret_cast< char * >(buf1);
12700 56 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
12701 56 : if (!SWIG_IsOK(res2)) {
12702 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCredential" "', argument " "2"" of type '" "char const *""'");
12703 : }
12704 56 : arg2 = reinterpret_cast< char * >(buf2);
12705 56 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
12706 56 : if (!SWIG_IsOK(res3)) {
12707 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SetCredential" "', argument " "3"" of type '" "char const *""'");
12708 : }
12709 56 : arg3 = reinterpret_cast< char * >(buf3);
12710 56 : {
12711 56 : if (!arg1) {
12712 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12713 : }
12714 : }
12715 56 : {
12716 56 : if (!arg2) {
12717 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12718 : }
12719 : }
12720 56 : {
12721 56 : const int bLocalUseExceptions = GetUseExceptions();
12722 56 : if ( bLocalUseExceptions ) {
12723 0 : pushErrorHandler();
12724 : }
12725 56 : {
12726 56 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12727 56 : wrapper_VSISetCredential((char const *)arg1,(char const *)arg2,(char const *)arg3);
12728 56 : SWIG_PYTHON_THREAD_END_ALLOW;
12729 : }
12730 56 : if ( bLocalUseExceptions ) {
12731 0 : popErrorHandler();
12732 : }
12733 : #ifndef SED_HACKS
12734 : if ( bLocalUseExceptions ) {
12735 : CPLErr eclass = CPLGetLastErrorType();
12736 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12737 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12738 : }
12739 : }
12740 : #endif
12741 : }
12742 56 : resultobj = SWIG_Py_Void();
12743 56 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12744 56 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12745 56 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
12746 56 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12747 : return resultobj;
12748 0 : fail:
12749 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12750 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12751 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
12752 : return NULL;
12753 : }
12754 :
12755 :
12756 0 : SWIGINTERN PyObject *_wrap_GetCredential(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12757 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12758 0 : char *arg1 = (char *) 0 ;
12759 0 : char *arg2 = (char *) 0 ;
12760 0 : char *arg3 = (char *) NULL ;
12761 0 : int res1 ;
12762 0 : char *buf1 = 0 ;
12763 0 : int alloc1 = 0 ;
12764 0 : int res2 ;
12765 0 : char *buf2 = 0 ;
12766 0 : int alloc2 = 0 ;
12767 0 : int res3 ;
12768 0 : char *buf3 = 0 ;
12769 0 : int alloc3 = 0 ;
12770 0 : PyObject *swig_obj[3] ;
12771 0 : char *result = 0 ;
12772 :
12773 0 : if (!SWIG_Python_UnpackTuple(args, "GetCredential", 2, 3, swig_obj)) SWIG_fail;
12774 0 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12775 0 : if (!SWIG_IsOK(res1)) {
12776 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetCredential" "', argument " "1"" of type '" "char const *""'");
12777 : }
12778 0 : arg1 = reinterpret_cast< char * >(buf1);
12779 0 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
12780 0 : if (!SWIG_IsOK(res2)) {
12781 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetCredential" "', argument " "2"" of type '" "char const *""'");
12782 : }
12783 0 : arg2 = reinterpret_cast< char * >(buf2);
12784 0 : if (swig_obj[2]) {
12785 0 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
12786 0 : if (!SWIG_IsOK(res3)) {
12787 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetCredential" "', argument " "3"" of type '" "char const *""'");
12788 : }
12789 0 : arg3 = reinterpret_cast< char * >(buf3);
12790 : }
12791 0 : {
12792 0 : if (!arg1) {
12793 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12794 : }
12795 : }
12796 0 : {
12797 0 : if (!arg2) {
12798 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12799 : }
12800 : }
12801 0 : {
12802 0 : const int bLocalUseExceptions = GetUseExceptions();
12803 0 : if ( bLocalUseExceptions ) {
12804 0 : pushErrorHandler();
12805 : }
12806 0 : {
12807 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12808 0 : result = (char *)wrapper_VSIGetCredential((char const *)arg1,(char const *)arg2,(char const *)arg3);
12809 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12810 : }
12811 0 : if ( bLocalUseExceptions ) {
12812 0 : popErrorHandler();
12813 : }
12814 : #ifndef SED_HACKS
12815 : if ( bLocalUseExceptions ) {
12816 : CPLErr eclass = CPLGetLastErrorType();
12817 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12818 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12819 : }
12820 : }
12821 : #endif
12822 : }
12823 0 : resultobj = SWIG_FromCharPtr((const char *)result);
12824 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12825 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12826 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
12827 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12828 : return resultobj;
12829 0 : fail:
12830 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12831 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12832 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
12833 : return NULL;
12834 : }
12835 :
12836 :
12837 12 : SWIGINTERN PyObject *_wrap_GetPathSpecificOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12838 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12839 12 : char *arg1 = (char *) 0 ;
12840 12 : char *arg2 = (char *) 0 ;
12841 12 : char *arg3 = (char *) NULL ;
12842 12 : int res1 ;
12843 12 : char *buf1 = 0 ;
12844 12 : int alloc1 = 0 ;
12845 12 : int res2 ;
12846 12 : char *buf2 = 0 ;
12847 12 : int alloc2 = 0 ;
12848 12 : int res3 ;
12849 12 : char *buf3 = 0 ;
12850 12 : int alloc3 = 0 ;
12851 12 : PyObject *swig_obj[3] ;
12852 12 : char *result = 0 ;
12853 :
12854 12 : if (!SWIG_Python_UnpackTuple(args, "GetPathSpecificOption", 2, 3, swig_obj)) SWIG_fail;
12855 12 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12856 12 : if (!SWIG_IsOK(res1)) {
12857 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetPathSpecificOption" "', argument " "1"" of type '" "char const *""'");
12858 : }
12859 12 : arg1 = reinterpret_cast< char * >(buf1);
12860 12 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
12861 12 : if (!SWIG_IsOK(res2)) {
12862 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetPathSpecificOption" "', argument " "2"" of type '" "char const *""'");
12863 : }
12864 12 : arg2 = reinterpret_cast< char * >(buf2);
12865 12 : if (swig_obj[2]) {
12866 2 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
12867 2 : if (!SWIG_IsOK(res3)) {
12868 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetPathSpecificOption" "', argument " "3"" of type '" "char const *""'");
12869 : }
12870 2 : arg3 = reinterpret_cast< char * >(buf3);
12871 : }
12872 12 : {
12873 12 : if (!arg1) {
12874 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12875 : }
12876 : }
12877 11 : {
12878 11 : if (!arg2) {
12879 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
12880 : }
12881 : }
12882 10 : {
12883 10 : const int bLocalUseExceptions = GetUseExceptions();
12884 10 : if ( bLocalUseExceptions ) {
12885 10 : pushErrorHandler();
12886 : }
12887 10 : {
12888 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12889 10 : result = (char *)wrapper_VSIGetPathSpecificOption((char const *)arg1,(char const *)arg2,(char const *)arg3);
12890 10 : SWIG_PYTHON_THREAD_END_ALLOW;
12891 : }
12892 10 : if ( bLocalUseExceptions ) {
12893 10 : popErrorHandler();
12894 : }
12895 : #ifndef SED_HACKS
12896 : if ( bLocalUseExceptions ) {
12897 : CPLErr eclass = CPLGetLastErrorType();
12898 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12899 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12900 : }
12901 : }
12902 : #endif
12903 : }
12904 10 : resultobj = SWIG_FromCharPtr((const char *)result);
12905 10 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12906 10 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12907 10 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
12908 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12909 : return resultobj;
12910 2 : fail:
12911 2 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12912 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12913 2 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
12914 : return NULL;
12915 : }
12916 :
12917 :
12918 8 : SWIGINTERN PyObject *_wrap_ClearCredentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12919 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12920 8 : char *arg1 = (char *) NULL ;
12921 8 : int res1 ;
12922 8 : char *buf1 = 0 ;
12923 8 : int alloc1 = 0 ;
12924 8 : PyObject *swig_obj[1] ;
12925 :
12926 8 : if (!SWIG_Python_UnpackTuple(args, "ClearCredentials", 0, 1, swig_obj)) SWIG_fail;
12927 8 : if (swig_obj[0]) {
12928 8 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12929 8 : if (!SWIG_IsOK(res1)) {
12930 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClearCredentials" "', argument " "1"" of type '" "char const *""'");
12931 : }
12932 8 : arg1 = reinterpret_cast< char * >(buf1);
12933 : }
12934 8 : {
12935 8 : const int bLocalUseExceptions = GetUseExceptions();
12936 8 : if ( bLocalUseExceptions ) {
12937 0 : pushErrorHandler();
12938 : }
12939 8 : {
12940 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12941 8 : wrapper_VSIClearCredentials((char const *)arg1);
12942 8 : SWIG_PYTHON_THREAD_END_ALLOW;
12943 : }
12944 8 : if ( bLocalUseExceptions ) {
12945 0 : popErrorHandler();
12946 : }
12947 : #ifndef SED_HACKS
12948 : if ( bLocalUseExceptions ) {
12949 : CPLErr eclass = CPLGetLastErrorType();
12950 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12951 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
12952 : }
12953 : }
12954 : #endif
12955 : }
12956 8 : resultobj = SWIG_Py_Void();
12957 8 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12958 8 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
12959 : return resultobj;
12960 0 : fail:
12961 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
12962 : return NULL;
12963 : }
12964 :
12965 :
12966 10 : SWIGINTERN PyObject *_wrap_ClearPathSpecificOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12967 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
12968 10 : char *arg1 = (char *) NULL ;
12969 10 : int res1 ;
12970 10 : char *buf1 = 0 ;
12971 10 : int alloc1 = 0 ;
12972 10 : PyObject *swig_obj[1] ;
12973 :
12974 10 : if (!SWIG_Python_UnpackTuple(args, "ClearPathSpecificOptions", 0, 1, swig_obj)) SWIG_fail;
12975 10 : if (swig_obj[0]) {
12976 7 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12977 7 : if (!SWIG_IsOK(res1)) {
12978 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClearPathSpecificOptions" "', argument " "1"" of type '" "char const *""'");
12979 : }
12980 7 : arg1 = reinterpret_cast< char * >(buf1);
12981 : }
12982 10 : {
12983 10 : const int bLocalUseExceptions = GetUseExceptions();
12984 10 : if ( bLocalUseExceptions ) {
12985 5 : pushErrorHandler();
12986 : }
12987 10 : {
12988 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12989 10 : wrapper_VSIClearPathSpecificOptions((char const *)arg1);
12990 10 : SWIG_PYTHON_THREAD_END_ALLOW;
12991 : }
12992 10 : if ( bLocalUseExceptions ) {
12993 5 : popErrorHandler();
12994 : }
12995 : #ifndef SED_HACKS
12996 : if ( bLocalUseExceptions ) {
12997 : CPLErr eclass = CPLGetLastErrorType();
12998 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
12999 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13000 : }
13001 : }
13002 : #endif
13003 : }
13004 10 : resultobj = SWIG_Py_Void();
13005 10 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
13006 10 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13007 : return resultobj;
13008 0 : fail:
13009 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
13010 : return NULL;
13011 : }
13012 :
13013 :
13014 0 : SWIGINTERN PyObject *_wrap_CPLBinaryToHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13015 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13016 0 : int arg1 ;
13017 0 : GByte *arg2 = (GByte *) 0 ;
13018 0 : int alloc1 = 0 ;
13019 0 : bool viewIsValid1 = false ;
13020 0 : Py_buffer view1 ;
13021 0 : PyObject *swig_obj[1] ;
13022 0 : retStringAndCPLFree *result = 0 ;
13023 :
13024 0 : if (!args) SWIG_fail;
13025 0 : swig_obj[0] = args;
13026 0 : {
13027 : /* %typemap(in,numinputs=1) (int nLen, char *pBuf ) */
13028 0 : char* ptr = NULL;
13029 0 : if( !GetBufferAsCharPtrIntSize(swig_obj[0], &arg1, &ptr, &alloc1, &viewIsValid1, &view1) ) {
13030 0 : SWIG_fail;
13031 : }
13032 0 : arg2 = (GByte *)ptr;
13033 : }
13034 0 : {
13035 0 : const int bLocalUseExceptions = GetUseExceptions();
13036 0 : if ( bLocalUseExceptions ) {
13037 0 : pushErrorHandler();
13038 : }
13039 0 : {
13040 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13041 0 : result = (retStringAndCPLFree *)CPLBinaryToHex(arg1,(GByte const *)arg2);
13042 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13043 : }
13044 0 : if ( bLocalUseExceptions ) {
13045 0 : popErrorHandler();
13046 : }
13047 : #ifndef SED_HACKS
13048 : if ( bLocalUseExceptions ) {
13049 : CPLErr eclass = CPLGetLastErrorType();
13050 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13051 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13052 : }
13053 : }
13054 : #endif
13055 : }
13056 0 : {
13057 : /* %typemap(out) (retStringAndCPLFree*) */
13058 0 : Py_XDECREF(resultobj);
13059 0 : if(result)
13060 : {
13061 0 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
13062 0 : CPLFree(result);
13063 : }
13064 : else
13065 : {
13066 0 : resultobj = Py_None;
13067 0 : Py_INCREF(resultobj);
13068 : }
13069 : }
13070 0 : {
13071 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
13072 0 : if( viewIsValid1 ) {
13073 0 : PyBuffer_Release(&view1);
13074 : }
13075 0 : else if (ReturnSame(alloc1) == SWIG_NEWOBJ ) {
13076 0 : delete[] arg2;
13077 : }
13078 : }
13079 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13080 : return resultobj;
13081 0 : fail:
13082 0 : {
13083 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
13084 0 : if( viewIsValid1 ) {
13085 0 : PyBuffer_Release(&view1);
13086 : }
13087 0 : else if (ReturnSame(alloc1) == SWIG_NEWOBJ ) {
13088 : delete[] arg2;
13089 : }
13090 : }
13091 : return NULL;
13092 : }
13093 :
13094 :
13095 0 : SWIGINTERN PyObject *_wrap_CPLHexToBinary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13096 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13097 0 : char *arg1 = (char *) 0 ;
13098 0 : int *arg2 = (int *) 0 ;
13099 0 : int res1 ;
13100 0 : char *buf1 = 0 ;
13101 0 : int alloc1 = 0 ;
13102 0 : void *argp2 = 0 ;
13103 0 : int res2 = 0 ;
13104 0 : PyObject *swig_obj[2] ;
13105 0 : GByte *result = 0 ;
13106 :
13107 0 : if (!SWIG_Python_UnpackTuple(args, "CPLHexToBinary", 2, 2, swig_obj)) SWIG_fail;
13108 0 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
13109 0 : if (!SWIG_IsOK(res1)) {
13110 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPLHexToBinary" "', argument " "1"" of type '" "char const *""'");
13111 : }
13112 0 : arg1 = reinterpret_cast< char * >(buf1);
13113 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
13114 0 : if (!SWIG_IsOK(res2)) {
13115 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPLHexToBinary" "', argument " "2"" of type '" "int *""'");
13116 : }
13117 0 : arg2 = reinterpret_cast< int * >(argp2);
13118 0 : {
13119 0 : const int bLocalUseExceptions = GetUseExceptions();
13120 0 : if ( bLocalUseExceptions ) {
13121 0 : pushErrorHandler();
13122 : }
13123 0 : {
13124 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13125 0 : result = (GByte *)CPLHexToBinary((char const *)arg1,arg2);
13126 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13127 : }
13128 0 : if ( bLocalUseExceptions ) {
13129 0 : popErrorHandler();
13130 : }
13131 : #ifndef SED_HACKS
13132 : if ( bLocalUseExceptions ) {
13133 : CPLErr eclass = CPLGetLastErrorType();
13134 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13135 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13136 : }
13137 : }
13138 : #endif
13139 : }
13140 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GByte, 0 | 0 );
13141 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
13142 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13143 : return resultobj;
13144 0 : fail:
13145 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
13146 : return NULL;
13147 : }
13148 :
13149 :
13150 3605 : SWIGINTERN PyObject *_wrap_FileFromMemBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13151 3605 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13152 3605 : char *arg1 = (char *) 0 ;
13153 3605 : GIntBig arg2 ;
13154 3605 : char *arg3 = (char *) 0 ;
13155 3605 : int bToFree1 = 0 ;
13156 3605 : int alloc2 = 0 ;
13157 3605 : bool viewIsValid2 = false ;
13158 3605 : Py_buffer view2 ;
13159 3605 : PyObject *swig_obj[2] ;
13160 3605 : VSI_RETVAL result;
13161 :
13162 3605 : if (!SWIG_Python_UnpackTuple(args, "FileFromMemBuffer", 2, 2, swig_obj)) SWIG_fail;
13163 3605 : {
13164 : /* %typemap(in) (const char *utf8_path) */
13165 3605 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
13166 : {
13167 1769 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
13168 : }
13169 : else
13170 : {
13171 1836 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
13172 :
13173 : }
13174 3605 : if (arg1 == NULL)
13175 : {
13176 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
13177 0 : SWIG_fail;
13178 : }
13179 : }
13180 3605 : {
13181 : /* %typemap(in,numinputs=1) (GIntBig nLen, char *pBuf ) */
13182 3605 : char* ptr = NULL;
13183 3605 : if( !GetBufferAsCharPtrGIntBigSize(swig_obj[1], &arg2, &ptr, &alloc2, &viewIsValid2, &view2) ) {
13184 0 : SWIG_fail;
13185 : }
13186 3605 : arg3 = (char *)ptr;
13187 : }
13188 3605 : {
13189 3605 : if (!arg1) {
13190 3605 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
13191 : }
13192 : }
13193 3605 : {
13194 3605 : const int bLocalUseExceptions = GetUseExceptions();
13195 3605 : if ( bLocalUseExceptions ) {
13196 1268 : pushErrorHandler();
13197 : }
13198 3605 : {
13199 3605 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13200 3605 : result = wrapper_VSIFileFromMemBuffer((char const *)arg1,arg2,(char const *)arg3);
13201 3605 : SWIG_PYTHON_THREAD_END_ALLOW;
13202 : }
13203 3605 : if ( bLocalUseExceptions ) {
13204 1268 : popErrorHandler();
13205 : }
13206 : #ifndef SED_HACKS
13207 : if ( bLocalUseExceptions ) {
13208 : CPLErr eclass = CPLGetLastErrorType();
13209 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13210 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13211 : }
13212 : }
13213 : #endif
13214 : }
13215 3605 : {
13216 : /* %typemap(out) VSI_RETVAL */
13217 3606 : if ( result != 0 && GetUseExceptions()) {
13218 0 : const char* pszMessage = CPLGetLastErrorMsg();
13219 0 : if( pszMessage[0] != '\0' )
13220 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13221 : else
13222 0 : PyErr_SetString( PyExc_RuntimeError, "unknown error occurred" );
13223 0 : SWIG_fail;
13224 : }
13225 : }
13226 3605 : {
13227 : /* %typemap(freearg) (const char *utf8_path) */
13228 3605 : GDALPythonFreeCStr(arg1, bToFree1);
13229 : }
13230 3605 : {
13231 : /* %typemap(freearg) (GIntBig *nLen, char *pBuf ) */
13232 3605 : if( viewIsValid2 ) {
13233 1253 : PyBuffer_Release(&view2);
13234 : }
13235 2352 : else if (ReturnSame(alloc2) == SWIG_NEWOBJ ) {
13236 2352 : delete[] arg3;
13237 : }
13238 : }
13239 3605 : {
13240 : /* %typemap(ret) VSI_RETVAL */
13241 3605 : resultobj = PyInt_FromLong( result );
13242 : }
13243 3605 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13244 : return resultobj;
13245 0 : fail:
13246 0 : {
13247 : /* %typemap(freearg) (const char *utf8_path) */
13248 0 : GDALPythonFreeCStr(arg1, bToFree1);
13249 : }
13250 0 : {
13251 : /* %typemap(freearg) (GIntBig *nLen, char *pBuf ) */
13252 0 : if( viewIsValid2 ) {
13253 0 : PyBuffer_Release(&view2);
13254 : }
13255 3605 : else if (ReturnSame(alloc2) == SWIG_NEWOBJ ) {
13256 0 : delete[] arg3;
13257 : }
13258 : }
13259 : return NULL;
13260 : }
13261 :
13262 :
13263 7689 : SWIGINTERN PyObject *_wrap_Unlink(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13264 7689 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13265 7689 : char *arg1 = (char *) 0 ;
13266 7689 : int bToFree1 = 0 ;
13267 7689 : PyObject *swig_obj[1] ;
13268 7689 : VSI_RETVAL result;
13269 :
13270 7689 : if (!args) SWIG_fail;
13271 7689 : swig_obj[0] = args;
13272 7689 : {
13273 : /* %typemap(in) (const char *utf8_path) */
13274 7689 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
13275 : {
13276 6837 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
13277 : }
13278 : else
13279 : {
13280 852 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
13281 :
13282 : }
13283 7689 : if (arg1 == NULL)
13284 : {
13285 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
13286 0 : SWIG_fail;
13287 : }
13288 : }
13289 7689 : {
13290 7689 : if (!arg1) {
13291 7689 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
13292 : }
13293 : }
13294 7689 : {
13295 7689 : const int bLocalUseExceptions = GetUseExceptions();
13296 7689 : if ( bLocalUseExceptions ) {
13297 1441 : pushErrorHandler();
13298 : }
13299 7689 : {
13300 7689 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13301 7689 : result = VSIUnlink((char const *)arg1);
13302 7689 : SWIG_PYTHON_THREAD_END_ALLOW;
13303 : }
13304 7689 : if ( bLocalUseExceptions ) {
13305 1441 : popErrorHandler();
13306 : }
13307 : #ifndef SED_HACKS
13308 : if ( bLocalUseExceptions ) {
13309 : CPLErr eclass = CPLGetLastErrorType();
13310 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13311 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13312 : }
13313 : }
13314 : #endif
13315 : }
13316 7689 : {
13317 : /* %typemap(out) VSI_RETVAL */
13318 8248 : if ( result != 0 && GetUseExceptions()) {
13319 27 : const char* pszMessage = CPLGetLastErrorMsg();
13320 27 : if( pszMessage[0] != '\0' )
13321 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13322 : else
13323 27 : PyErr_SetString( PyExc_RuntimeError, "unknown error occurred" );
13324 27 : SWIG_fail;
13325 : }
13326 : }
13327 7662 : {
13328 : /* %typemap(freearg) (const char *utf8_path) */
13329 7662 : GDALPythonFreeCStr(arg1, bToFree1);
13330 : }
13331 7662 : {
13332 : /* %typemap(ret) VSI_RETVAL */
13333 7662 : resultobj = PyInt_FromLong( result );
13334 : }
13335 7662 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13336 : return resultobj;
13337 27 : fail:
13338 27 : {
13339 : /* %typemap(freearg) (const char *utf8_path) */
13340 7716 : GDALPythonFreeCStr(arg1, bToFree1);
13341 : }
13342 : return NULL;
13343 : }
13344 :
13345 :
13346 11 : SWIGINTERN PyObject *_wrap_UnlinkBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13347 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13348 11 : char **arg1 = (char **) 0 ;
13349 11 : PyObject *swig_obj[1] ;
13350 11 : bool result;
13351 :
13352 11 : if (!args) SWIG_fail;
13353 11 : swig_obj[0] = args;
13354 11 : {
13355 : /* %typemap(in) char **dict */
13356 11 : arg1 = NULL;
13357 11 : if ( PySequence_Check( swig_obj[0] ) ) {
13358 11 : int bErr = FALSE;
13359 11 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
13360 11 : if ( bErr )
13361 : {
13362 0 : SWIG_fail;
13363 : }
13364 : }
13365 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
13366 0 : int bErr = FALSE;
13367 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
13368 0 : if ( bErr )
13369 : {
13370 0 : SWIG_fail;
13371 : }
13372 : }
13373 : else {
13374 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
13375 0 : SWIG_fail;
13376 : }
13377 : }
13378 11 : {
13379 11 : const int bLocalUseExceptions = GetUseExceptions();
13380 11 : if ( bLocalUseExceptions ) {
13381 0 : pushErrorHandler();
13382 : }
13383 11 : {
13384 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13385 11 : result = (bool)wrapper_VSIUnlinkBatch(arg1);
13386 11 : SWIG_PYTHON_THREAD_END_ALLOW;
13387 : }
13388 11 : if ( bLocalUseExceptions ) {
13389 0 : popErrorHandler();
13390 : }
13391 : #ifndef SED_HACKS
13392 : if ( bLocalUseExceptions ) {
13393 : CPLErr eclass = CPLGetLastErrorType();
13394 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13395 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13396 : }
13397 : }
13398 : #endif
13399 : }
13400 11 : resultobj = SWIG_From_bool(static_cast< bool >(result));
13401 11 : {
13402 : /* %typemap(freearg) char **dict */
13403 11 : CSLDestroy( arg1 );
13404 : }
13405 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13406 : return resultobj;
13407 0 : fail:
13408 0 : {
13409 : /* %typemap(freearg) char **dict */
13410 0 : CSLDestroy( arg1 );
13411 : }
13412 : return NULL;
13413 : }
13414 :
13415 :
13416 0 : SWIGINTERN PyObject *_wrap_HasThreadSupport(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13417 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13418 0 : int result;
13419 :
13420 0 : if (!SWIG_Python_UnpackTuple(args, "HasThreadSupport", 0, 0, 0)) SWIG_fail;
13421 0 : {
13422 0 : const int bLocalUseExceptions = GetUseExceptions();
13423 0 : if ( bLocalUseExceptions ) {
13424 0 : pushErrorHandler();
13425 : }
13426 0 : {
13427 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13428 0 : result = (int)wrapper_HasThreadSupport();
13429 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13430 : }
13431 0 : if ( bLocalUseExceptions ) {
13432 0 : popErrorHandler();
13433 : }
13434 : #ifndef SED_HACKS
13435 : if ( bLocalUseExceptions ) {
13436 : CPLErr eclass = CPLGetLastErrorType();
13437 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13438 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13439 : }
13440 : }
13441 : #endif
13442 : }
13443 0 : resultobj = SWIG_From_int(static_cast< int >(result));
13444 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13445 : return resultobj;
13446 0 : fail:
13447 0 : return NULL;
13448 : }
13449 :
13450 :
13451 2 : SWIGINTERN PyObject *_wrap_GetCurrentThreadCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13452 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13453 2 : int result;
13454 :
13455 2 : if (!SWIG_Python_UnpackTuple(args, "GetCurrentThreadCount", 0, 0, 0)) SWIG_fail;
13456 2 : {
13457 2 : const int bLocalUseExceptions = GetUseExceptions();
13458 2 : if ( bLocalUseExceptions ) {
13459 2 : pushErrorHandler();
13460 : }
13461 2 : {
13462 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13463 2 : result = (int)CPLGetCurrentThreadCount();
13464 2 : SWIG_PYTHON_THREAD_END_ALLOW;
13465 : }
13466 2 : if ( bLocalUseExceptions ) {
13467 2 : 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 2 : resultobj = SWIG_From_int(static_cast< int >(result));
13479 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13480 : return resultobj;
13481 0 : fail:
13482 0 : return NULL;
13483 : }
13484 :
13485 :
13486 5200 : SWIGINTERN PyObject *_wrap_Mkdir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13487 5200 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13488 5200 : char *arg1 = (char *) 0 ;
13489 5200 : int arg2 ;
13490 5200 : int bToFree1 = 0 ;
13491 5200 : int val2 ;
13492 5200 : int ecode2 = 0 ;
13493 5200 : PyObject *swig_obj[2] ;
13494 5200 : VSI_RETVAL result;
13495 :
13496 5200 : if (!SWIG_Python_UnpackTuple(args, "Mkdir", 2, 2, swig_obj)) SWIG_fail;
13497 5200 : {
13498 : /* %typemap(in) (const char *utf8_path) */
13499 5200 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
13500 : {
13501 4908 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
13502 : }
13503 : else
13504 : {
13505 292 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
13506 :
13507 : }
13508 5200 : if (arg1 == NULL)
13509 : {
13510 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
13511 0 : SWIG_fail;
13512 : }
13513 : }
13514 5200 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13515 5200 : if (!SWIG_IsOK(ecode2)) {
13516 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mkdir" "', argument " "2"" of type '" "int""'");
13517 : }
13518 5200 : arg2 = static_cast< int >(val2);
13519 5200 : {
13520 5200 : if (!arg1) {
13521 5200 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
13522 : }
13523 : }
13524 5200 : {
13525 5200 : const int bLocalUseExceptions = GetUseExceptions();
13526 5200 : if ( bLocalUseExceptions ) {
13527 1826 : pushErrorHandler();
13528 : }
13529 5200 : {
13530 5200 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13531 5200 : result = VSIMkdir((char const *)arg1,arg2);
13532 5200 : SWIG_PYTHON_THREAD_END_ALLOW;
13533 : }
13534 5200 : if ( bLocalUseExceptions ) {
13535 1826 : popErrorHandler();
13536 : }
13537 : #ifndef SED_HACKS
13538 : if ( bLocalUseExceptions ) {
13539 : CPLErr eclass = CPLGetLastErrorType();
13540 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13541 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13542 : }
13543 : }
13544 : #endif
13545 : }
13546 5200 : {
13547 : /* %typemap(out) VSI_RETVAL */
13548 5247 : if ( result != 0 && GetUseExceptions()) {
13549 0 : const char* pszMessage = CPLGetLastErrorMsg();
13550 0 : if( pszMessage[0] != '\0' )
13551 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13552 : else
13553 0 : PyErr_SetString( PyExc_RuntimeError, "unknown error occurred" );
13554 0 : SWIG_fail;
13555 : }
13556 : }
13557 5200 : {
13558 : /* %typemap(freearg) (const char *utf8_path) */
13559 5200 : GDALPythonFreeCStr(arg1, bToFree1);
13560 : }
13561 5200 : {
13562 : /* %typemap(ret) VSI_RETVAL */
13563 5200 : resultobj = PyInt_FromLong( result );
13564 : }
13565 5200 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13566 : return resultobj;
13567 0 : fail:
13568 0 : {
13569 : /* %typemap(freearg) (const char *utf8_path) */
13570 5200 : GDALPythonFreeCStr(arg1, bToFree1);
13571 : }
13572 : return NULL;
13573 : }
13574 :
13575 :
13576 35 : SWIGINTERN PyObject *_wrap_Rmdir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13577 35 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13578 35 : char *arg1 = (char *) 0 ;
13579 35 : int bToFree1 = 0 ;
13580 35 : PyObject *swig_obj[1] ;
13581 35 : VSI_RETVAL result;
13582 :
13583 35 : if (!args) SWIG_fail;
13584 35 : swig_obj[0] = args;
13585 35 : {
13586 : /* %typemap(in) (const char *utf8_path) */
13587 35 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
13588 : {
13589 31 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
13590 : }
13591 : else
13592 : {
13593 4 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
13594 :
13595 : }
13596 35 : if (arg1 == NULL)
13597 : {
13598 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
13599 0 : SWIG_fail;
13600 : }
13601 : }
13602 35 : {
13603 35 : if (!arg1) {
13604 35 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
13605 : }
13606 : }
13607 35 : {
13608 35 : const int bLocalUseExceptions = GetUseExceptions();
13609 35 : if ( bLocalUseExceptions ) {
13610 2 : pushErrorHandler();
13611 : }
13612 35 : {
13613 35 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13614 35 : result = VSIRmdir((char const *)arg1);
13615 35 : SWIG_PYTHON_THREAD_END_ALLOW;
13616 : }
13617 35 : if ( bLocalUseExceptions ) {
13618 2 : popErrorHandler();
13619 : }
13620 : #ifndef SED_HACKS
13621 : if ( bLocalUseExceptions ) {
13622 : CPLErr eclass = CPLGetLastErrorType();
13623 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13624 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13625 : }
13626 : }
13627 : #endif
13628 : }
13629 35 : {
13630 : /* %typemap(out) VSI_RETVAL */
13631 52 : if ( result != 0 && GetUseExceptions()) {
13632 0 : const char* pszMessage = CPLGetLastErrorMsg();
13633 0 : if( pszMessage[0] != '\0' )
13634 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13635 : else
13636 0 : PyErr_SetString( PyExc_RuntimeError, "unknown error occurred" );
13637 0 : SWIG_fail;
13638 : }
13639 : }
13640 35 : {
13641 : /* %typemap(freearg) (const char *utf8_path) */
13642 35 : GDALPythonFreeCStr(arg1, bToFree1);
13643 : }
13644 35 : {
13645 : /* %typemap(ret) VSI_RETVAL */
13646 35 : resultobj = PyInt_FromLong( result );
13647 : }
13648 35 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13649 : return resultobj;
13650 0 : fail:
13651 0 : {
13652 : /* %typemap(freearg) (const char *utf8_path) */
13653 35 : GDALPythonFreeCStr(arg1, bToFree1);
13654 : }
13655 : return NULL;
13656 : }
13657 :
13658 :
13659 10 : SWIGINTERN PyObject *_wrap_MkdirRecursive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13660 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13661 10 : char *arg1 = (char *) 0 ;
13662 10 : int arg2 ;
13663 10 : int bToFree1 = 0 ;
13664 10 : int val2 ;
13665 10 : int ecode2 = 0 ;
13666 10 : PyObject *swig_obj[2] ;
13667 10 : VSI_RETVAL result;
13668 :
13669 10 : if (!SWIG_Python_UnpackTuple(args, "MkdirRecursive", 2, 2, swig_obj)) SWIG_fail;
13670 10 : {
13671 : /* %typemap(in) (const char *utf8_path) */
13672 10 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
13673 : {
13674 10 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
13675 : }
13676 : else
13677 : {
13678 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
13679 :
13680 : }
13681 10 : if (arg1 == NULL)
13682 : {
13683 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
13684 0 : SWIG_fail;
13685 : }
13686 : }
13687 10 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13688 10 : if (!SWIG_IsOK(ecode2)) {
13689 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MkdirRecursive" "', argument " "2"" of type '" "int""'");
13690 : }
13691 10 : arg2 = static_cast< int >(val2);
13692 10 : {
13693 10 : if (!arg1) {
13694 10 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
13695 : }
13696 : }
13697 10 : {
13698 10 : const int bLocalUseExceptions = GetUseExceptions();
13699 10 : if ( bLocalUseExceptions ) {
13700 8 : pushErrorHandler();
13701 : }
13702 10 : {
13703 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13704 10 : result = VSIMkdirRecursive((char const *)arg1,arg2);
13705 10 : SWIG_PYTHON_THREAD_END_ALLOW;
13706 : }
13707 10 : if ( bLocalUseExceptions ) {
13708 8 : popErrorHandler();
13709 : }
13710 : #ifndef SED_HACKS
13711 : if ( bLocalUseExceptions ) {
13712 : CPLErr eclass = CPLGetLastErrorType();
13713 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13714 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13715 : }
13716 : }
13717 : #endif
13718 : }
13719 10 : {
13720 : /* %typemap(out) VSI_RETVAL */
13721 10 : if ( result != 0 && GetUseExceptions()) {
13722 0 : const char* pszMessage = CPLGetLastErrorMsg();
13723 0 : if( pszMessage[0] != '\0' )
13724 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13725 : else
13726 0 : PyErr_SetString( PyExc_RuntimeError, "unknown error occurred" );
13727 0 : SWIG_fail;
13728 : }
13729 : }
13730 10 : {
13731 : /* %typemap(freearg) (const char *utf8_path) */
13732 10 : GDALPythonFreeCStr(arg1, bToFree1);
13733 : }
13734 10 : {
13735 : /* %typemap(ret) VSI_RETVAL */
13736 10 : resultobj = PyInt_FromLong( result );
13737 : }
13738 10 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13739 : return resultobj;
13740 0 : fail:
13741 0 : {
13742 : /* %typemap(freearg) (const char *utf8_path) */
13743 10 : GDALPythonFreeCStr(arg1, bToFree1);
13744 : }
13745 : return NULL;
13746 : }
13747 :
13748 :
13749 4855 : SWIGINTERN PyObject *_wrap_RmdirRecursive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13750 4855 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13751 4855 : char *arg1 = (char *) 0 ;
13752 4855 : int bToFree1 = 0 ;
13753 4855 : PyObject *swig_obj[1] ;
13754 4855 : VSI_RETVAL result;
13755 :
13756 4855 : if (!args) SWIG_fail;
13757 4855 : swig_obj[0] = args;
13758 4855 : {
13759 : /* %typemap(in) (const char *utf8_path) */
13760 4855 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
13761 : {
13762 4848 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
13763 : }
13764 : else
13765 : {
13766 7 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
13767 :
13768 : }
13769 4855 : if (arg1 == NULL)
13770 : {
13771 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
13772 0 : SWIG_fail;
13773 : }
13774 : }
13775 4855 : {
13776 4855 : if (!arg1) {
13777 4855 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
13778 : }
13779 : }
13780 4855 : {
13781 4855 : const int bLocalUseExceptions = GetUseExceptions();
13782 4855 : if ( bLocalUseExceptions ) {
13783 1780 : pushErrorHandler();
13784 : }
13785 4855 : {
13786 4855 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13787 4855 : result = VSIRmdirRecursive((char const *)arg1);
13788 4855 : SWIG_PYTHON_THREAD_END_ALLOW;
13789 : }
13790 4855 : if ( bLocalUseExceptions ) {
13791 1780 : popErrorHandler();
13792 : }
13793 : #ifndef SED_HACKS
13794 : if ( bLocalUseExceptions ) {
13795 : CPLErr eclass = CPLGetLastErrorType();
13796 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13797 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13798 : }
13799 : }
13800 : #endif
13801 : }
13802 4855 : {
13803 : /* %typemap(out) VSI_RETVAL */
13804 4866 : if ( result != 0 && GetUseExceptions()) {
13805 0 : const char* pszMessage = CPLGetLastErrorMsg();
13806 0 : if( pszMessage[0] != '\0' )
13807 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13808 : else
13809 0 : PyErr_SetString( PyExc_RuntimeError, "unknown error occurred" );
13810 0 : SWIG_fail;
13811 : }
13812 : }
13813 4855 : {
13814 : /* %typemap(freearg) (const char *utf8_path) */
13815 4855 : GDALPythonFreeCStr(arg1, bToFree1);
13816 : }
13817 4855 : {
13818 : /* %typemap(ret) VSI_RETVAL */
13819 4855 : resultobj = PyInt_FromLong( result );
13820 : }
13821 4855 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13822 : return resultobj;
13823 0 : fail:
13824 0 : {
13825 : /* %typemap(freearg) (const char *utf8_path) */
13826 4855 : GDALPythonFreeCStr(arg1, bToFree1);
13827 : }
13828 : return NULL;
13829 : }
13830 :
13831 :
13832 14 : SWIGINTERN PyObject *_wrap_Rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13833 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13834 14 : char *arg1 = (char *) 0 ;
13835 14 : char *arg2 = (char *) 0 ;
13836 14 : int bToFree1 = 0 ;
13837 14 : int bToFree2 = 0 ;
13838 14 : PyObject *swig_obj[2] ;
13839 14 : VSI_RETVAL result;
13840 :
13841 14 : if (!SWIG_Python_UnpackTuple(args, "Rename", 2, 2, swig_obj)) SWIG_fail;
13842 14 : {
13843 : /* %typemap(in) (const char *utf8_path) */
13844 14 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
13845 : {
13846 12 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
13847 : }
13848 : else
13849 : {
13850 2 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
13851 :
13852 : }
13853 14 : if (arg1 == NULL)
13854 : {
13855 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
13856 0 : SWIG_fail;
13857 : }
13858 : }
13859 14 : {
13860 : /* %typemap(in) (const char *utf8_path) */
13861 14 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
13862 : {
13863 12 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
13864 : }
13865 : else
13866 : {
13867 2 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
13868 :
13869 : }
13870 14 : if (arg2 == NULL)
13871 : {
13872 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
13873 0 : SWIG_fail;
13874 : }
13875 : }
13876 14 : {
13877 14 : if (!arg1) {
13878 14 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
13879 : }
13880 : }
13881 14 : {
13882 14 : if (!arg2) {
13883 14 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
13884 : }
13885 : }
13886 14 : {
13887 14 : const int bLocalUseExceptions = GetUseExceptions();
13888 14 : if ( bLocalUseExceptions ) {
13889 2 : pushErrorHandler();
13890 : }
13891 14 : {
13892 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13893 14 : result = VSIRename((char const *)arg1,(char const *)arg2);
13894 14 : SWIG_PYTHON_THREAD_END_ALLOW;
13895 : }
13896 14 : if ( bLocalUseExceptions ) {
13897 2 : popErrorHandler();
13898 : }
13899 : #ifndef SED_HACKS
13900 : if ( bLocalUseExceptions ) {
13901 : CPLErr eclass = CPLGetLastErrorType();
13902 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
13903 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
13904 : }
13905 : }
13906 : #endif
13907 : }
13908 14 : {
13909 : /* %typemap(out) VSI_RETVAL */
13910 16 : if ( result != 0 && GetUseExceptions()) {
13911 1 : const char* pszMessage = CPLGetLastErrorMsg();
13912 1 : if( pszMessage[0] != '\0' )
13913 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
13914 : else
13915 1 : PyErr_SetString( PyExc_RuntimeError, "unknown error occurred" );
13916 1 : SWIG_fail;
13917 : }
13918 : }
13919 13 : {
13920 : /* %typemap(freearg) (const char *utf8_path) */
13921 13 : GDALPythonFreeCStr(arg1, bToFree1);
13922 : }
13923 13 : {
13924 : /* %typemap(freearg) (const char *utf8_path) */
13925 13 : GDALPythonFreeCStr(arg2, bToFree2);
13926 : }
13927 13 : {
13928 : /* %typemap(ret) VSI_RETVAL */
13929 13 : resultobj = PyInt_FromLong( result );
13930 : }
13931 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
13932 : return resultobj;
13933 1 : fail:
13934 1 : {
13935 : /* %typemap(freearg) (const char *utf8_path) */
13936 1 : GDALPythonFreeCStr(arg1, bToFree1);
13937 : }
13938 1 : {
13939 : /* %typemap(freearg) (const char *utf8_path) */
13940 15 : GDALPythonFreeCStr(arg2, bToFree2);
13941 : }
13942 : return NULL;
13943 : }
13944 :
13945 :
13946 7 : SWIGINTERN PyObject *_wrap_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13947 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
13948 7 : char *arg1 = (char *) 0 ;
13949 7 : char *arg2 = (char *) 0 ;
13950 7 : char **arg3 = (char **) NULL ;
13951 7 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
13952 7 : void *arg5 = (void *) NULL ;
13953 7 : int bToFree1 = 0 ;
13954 7 : int bToFree2 = 0 ;
13955 7 : PyObject * obj0 = 0 ;
13956 7 : PyObject * obj1 = 0 ;
13957 7 : PyObject * obj2 = 0 ;
13958 7 : PyObject * obj3 = 0 ;
13959 7 : PyObject * obj4 = 0 ;
13960 7 : char * kwnames[] = {
13961 : (char *)"old_path", (char *)"new_path", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
13962 : };
13963 7 : VSI_RETVAL result;
13964 :
13965 : /* %typemap(arginit) ( const char* callback_data=NULL) */
13966 7 : PyProgressData *psProgressInfo;
13967 7 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
13968 7 : psProgressInfo->nLastReported = -1;
13969 7 : psProgressInfo->psPyCallback = NULL;
13970 7 : psProgressInfo->psPyCallbackData = NULL;
13971 7 : arg5 = psProgressInfo;
13972 7 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:Move", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
13973 7 : {
13974 : /* %typemap(in) (const char *utf8_path) */
13975 7 : if (PyUnicode_Check(obj0) || PyBytes_Check(obj0))
13976 : {
13977 0 : arg1 = GDALPythonObjectToCStr( obj0, &bToFree1 );
13978 : }
13979 : else
13980 : {
13981 7 : arg1 = GDALPythonPathToCStr(obj0, &bToFree1);
13982 :
13983 : }
13984 7 : if (arg1 == NULL)
13985 : {
13986 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
13987 0 : SWIG_fail;
13988 : }
13989 : }
13990 7 : {
13991 : /* %typemap(in) (const char *utf8_path) */
13992 7 : if (PyUnicode_Check(obj1) || PyBytes_Check(obj1))
13993 : {
13994 0 : arg2 = GDALPythonObjectToCStr( obj1, &bToFree2 );
13995 : }
13996 : else
13997 : {
13998 7 : arg2 = GDALPythonPathToCStr(obj1, &bToFree2);
13999 :
14000 : }
14001 7 : if (arg2 == NULL)
14002 : {
14003 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
14004 0 : SWIG_fail;
14005 : }
14006 : }
14007 7 : if (obj2) {
14008 0 : {
14009 : /* %typemap(in) char **dict */
14010 0 : arg3 = NULL;
14011 0 : if ( PySequence_Check( obj2 ) ) {
14012 0 : int bErr = FALSE;
14013 0 : arg3 = CSLFromPySequence(obj2, &bErr);
14014 0 : if ( bErr )
14015 : {
14016 0 : SWIG_fail;
14017 : }
14018 : }
14019 0 : else if ( PyMapping_Check( obj2 ) ) {
14020 0 : int bErr = FALSE;
14021 0 : arg3 = CSLFromPyMapping(obj2, &bErr);
14022 0 : if ( bErr )
14023 : {
14024 0 : SWIG_fail;
14025 : }
14026 : }
14027 : else {
14028 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
14029 0 : SWIG_fail;
14030 : }
14031 : }
14032 : }
14033 7 : if (obj3) {
14034 4 : {
14035 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
14036 : /* callback_func typemap */
14037 :
14038 : /* In some cases 0 is passed instead of None. */
14039 : /* See https://github.com/OSGeo/gdal/pull/219 */
14040 4 : if ( PyLong_Check(obj3) || PyInt_Check(obj3) )
14041 : {
14042 0 : if( PyLong_AsLong(obj3) == 0 )
14043 : {
14044 0 : obj3 = Py_None;
14045 : }
14046 : }
14047 :
14048 4 : if (obj3 && obj3 != Py_None ) {
14049 4 : void* cbfunction = NULL;
14050 4 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj3,
14051 : (void**)&cbfunction,
14052 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
14053 : SWIG_POINTER_EXCEPTION | 0 ));
14054 :
14055 4 : if ( cbfunction == GDALTermProgress ) {
14056 : arg4 = GDALTermProgress;
14057 : } else {
14058 4 : if (!PyCallable_Check(obj3)) {
14059 0 : PyErr_SetString( PyExc_RuntimeError,
14060 : "Object given is not a Python function" );
14061 0 : SWIG_fail;
14062 : }
14063 4 : psProgressInfo->psPyCallback = obj3;
14064 4 : arg4 = PyProgressProxy;
14065 : }
14066 :
14067 : }
14068 :
14069 : }
14070 : }
14071 7 : if (obj4) {
14072 0 : {
14073 : /* %typemap(in) ( void* callback_data=NULL) */
14074 0 : psProgressInfo->psPyCallbackData = obj4 ;
14075 : }
14076 : }
14077 7 : {
14078 7 : if (!arg1) {
14079 7 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
14080 : }
14081 : }
14082 7 : {
14083 7 : if (!arg2) {
14084 7 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
14085 : }
14086 : }
14087 7 : {
14088 7 : const int bLocalUseExceptions = GetUseExceptions();
14089 7 : if ( bLocalUseExceptions ) {
14090 0 : pushErrorHandler();
14091 : }
14092 7 : {
14093 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14094 7 : result = wrapper_VSIMove((char const *)arg1,(char const *)arg2,arg3,arg4,arg5);
14095 7 : SWIG_PYTHON_THREAD_END_ALLOW;
14096 : }
14097 7 : if ( bLocalUseExceptions ) {
14098 0 : popErrorHandler();
14099 : }
14100 : #ifndef SED_HACKS
14101 : if ( bLocalUseExceptions ) {
14102 : CPLErr eclass = CPLGetLastErrorType();
14103 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14104 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14105 : }
14106 : }
14107 : #endif
14108 : }
14109 7 : {
14110 : /* %typemap(out) VSI_RETVAL */
14111 8 : if ( result != 0 && GetUseExceptions()) {
14112 0 : const char* pszMessage = CPLGetLastErrorMsg();
14113 0 : if( pszMessage[0] != '\0' )
14114 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
14115 : else
14116 0 : PyErr_SetString( PyExc_RuntimeError, "unknown error occurred" );
14117 0 : SWIG_fail;
14118 : }
14119 : }
14120 7 : {
14121 : /* %typemap(freearg) (const char *utf8_path) */
14122 7 : GDALPythonFreeCStr(arg1, bToFree1);
14123 : }
14124 7 : {
14125 : /* %typemap(freearg) (const char *utf8_path) */
14126 7 : GDALPythonFreeCStr(arg2, bToFree2);
14127 : }
14128 7 : {
14129 : /* %typemap(freearg) char **dict */
14130 7 : CSLDestroy( arg3 );
14131 : }
14132 7 : {
14133 : /* %typemap(freearg) ( void* callback_data=NULL) */
14134 :
14135 7 : CPLFree(psProgressInfo);
14136 :
14137 : }
14138 7 : {
14139 : /* %typemap(ret) VSI_RETVAL */
14140 7 : resultobj = PyInt_FromLong( result );
14141 : }
14142 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14143 : return resultobj;
14144 0 : fail:
14145 0 : {
14146 : /* %typemap(freearg) (const char *utf8_path) */
14147 0 : GDALPythonFreeCStr(arg1, bToFree1);
14148 : }
14149 0 : {
14150 : /* %typemap(freearg) (const char *utf8_path) */
14151 0 : GDALPythonFreeCStr(arg2, bToFree2);
14152 : }
14153 0 : {
14154 : /* %typemap(freearg) char **dict */
14155 0 : CSLDestroy( arg3 );
14156 : }
14157 0 : {
14158 : /* %typemap(freearg) ( void* callback_data=NULL) */
14159 :
14160 0 : CPLFree(psProgressInfo);
14161 :
14162 : }
14163 : return NULL;
14164 : }
14165 :
14166 :
14167 42 : SWIGINTERN PyObject *_wrap_Sync(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14168 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14169 42 : char *arg1 = (char *) 0 ;
14170 42 : char *arg2 = (char *) 0 ;
14171 42 : char **arg3 = (char **) NULL ;
14172 42 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
14173 42 : void *arg5 = (void *) NULL ;
14174 42 : int bToFree1 = 0 ;
14175 42 : int bToFree2 = 0 ;
14176 42 : PyObject * obj0 = 0 ;
14177 42 : PyObject * obj1 = 0 ;
14178 42 : PyObject * obj2 = 0 ;
14179 42 : PyObject * obj3 = 0 ;
14180 42 : PyObject * obj4 = 0 ;
14181 42 : char * kwnames[] = {
14182 : (char *)"pszSource", (char *)"pszTarget", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
14183 : };
14184 42 : bool result;
14185 :
14186 : /* %typemap(arginit) ( const char* callback_data=NULL) */
14187 42 : PyProgressData *psProgressInfo;
14188 42 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
14189 42 : psProgressInfo->nLastReported = -1;
14190 42 : psProgressInfo->psPyCallback = NULL;
14191 42 : psProgressInfo->psPyCallbackData = NULL;
14192 42 : arg5 = psProgressInfo;
14193 42 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:Sync", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
14194 42 : {
14195 : /* %typemap(in) (const char *utf8_path) */
14196 42 : if (PyUnicode_Check(obj0) || PyBytes_Check(obj0))
14197 : {
14198 30 : arg1 = GDALPythonObjectToCStr( obj0, &bToFree1 );
14199 : }
14200 : else
14201 : {
14202 12 : arg1 = GDALPythonPathToCStr(obj0, &bToFree1);
14203 :
14204 : }
14205 42 : if (arg1 == NULL)
14206 : {
14207 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
14208 0 : SWIG_fail;
14209 : }
14210 : }
14211 42 : {
14212 : /* %typemap(in) (const char *utf8_path) */
14213 42 : if (PyUnicode_Check(obj1) || PyBytes_Check(obj1))
14214 : {
14215 31 : arg2 = GDALPythonObjectToCStr( obj1, &bToFree2 );
14216 : }
14217 : else
14218 : {
14219 11 : arg2 = GDALPythonPathToCStr(obj1, &bToFree2);
14220 :
14221 : }
14222 42 : if (arg2 == NULL)
14223 : {
14224 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
14225 0 : SWIG_fail;
14226 : }
14227 : }
14228 42 : if (obj2) {
14229 26 : {
14230 : /* %typemap(in) char **dict */
14231 26 : arg3 = NULL;
14232 26 : if ( PySequence_Check( obj2 ) ) {
14233 26 : int bErr = FALSE;
14234 26 : arg3 = CSLFromPySequence(obj2, &bErr);
14235 26 : if ( bErr )
14236 : {
14237 0 : SWIG_fail;
14238 : }
14239 : }
14240 0 : else if ( PyMapping_Check( obj2 ) ) {
14241 0 : int bErr = FALSE;
14242 0 : arg3 = CSLFromPyMapping(obj2, &bErr);
14243 0 : if ( bErr )
14244 : {
14245 0 : SWIG_fail;
14246 : }
14247 : }
14248 : else {
14249 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
14250 0 : SWIG_fail;
14251 : }
14252 : }
14253 : }
14254 42 : if (obj3) {
14255 7 : {
14256 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
14257 : /* callback_func typemap */
14258 :
14259 : /* In some cases 0 is passed instead of None. */
14260 : /* See https://github.com/OSGeo/gdal/pull/219 */
14261 7 : if ( PyLong_Check(obj3) || PyInt_Check(obj3) )
14262 : {
14263 0 : if( PyLong_AsLong(obj3) == 0 )
14264 : {
14265 0 : obj3 = Py_None;
14266 : }
14267 : }
14268 :
14269 7 : if (obj3 && obj3 != Py_None ) {
14270 7 : void* cbfunction = NULL;
14271 7 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj3,
14272 : (void**)&cbfunction,
14273 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
14274 : SWIG_POINTER_EXCEPTION | 0 ));
14275 :
14276 7 : if ( cbfunction == GDALTermProgress ) {
14277 : arg4 = GDALTermProgress;
14278 : } else {
14279 7 : if (!PyCallable_Check(obj3)) {
14280 0 : PyErr_SetString( PyExc_RuntimeError,
14281 : "Object given is not a Python function" );
14282 0 : SWIG_fail;
14283 : }
14284 7 : psProgressInfo->psPyCallback = obj3;
14285 7 : arg4 = PyProgressProxy;
14286 : }
14287 :
14288 : }
14289 :
14290 : }
14291 : }
14292 42 : if (obj4) {
14293 6 : {
14294 : /* %typemap(in) ( void* callback_data=NULL) */
14295 6 : psProgressInfo->psPyCallbackData = obj4 ;
14296 : }
14297 : }
14298 42 : {
14299 42 : if (!arg1) {
14300 42 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
14301 : }
14302 : }
14303 42 : {
14304 42 : if (!arg2) {
14305 42 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
14306 : }
14307 : }
14308 42 : {
14309 42 : const int bLocalUseExceptions = GetUseExceptions();
14310 42 : if ( bLocalUseExceptions ) {
14311 1 : pushErrorHandler();
14312 : }
14313 42 : {
14314 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14315 42 : result = (bool)wrapper_VSISync((char const *)arg1,(char const *)arg2,arg3,arg4,arg5);
14316 42 : SWIG_PYTHON_THREAD_END_ALLOW;
14317 : }
14318 42 : if ( bLocalUseExceptions ) {
14319 1 : popErrorHandler();
14320 : }
14321 : #ifndef SED_HACKS
14322 : if ( bLocalUseExceptions ) {
14323 : CPLErr eclass = CPLGetLastErrorType();
14324 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14325 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14326 : }
14327 : }
14328 : #endif
14329 : }
14330 42 : resultobj = SWIG_From_bool(static_cast< bool >(result));
14331 42 : {
14332 : /* %typemap(freearg) (const char *utf8_path) */
14333 42 : GDALPythonFreeCStr(arg1, bToFree1);
14334 : }
14335 42 : {
14336 : /* %typemap(freearg) (const char *utf8_path) */
14337 42 : GDALPythonFreeCStr(arg2, bToFree2);
14338 : }
14339 42 : {
14340 : /* %typemap(freearg) char **dict */
14341 42 : CSLDestroy( arg3 );
14342 : }
14343 42 : {
14344 : /* %typemap(freearg) ( void* callback_data=NULL) */
14345 :
14346 42 : CPLFree(psProgressInfo);
14347 :
14348 : }
14349 44 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14350 : return resultobj;
14351 0 : fail:
14352 0 : {
14353 : /* %typemap(freearg) (const char *utf8_path) */
14354 0 : GDALPythonFreeCStr(arg1, bToFree1);
14355 : }
14356 0 : {
14357 : /* %typemap(freearg) (const char *utf8_path) */
14358 0 : GDALPythonFreeCStr(arg2, bToFree2);
14359 : }
14360 0 : {
14361 : /* %typemap(freearg) char **dict */
14362 0 : CSLDestroy( arg3 );
14363 : }
14364 0 : {
14365 : /* %typemap(freearg) ( void* callback_data=NULL) */
14366 :
14367 0 : CPLFree(psProgressInfo);
14368 :
14369 : }
14370 : return NULL;
14371 : }
14372 :
14373 :
14374 1 : SWIGINTERN PyObject *_wrap_AbortPendingUploads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14375 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14376 1 : char *arg1 = (char *) 0 ;
14377 1 : int bToFree1 = 0 ;
14378 1 : PyObject *swig_obj[1] ;
14379 1 : bool result;
14380 :
14381 1 : if (!args) SWIG_fail;
14382 1 : swig_obj[0] = args;
14383 1 : {
14384 : /* %typemap(in) (const char *utf8_path) */
14385 1 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
14386 : {
14387 1 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
14388 : }
14389 : else
14390 : {
14391 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
14392 :
14393 : }
14394 1 : if (arg1 == NULL)
14395 : {
14396 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
14397 0 : SWIG_fail;
14398 : }
14399 : }
14400 1 : {
14401 1 : if (!arg1) {
14402 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
14403 : }
14404 : }
14405 1 : {
14406 1 : const int bLocalUseExceptions = GetUseExceptions();
14407 1 : if ( bLocalUseExceptions ) {
14408 0 : pushErrorHandler();
14409 : }
14410 1 : {
14411 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14412 1 : result = (bool)VSIAbortPendingUploads((char const *)arg1);
14413 1 : SWIG_PYTHON_THREAD_END_ALLOW;
14414 : }
14415 1 : if ( bLocalUseExceptions ) {
14416 0 : popErrorHandler();
14417 : }
14418 : #ifndef SED_HACKS
14419 : if ( bLocalUseExceptions ) {
14420 : CPLErr eclass = CPLGetLastErrorType();
14421 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14422 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14423 : }
14424 : }
14425 : #endif
14426 : }
14427 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
14428 1 : {
14429 : /* %typemap(freearg) (const char *utf8_path) */
14430 1 : GDALPythonFreeCStr(arg1, bToFree1);
14431 : }
14432 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14433 : return resultobj;
14434 0 : fail:
14435 0 : {
14436 : /* %typemap(freearg) (const char *utf8_path) */
14437 1 : GDALPythonFreeCStr(arg1, bToFree1);
14438 : }
14439 : return NULL;
14440 : }
14441 :
14442 :
14443 29 : SWIGINTERN PyObject *_wrap_CopyFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14444 29 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14445 29 : char *arg1 = (char *) 0 ;
14446 29 : char *arg2 = (char *) 0 ;
14447 29 : VSILFILE *arg3 = (VSILFILE *) NULL ;
14448 29 : GIntBig arg4 = (GIntBig) -1 ;
14449 29 : char **arg5 = (char **) NULL ;
14450 29 : GDALProgressFunc arg6 = (GDALProgressFunc) NULL ;
14451 29 : void *arg7 = (void *) NULL ;
14452 29 : int bToFree1 = 0 ;
14453 29 : int bToFree2 = 0 ;
14454 29 : void *argp3 = 0 ;
14455 29 : int res3 = 0 ;
14456 29 : PyObject * obj0 = 0 ;
14457 29 : PyObject * obj1 = 0 ;
14458 29 : PyObject * obj2 = 0 ;
14459 29 : PyObject * obj3 = 0 ;
14460 29 : PyObject * obj4 = 0 ;
14461 29 : PyObject * obj5 = 0 ;
14462 29 : PyObject * obj6 = 0 ;
14463 29 : char * kwnames[] = {
14464 : (char *)"pszSource", (char *)"pszTarget", (char *)"fpSource", (char *)"nSourceSize", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
14465 : };
14466 29 : int result;
14467 :
14468 : /* %typemap(arginit) ( const char* callback_data=NULL) */
14469 29 : PyProgressData *psProgressInfo;
14470 29 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
14471 29 : psProgressInfo->nLastReported = -1;
14472 29 : psProgressInfo->psPyCallback = NULL;
14473 29 : psProgressInfo->psPyCallbackData = NULL;
14474 29 : arg7 = psProgressInfo;
14475 29 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOOOO:CopyFile", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
14476 29 : {
14477 : /* %typemap(in) (const char *utf8_path_or_none) */
14478 29 : if( obj0 == Py_None )
14479 : {
14480 : arg1 = NULL;
14481 : }
14482 : else
14483 : {
14484 25 : arg1 = GDALPythonObjectToCStr( obj0, &bToFree1 );
14485 25 : if (arg1 == NULL)
14486 : {
14487 0 : PyErr_SetString( PyExc_RuntimeError, "not a string" );
14488 0 : SWIG_fail;
14489 : }
14490 : }
14491 : }
14492 29 : {
14493 : /* %typemap(in) (const char *utf8_path) */
14494 29 : if (PyUnicode_Check(obj1) || PyBytes_Check(obj1))
14495 : {
14496 18 : arg2 = GDALPythonObjectToCStr( obj1, &bToFree2 );
14497 : }
14498 : else
14499 : {
14500 11 : arg2 = GDALPythonPathToCStr(obj1, &bToFree2);
14501 :
14502 : }
14503 29 : if (arg2 == NULL)
14504 : {
14505 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
14506 0 : SWIG_fail;
14507 : }
14508 : }
14509 29 : if (obj2) {
14510 3 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_VSILFILE, 0 | 0 );
14511 3 : if (!SWIG_IsOK(res3)) {
14512 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CopyFile" "', argument " "3"" of type '" "VSILFILE *""'");
14513 : }
14514 3 : arg3 = reinterpret_cast< VSILFILE * >(argp3);
14515 : }
14516 29 : if (obj3) {
14517 0 : {
14518 0 : arg4 = (GIntBig)PyLong_AsLongLong(obj3);
14519 : }
14520 : }
14521 29 : if (obj4) {
14522 1 : {
14523 : /* %typemap(in) char **dict */
14524 1 : arg5 = NULL;
14525 1 : if ( PySequence_Check( obj4 ) ) {
14526 1 : int bErr = FALSE;
14527 1 : arg5 = CSLFromPySequence(obj4, &bErr);
14528 1 : if ( bErr )
14529 : {
14530 0 : SWIG_fail;
14531 : }
14532 : }
14533 0 : else if ( PyMapping_Check( obj4 ) ) {
14534 0 : int bErr = FALSE;
14535 0 : arg5 = CSLFromPyMapping(obj4, &bErr);
14536 0 : if ( bErr )
14537 : {
14538 0 : SWIG_fail;
14539 : }
14540 : }
14541 : else {
14542 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
14543 0 : SWIG_fail;
14544 : }
14545 : }
14546 : }
14547 29 : if (obj5) {
14548 4 : {
14549 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
14550 : /* callback_func typemap */
14551 :
14552 : /* In some cases 0 is passed instead of None. */
14553 : /* See https://github.com/OSGeo/gdal/pull/219 */
14554 4 : if ( PyLong_Check(obj5) || PyInt_Check(obj5) )
14555 : {
14556 0 : if( PyLong_AsLong(obj5) == 0 )
14557 : {
14558 0 : obj5 = Py_None;
14559 : }
14560 : }
14561 :
14562 4 : if (obj5 && obj5 != Py_None ) {
14563 4 : void* cbfunction = NULL;
14564 4 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj5,
14565 : (void**)&cbfunction,
14566 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
14567 : SWIG_POINTER_EXCEPTION | 0 ));
14568 :
14569 4 : if ( cbfunction == GDALTermProgress ) {
14570 : arg6 = GDALTermProgress;
14571 : } else {
14572 4 : if (!PyCallable_Check(obj5)) {
14573 0 : PyErr_SetString( PyExc_RuntimeError,
14574 : "Object given is not a Python function" );
14575 0 : SWIG_fail;
14576 : }
14577 4 : psProgressInfo->psPyCallback = obj5;
14578 4 : arg6 = PyProgressProxy;
14579 : }
14580 :
14581 : }
14582 :
14583 : }
14584 : }
14585 29 : if (obj6) {
14586 4 : {
14587 : /* %typemap(in) ( void* callback_data=NULL) */
14588 4 : psProgressInfo->psPyCallbackData = obj6 ;
14589 : }
14590 : }
14591 29 : {
14592 29 : if (!arg2) {
14593 29 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
14594 : }
14595 : }
14596 29 : {
14597 29 : const int bLocalUseExceptions = GetUseExceptions();
14598 29 : if ( bLocalUseExceptions ) {
14599 11 : pushErrorHandler();
14600 : }
14601 29 : {
14602 29 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14603 29 : result = (int)wrapper_VSICopyFile((char const *)arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
14604 29 : SWIG_PYTHON_THREAD_END_ALLOW;
14605 : }
14606 29 : if ( bLocalUseExceptions ) {
14607 11 : popErrorHandler();
14608 : }
14609 : #ifndef SED_HACKS
14610 : if ( bLocalUseExceptions ) {
14611 : CPLErr eclass = CPLGetLastErrorType();
14612 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14613 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14614 : }
14615 : }
14616 : #endif
14617 : }
14618 29 : resultobj = SWIG_From_int(static_cast< int >(result));
14619 29 : {
14620 : /* %typemap(freearg) (const char *utf8_path_or_none) */
14621 29 : if( arg1 != NULL )
14622 25 : GDALPythonFreeCStr(arg1, bToFree1);
14623 : }
14624 29 : {
14625 : /* %typemap(freearg) (const char *utf8_path) */
14626 29 : GDALPythonFreeCStr(arg2, bToFree2);
14627 : }
14628 29 : {
14629 : /* %typemap(freearg) char **dict */
14630 29 : CSLDestroy( arg5 );
14631 : }
14632 29 : {
14633 : /* %typemap(freearg) ( void* callback_data=NULL) */
14634 :
14635 29 : CPLFree(psProgressInfo);
14636 :
14637 : }
14638 29 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14639 : return resultobj;
14640 0 : fail:
14641 0 : {
14642 : /* %typemap(freearg) (const char *utf8_path_or_none) */
14643 0 : if( arg1 != NULL )
14644 0 : GDALPythonFreeCStr(arg1, bToFree1);
14645 : }
14646 0 : {
14647 : /* %typemap(freearg) (const char *utf8_path) */
14648 0 : GDALPythonFreeCStr(arg2, bToFree2);
14649 : }
14650 0 : {
14651 : /* %typemap(freearg) char **dict */
14652 0 : CSLDestroy( arg5 );
14653 : }
14654 0 : {
14655 : /* %typemap(freearg) ( void* callback_data=NULL) */
14656 :
14657 0 : CPLFree(psProgressInfo);
14658 :
14659 : }
14660 : return NULL;
14661 : }
14662 :
14663 :
14664 20 : SWIGINTERN PyObject *_wrap_CopyFileRestartable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14665 20 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14666 20 : char *arg1 = (char *) 0 ;
14667 20 : char *arg2 = (char *) 0 ;
14668 20 : char *arg3 = (char *) 0 ;
14669 20 : int *arg4 = (int *) 0 ;
14670 20 : char **arg5 = (char **) 0 ;
14671 20 : char **arg6 = (char **) NULL ;
14672 20 : GDALProgressFunc arg7 = (GDALProgressFunc) NULL ;
14673 20 : void *arg8 = (void *) NULL ;
14674 20 : int bToFree1 = 0 ;
14675 20 : int bToFree2 = 0 ;
14676 20 : int res3 ;
14677 20 : char *buf3 = 0 ;
14678 20 : int alloc3 = 0 ;
14679 20 : int nRetCode4 = 0 ;
14680 20 : char *pszOutputPayload4 = 0 ;
14681 20 : PyObject *swig_obj[6] ;
14682 :
14683 : /* %typemap(arginit) ( const char* callback_data=NULL) */
14684 20 : PyProgressData *psProgressInfo;
14685 20 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
14686 20 : psProgressInfo->nLastReported = -1;
14687 20 : psProgressInfo->psPyCallback = NULL;
14688 20 : psProgressInfo->psPyCallbackData = NULL;
14689 20 : arg8 = psProgressInfo;
14690 20 : {
14691 : /* %typemap(in) (int* pnRetCode, char** ppszOutputPayload) */
14692 20 : arg4 = &nRetCode4;
14693 20 : arg5 = &pszOutputPayload4;
14694 : }
14695 20 : if (!SWIG_Python_UnpackTuple(args, "CopyFileRestartable", 3, 6, swig_obj)) SWIG_fail;
14696 20 : {
14697 : /* %typemap(in) (const char *utf8_path_or_none) */
14698 20 : if( swig_obj[0] == Py_None )
14699 : {
14700 : arg1 = NULL;
14701 : }
14702 : else
14703 : {
14704 20 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
14705 20 : if (arg1 == NULL)
14706 : {
14707 0 : PyErr_SetString( PyExc_RuntimeError, "not a string" );
14708 0 : SWIG_fail;
14709 : }
14710 : }
14711 : }
14712 20 : {
14713 : /* %typemap(in) (const char *utf8_path) */
14714 20 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
14715 : {
14716 20 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
14717 : }
14718 : else
14719 : {
14720 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
14721 :
14722 : }
14723 20 : if (arg2 == NULL)
14724 : {
14725 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
14726 0 : SWIG_fail;
14727 : }
14728 : }
14729 20 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
14730 20 : if (!SWIG_IsOK(res3)) {
14731 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CopyFileRestartable" "', argument " "3"" of type '" "char const *""'");
14732 : }
14733 20 : arg3 = reinterpret_cast< char * >(buf3);
14734 20 : if (swig_obj[3]) {
14735 18 : {
14736 : /* %typemap(in) char **dict */
14737 18 : arg6 = NULL;
14738 18 : if ( PySequence_Check( swig_obj[3] ) ) {
14739 18 : int bErr = FALSE;
14740 18 : arg6 = CSLFromPySequence(swig_obj[3], &bErr);
14741 18 : if ( bErr )
14742 : {
14743 0 : SWIG_fail;
14744 : }
14745 : }
14746 0 : else if ( PyMapping_Check( swig_obj[3] ) ) {
14747 0 : int bErr = FALSE;
14748 0 : arg6 = CSLFromPyMapping(swig_obj[3], &bErr);
14749 0 : if ( bErr )
14750 : {
14751 0 : SWIG_fail;
14752 : }
14753 : }
14754 : else {
14755 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
14756 0 : SWIG_fail;
14757 : }
14758 : }
14759 : }
14760 20 : if (swig_obj[4]) {
14761 2 : {
14762 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
14763 : /* callback_func typemap */
14764 :
14765 : /* In some cases 0 is passed instead of None. */
14766 : /* See https://github.com/OSGeo/gdal/pull/219 */
14767 2 : if ( PyLong_Check(swig_obj[4]) || PyInt_Check(swig_obj[4]) )
14768 : {
14769 0 : if( PyLong_AsLong(swig_obj[4]) == 0 )
14770 : {
14771 0 : swig_obj[4] = Py_None;
14772 : }
14773 : }
14774 :
14775 2 : if (swig_obj[4] && swig_obj[4] != Py_None ) {
14776 2 : void* cbfunction = NULL;
14777 2 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[4],
14778 : (void**)&cbfunction,
14779 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
14780 : SWIG_POINTER_EXCEPTION | 0 ));
14781 :
14782 2 : if ( cbfunction == GDALTermProgress ) {
14783 : arg7 = GDALTermProgress;
14784 : } else {
14785 2 : if (!PyCallable_Check(swig_obj[4])) {
14786 0 : PyErr_SetString( PyExc_RuntimeError,
14787 : "Object given is not a Python function" );
14788 0 : SWIG_fail;
14789 : }
14790 2 : psProgressInfo->psPyCallback = swig_obj[4];
14791 2 : arg7 = PyProgressProxy;
14792 : }
14793 :
14794 : }
14795 :
14796 : }
14797 : }
14798 20 : if (swig_obj[5]) {
14799 0 : {
14800 : /* %typemap(in) ( void* callback_data=NULL) */
14801 0 : psProgressInfo->psPyCallbackData = swig_obj[5] ;
14802 : }
14803 : }
14804 20 : {
14805 20 : if (!arg2) {
14806 20 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
14807 : }
14808 : }
14809 20 : {
14810 20 : const int bLocalUseExceptions = GetUseExceptions();
14811 20 : if ( bLocalUseExceptions ) {
14812 0 : pushErrorHandler();
14813 : }
14814 20 : {
14815 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14816 20 : CopyFileRestartable((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8);
14817 20 : SWIG_PYTHON_THREAD_END_ALLOW;
14818 : }
14819 20 : if ( bLocalUseExceptions ) {
14820 0 : popErrorHandler();
14821 : }
14822 : #ifndef SED_HACKS
14823 : if ( bLocalUseExceptions ) {
14824 : CPLErr eclass = CPLGetLastErrorType();
14825 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14826 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14827 : }
14828 : }
14829 : #endif
14830 : }
14831 20 : resultobj = SWIG_Py_Void();
14832 20 : {
14833 : /* %typemap(argout) (int* pnRetCode, char** ppszOutputPayload) */
14834 20 : PyObject *r = PyTuple_New( 2 );
14835 20 : PyTuple_SetItem( r, 0, PyLong_FromLong(*arg4) );
14836 20 : if( *arg5 )
14837 : {
14838 2 : PyTuple_SetItem( r, 1, GDALPythonObjectFromCStr(*arg5) );
14839 2 : VSIFree(*arg5);
14840 : }
14841 : else
14842 : {
14843 18 : Py_INCREF(Py_None);
14844 18 : PyTuple_SetItem( r, 1, Py_None );
14845 : }
14846 : #if SWIG_VERSION >= 0x040300
14847 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
14848 : #else
14849 20 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
14850 : #endif
14851 : }
14852 20 : {
14853 : /* %typemap(freearg) (const char *utf8_path_or_none) */
14854 20 : if( arg1 != NULL )
14855 20 : GDALPythonFreeCStr(arg1, bToFree1);
14856 : }
14857 20 : {
14858 : /* %typemap(freearg) (const char *utf8_path) */
14859 20 : GDALPythonFreeCStr(arg2, bToFree2);
14860 : }
14861 20 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
14862 20 : {
14863 : /* %typemap(freearg) char **dict */
14864 20 : CSLDestroy( arg6 );
14865 : }
14866 20 : {
14867 : /* %typemap(freearg) ( void* callback_data=NULL) */
14868 :
14869 20 : CPLFree(psProgressInfo);
14870 :
14871 : }
14872 20 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14873 : return resultobj;
14874 0 : fail:
14875 0 : {
14876 : /* %typemap(freearg) (const char *utf8_path_or_none) */
14877 0 : if( arg1 != NULL )
14878 0 : GDALPythonFreeCStr(arg1, bToFree1);
14879 : }
14880 0 : {
14881 : /* %typemap(freearg) (const char *utf8_path) */
14882 0 : GDALPythonFreeCStr(arg2, bToFree2);
14883 : }
14884 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
14885 0 : {
14886 : /* %typemap(freearg) char **dict */
14887 0 : CSLDestroy( arg6 );
14888 : }
14889 0 : {
14890 : /* %typemap(freearg) ( void* callback_data=NULL) */
14891 :
14892 0 : CPLFree(psProgressInfo);
14893 :
14894 : }
14895 : return NULL;
14896 : }
14897 :
14898 :
14899 0 : SWIGINTERN PyObject *_wrap_MoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14900 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14901 0 : char *arg1 = (char *) 0 ;
14902 0 : char *arg2 = (char *) 0 ;
14903 0 : int bToFree1 = 0 ;
14904 0 : int bToFree2 = 0 ;
14905 0 : PyObject *swig_obj[2] ;
14906 0 : int result;
14907 :
14908 0 : if (!SWIG_Python_UnpackTuple(args, "MoveFile", 2, 2, swig_obj)) SWIG_fail;
14909 0 : {
14910 : /* %typemap(in) (const char *utf8_path_or_none) */
14911 0 : if( swig_obj[0] == Py_None )
14912 : {
14913 : arg1 = NULL;
14914 : }
14915 : else
14916 : {
14917 0 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
14918 0 : if (arg1 == NULL)
14919 : {
14920 0 : PyErr_SetString( PyExc_RuntimeError, "not a string" );
14921 0 : SWIG_fail;
14922 : }
14923 : }
14924 : }
14925 0 : {
14926 : /* %typemap(in) (const char *utf8_path) */
14927 0 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
14928 : {
14929 0 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
14930 : }
14931 : else
14932 : {
14933 0 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
14934 :
14935 : }
14936 0 : if (arg2 == NULL)
14937 : {
14938 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
14939 0 : SWIG_fail;
14940 : }
14941 : }
14942 0 : {
14943 0 : if (!arg2) {
14944 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
14945 : }
14946 : }
14947 0 : {
14948 0 : const int bLocalUseExceptions = GetUseExceptions();
14949 0 : if ( bLocalUseExceptions ) {
14950 0 : pushErrorHandler();
14951 : }
14952 0 : {
14953 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14954 0 : result = (int)wrapper_MoveFile((char const *)arg1,(char const *)arg2);
14955 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14956 : }
14957 0 : if ( bLocalUseExceptions ) {
14958 0 : popErrorHandler();
14959 : }
14960 : #ifndef SED_HACKS
14961 : if ( bLocalUseExceptions ) {
14962 : CPLErr eclass = CPLGetLastErrorType();
14963 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
14964 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
14965 : }
14966 : }
14967 : #endif
14968 : }
14969 0 : resultobj = SWIG_From_int(static_cast< int >(result));
14970 0 : {
14971 : /* %typemap(freearg) (const char *utf8_path_or_none) */
14972 0 : if( arg1 != NULL )
14973 0 : GDALPythonFreeCStr(arg1, bToFree1);
14974 : }
14975 0 : {
14976 : /* %typemap(freearg) (const char *utf8_path) */
14977 0 : GDALPythonFreeCStr(arg2, bToFree2);
14978 : }
14979 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
14980 : return resultobj;
14981 0 : fail:
14982 0 : {
14983 : /* %typemap(freearg) (const char *utf8_path_or_none) */
14984 0 : if( arg1 != NULL )
14985 0 : GDALPythonFreeCStr(arg1, bToFree1);
14986 : }
14987 0 : {
14988 : /* %typemap(freearg) (const char *utf8_path) */
14989 0 : GDALPythonFreeCStr(arg2, bToFree2);
14990 : }
14991 : return NULL;
14992 : }
14993 :
14994 :
14995 9 : SWIGINTERN PyObject *_wrap_GetActualURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14996 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
14997 9 : char *arg1 = (char *) 0 ;
14998 9 : int bToFree1 = 0 ;
14999 9 : PyObject *swig_obj[1] ;
15000 9 : char *result = 0 ;
15001 :
15002 9 : if (!args) SWIG_fail;
15003 9 : swig_obj[0] = args;
15004 9 : {
15005 : /* %typemap(in) (const char *utf8_path) */
15006 9 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
15007 : {
15008 9 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
15009 : }
15010 : else
15011 : {
15012 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
15013 :
15014 : }
15015 9 : if (arg1 == NULL)
15016 : {
15017 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15018 0 : SWIG_fail;
15019 : }
15020 : }
15021 9 : {
15022 9 : if (!arg1) {
15023 9 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
15024 : }
15025 : }
15026 9 : {
15027 9 : const int bLocalUseExceptions = GetUseExceptions();
15028 9 : if ( bLocalUseExceptions ) {
15029 2 : pushErrorHandler();
15030 : }
15031 9 : {
15032 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15033 9 : result = (char *)VSIGetActualURL((char const *)arg1);
15034 9 : SWIG_PYTHON_THREAD_END_ALLOW;
15035 : }
15036 9 : if ( bLocalUseExceptions ) {
15037 2 : 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 9 : resultobj = SWIG_FromCharPtr((const char *)result);
15049 9 : {
15050 : /* %typemap(freearg) (const char *utf8_path) */
15051 9 : GDALPythonFreeCStr(arg1, bToFree1);
15052 : }
15053 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15054 : return resultobj;
15055 0 : fail:
15056 0 : {
15057 : /* %typemap(freearg) (const char *utf8_path) */
15058 9 : GDALPythonFreeCStr(arg1, bToFree1);
15059 : }
15060 : return NULL;
15061 : }
15062 :
15063 :
15064 23 : SWIGINTERN PyObject *_wrap_GetSignedURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15065 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15066 23 : char *arg1 = (char *) 0 ;
15067 23 : char **arg2 = (char **) NULL ;
15068 23 : int bToFree1 = 0 ;
15069 23 : PyObject *swig_obj[2] ;
15070 23 : retStringAndCPLFree *result = 0 ;
15071 :
15072 23 : if (!SWIG_Python_UnpackTuple(args, "GetSignedURL", 1, 2, swig_obj)) SWIG_fail;
15073 23 : {
15074 : /* %typemap(in) (const char *utf8_path) */
15075 23 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
15076 : {
15077 23 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
15078 : }
15079 : else
15080 : {
15081 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
15082 :
15083 : }
15084 23 : if (arg1 == NULL)
15085 : {
15086 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15087 0 : SWIG_fail;
15088 : }
15089 : }
15090 23 : if (swig_obj[1]) {
15091 7 : {
15092 : /* %typemap(in) char **dict */
15093 7 : arg2 = NULL;
15094 7 : if ( PySequence_Check( swig_obj[1] ) ) {
15095 7 : int bErr = FALSE;
15096 7 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
15097 7 : if ( bErr )
15098 : {
15099 0 : SWIG_fail;
15100 : }
15101 : }
15102 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
15103 0 : int bErr = FALSE;
15104 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
15105 0 : if ( bErr )
15106 : {
15107 0 : SWIG_fail;
15108 : }
15109 : }
15110 : else {
15111 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
15112 0 : SWIG_fail;
15113 : }
15114 : }
15115 : }
15116 23 : {
15117 23 : if (!arg1) {
15118 23 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
15119 : }
15120 : }
15121 23 : {
15122 23 : const int bLocalUseExceptions = GetUseExceptions();
15123 23 : if ( bLocalUseExceptions ) {
15124 4 : pushErrorHandler();
15125 : }
15126 23 : {
15127 23 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15128 23 : result = (retStringAndCPLFree *)wrapper_VSIGetSignedURL((char const *)arg1,arg2);
15129 23 : SWIG_PYTHON_THREAD_END_ALLOW;
15130 : }
15131 23 : if ( bLocalUseExceptions ) {
15132 4 : popErrorHandler();
15133 : }
15134 : #ifndef SED_HACKS
15135 : if ( bLocalUseExceptions ) {
15136 : CPLErr eclass = CPLGetLastErrorType();
15137 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15138 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15139 : }
15140 : }
15141 : #endif
15142 : }
15143 23 : {
15144 : /* %typemap(out) (retStringAndCPLFree*) */
15145 23 : Py_XDECREF(resultobj);
15146 23 : if(result)
15147 : {
15148 14 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
15149 14 : CPLFree(result);
15150 : }
15151 : else
15152 : {
15153 9 : resultobj = Py_None;
15154 9 : Py_INCREF(resultobj);
15155 : }
15156 : }
15157 23 : {
15158 : /* %typemap(freearg) (const char *utf8_path) */
15159 23 : GDALPythonFreeCStr(arg1, bToFree1);
15160 : }
15161 23 : {
15162 : /* %typemap(freearg) char **dict */
15163 23 : CSLDestroy( arg2 );
15164 : }
15165 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15166 : return resultobj;
15167 0 : fail:
15168 0 : {
15169 : /* %typemap(freearg) (const char *utf8_path) */
15170 0 : GDALPythonFreeCStr(arg1, bToFree1);
15171 : }
15172 0 : {
15173 : /* %typemap(freearg) char **dict */
15174 0 : CSLDestroy( arg2 );
15175 : }
15176 : return NULL;
15177 : }
15178 :
15179 :
15180 2 : SWIGINTERN PyObject *_wrap_GetFileSystemsPrefixes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15181 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15182 2 : char **result = 0 ;
15183 :
15184 2 : if (!SWIG_Python_UnpackTuple(args, "GetFileSystemsPrefixes", 0, 0, 0)) SWIG_fail;
15185 2 : {
15186 2 : const int bLocalUseExceptions = GetUseExceptions();
15187 2 : if ( bLocalUseExceptions ) {
15188 0 : pushErrorHandler();
15189 : }
15190 2 : {
15191 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15192 2 : result = (char **)VSIGetFileSystemsPrefixes();
15193 2 : SWIG_PYTHON_THREAD_END_ALLOW;
15194 : }
15195 2 : if ( bLocalUseExceptions ) {
15196 0 : popErrorHandler();
15197 : }
15198 : #ifndef SED_HACKS
15199 : if ( bLocalUseExceptions ) {
15200 : CPLErr eclass = CPLGetLastErrorType();
15201 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15202 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15203 : }
15204 : }
15205 : #endif
15206 : }
15207 2 : {
15208 : /* %typemap(out) char **CSL -> ( string ) */
15209 2 : bool bErr = false;
15210 2 : resultobj = CSLToList(result, &bErr);
15211 2 : CSLDestroy(result);
15212 2 : if( bErr ) {
15213 0 : SWIG_fail;
15214 : }
15215 : }
15216 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15217 : return resultobj;
15218 : fail:
15219 : return NULL;
15220 : }
15221 :
15222 :
15223 30 : SWIGINTERN PyObject *_wrap_GetFileSystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15224 30 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15225 30 : char *arg1 = (char *) 0 ;
15226 30 : int bToFree1 = 0 ;
15227 30 : PyObject *swig_obj[1] ;
15228 30 : char *result = 0 ;
15229 :
15230 30 : if (!args) SWIG_fail;
15231 30 : swig_obj[0] = args;
15232 30 : {
15233 : /* %typemap(in) (const char *utf8_path) */
15234 30 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
15235 : {
15236 30 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
15237 : }
15238 : else
15239 : {
15240 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
15241 :
15242 : }
15243 30 : if (arg1 == NULL)
15244 : {
15245 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15246 0 : SWIG_fail;
15247 : }
15248 : }
15249 30 : {
15250 30 : if (!arg1) {
15251 30 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
15252 : }
15253 : }
15254 30 : {
15255 30 : const int bLocalUseExceptions = GetUseExceptions();
15256 30 : if ( bLocalUseExceptions ) {
15257 0 : pushErrorHandler();
15258 : }
15259 30 : {
15260 30 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15261 30 : result = (char *)VSIGetFileSystemOptions((char const *)arg1);
15262 30 : SWIG_PYTHON_THREAD_END_ALLOW;
15263 : }
15264 30 : if ( bLocalUseExceptions ) {
15265 0 : popErrorHandler();
15266 : }
15267 : #ifndef SED_HACKS
15268 : if ( bLocalUseExceptions ) {
15269 : CPLErr eclass = CPLGetLastErrorType();
15270 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15271 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15272 : }
15273 : }
15274 : #endif
15275 : }
15276 30 : resultobj = SWIG_FromCharPtr((const char *)result);
15277 30 : {
15278 : /* %typemap(freearg) (const char *utf8_path) */
15279 30 : GDALPythonFreeCStr(arg1, bToFree1);
15280 : }
15281 30 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15282 : return resultobj;
15283 0 : fail:
15284 0 : {
15285 : /* %typemap(freearg) (const char *utf8_path) */
15286 30 : GDALPythonFreeCStr(arg1, bToFree1);
15287 : }
15288 : return NULL;
15289 : }
15290 :
15291 :
15292 277 : SWIGINTERN PyObject *VSILFILE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15293 277 : PyObject *obj;
15294 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
15295 277 : SWIG_TypeNewClientData(SWIGTYPE_p_VSILFILE, SWIG_NewClientData(obj));
15296 277 : return SWIG_Py_Void();
15297 : }
15298 :
15299 491 : SWIGINTERN PyObject *_wrap_StatBuf_mode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15300 491 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15301 491 : StatBuf *arg1 = (StatBuf *) 0 ;
15302 491 : void *argp1 = 0 ;
15303 491 : int res1 = 0 ;
15304 491 : PyObject *swig_obj[1] ;
15305 491 : int result;
15306 :
15307 491 : if (!args) SWIG_fail;
15308 491 : swig_obj[0] = args;
15309 491 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StatBuf, 0 | 0 );
15310 491 : if (!SWIG_IsOK(res1)) {
15311 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatBuf_mode_get" "', argument " "1"" of type '" "StatBuf *""'");
15312 : }
15313 491 : arg1 = reinterpret_cast< StatBuf * >(argp1);
15314 491 : {
15315 491 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15316 491 : result = (int) ((arg1)->mode);
15317 491 : SWIG_PYTHON_THREAD_END_ALLOW;
15318 : }
15319 491 : resultobj = SWIG_From_int(static_cast< int >(result));
15320 491 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15321 : return resultobj;
15322 : fail:
15323 : return NULL;
15324 : }
15325 :
15326 :
15327 1485 : SWIGINTERN PyObject *_wrap_StatBuf_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15328 1485 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15329 1485 : StatBuf *arg1 = (StatBuf *) 0 ;
15330 1485 : void *argp1 = 0 ;
15331 1485 : int res1 = 0 ;
15332 1485 : PyObject *swig_obj[1] ;
15333 1485 : GIntBig result;
15334 :
15335 1485 : if (!args) SWIG_fail;
15336 1485 : swig_obj[0] = args;
15337 1485 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StatBuf, 0 | 0 );
15338 1485 : if (!SWIG_IsOK(res1)) {
15339 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatBuf_size_get" "', argument " "1"" of type '" "StatBuf *""'");
15340 : }
15341 1485 : arg1 = reinterpret_cast< StatBuf * >(argp1);
15342 1485 : {
15343 1485 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15344 1485 : result = ((arg1)->size);
15345 1485 : SWIG_PYTHON_THREAD_END_ALLOW;
15346 : }
15347 1485 : {
15348 1485 : resultobj = PyLong_FromLongLong(result);
15349 : }
15350 1485 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15351 : return resultobj;
15352 : fail:
15353 : return NULL;
15354 : }
15355 :
15356 :
15357 41 : SWIGINTERN PyObject *_wrap_StatBuf_mtime_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15358 41 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15359 41 : StatBuf *arg1 = (StatBuf *) 0 ;
15360 41 : void *argp1 = 0 ;
15361 41 : int res1 = 0 ;
15362 41 : PyObject *swig_obj[1] ;
15363 41 : GIntBig result;
15364 :
15365 41 : if (!args) SWIG_fail;
15366 41 : swig_obj[0] = args;
15367 41 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StatBuf, 0 | 0 );
15368 41 : if (!SWIG_IsOK(res1)) {
15369 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatBuf_mtime_get" "', argument " "1"" of type '" "StatBuf *""'");
15370 : }
15371 41 : arg1 = reinterpret_cast< StatBuf * >(argp1);
15372 41 : {
15373 41 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15374 41 : result = ((arg1)->mtime);
15375 41 : SWIG_PYTHON_THREAD_END_ALLOW;
15376 : }
15377 41 : {
15378 41 : resultobj = PyLong_FromLongLong(result);
15379 : }
15380 41 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15381 : return resultobj;
15382 : fail:
15383 : return NULL;
15384 : }
15385 :
15386 :
15387 0 : SWIGINTERN PyObject *_wrap_new_StatBuf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15388 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15389 0 : StatBuf *arg1 = (StatBuf *) 0 ;
15390 0 : void *argp1 = 0 ;
15391 0 : int res1 = 0 ;
15392 0 : PyObject *swig_obj[1] ;
15393 0 : StatBuf *result = 0 ;
15394 :
15395 0 : if (!args) SWIG_fail;
15396 0 : swig_obj[0] = args;
15397 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StatBuf, 0 | 0 );
15398 0 : if (!SWIG_IsOK(res1)) {
15399 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StatBuf" "', argument " "1"" of type '" "StatBuf *""'");
15400 : }
15401 0 : arg1 = reinterpret_cast< StatBuf * >(argp1);
15402 0 : {
15403 0 : const int bLocalUseExceptions = GetUseExceptions();
15404 0 : if ( bLocalUseExceptions ) {
15405 0 : pushErrorHandler();
15406 : }
15407 0 : {
15408 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15409 0 : result = (StatBuf *)new_StatBuf(arg1);
15410 0 : SWIG_PYTHON_THREAD_END_ALLOW;
15411 : }
15412 0 : if ( bLocalUseExceptions ) {
15413 0 : popErrorHandler();
15414 : }
15415 : #ifndef SED_HACKS
15416 : if ( bLocalUseExceptions ) {
15417 : CPLErr eclass = CPLGetLastErrorType();
15418 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15419 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15420 : }
15421 : }
15422 : #endif
15423 : }
15424 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StatBuf, SWIG_POINTER_NEW | 0 );
15425 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15426 : return resultobj;
15427 : fail:
15428 : return NULL;
15429 : }
15430 :
15431 :
15432 2336 : SWIGINTERN PyObject *_wrap_delete_StatBuf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15433 2336 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15434 2336 : StatBuf *arg1 = (StatBuf *) 0 ;
15435 2336 : void *argp1 = 0 ;
15436 2336 : int res1 = 0 ;
15437 2336 : PyObject *swig_obj[1] ;
15438 :
15439 2336 : if (!args) SWIG_fail;
15440 2336 : swig_obj[0] = args;
15441 2336 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StatBuf, SWIG_POINTER_DISOWN | 0 );
15442 2336 : if (!SWIG_IsOK(res1)) {
15443 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StatBuf" "', argument " "1"" of type '" "StatBuf *""'");
15444 : }
15445 2336 : arg1 = reinterpret_cast< StatBuf * >(argp1);
15446 2336 : {
15447 2336 : const int bLocalUseExceptions = GetUseExceptions();
15448 2336 : if ( bLocalUseExceptions ) {
15449 783 : pushErrorHandler();
15450 : }
15451 2336 : {
15452 2336 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15453 2336 : delete_StatBuf(arg1);
15454 2336 : SWIG_PYTHON_THREAD_END_ALLOW;
15455 : }
15456 2336 : if ( bLocalUseExceptions ) {
15457 783 : popErrorHandler();
15458 : }
15459 : #ifndef SED_HACKS
15460 : if ( bLocalUseExceptions ) {
15461 : CPLErr eclass = CPLGetLastErrorType();
15462 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15463 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15464 : }
15465 : }
15466 : #endif
15467 : }
15468 2336 : resultobj = SWIG_Py_Void();
15469 2336 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15470 : return resultobj;
15471 : fail:
15472 : return NULL;
15473 : }
15474 :
15475 :
15476 5 : SWIGINTERN PyObject *_wrap_StatBuf_IsDirectory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15477 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15478 5 : StatBuf *arg1 = (StatBuf *) 0 ;
15479 5 : void *argp1 = 0 ;
15480 5 : int res1 = 0 ;
15481 5 : PyObject *swig_obj[1] ;
15482 5 : int result;
15483 :
15484 5 : if (!args) SWIG_fail;
15485 5 : swig_obj[0] = args;
15486 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StatBuf, 0 | 0 );
15487 5 : if (!SWIG_IsOK(res1)) {
15488 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatBuf_IsDirectory" "', argument " "1"" of type '" "StatBuf *""'");
15489 : }
15490 5 : arg1 = reinterpret_cast< StatBuf * >(argp1);
15491 5 : {
15492 5 : const int bLocalUseExceptions = GetUseExceptions();
15493 5 : if ( bLocalUseExceptions ) {
15494 0 : pushErrorHandler();
15495 : }
15496 5 : {
15497 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15498 5 : result = (int)StatBuf_IsDirectory(arg1);
15499 5 : SWIG_PYTHON_THREAD_END_ALLOW;
15500 : }
15501 5 : if ( bLocalUseExceptions ) {
15502 0 : popErrorHandler();
15503 : }
15504 : #ifndef SED_HACKS
15505 : if ( bLocalUseExceptions ) {
15506 : CPLErr eclass = CPLGetLastErrorType();
15507 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15508 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15509 : }
15510 : }
15511 : #endif
15512 : }
15513 5 : resultobj = SWIG_From_int(static_cast< int >(result));
15514 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15515 : return resultobj;
15516 : fail:
15517 : return NULL;
15518 : }
15519 :
15520 :
15521 277 : SWIGINTERN PyObject *StatBuf_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15522 277 : PyObject *obj;
15523 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
15524 277 : SWIG_TypeNewClientData(SWIGTYPE_p_StatBuf, SWIG_NewClientData(obj));
15525 277 : return SWIG_Py_Void();
15526 : }
15527 :
15528 0 : SWIGINTERN PyObject *StatBuf_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15529 0 : return SWIG_Python_InitShadowInstance(args);
15530 : }
15531 :
15532 3862 : SWIGINTERN PyObject *_wrap_VSIStatL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15533 3862 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15534 3862 : char *arg1 = (char *) 0 ;
15535 3862 : StatBuf *arg2 = (StatBuf *) 0 ;
15536 3862 : int arg3 = (int) 0 ;
15537 3862 : int bToFree1 = 0 ;
15538 3862 : StatBuf sStatBuf2 ;
15539 3862 : int val3 ;
15540 3862 : int ecode3 = 0 ;
15541 3862 : PyObject *swig_obj[2] ;
15542 3862 : int result;
15543 :
15544 3862 : {
15545 : /* %typemap(in,numinputs=0) (StatBuf *psStatBufOut) (StatBuf sStatBuf2 ) */
15546 3862 : arg2 = &sStatBuf2;
15547 : }
15548 3862 : if (!SWIG_Python_UnpackTuple(args, "VSIStatL", 1, 2, swig_obj)) SWIG_fail;
15549 3862 : {
15550 : /* %typemap(in) (const char *utf8_path) */
15551 3862 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
15552 : {
15553 2952 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
15554 : }
15555 : else
15556 : {
15557 910 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
15558 :
15559 : }
15560 3862 : if (arg1 == NULL)
15561 : {
15562 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15563 0 : SWIG_fail;
15564 : }
15565 : }
15566 3862 : if (swig_obj[1]) {
15567 42 : ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
15568 42 : if (!SWIG_IsOK(ecode3)) {
15569 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VSIStatL" "', argument " "3"" of type '" "int""'");
15570 : }
15571 : arg3 = static_cast< int >(val3);
15572 : }
15573 3862 : {
15574 3862 : if (!arg1) {
15575 3862 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
15576 : }
15577 : }
15578 3862 : {
15579 3862 : const int bLocalUseExceptions = GetUseExceptions();
15580 3862 : if ( bLocalUseExceptions ) {
15581 1208 : pushErrorHandler();
15582 : }
15583 3862 : {
15584 3862 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15585 3862 : result = (int)wrapper_VSIStatL((char const *)arg1,arg2,arg3);
15586 3862 : SWIG_PYTHON_THREAD_END_ALLOW;
15587 : }
15588 3862 : if ( bLocalUseExceptions ) {
15589 1208 : popErrorHandler();
15590 : }
15591 : #ifndef SED_HACKS
15592 : if ( bLocalUseExceptions ) {
15593 : CPLErr eclass = CPLGetLastErrorType();
15594 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15595 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15596 : }
15597 : }
15598 : #endif
15599 : }
15600 3862 : resultobj = SWIG_From_int(static_cast< int >(result));
15601 3862 : {
15602 : /* %typemap(argout) (StatBuf *psStatBufOut)*/
15603 3862 : Py_DECREF(resultobj);
15604 3862 : if (result == 0)
15605 2336 : resultobj = SWIG_NewPointerObj((void*)new_StatBuf( arg2 ),SWIGTYPE_p_StatBuf,1);
15606 : else
15607 : {
15608 1526 : resultobj = Py_None;
15609 1526 : Py_INCREF(resultobj);
15610 : }
15611 : }
15612 3862 : {
15613 : /* %typemap(freearg) (const char *utf8_path) */
15614 3862 : GDALPythonFreeCStr(arg1, bToFree1);
15615 : }
15616 4094 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15617 : return resultobj;
15618 0 : fail:
15619 0 : {
15620 : /* %typemap(freearg) (const char *utf8_path) */
15621 3862 : GDALPythonFreeCStr(arg1, bToFree1);
15622 : }
15623 : return NULL;
15624 : }
15625 :
15626 :
15627 65 : SWIGINTERN PyObject *_wrap_GetFileMetadata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15628 65 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15629 65 : char *arg1 = (char *) 0 ;
15630 65 : char *arg2 = (char *) 0 ;
15631 65 : char **arg3 = (char **) NULL ;
15632 65 : int bToFree1 = 0 ;
15633 65 : int res2 ;
15634 65 : char *buf2 = 0 ;
15635 65 : int alloc2 = 0 ;
15636 65 : PyObject *swig_obj[3] ;
15637 65 : char **result = 0 ;
15638 :
15639 65 : if (!SWIG_Python_UnpackTuple(args, "GetFileMetadata", 2, 3, swig_obj)) SWIG_fail;
15640 65 : {
15641 : /* %typemap(in) (const char *utf8_path) */
15642 65 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
15643 : {
15644 65 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
15645 : }
15646 : else
15647 : {
15648 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
15649 :
15650 : }
15651 65 : if (arg1 == NULL)
15652 : {
15653 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15654 0 : SWIG_fail;
15655 : }
15656 : }
15657 65 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
15658 65 : if (!SWIG_IsOK(res2)) {
15659 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetFileMetadata" "', argument " "2"" of type '" "char const *""'");
15660 : }
15661 65 : arg2 = reinterpret_cast< char * >(buf2);
15662 65 : if (swig_obj[2]) {
15663 0 : {
15664 : /* %typemap(in) char **dict */
15665 0 : arg3 = NULL;
15666 0 : if ( PySequence_Check( swig_obj[2] ) ) {
15667 0 : int bErr = FALSE;
15668 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
15669 0 : if ( bErr )
15670 : {
15671 0 : SWIG_fail;
15672 : }
15673 : }
15674 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
15675 0 : int bErr = FALSE;
15676 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
15677 0 : if ( bErr )
15678 : {
15679 0 : SWIG_fail;
15680 : }
15681 : }
15682 : else {
15683 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
15684 0 : SWIG_fail;
15685 : }
15686 : }
15687 : }
15688 65 : {
15689 65 : if (!arg1) {
15690 65 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
15691 : }
15692 : }
15693 65 : {
15694 65 : const int bLocalUseExceptions = GetUseExceptions();
15695 65 : if ( bLocalUseExceptions ) {
15696 46 : pushErrorHandler();
15697 : }
15698 65 : {
15699 65 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15700 65 : result = (char **)VSIGetFileMetadata((char const *)arg1,(char const *)arg2,arg3);
15701 65 : SWIG_PYTHON_THREAD_END_ALLOW;
15702 : }
15703 65 : if ( bLocalUseExceptions ) {
15704 46 : popErrorHandler();
15705 : }
15706 : #ifndef SED_HACKS
15707 : if ( bLocalUseExceptions ) {
15708 : CPLErr eclass = CPLGetLastErrorType();
15709 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15710 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15711 : }
15712 : }
15713 : #endif
15714 : }
15715 65 : {
15716 : /* %typemap(out) char **dict */
15717 65 : resultobj = GetCSLStringAsPyDict(result, true);
15718 : }
15719 65 : {
15720 : /* %typemap(freearg) (const char *utf8_path) */
15721 65 : GDALPythonFreeCStr(arg1, bToFree1);
15722 : }
15723 65 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
15724 65 : {
15725 : /* %typemap(freearg) char **dict */
15726 65 : CSLDestroy( arg3 );
15727 : }
15728 85 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15729 : return resultobj;
15730 0 : fail:
15731 0 : {
15732 : /* %typemap(freearg) (const char *utf8_path) */
15733 0 : GDALPythonFreeCStr(arg1, bToFree1);
15734 : }
15735 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
15736 0 : {
15737 : /* %typemap(freearg) char **dict */
15738 0 : CSLDestroy( arg3 );
15739 : }
15740 : return NULL;
15741 : }
15742 :
15743 :
15744 17 : SWIGINTERN PyObject *_wrap_SetFileMetadata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15745 17 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15746 17 : char *arg1 = (char *) 0 ;
15747 17 : char **arg2 = (char **) 0 ;
15748 17 : char *arg3 = (char *) 0 ;
15749 17 : char **arg4 = (char **) NULL ;
15750 17 : int bToFree1 = 0 ;
15751 17 : int res3 ;
15752 17 : char *buf3 = 0 ;
15753 17 : int alloc3 = 0 ;
15754 17 : PyObject *swig_obj[4] ;
15755 17 : bool result;
15756 :
15757 17 : if (!SWIG_Python_UnpackTuple(args, "SetFileMetadata", 3, 4, swig_obj)) SWIG_fail;
15758 17 : {
15759 : /* %typemap(in) (const char *utf8_path) */
15760 17 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
15761 : {
15762 17 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
15763 : }
15764 : else
15765 : {
15766 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
15767 :
15768 : }
15769 17 : if (arg1 == NULL)
15770 : {
15771 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15772 0 : SWIG_fail;
15773 : }
15774 : }
15775 17 : {
15776 : /* %typemap(in) char **dict */
15777 17 : arg2 = NULL;
15778 17 : if ( PySequence_Check( swig_obj[1] ) ) {
15779 0 : int bErr = FALSE;
15780 0 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
15781 0 : if ( bErr )
15782 : {
15783 0 : SWIG_fail;
15784 : }
15785 : }
15786 17 : else if ( PyMapping_Check( swig_obj[1] ) ) {
15787 17 : int bErr = FALSE;
15788 17 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
15789 17 : if ( bErr )
15790 : {
15791 0 : SWIG_fail;
15792 : }
15793 : }
15794 : else {
15795 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
15796 0 : SWIG_fail;
15797 : }
15798 : }
15799 17 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
15800 17 : if (!SWIG_IsOK(res3)) {
15801 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SetFileMetadata" "', argument " "3"" of type '" "char const *""'");
15802 : }
15803 17 : arg3 = reinterpret_cast< char * >(buf3);
15804 17 : if (swig_obj[3]) {
15805 1 : {
15806 : /* %typemap(in) char **dict */
15807 1 : arg4 = NULL;
15808 1 : if ( PySequence_Check( swig_obj[3] ) ) {
15809 1 : int bErr = FALSE;
15810 1 : arg4 = CSLFromPySequence(swig_obj[3], &bErr);
15811 1 : if ( bErr )
15812 : {
15813 0 : SWIG_fail;
15814 : }
15815 : }
15816 0 : else if ( PyMapping_Check( swig_obj[3] ) ) {
15817 0 : int bErr = FALSE;
15818 0 : arg4 = CSLFromPyMapping(swig_obj[3], &bErr);
15819 0 : if ( bErr )
15820 : {
15821 0 : SWIG_fail;
15822 : }
15823 : }
15824 : else {
15825 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
15826 0 : SWIG_fail;
15827 : }
15828 : }
15829 : }
15830 17 : {
15831 17 : if (!arg1) {
15832 17 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
15833 : }
15834 : }
15835 17 : {
15836 17 : const int bLocalUseExceptions = GetUseExceptions();
15837 17 : if ( bLocalUseExceptions ) {
15838 0 : pushErrorHandler();
15839 : }
15840 17 : {
15841 17 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15842 17 : result = (bool)VSISetFileMetadata((char const *)arg1,arg2,(char const *)arg3,arg4);
15843 17 : SWIG_PYTHON_THREAD_END_ALLOW;
15844 : }
15845 17 : if ( bLocalUseExceptions ) {
15846 0 : popErrorHandler();
15847 : }
15848 : #ifndef SED_HACKS
15849 : if ( bLocalUseExceptions ) {
15850 : CPLErr eclass = CPLGetLastErrorType();
15851 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15852 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15853 : }
15854 : }
15855 : #endif
15856 : }
15857 17 : resultobj = SWIG_From_bool(static_cast< bool >(result));
15858 17 : {
15859 : /* %typemap(freearg) (const char *utf8_path) */
15860 17 : GDALPythonFreeCStr(arg1, bToFree1);
15861 : }
15862 17 : {
15863 : /* %typemap(freearg) char **dict */
15864 17 : CSLDestroy( arg2 );
15865 : }
15866 17 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
15867 17 : {
15868 : /* %typemap(freearg) char **dict */
15869 17 : CSLDestroy( arg4 );
15870 : }
15871 17 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15872 : return resultobj;
15873 0 : fail:
15874 0 : {
15875 : /* %typemap(freearg) (const char *utf8_path) */
15876 0 : GDALPythonFreeCStr(arg1, bToFree1);
15877 : }
15878 0 : {
15879 : /* %typemap(freearg) char **dict */
15880 0 : CSLDestroy( arg2 );
15881 : }
15882 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
15883 0 : {
15884 : /* %typemap(freearg) char **dict */
15885 0 : CSLDestroy( arg4 );
15886 : }
15887 : return NULL;
15888 : }
15889 :
15890 :
15891 4590 : SWIGINTERN PyObject *_wrap_VSIFOpenL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15892 4590 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15893 4590 : char *arg1 = (char *) 0 ;
15894 4590 : char *arg2 = (char *) 0 ;
15895 4590 : int bToFree1 = 0 ;
15896 4590 : int res2 ;
15897 4590 : char *buf2 = 0 ;
15898 4590 : int alloc2 = 0 ;
15899 4590 : PyObject *swig_obj[2] ;
15900 4590 : VSILFILE *result = 0 ;
15901 :
15902 4590 : if (!SWIG_Python_UnpackTuple(args, "VSIFOpenL", 2, 2, swig_obj)) SWIG_fail;
15903 4590 : {
15904 : /* %typemap(in) (const char *utf8_path) */
15905 4590 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
15906 : {
15907 3922 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
15908 : }
15909 : else
15910 : {
15911 668 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
15912 :
15913 : }
15914 4590 : if (arg1 == NULL)
15915 : {
15916 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
15917 0 : SWIG_fail;
15918 : }
15919 : }
15920 4590 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
15921 4590 : if (!SWIG_IsOK(res2)) {
15922 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VSIFOpenL" "', argument " "2"" of type '" "char const *""'");
15923 : }
15924 4590 : arg2 = reinterpret_cast< char * >(buf2);
15925 4590 : {
15926 4590 : if (!arg1) {
15927 4590 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
15928 : }
15929 : }
15930 4590 : {
15931 4590 : const int bLocalUseExceptions = GetUseExceptions();
15932 4590 : if ( bLocalUseExceptions ) {
15933 900 : pushErrorHandler();
15934 : }
15935 4590 : {
15936 4590 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15937 4590 : result = (VSILFILE *)wrapper_VSIFOpenL((char const *)arg1,(char const *)arg2);
15938 4590 : SWIG_PYTHON_THREAD_END_ALLOW;
15939 : }
15940 4590 : if ( bLocalUseExceptions ) {
15941 900 : popErrorHandler();
15942 : }
15943 : #ifndef SED_HACKS
15944 : if ( bLocalUseExceptions ) {
15945 : CPLErr eclass = CPLGetLastErrorType();
15946 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
15947 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
15948 : }
15949 : }
15950 : #endif
15951 : }
15952 4590 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VSILFILE, 0 | 0 );
15953 4590 : {
15954 : /* %typemap(freearg) (const char *utf8_path) */
15955 4590 : GDALPythonFreeCStr(arg1, bToFree1);
15956 : }
15957 4590 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
15958 4646 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
15959 : return resultobj;
15960 0 : fail:
15961 0 : {
15962 : /* %typemap(freearg) (const char *utf8_path) */
15963 0 : GDALPythonFreeCStr(arg1, bToFree1);
15964 : }
15965 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
15966 : return NULL;
15967 : }
15968 :
15969 :
15970 428 : SWIGINTERN PyObject *_wrap_VSIFOpenExL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15971 428 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
15972 428 : char *arg1 = (char *) 0 ;
15973 428 : char *arg2 = (char *) 0 ;
15974 428 : int arg3 = (int) FALSE ;
15975 428 : char **arg4 = (char **) NULL ;
15976 428 : int bToFree1 = 0 ;
15977 428 : int res2 ;
15978 428 : char *buf2 = 0 ;
15979 428 : int alloc2 = 0 ;
15980 428 : int val3 ;
15981 428 : int ecode3 = 0 ;
15982 428 : PyObject *swig_obj[4] ;
15983 428 : VSILFILE *result = 0 ;
15984 :
15985 428 : if (!SWIG_Python_UnpackTuple(args, "VSIFOpenExL", 2, 4, swig_obj)) SWIG_fail;
15986 428 : {
15987 : /* %typemap(in) (const char *utf8_path) */
15988 428 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
15989 : {
15990 255 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
15991 : }
15992 : else
15993 : {
15994 173 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
15995 :
15996 : }
15997 428 : if (arg1 == NULL)
15998 : {
15999 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
16000 0 : SWIG_fail;
16001 : }
16002 : }
16003 428 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
16004 428 : if (!SWIG_IsOK(res2)) {
16005 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VSIFOpenExL" "', argument " "2"" of type '" "char const *""'");
16006 : }
16007 428 : arg2 = reinterpret_cast< char * >(buf2);
16008 428 : if (swig_obj[2]) {
16009 428 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
16010 428 : if (!SWIG_IsOK(ecode3)) {
16011 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VSIFOpenExL" "', argument " "3"" of type '" "int""'");
16012 : }
16013 : arg3 = static_cast< int >(val3);
16014 : }
16015 428 : if (swig_obj[3]) {
16016 246 : {
16017 : /* %typemap(in) char **dict */
16018 246 : arg4 = NULL;
16019 246 : if ( PySequence_Check( swig_obj[3] ) ) {
16020 21 : int bErr = FALSE;
16021 21 : arg4 = CSLFromPySequence(swig_obj[3], &bErr);
16022 21 : if ( bErr )
16023 : {
16024 0 : SWIG_fail;
16025 : }
16026 : }
16027 225 : else if ( PyMapping_Check( swig_obj[3] ) ) {
16028 225 : int bErr = FALSE;
16029 225 : arg4 = CSLFromPyMapping(swig_obj[3], &bErr);
16030 225 : if ( bErr )
16031 : {
16032 0 : SWIG_fail;
16033 : }
16034 : }
16035 : else {
16036 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
16037 0 : SWIG_fail;
16038 : }
16039 : }
16040 : }
16041 428 : {
16042 428 : if (!arg1) {
16043 428 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
16044 : }
16045 : }
16046 428 : {
16047 428 : const int bLocalUseExceptions = GetUseExceptions();
16048 428 : if ( bLocalUseExceptions ) {
16049 226 : pushErrorHandler();
16050 : }
16051 428 : {
16052 428 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16053 428 : result = (VSILFILE *)wrapper_VSIFOpenExL((char const *)arg1,(char const *)arg2,arg3,arg4);
16054 428 : SWIG_PYTHON_THREAD_END_ALLOW;
16055 : }
16056 428 : if ( bLocalUseExceptions ) {
16057 226 : popErrorHandler();
16058 : }
16059 : #ifndef SED_HACKS
16060 : if ( bLocalUseExceptions ) {
16061 : CPLErr eclass = CPLGetLastErrorType();
16062 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16063 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16064 : }
16065 : }
16066 : #endif
16067 : }
16068 428 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VSILFILE, 0 | 0 );
16069 428 : {
16070 : /* %typemap(freearg) (const char *utf8_path) */
16071 428 : GDALPythonFreeCStr(arg1, bToFree1);
16072 : }
16073 428 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16074 428 : {
16075 : /* %typemap(freearg) char **dict */
16076 428 : CSLDestroy( arg4 );
16077 : }
16078 430 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16079 : return resultobj;
16080 0 : fail:
16081 0 : {
16082 : /* %typemap(freearg) (const char *utf8_path) */
16083 0 : GDALPythonFreeCStr(arg1, bToFree1);
16084 : }
16085 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16086 0 : {
16087 : /* %typemap(freearg) char **dict */
16088 0 : CSLDestroy( arg4 );
16089 : }
16090 : return NULL;
16091 : }
16092 :
16093 :
16094 40 : SWIGINTERN PyObject *_wrap_VSIFEofL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16095 40 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16096 40 : VSILFILE *arg1 = (VSILFILE *) 0 ;
16097 40 : void *argp1 = 0 ;
16098 40 : int res1 = 0 ;
16099 40 : PyObject *swig_obj[1] ;
16100 40 : int result;
16101 :
16102 40 : if (!args) SWIG_fail;
16103 40 : swig_obj[0] = args;
16104 40 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_VSILFILE, 0 | 0 );
16105 40 : if (!SWIG_IsOK(res1)) {
16106 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VSIFEofL" "', argument " "1"" of type '" "VSILFILE *""'");
16107 : }
16108 40 : arg1 = reinterpret_cast< VSILFILE * >(argp1);
16109 40 : {
16110 40 : if (!arg1) {
16111 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
16112 : }
16113 : }
16114 40 : {
16115 40 : const int bLocalUseExceptions = GetUseExceptions();
16116 40 : if ( bLocalUseExceptions ) {
16117 11 : pushErrorHandler();
16118 : }
16119 40 : {
16120 40 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16121 40 : result = (int)VSIFEofL(arg1);
16122 40 : SWIG_PYTHON_THREAD_END_ALLOW;
16123 : }
16124 40 : if ( bLocalUseExceptions ) {
16125 11 : popErrorHandler();
16126 : }
16127 : #ifndef SED_HACKS
16128 : if ( bLocalUseExceptions ) {
16129 : CPLErr eclass = CPLGetLastErrorType();
16130 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16131 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16132 : }
16133 : }
16134 : #endif
16135 : }
16136 40 : resultobj = SWIG_From_int(static_cast< int >(result));
16137 40 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16138 : return resultobj;
16139 : fail:
16140 : return NULL;
16141 : }
16142 :
16143 :
16144 1653 : SWIGINTERN PyObject *_wrap_VSIFErrorL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16145 1653 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16146 1653 : VSILFILE *arg1 = (VSILFILE *) 0 ;
16147 1653 : void *argp1 = 0 ;
16148 1653 : int res1 = 0 ;
16149 1653 : PyObject *swig_obj[1] ;
16150 1653 : int result;
16151 :
16152 1653 : if (!args) SWIG_fail;
16153 1653 : swig_obj[0] = args;
16154 1653 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_VSILFILE, 0 | 0 );
16155 1653 : if (!SWIG_IsOK(res1)) {
16156 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VSIFErrorL" "', argument " "1"" of type '" "VSILFILE *""'");
16157 : }
16158 1653 : arg1 = reinterpret_cast< VSILFILE * >(argp1);
16159 1653 : {
16160 1653 : if (!arg1) {
16161 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
16162 : }
16163 : }
16164 1653 : {
16165 1653 : const int bLocalUseExceptions = GetUseExceptions();
16166 1653 : if ( bLocalUseExceptions ) {
16167 10 : pushErrorHandler();
16168 : }
16169 1653 : {
16170 1653 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16171 1653 : result = (int)VSIFErrorL(arg1);
16172 1653 : SWIG_PYTHON_THREAD_END_ALLOW;
16173 : }
16174 1653 : if ( bLocalUseExceptions ) {
16175 10 : popErrorHandler();
16176 : }
16177 : #ifndef SED_HACKS
16178 : if ( bLocalUseExceptions ) {
16179 : CPLErr eclass = CPLGetLastErrorType();
16180 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16181 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16182 : }
16183 : }
16184 : #endif
16185 : }
16186 1653 : resultobj = SWIG_From_int(static_cast< int >(result));
16187 1653 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16188 : return resultobj;
16189 : fail:
16190 : return NULL;
16191 : }
16192 :
16193 :
16194 5 : SWIGINTERN PyObject *_wrap_VSIFClearErrL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16195 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16196 5 : VSILFILE *arg1 = (VSILFILE *) 0 ;
16197 5 : void *argp1 = 0 ;
16198 5 : int res1 = 0 ;
16199 5 : PyObject *swig_obj[1] ;
16200 :
16201 5 : if (!args) SWIG_fail;
16202 5 : swig_obj[0] = args;
16203 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_VSILFILE, 0 | 0 );
16204 5 : if (!SWIG_IsOK(res1)) {
16205 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VSIFClearErrL" "', argument " "1"" of type '" "VSILFILE *""'");
16206 : }
16207 5 : arg1 = reinterpret_cast< VSILFILE * >(argp1);
16208 5 : {
16209 5 : if (!arg1) {
16210 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
16211 : }
16212 : }
16213 5 : {
16214 5 : const int bLocalUseExceptions = GetUseExceptions();
16215 5 : if ( bLocalUseExceptions ) {
16216 1 : pushErrorHandler();
16217 : }
16218 5 : {
16219 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16220 5 : VSIFClearErrL(arg1);
16221 5 : SWIG_PYTHON_THREAD_END_ALLOW;
16222 : }
16223 5 : if ( bLocalUseExceptions ) {
16224 1 : popErrorHandler();
16225 : }
16226 : #ifndef SED_HACKS
16227 : if ( bLocalUseExceptions ) {
16228 : CPLErr eclass = CPLGetLastErrorType();
16229 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16230 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16231 : }
16232 : }
16233 : #endif
16234 : }
16235 5 : resultobj = SWIG_Py_Void();
16236 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16237 : return resultobj;
16238 : fail:
16239 : return NULL;
16240 : }
16241 :
16242 :
16243 3 : SWIGINTERN PyObject *_wrap_VSIFFlushL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16244 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16245 3 : VSILFILE *arg1 = (VSILFILE *) 0 ;
16246 3 : void *argp1 = 0 ;
16247 3 : int res1 = 0 ;
16248 3 : PyObject *swig_obj[1] ;
16249 3 : int result;
16250 :
16251 3 : if (!args) SWIG_fail;
16252 3 : swig_obj[0] = args;
16253 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_VSILFILE, 0 | 0 );
16254 3 : if (!SWIG_IsOK(res1)) {
16255 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VSIFFlushL" "', argument " "1"" of type '" "VSILFILE *""'");
16256 : }
16257 3 : arg1 = reinterpret_cast< VSILFILE * >(argp1);
16258 3 : {
16259 3 : if (!arg1) {
16260 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
16261 : }
16262 : }
16263 3 : {
16264 3 : const int bLocalUseExceptions = GetUseExceptions();
16265 3 : if ( bLocalUseExceptions ) {
16266 0 : pushErrorHandler();
16267 : }
16268 3 : {
16269 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16270 3 : result = (int)VSIFFlushL(arg1);
16271 3 : SWIG_PYTHON_THREAD_END_ALLOW;
16272 : }
16273 3 : if ( bLocalUseExceptions ) {
16274 0 : popErrorHandler();
16275 : }
16276 : #ifndef SED_HACKS
16277 : if ( bLocalUseExceptions ) {
16278 : CPLErr eclass = CPLGetLastErrorType();
16279 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16280 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16281 : }
16282 : }
16283 : #endif
16284 : }
16285 3 : resultobj = SWIG_From_int(static_cast< int >(result));
16286 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16287 : return resultobj;
16288 : fail:
16289 : return NULL;
16290 : }
16291 :
16292 :
16293 4698 : SWIGINTERN PyObject *_wrap_VSIFCloseL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16294 4698 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16295 4698 : VSILFILE *arg1 = (VSILFILE *) 0 ;
16296 4698 : void *argp1 = 0 ;
16297 4698 : int res1 = 0 ;
16298 4698 : PyObject *swig_obj[1] ;
16299 4698 : VSI_RETVAL result;
16300 :
16301 4698 : if (!args) SWIG_fail;
16302 4698 : swig_obj[0] = args;
16303 4698 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_VSILFILE, 0 | 0 );
16304 4698 : if (!SWIG_IsOK(res1)) {
16305 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VSIFCloseL" "', argument " "1"" of type '" "VSILFILE *""'");
16306 : }
16307 4698 : arg1 = reinterpret_cast< VSILFILE * >(argp1);
16308 4698 : {
16309 4698 : if (!arg1) {
16310 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
16311 : }
16312 : }
16313 4698 : {
16314 4698 : const int bLocalUseExceptions = GetUseExceptions();
16315 4698 : if ( bLocalUseExceptions ) {
16316 1050 : pushErrorHandler();
16317 : }
16318 4698 : {
16319 4698 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16320 4698 : result = VSIFCloseL(arg1);
16321 4698 : SWIG_PYTHON_THREAD_END_ALLOW;
16322 : }
16323 4698 : if ( bLocalUseExceptions ) {
16324 1050 : popErrorHandler();
16325 : }
16326 : #ifndef SED_HACKS
16327 : if ( bLocalUseExceptions ) {
16328 : CPLErr eclass = CPLGetLastErrorType();
16329 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16330 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16331 : }
16332 : }
16333 : #endif
16334 : }
16335 4698 : {
16336 : /* %typemap(out) VSI_RETVAL */
16337 4777 : if ( result != 0 && GetUseExceptions()) {
16338 0 : const char* pszMessage = CPLGetLastErrorMsg();
16339 0 : if( pszMessage[0] != '\0' )
16340 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
16341 : else
16342 0 : PyErr_SetString( PyExc_RuntimeError, "unknown error occurred" );
16343 0 : SWIG_fail;
16344 : }
16345 : }
16346 4698 : {
16347 : /* %typemap(ret) VSI_RETVAL */
16348 4698 : resultobj = PyInt_FromLong( result );
16349 : }
16350 4698 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16351 : return resultobj;
16352 : fail:
16353 : return NULL;
16354 : }
16355 :
16356 :
16357 65954 : SWIGINTERN PyObject *_wrap_VSIFSeekL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16358 65954 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16359 65954 : VSILFILE *arg1 = (VSILFILE *) 0 ;
16360 65954 : GIntBig arg2 ;
16361 65954 : int arg3 ;
16362 65954 : void *argp1 = 0 ;
16363 65954 : int res1 = 0 ;
16364 65954 : int val3 ;
16365 65954 : int ecode3 = 0 ;
16366 65954 : PyObject *swig_obj[3] ;
16367 65954 : int result;
16368 :
16369 65954 : if (!SWIG_Python_UnpackTuple(args, "VSIFSeekL", 3, 3, swig_obj)) SWIG_fail;
16370 65954 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_VSILFILE, 0 | 0 );
16371 65954 : if (!SWIG_IsOK(res1)) {
16372 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VSIFSeekL" "', argument " "1"" of type '" "VSILFILE *""'");
16373 : }
16374 65954 : arg1 = reinterpret_cast< VSILFILE * >(argp1);
16375 65954 : {
16376 65954 : arg2 = (GIntBig)PyLong_AsLongLong(swig_obj[1]);
16377 : }
16378 65954 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
16379 65954 : if (!SWIG_IsOK(ecode3)) {
16380 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VSIFSeekL" "', argument " "3"" of type '" "int""'");
16381 : }
16382 65954 : arg3 = static_cast< int >(val3);
16383 65954 : {
16384 65954 : if (!arg1) {
16385 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
16386 : }
16387 : }
16388 65954 : {
16389 65954 : const int bLocalUseExceptions = GetUseExceptions();
16390 65954 : if ( bLocalUseExceptions ) {
16391 2737 : pushErrorHandler();
16392 : }
16393 65954 : {
16394 65954 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16395 65954 : result = (int)wrapper_VSIFSeekL(arg1,arg2,arg3);
16396 65954 : SWIG_PYTHON_THREAD_END_ALLOW;
16397 : }
16398 65954 : if ( bLocalUseExceptions ) {
16399 2737 : popErrorHandler();
16400 : }
16401 : #ifndef SED_HACKS
16402 : if ( bLocalUseExceptions ) {
16403 : CPLErr eclass = CPLGetLastErrorType();
16404 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16405 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16406 : }
16407 : }
16408 : #endif
16409 : }
16410 65954 : resultobj = SWIG_From_int(static_cast< int >(result));
16411 65954 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16412 : return resultobj;
16413 : fail:
16414 : return NULL;
16415 : }
16416 :
16417 :
16418 895 : SWIGINTERN PyObject *_wrap_VSIFTellL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16419 895 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16420 895 : VSILFILE *arg1 = (VSILFILE *) 0 ;
16421 895 : void *argp1 = 0 ;
16422 895 : int res1 = 0 ;
16423 895 : PyObject *swig_obj[1] ;
16424 895 : GIntBig result;
16425 :
16426 895 : if (!args) SWIG_fail;
16427 895 : swig_obj[0] = args;
16428 895 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_VSILFILE, 0 | 0 );
16429 895 : if (!SWIG_IsOK(res1)) {
16430 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VSIFTellL" "', argument " "1"" of type '" "VSILFILE *""'");
16431 : }
16432 895 : arg1 = reinterpret_cast< VSILFILE * >(argp1);
16433 895 : {
16434 895 : if (!arg1) {
16435 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
16436 : }
16437 : }
16438 895 : {
16439 895 : const int bLocalUseExceptions = GetUseExceptions();
16440 895 : if ( bLocalUseExceptions ) {
16441 666 : pushErrorHandler();
16442 : }
16443 895 : {
16444 895 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16445 895 : result = VSIFTellL(arg1);
16446 895 : SWIG_PYTHON_THREAD_END_ALLOW;
16447 : }
16448 895 : if ( bLocalUseExceptions ) {
16449 666 : popErrorHandler();
16450 : }
16451 : #ifndef SED_HACKS
16452 : if ( bLocalUseExceptions ) {
16453 : CPLErr eclass = CPLGetLastErrorType();
16454 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16455 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16456 : }
16457 : }
16458 : #endif
16459 : }
16460 895 : {
16461 895 : resultobj = PyLong_FromLongLong(result);
16462 : }
16463 895 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16464 : return resultobj;
16465 : fail:
16466 : return NULL;
16467 : }
16468 :
16469 :
16470 37 : SWIGINTERN PyObject *_wrap_VSIFTruncateL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16471 37 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16472 37 : VSILFILE *arg1 = (VSILFILE *) 0 ;
16473 37 : GIntBig arg2 ;
16474 37 : void *argp1 = 0 ;
16475 37 : int res1 = 0 ;
16476 37 : PyObject *swig_obj[2] ;
16477 37 : int result;
16478 :
16479 37 : if (!SWIG_Python_UnpackTuple(args, "VSIFTruncateL", 2, 2, swig_obj)) SWIG_fail;
16480 37 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_VSILFILE, 0 | 0 );
16481 37 : if (!SWIG_IsOK(res1)) {
16482 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VSIFTruncateL" "', argument " "1"" of type '" "VSILFILE *""'");
16483 : }
16484 37 : arg1 = reinterpret_cast< VSILFILE * >(argp1);
16485 37 : {
16486 37 : arg2 = (GIntBig)PyLong_AsLongLong(swig_obj[1]);
16487 : }
16488 37 : {
16489 37 : if (!arg1) {
16490 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
16491 : }
16492 : }
16493 37 : {
16494 37 : const int bLocalUseExceptions = GetUseExceptions();
16495 37 : if ( bLocalUseExceptions ) {
16496 16 : pushErrorHandler();
16497 : }
16498 37 : {
16499 37 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16500 37 : result = (int)VSIFTruncateL(arg1,arg2);
16501 37 : SWIG_PYTHON_THREAD_END_ALLOW;
16502 : }
16503 37 : if ( bLocalUseExceptions ) {
16504 16 : popErrorHandler();
16505 : }
16506 : #ifndef SED_HACKS
16507 : if ( bLocalUseExceptions ) {
16508 : CPLErr eclass = CPLGetLastErrorType();
16509 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16510 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16511 : }
16512 : }
16513 : #endif
16514 : }
16515 37 : resultobj = SWIG_From_int(static_cast< int >(result));
16516 37 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16517 : return resultobj;
16518 : fail:
16519 : return NULL;
16520 : }
16521 :
16522 :
16523 2 : SWIGINTERN PyObject *_wrap_VSISupportsSparseFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16524 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16525 2 : char *arg1 = (char *) 0 ;
16526 2 : int bToFree1 = 0 ;
16527 2 : PyObject *swig_obj[1] ;
16528 2 : int result;
16529 :
16530 2 : if (!args) SWIG_fail;
16531 2 : swig_obj[0] = args;
16532 2 : {
16533 : /* %typemap(in) (const char *utf8_path) */
16534 2 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
16535 : {
16536 2 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
16537 : }
16538 : else
16539 : {
16540 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
16541 :
16542 : }
16543 2 : if (arg1 == NULL)
16544 : {
16545 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
16546 0 : SWIG_fail;
16547 : }
16548 : }
16549 2 : {
16550 2 : if (!arg1) {
16551 2 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
16552 : }
16553 : }
16554 2 : {
16555 2 : const int bLocalUseExceptions = GetUseExceptions();
16556 2 : if ( bLocalUseExceptions ) {
16557 0 : pushErrorHandler();
16558 : }
16559 2 : {
16560 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16561 2 : result = (int)VSISupportsSparseFiles((char const *)arg1);
16562 2 : SWIG_PYTHON_THREAD_END_ALLOW;
16563 : }
16564 2 : if ( bLocalUseExceptions ) {
16565 0 : popErrorHandler();
16566 : }
16567 : #ifndef SED_HACKS
16568 : if ( bLocalUseExceptions ) {
16569 : CPLErr eclass = CPLGetLastErrorType();
16570 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16571 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16572 : }
16573 : }
16574 : #endif
16575 : }
16576 2 : resultobj = SWIG_From_int(static_cast< int >(result));
16577 2 : {
16578 : /* %typemap(freearg) (const char *utf8_path) */
16579 2 : GDALPythonFreeCStr(arg1, bToFree1);
16580 : }
16581 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16582 : return resultobj;
16583 0 : fail:
16584 0 : {
16585 : /* %typemap(freearg) (const char *utf8_path) */
16586 2 : GDALPythonFreeCStr(arg1, bToFree1);
16587 : }
16588 : return NULL;
16589 : }
16590 :
16591 :
16592 3 : SWIGINTERN PyObject *_wrap_VSIFGetRangeStatusL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16593 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16594 3 : VSILFILE *arg1 = (VSILFILE *) 0 ;
16595 3 : GIntBig arg2 ;
16596 3 : GIntBig arg3 ;
16597 3 : void *argp1 = 0 ;
16598 3 : int res1 = 0 ;
16599 3 : PyObject *swig_obj[3] ;
16600 3 : int result;
16601 :
16602 3 : if (!SWIG_Python_UnpackTuple(args, "VSIFGetRangeStatusL", 3, 3, swig_obj)) SWIG_fail;
16603 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_VSILFILE, 0 | 0 );
16604 3 : if (!SWIG_IsOK(res1)) {
16605 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VSIFGetRangeStatusL" "', argument " "1"" of type '" "VSILFILE *""'");
16606 : }
16607 3 : arg1 = reinterpret_cast< VSILFILE * >(argp1);
16608 3 : {
16609 3 : arg2 = (GIntBig)PyLong_AsLongLong(swig_obj[1]);
16610 : }
16611 3 : {
16612 3 : arg3 = (GIntBig)PyLong_AsLongLong(swig_obj[2]);
16613 : }
16614 3 : {
16615 3 : if (!arg1) {
16616 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
16617 : }
16618 : }
16619 3 : {
16620 3 : const int bLocalUseExceptions = GetUseExceptions();
16621 3 : if ( bLocalUseExceptions ) {
16622 0 : pushErrorHandler();
16623 : }
16624 3 : {
16625 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16626 3 : result = (int)VSIFGetRangeStatusL(arg1,arg2,arg3);
16627 3 : SWIG_PYTHON_THREAD_END_ALLOW;
16628 : }
16629 3 : if ( bLocalUseExceptions ) {
16630 0 : popErrorHandler();
16631 : }
16632 : #ifndef SED_HACKS
16633 : if ( bLocalUseExceptions ) {
16634 : CPLErr eclass = CPLGetLastErrorType();
16635 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16636 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16637 : }
16638 : }
16639 : #endif
16640 : }
16641 3 : resultobj = SWIG_From_int(static_cast< int >(result));
16642 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16643 : return resultobj;
16644 : fail:
16645 : return NULL;
16646 : }
16647 :
16648 :
16649 346837 : SWIGINTERN PyObject *_wrap_VSIFWriteL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16650 346837 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16651 346837 : int arg1 ;
16652 346837 : char *arg2 = (char *) 0 ;
16653 346837 : int arg3 ;
16654 346837 : int arg4 ;
16655 346837 : VSILFILE *arg5 = (VSILFILE *) 0 ;
16656 346837 : int alloc1 = 0 ;
16657 346837 : bool viewIsValid1 = false ;
16658 346837 : Py_buffer view1 ;
16659 346837 : int val3 ;
16660 346837 : int ecode3 = 0 ;
16661 346837 : int val4 ;
16662 346837 : int ecode4 = 0 ;
16663 346837 : void *argp5 = 0 ;
16664 346837 : int res5 = 0 ;
16665 346837 : PyObject *swig_obj[4] ;
16666 346837 : int result;
16667 :
16668 346837 : if (!SWIG_Python_UnpackTuple(args, "VSIFWriteL", 4, 4, swig_obj)) SWIG_fail;
16669 346837 : {
16670 : /* %typemap(in,numinputs=1) (int nLen, char *pBuf ) */
16671 346837 : char* ptr = NULL;
16672 346837 : if( !GetBufferAsCharPtrIntSize(swig_obj[0], &arg1, &ptr, &alloc1, &viewIsValid1, &view1) ) {
16673 0 : SWIG_fail;
16674 : }
16675 346837 : arg2 = (char *)ptr;
16676 : }
16677 346837 : ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
16678 346837 : if (!SWIG_IsOK(ecode3)) {
16679 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VSIFWriteL" "', argument " "3"" of type '" "int""'");
16680 : }
16681 346837 : arg3 = static_cast< int >(val3);
16682 346837 : ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
16683 346837 : if (!SWIG_IsOK(ecode4)) {
16684 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VSIFWriteL" "', argument " "4"" of type '" "int""'");
16685 : }
16686 346837 : arg4 = static_cast< int >(val4);
16687 346837 : res5 = SWIG_ConvertPtr(swig_obj[3], &argp5,SWIGTYPE_p_VSILFILE, 0 | 0 );
16688 346837 : if (!SWIG_IsOK(res5)) {
16689 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VSIFWriteL" "', argument " "5"" of type '" "VSILFILE *""'");
16690 : }
16691 346837 : arg5 = reinterpret_cast< VSILFILE * >(argp5);
16692 346837 : {
16693 346837 : if (!arg5) {
16694 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
16695 : }
16696 : }
16697 346837 : {
16698 346837 : const int bLocalUseExceptions = GetUseExceptions();
16699 346837 : if ( bLocalUseExceptions ) {
16700 105895 : pushErrorHandler();
16701 : }
16702 346837 : {
16703 346837 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16704 346837 : result = (int)wrapper_VSIFWriteL(arg1,arg2,arg3,arg4,arg5);
16705 346837 : SWIG_PYTHON_THREAD_END_ALLOW;
16706 : }
16707 346837 : if ( bLocalUseExceptions ) {
16708 105895 : popErrorHandler();
16709 : }
16710 : #ifndef SED_HACKS
16711 : if ( bLocalUseExceptions ) {
16712 : CPLErr eclass = CPLGetLastErrorType();
16713 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16714 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16715 : }
16716 : }
16717 : #endif
16718 : }
16719 346837 : resultobj = SWIG_From_int(static_cast< int >(result));
16720 346837 : {
16721 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
16722 346837 : if( viewIsValid1 ) {
16723 6555 : PyBuffer_Release(&view1);
16724 : }
16725 340282 : else if (ReturnSame(alloc1) == SWIG_NEWOBJ ) {
16726 340282 : delete[] arg2;
16727 : }
16728 : }
16729 346837 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16730 : return resultobj;
16731 0 : fail:
16732 0 : {
16733 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
16734 0 : if( viewIsValid1 ) {
16735 0 : PyBuffer_Release(&view1);
16736 : }
16737 346837 : else if (ReturnSame(alloc1) == SWIG_NEWOBJ ) {
16738 0 : delete[] arg2;
16739 : }
16740 : }
16741 : return NULL;
16742 : }
16743 :
16744 :
16745 213 : SWIGINTERN PyObject *_wrap_CPLReadLineL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16746 213 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16747 213 : VSILFILE *arg1 = (VSILFILE *) 0 ;
16748 213 : void *argp1 = 0 ;
16749 213 : int res1 = 0 ;
16750 213 : PyObject *swig_obj[1] ;
16751 213 : char *result = 0 ;
16752 :
16753 213 : if (!args) SWIG_fail;
16754 213 : swig_obj[0] = args;
16755 213 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_VSILFILE, 0 | 0 );
16756 213 : if (!SWIG_IsOK(res1)) {
16757 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPLReadLineL" "', argument " "1"" of type '" "VSILFILE *""'");
16758 : }
16759 213 : arg1 = reinterpret_cast< VSILFILE * >(argp1);
16760 213 : {
16761 213 : if (!arg1) {
16762 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
16763 : }
16764 : }
16765 213 : {
16766 213 : const int bLocalUseExceptions = GetUseExceptions();
16767 213 : if ( bLocalUseExceptions ) {
16768 41 : pushErrorHandler();
16769 : }
16770 213 : {
16771 213 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16772 213 : result = (char *)CPLReadLineL(arg1);
16773 213 : SWIG_PYTHON_THREAD_END_ALLOW;
16774 : }
16775 213 : if ( bLocalUseExceptions ) {
16776 41 : popErrorHandler();
16777 : }
16778 : #ifndef SED_HACKS
16779 : if ( bLocalUseExceptions ) {
16780 : CPLErr eclass = CPLGetLastErrorType();
16781 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16782 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16783 : }
16784 : }
16785 : #endif
16786 : }
16787 213 : resultobj = SWIG_FromCharPtr((const char *)result);
16788 213 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16789 : return resultobj;
16790 : fail:
16791 : return NULL;
16792 : }
16793 :
16794 :
16795 338 : SWIGINTERN PyObject *_wrap_VSICurlClearCache(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16796 338 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16797 :
16798 338 : if (!SWIG_Python_UnpackTuple(args, "VSICurlClearCache", 0, 0, 0)) SWIG_fail;
16799 338 : {
16800 338 : const int bLocalUseExceptions = GetUseExceptions();
16801 338 : if ( bLocalUseExceptions ) {
16802 114 : pushErrorHandler();
16803 : }
16804 338 : {
16805 338 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16806 338 : VSICurlClearCache();
16807 338 : SWIG_PYTHON_THREAD_END_ALLOW;
16808 : }
16809 338 : if ( bLocalUseExceptions ) {
16810 114 : 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 338 : resultobj = SWIG_Py_Void();
16822 338 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16823 : return resultobj;
16824 0 : fail:
16825 0 : return NULL;
16826 : }
16827 :
16828 :
16829 2 : SWIGINTERN PyObject *_wrap_VSICurlPartialClearCache(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16830 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16831 2 : char *arg1 = (char *) 0 ;
16832 2 : int bToFree1 = 0 ;
16833 2 : PyObject *swig_obj[1] ;
16834 :
16835 2 : if (!args) SWIG_fail;
16836 2 : swig_obj[0] = args;
16837 2 : {
16838 : /* %typemap(in) (const char *utf8_path) */
16839 2 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
16840 : {
16841 2 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
16842 : }
16843 : else
16844 : {
16845 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
16846 :
16847 : }
16848 2 : if (arg1 == NULL)
16849 : {
16850 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
16851 0 : SWIG_fail;
16852 : }
16853 : }
16854 2 : {
16855 2 : if (!arg1) {
16856 2 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
16857 : }
16858 : }
16859 2 : {
16860 2 : const int bLocalUseExceptions = GetUseExceptions();
16861 2 : if ( bLocalUseExceptions ) {
16862 0 : pushErrorHandler();
16863 : }
16864 2 : {
16865 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16866 2 : VSICurlPartialClearCache((char const *)arg1);
16867 2 : SWIG_PYTHON_THREAD_END_ALLOW;
16868 : }
16869 2 : if ( bLocalUseExceptions ) {
16870 0 : popErrorHandler();
16871 : }
16872 : #ifndef SED_HACKS
16873 : if ( bLocalUseExceptions ) {
16874 : CPLErr eclass = CPLGetLastErrorType();
16875 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16876 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16877 : }
16878 : }
16879 : #endif
16880 : }
16881 2 : resultobj = SWIG_Py_Void();
16882 2 : {
16883 : /* %typemap(freearg) (const char *utf8_path) */
16884 2 : GDALPythonFreeCStr(arg1, bToFree1);
16885 : }
16886 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16887 : return resultobj;
16888 0 : fail:
16889 0 : {
16890 : /* %typemap(freearg) (const char *utf8_path) */
16891 2 : GDALPythonFreeCStr(arg1, bToFree1);
16892 : }
16893 : return NULL;
16894 : }
16895 :
16896 :
16897 2 : SWIGINTERN PyObject *_wrap_NetworkStatsReset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16898 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16899 :
16900 2 : if (!SWIG_Python_UnpackTuple(args, "NetworkStatsReset", 0, 0, 0)) SWIG_fail;
16901 2 : {
16902 2 : const int bLocalUseExceptions = GetUseExceptions();
16903 2 : if ( bLocalUseExceptions ) {
16904 0 : pushErrorHandler();
16905 : }
16906 2 : {
16907 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16908 2 : VSINetworkStatsReset();
16909 2 : SWIG_PYTHON_THREAD_END_ALLOW;
16910 : }
16911 2 : if ( bLocalUseExceptions ) {
16912 0 : popErrorHandler();
16913 : }
16914 : #ifndef SED_HACKS
16915 : if ( bLocalUseExceptions ) {
16916 : CPLErr eclass = CPLGetLastErrorType();
16917 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16918 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16919 : }
16920 : }
16921 : #endif
16922 : }
16923 2 : resultobj = SWIG_Py_Void();
16924 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
16925 : return resultobj;
16926 0 : fail:
16927 0 : return NULL;
16928 : }
16929 :
16930 :
16931 1 : SWIGINTERN PyObject *_wrap_NetworkStatsGetAsSerializedJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16932 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
16933 1 : char **arg1 = (char **) NULL ;
16934 1 : PyObject *swig_obj[1] ;
16935 1 : retStringAndCPLFree *result = 0 ;
16936 :
16937 1 : if (!SWIG_Python_UnpackTuple(args, "NetworkStatsGetAsSerializedJSON", 0, 1, swig_obj)) SWIG_fail;
16938 1 : if (swig_obj[0]) {
16939 0 : {
16940 : /* %typemap(in) char **dict */
16941 0 : arg1 = NULL;
16942 0 : if ( PySequence_Check( swig_obj[0] ) ) {
16943 0 : int bErr = FALSE;
16944 0 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
16945 0 : if ( bErr )
16946 : {
16947 0 : SWIG_fail;
16948 : }
16949 : }
16950 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
16951 0 : int bErr = FALSE;
16952 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
16953 0 : if ( bErr )
16954 : {
16955 0 : SWIG_fail;
16956 : }
16957 : }
16958 : else {
16959 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
16960 0 : SWIG_fail;
16961 : }
16962 : }
16963 : }
16964 1 : {
16965 1 : const int bLocalUseExceptions = GetUseExceptions();
16966 1 : if ( bLocalUseExceptions ) {
16967 0 : pushErrorHandler();
16968 : }
16969 1 : {
16970 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16971 1 : result = (retStringAndCPLFree *)VSINetworkStatsGetAsSerializedJSON(arg1);
16972 1 : SWIG_PYTHON_THREAD_END_ALLOW;
16973 : }
16974 1 : if ( bLocalUseExceptions ) {
16975 0 : popErrorHandler();
16976 : }
16977 : #ifndef SED_HACKS
16978 : if ( bLocalUseExceptions ) {
16979 : CPLErr eclass = CPLGetLastErrorType();
16980 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
16981 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
16982 : }
16983 : }
16984 : #endif
16985 : }
16986 1 : {
16987 : /* %typemap(out) (retStringAndCPLFree*) */
16988 1 : Py_XDECREF(resultobj);
16989 1 : if(result)
16990 : {
16991 1 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
16992 1 : CPLFree(result);
16993 : }
16994 : else
16995 : {
16996 0 : resultobj = Py_None;
16997 0 : Py_INCREF(resultobj);
16998 : }
16999 : }
17000 1 : {
17001 : /* %typemap(freearg) char **dict */
17002 1 : CSLDestroy( arg1 );
17003 : }
17004 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17005 : return resultobj;
17006 0 : fail:
17007 0 : {
17008 : /* %typemap(freearg) char **dict */
17009 0 : CSLDestroy( arg1 );
17010 : }
17011 : return NULL;
17012 : }
17013 :
17014 :
17015 922 : SWIGINTERN PyObject *_wrap_ParseCommandLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17016 922 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17017 922 : char *arg1 = (char *) 0 ;
17018 922 : int bToFree1 = 0 ;
17019 922 : PyObject *swig_obj[1] ;
17020 922 : char **result = 0 ;
17021 :
17022 922 : if (!args) SWIG_fail;
17023 922 : swig_obj[0] = args;
17024 922 : {
17025 : /* %typemap(in) (const char *utf8_path) */
17026 922 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
17027 : {
17028 922 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
17029 : }
17030 : else
17031 : {
17032 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
17033 :
17034 : }
17035 922 : if (arg1 == NULL)
17036 : {
17037 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
17038 0 : SWIG_fail;
17039 : }
17040 : }
17041 922 : {
17042 922 : if (!arg1) {
17043 922 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
17044 : }
17045 : }
17046 922 : {
17047 922 : const int bLocalUseExceptions = GetUseExceptions();
17048 922 : if ( bLocalUseExceptions ) {
17049 800 : pushErrorHandler();
17050 : }
17051 922 : {
17052 922 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17053 922 : result = (char **)CSLParseCommandLine((char const *)arg1);
17054 922 : SWIG_PYTHON_THREAD_END_ALLOW;
17055 : }
17056 922 : if ( bLocalUseExceptions ) {
17057 800 : popErrorHandler();
17058 : }
17059 : #ifndef SED_HACKS
17060 : if ( bLocalUseExceptions ) {
17061 : CPLErr eclass = CPLGetLastErrorType();
17062 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17063 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17064 : }
17065 : }
17066 : #endif
17067 : }
17068 922 : {
17069 : /* %typemap(out) char **CSL -> ( string ) */
17070 922 : bool bErr = false;
17071 922 : resultobj = CSLToList(result, &bErr);
17072 922 : CSLDestroy(result);
17073 922 : if( bErr ) {
17074 0 : SWIG_fail;
17075 : }
17076 : }
17077 922 : {
17078 : /* %typemap(freearg) (const char *utf8_path) */
17079 922 : GDALPythonFreeCStr(arg1, bToFree1);
17080 : }
17081 922 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17082 : return resultobj;
17083 0 : fail:
17084 0 : {
17085 : /* %typemap(freearg) (const char *utf8_path) */
17086 922 : GDALPythonFreeCStr(arg1, bToFree1);
17087 : }
17088 : return NULL;
17089 : }
17090 :
17091 :
17092 50 : SWIGINTERN PyObject *_wrap_GetNumCPUs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17093 50 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17094 50 : int result;
17095 :
17096 50 : if (!SWIG_Python_UnpackTuple(args, "GetNumCPUs", 0, 0, 0)) SWIG_fail;
17097 50 : {
17098 50 : const int bLocalUseExceptions = GetUseExceptions();
17099 50 : if ( bLocalUseExceptions ) {
17100 42 : pushErrorHandler();
17101 : }
17102 50 : {
17103 50 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17104 50 : result = (int)CPLGetNumCPUs();
17105 50 : SWIG_PYTHON_THREAD_END_ALLOW;
17106 : }
17107 50 : if ( bLocalUseExceptions ) {
17108 42 : popErrorHandler();
17109 : }
17110 : #ifndef SED_HACKS
17111 : if ( bLocalUseExceptions ) {
17112 : CPLErr eclass = CPLGetLastErrorType();
17113 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17114 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17115 : }
17116 : }
17117 : #endif
17118 : }
17119 50 : resultobj = SWIG_From_int(static_cast< int >(result));
17120 50 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17121 : return resultobj;
17122 0 : fail:
17123 0 : return NULL;
17124 : }
17125 :
17126 :
17127 2 : SWIGINTERN PyObject *_wrap_GetUsablePhysicalRAM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17128 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17129 2 : GIntBig result;
17130 :
17131 2 : if (!SWIG_Python_UnpackTuple(args, "GetUsablePhysicalRAM", 0, 0, 0)) SWIG_fail;
17132 2 : {
17133 2 : const int bLocalUseExceptions = GetUseExceptions();
17134 2 : if ( bLocalUseExceptions ) {
17135 1 : pushErrorHandler();
17136 : }
17137 2 : {
17138 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17139 2 : result = CPLGetUsablePhysicalRAM();
17140 2 : SWIG_PYTHON_THREAD_END_ALLOW;
17141 : }
17142 2 : if ( bLocalUseExceptions ) {
17143 1 : popErrorHandler();
17144 : }
17145 : #ifndef SED_HACKS
17146 : if ( bLocalUseExceptions ) {
17147 : CPLErr eclass = CPLGetLastErrorType();
17148 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17149 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17150 : }
17151 : }
17152 : #endif
17153 : }
17154 2 : {
17155 2 : resultobj = PyLong_FromLongLong(result);
17156 : }
17157 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17158 : return resultobj;
17159 0 : fail:
17160 0 : return NULL;
17161 : }
17162 :
17163 :
17164 8 : SWIGINTERN PyObject *_wrap_MultipartUploadGetCapabilities(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17165 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17166 8 : char *arg1 = (char *) 0 ;
17167 8 : int *arg2 = (int *) 0 ;
17168 8 : int *arg3 = (int *) 0 ;
17169 8 : int *arg4 = (int *) 0 ;
17170 8 : int *arg5 = (int *) 0 ;
17171 8 : size_t *arg6 = (size_t *) 0 ;
17172 8 : size_t *arg7 = (size_t *) 0 ;
17173 8 : int *arg8 = (int *) 0 ;
17174 8 : int res1 ;
17175 8 : char *buf1 = 0 ;
17176 8 : int alloc1 = 0 ;
17177 8 : int nRetCode2 = 0 ;
17178 8 : int bNonSequentialUploadSupported2 = 0 ;
17179 8 : int bParallelUploadSupported2 = 0 ;
17180 8 : int bSupportsAbort2 = 0 ;
17181 8 : size_t nMinPartSize2 = 0 ;
17182 8 : size_t nMaxPartSize2 = 0 ;
17183 8 : int nMaxPartCount2 = 0 ;
17184 8 : PyObject *swig_obj[1] ;
17185 :
17186 8 : {
17187 8 : arg2 = &nRetCode2;
17188 8 : arg3 = &bNonSequentialUploadSupported2;
17189 8 : arg4 = &bParallelUploadSupported2;
17190 8 : arg5 = &bSupportsAbort2;
17191 8 : arg6 = &nMinPartSize2;
17192 8 : arg7 = &nMaxPartSize2;
17193 8 : arg8 = &nMaxPartCount2;
17194 : }
17195 8 : if (!args) SWIG_fail;
17196 8 : swig_obj[0] = args;
17197 8 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
17198 8 : if (!SWIG_IsOK(res1)) {
17199 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartUploadGetCapabilities" "', argument " "1"" of type '" "char const *""'");
17200 : }
17201 8 : arg1 = reinterpret_cast< char * >(buf1);
17202 8 : {
17203 8 : if (!arg1) {
17204 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
17205 : }
17206 : }
17207 7 : {
17208 7 : const int bLocalUseExceptions = GetUseExceptions();
17209 7 : if ( bLocalUseExceptions ) {
17210 2 : pushErrorHandler();
17211 : }
17212 7 : {
17213 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17214 7 : MultipartUploadGetCapabilities((char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17215 7 : SWIG_PYTHON_THREAD_END_ALLOW;
17216 : }
17217 7 : if ( bLocalUseExceptions ) {
17218 2 : popErrorHandler();
17219 : }
17220 : #ifndef SED_HACKS
17221 : if ( bLocalUseExceptions ) {
17222 : CPLErr eclass = CPLGetLastErrorType();
17223 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17224 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17225 : }
17226 : }
17227 : #endif
17228 : }
17229 7 : resultobj = SWIG_Py_Void();
17230 7 : {
17231 7 : if( *arg2 == 0 )
17232 : {
17233 2 : Py_DECREF(resultobj);
17234 2 : resultobj = Py_None;
17235 2 : Py_INCREF(Py_None);
17236 : }
17237 : else
17238 : {
17239 5 : PyObject *r = PyTuple_New( 6 );
17240 5 : PyTuple_SetItem( r, 0, PyBool_FromLong(*arg3) );
17241 5 : PyTuple_SetItem( r, 1, PyBool_FromLong(*arg4) );
17242 5 : PyTuple_SetItem( r, 2, PyBool_FromLong(*arg5) );
17243 5 : PyTuple_SetItem( r, 3, PyLong_FromUnsignedLongLong(*arg6) );
17244 5 : PyTuple_SetItem( r, 4, PyLong_FromUnsignedLongLong(*arg7) );
17245 5 : PyTuple_SetItem( r, 5, PyLong_FromUnsignedLongLong(*arg8) );
17246 : #if SWIG_VERSION >= 0x040300
17247 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
17248 : #else
17249 5 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
17250 : #endif
17251 : }
17252 : }
17253 7 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17254 10 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17255 : return resultobj;
17256 1 : fail:
17257 1 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17258 : return NULL;
17259 : }
17260 :
17261 :
17262 5 : SWIGINTERN PyObject *_wrap_MultipartUploadStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17263 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17264 5 : char *arg1 = (char *) 0 ;
17265 5 : char **arg2 = (char **) NULL ;
17266 5 : int res1 ;
17267 5 : char *buf1 = 0 ;
17268 5 : int alloc1 = 0 ;
17269 5 : PyObject *swig_obj[2] ;
17270 5 : retStringAndCPLFree *result = 0 ;
17271 :
17272 5 : if (!SWIG_Python_UnpackTuple(args, "MultipartUploadStart", 1, 2, swig_obj)) SWIG_fail;
17273 5 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
17274 5 : if (!SWIG_IsOK(res1)) {
17275 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartUploadStart" "', argument " "1"" of type '" "char const *""'");
17276 : }
17277 5 : arg1 = reinterpret_cast< char * >(buf1);
17278 5 : if (swig_obj[1]) {
17279 0 : {
17280 : /* %typemap(in) char **dict */
17281 0 : arg2 = NULL;
17282 0 : if ( PySequence_Check( swig_obj[1] ) ) {
17283 0 : int bErr = FALSE;
17284 0 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
17285 0 : if ( bErr )
17286 : {
17287 0 : SWIG_fail;
17288 : }
17289 : }
17290 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
17291 0 : int bErr = FALSE;
17292 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
17293 0 : if ( bErr )
17294 : {
17295 0 : SWIG_fail;
17296 : }
17297 : }
17298 : else {
17299 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
17300 0 : SWIG_fail;
17301 : }
17302 : }
17303 : }
17304 5 : {
17305 5 : if (!arg1) {
17306 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
17307 : }
17308 : }
17309 4 : {
17310 4 : const int bLocalUseExceptions = GetUseExceptions();
17311 4 : if ( bLocalUseExceptions ) {
17312 1 : pushErrorHandler();
17313 : }
17314 4 : {
17315 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17316 4 : result = (retStringAndCPLFree *)MultipartUploadStart((char const *)arg1,arg2);
17317 4 : SWIG_PYTHON_THREAD_END_ALLOW;
17318 : }
17319 4 : if ( bLocalUseExceptions ) {
17320 1 : popErrorHandler();
17321 : }
17322 : #ifndef SED_HACKS
17323 : if ( bLocalUseExceptions ) {
17324 : CPLErr eclass = CPLGetLastErrorType();
17325 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17326 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17327 : }
17328 : }
17329 : #endif
17330 : }
17331 4 : {
17332 : /* %typemap(out) (retStringAndCPLFree*) */
17333 4 : Py_XDECREF(resultobj);
17334 4 : if(result)
17335 : {
17336 1 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
17337 1 : CPLFree(result);
17338 : }
17339 : else
17340 : {
17341 3 : resultobj = Py_None;
17342 3 : Py_INCREF(resultobj);
17343 : }
17344 : }
17345 4 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17346 4 : {
17347 : /* %typemap(freearg) char **dict */
17348 4 : CSLDestroy( arg2 );
17349 : }
17350 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17351 : return resultobj;
17352 1 : fail:
17353 1 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17354 1 : {
17355 : /* %typemap(freearg) char **dict */
17356 1 : CSLDestroy( arg2 );
17357 : }
17358 : return NULL;
17359 : }
17360 :
17361 :
17362 7 : SWIGINTERN PyObject *_wrap_MultipartUploadAddPart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17363 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17364 7 : char *arg1 = (char *) 0 ;
17365 7 : char *arg2 = (char *) 0 ;
17366 7 : int arg3 ;
17367 7 : GUIntBig arg4 ;
17368 7 : size_t arg5 ;
17369 7 : char *arg6 = (char *) 0 ;
17370 7 : char **arg7 = (char **) NULL ;
17371 7 : int res1 ;
17372 7 : char *buf1 = 0 ;
17373 7 : int alloc1 = 0 ;
17374 7 : int res2 ;
17375 7 : char *buf2 = 0 ;
17376 7 : int alloc2 = 0 ;
17377 7 : int val3 ;
17378 7 : int ecode3 = 0 ;
17379 7 : int alloc5 = 0 ;
17380 7 : bool viewIsValid5 = false ;
17381 7 : Py_buffer view5 ;
17382 7 : PyObject *swig_obj[6] ;
17383 7 : retStringAndCPLFree *result = 0 ;
17384 :
17385 7 : if (!SWIG_Python_UnpackTuple(args, "MultipartUploadAddPart", 5, 6, swig_obj)) SWIG_fail;
17386 7 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
17387 7 : if (!SWIG_IsOK(res1)) {
17388 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartUploadAddPart" "', argument " "1"" of type '" "char const *""'");
17389 : }
17390 7 : arg1 = reinterpret_cast< char * >(buf1);
17391 7 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
17392 7 : if (!SWIG_IsOK(res2)) {
17393 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipartUploadAddPart" "', argument " "2"" of type '" "char const *""'");
17394 : }
17395 7 : arg2 = reinterpret_cast< char * >(buf2);
17396 7 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
17397 7 : if (!SWIG_IsOK(ecode3)) {
17398 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MultipartUploadAddPart" "', argument " "3"" of type '" "int""'");
17399 : }
17400 7 : arg3 = static_cast< int >(val3);
17401 7 : {
17402 7 : arg4 = (GIntBig)PyLong_AsUnsignedLongLong(swig_obj[3]);
17403 : }
17404 7 : {
17405 : /* %typemap(in,numinputs=1) (size_t nLen, char *pBuf ) */
17406 7 : char* ptr = NULL;
17407 7 : if( !GetBufferAsCharPtrSizetSize(swig_obj[4], &arg5, &ptr, &alloc5, &viewIsValid5, &view5) ) {
17408 0 : SWIG_fail;
17409 : }
17410 7 : arg6 = (char *)ptr;
17411 : }
17412 7 : if (swig_obj[5]) {
17413 0 : {
17414 : /* %typemap(in) char **dict */
17415 0 : arg7 = NULL;
17416 0 : if ( PySequence_Check( swig_obj[5] ) ) {
17417 0 : int bErr = FALSE;
17418 0 : arg7 = CSLFromPySequence(swig_obj[5], &bErr);
17419 0 : if ( bErr )
17420 : {
17421 0 : SWIG_fail;
17422 : }
17423 : }
17424 0 : else if ( PyMapping_Check( swig_obj[5] ) ) {
17425 0 : int bErr = FALSE;
17426 0 : arg7 = CSLFromPyMapping(swig_obj[5], &bErr);
17427 0 : if ( bErr )
17428 : {
17429 0 : SWIG_fail;
17430 : }
17431 : }
17432 : else {
17433 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
17434 0 : SWIG_fail;
17435 : }
17436 : }
17437 : }
17438 7 : {
17439 7 : if (!arg1) {
17440 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
17441 : }
17442 : }
17443 6 : {
17444 6 : if (!arg2) {
17445 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
17446 : }
17447 : }
17448 5 : {
17449 5 : const int bLocalUseExceptions = GetUseExceptions();
17450 5 : if ( bLocalUseExceptions ) {
17451 1 : pushErrorHandler();
17452 : }
17453 5 : {
17454 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17455 5 : result = (retStringAndCPLFree *)MultipartUploadAddPart((char const *)arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
17456 5 : SWIG_PYTHON_THREAD_END_ALLOW;
17457 : }
17458 5 : if ( bLocalUseExceptions ) {
17459 1 : popErrorHandler();
17460 : }
17461 : #ifndef SED_HACKS
17462 : if ( bLocalUseExceptions ) {
17463 : CPLErr eclass = CPLGetLastErrorType();
17464 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17465 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17466 : }
17467 : }
17468 : #endif
17469 : }
17470 5 : {
17471 : /* %typemap(out) (retStringAndCPLFree*) */
17472 5 : Py_XDECREF(resultobj);
17473 5 : if(result)
17474 : {
17475 2 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
17476 2 : CPLFree(result);
17477 : }
17478 : else
17479 : {
17480 3 : resultobj = Py_None;
17481 3 : Py_INCREF(resultobj);
17482 : }
17483 : }
17484 5 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17485 5 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17486 5 : {
17487 : /* %typemap(freearg) (size_t *nLen, char *pBuf ) */
17488 5 : if( viewIsValid5 ) {
17489 5 : PyBuffer_Release(&view5);
17490 : }
17491 0 : else if (ReturnSame(alloc5) == SWIG_NEWOBJ ) {
17492 0 : delete[] arg6;
17493 : }
17494 : }
17495 5 : {
17496 : /* %typemap(freearg) char **dict */
17497 5 : CSLDestroy( arg7 );
17498 : }
17499 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17500 : return resultobj;
17501 2 : fail:
17502 2 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17503 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17504 2 : {
17505 : /* %typemap(freearg) (size_t *nLen, char *pBuf ) */
17506 2 : if( viewIsValid5 ) {
17507 2 : PyBuffer_Release(&view5);
17508 : }
17509 0 : else if (ReturnSame(alloc5) == SWIG_NEWOBJ ) {
17510 0 : delete[] arg6;
17511 : }
17512 : }
17513 2 : {
17514 : /* %typemap(freearg) char **dict */
17515 2 : CSLDestroy( arg7 );
17516 : }
17517 : return NULL;
17518 : }
17519 :
17520 :
17521 7 : SWIGINTERN PyObject *_wrap_MultipartUploadEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17522 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17523 7 : char *arg1 = (char *) 0 ;
17524 7 : char *arg2 = (char *) 0 ;
17525 7 : char **arg3 = (char **) 0 ;
17526 7 : GUIntBig arg4 ;
17527 7 : char **arg5 = (char **) NULL ;
17528 7 : int res1 ;
17529 7 : char *buf1 = 0 ;
17530 7 : int alloc1 = 0 ;
17531 7 : int res2 ;
17532 7 : char *buf2 = 0 ;
17533 7 : int alloc2 = 0 ;
17534 7 : PyObject *swig_obj[5] ;
17535 7 : bool result;
17536 :
17537 7 : if (!SWIG_Python_UnpackTuple(args, "MultipartUploadEnd", 4, 5, swig_obj)) SWIG_fail;
17538 7 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
17539 7 : if (!SWIG_IsOK(res1)) {
17540 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartUploadEnd" "', argument " "1"" of type '" "char const *""'");
17541 : }
17542 7 : arg1 = reinterpret_cast< char * >(buf1);
17543 7 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
17544 7 : if (!SWIG_IsOK(res2)) {
17545 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipartUploadEnd" "', argument " "2"" of type '" "char const *""'");
17546 : }
17547 7 : arg2 = reinterpret_cast< char * >(buf2);
17548 7 : {
17549 : /* %typemap(in) char **dict */
17550 7 : arg3 = NULL;
17551 7 : if ( PySequence_Check( swig_obj[2] ) ) {
17552 7 : int bErr = FALSE;
17553 7 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
17554 7 : if ( bErr )
17555 : {
17556 0 : SWIG_fail;
17557 : }
17558 : }
17559 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
17560 0 : int bErr = FALSE;
17561 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
17562 0 : if ( bErr )
17563 : {
17564 0 : SWIG_fail;
17565 : }
17566 : }
17567 : else {
17568 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
17569 0 : SWIG_fail;
17570 : }
17571 : }
17572 7 : {
17573 7 : arg4 = (GIntBig)PyLong_AsUnsignedLongLong(swig_obj[3]);
17574 : }
17575 7 : if (swig_obj[4]) {
17576 0 : {
17577 : /* %typemap(in) char **dict */
17578 0 : arg5 = NULL;
17579 0 : if ( PySequence_Check( swig_obj[4] ) ) {
17580 0 : int bErr = FALSE;
17581 0 : arg5 = CSLFromPySequence(swig_obj[4], &bErr);
17582 0 : if ( bErr )
17583 : {
17584 0 : SWIG_fail;
17585 : }
17586 : }
17587 0 : else if ( PyMapping_Check( swig_obj[4] ) ) {
17588 0 : int bErr = FALSE;
17589 0 : arg5 = CSLFromPyMapping(swig_obj[4], &bErr);
17590 0 : if ( bErr )
17591 : {
17592 0 : SWIG_fail;
17593 : }
17594 : }
17595 : else {
17596 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
17597 0 : SWIG_fail;
17598 : }
17599 : }
17600 : }
17601 7 : {
17602 7 : if (!arg1) {
17603 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
17604 : }
17605 : }
17606 6 : {
17607 6 : if (!arg2) {
17608 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
17609 : }
17610 : }
17611 5 : {
17612 5 : const int bLocalUseExceptions = GetUseExceptions();
17613 5 : if ( bLocalUseExceptions ) {
17614 1 : pushErrorHandler();
17615 : }
17616 5 : {
17617 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17618 5 : result = (bool)MultipartUploadEnd((char const *)arg1,(char const *)arg2,arg3,arg4,arg5);
17619 5 : SWIG_PYTHON_THREAD_END_ALLOW;
17620 : }
17621 5 : if ( bLocalUseExceptions ) {
17622 1 : popErrorHandler();
17623 : }
17624 : #ifndef SED_HACKS
17625 : if ( bLocalUseExceptions ) {
17626 : CPLErr eclass = CPLGetLastErrorType();
17627 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17628 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17629 : }
17630 : }
17631 : #endif
17632 : }
17633 5 : resultobj = SWIG_From_bool(static_cast< bool >(result));
17634 5 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17635 5 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17636 5 : {
17637 : /* %typemap(freearg) char **dict */
17638 5 : CSLDestroy( arg3 );
17639 : }
17640 5 : {
17641 : /* %typemap(freearg) char **dict */
17642 5 : CSLDestroy( arg5 );
17643 : }
17644 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17645 : return resultobj;
17646 2 : fail:
17647 2 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17648 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17649 2 : {
17650 : /* %typemap(freearg) char **dict */
17651 2 : CSLDestroy( arg3 );
17652 : }
17653 2 : {
17654 : /* %typemap(freearg) char **dict */
17655 2 : CSLDestroy( arg5 );
17656 : }
17657 : return NULL;
17658 : }
17659 :
17660 :
17661 8 : SWIGINTERN PyObject *_wrap_MultipartUploadAbort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17662 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17663 8 : char *arg1 = (char *) 0 ;
17664 8 : char *arg2 = (char *) 0 ;
17665 8 : char **arg3 = (char **) NULL ;
17666 8 : int res1 ;
17667 8 : char *buf1 = 0 ;
17668 8 : int alloc1 = 0 ;
17669 8 : int res2 ;
17670 8 : char *buf2 = 0 ;
17671 8 : int alloc2 = 0 ;
17672 8 : PyObject *swig_obj[3] ;
17673 8 : bool result;
17674 :
17675 8 : if (!SWIG_Python_UnpackTuple(args, "MultipartUploadAbort", 2, 3, swig_obj)) SWIG_fail;
17676 8 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
17677 8 : if (!SWIG_IsOK(res1)) {
17678 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartUploadAbort" "', argument " "1"" of type '" "char const *""'");
17679 : }
17680 8 : arg1 = reinterpret_cast< char * >(buf1);
17681 8 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
17682 8 : if (!SWIG_IsOK(res2)) {
17683 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipartUploadAbort" "', argument " "2"" of type '" "char const *""'");
17684 : }
17685 8 : arg2 = reinterpret_cast< char * >(buf2);
17686 8 : if (swig_obj[2]) {
17687 0 : {
17688 : /* %typemap(in) char **dict */
17689 0 : arg3 = NULL;
17690 0 : if ( PySequence_Check( swig_obj[2] ) ) {
17691 0 : int bErr = FALSE;
17692 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
17693 0 : if ( bErr )
17694 : {
17695 0 : SWIG_fail;
17696 : }
17697 : }
17698 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
17699 0 : int bErr = FALSE;
17700 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
17701 0 : if ( bErr )
17702 : {
17703 0 : SWIG_fail;
17704 : }
17705 : }
17706 : else {
17707 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
17708 0 : SWIG_fail;
17709 : }
17710 : }
17711 : }
17712 8 : {
17713 8 : if (!arg1) {
17714 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
17715 : }
17716 : }
17717 7 : {
17718 7 : if (!arg2) {
17719 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
17720 : }
17721 : }
17722 6 : {
17723 6 : const int bLocalUseExceptions = GetUseExceptions();
17724 6 : if ( bLocalUseExceptions ) {
17725 3 : pushErrorHandler();
17726 : }
17727 6 : {
17728 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17729 6 : result = (bool)MultipartUploadAbort((char const *)arg1,(char const *)arg2,arg3);
17730 6 : SWIG_PYTHON_THREAD_END_ALLOW;
17731 : }
17732 6 : if ( bLocalUseExceptions ) {
17733 3 : popErrorHandler();
17734 : }
17735 : #ifndef SED_HACKS
17736 : if ( bLocalUseExceptions ) {
17737 : CPLErr eclass = CPLGetLastErrorType();
17738 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17739 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17740 : }
17741 : }
17742 : #endif
17743 : }
17744 6 : resultobj = SWIG_From_bool(static_cast< bool >(result));
17745 6 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17746 6 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17747 6 : {
17748 : /* %typemap(freearg) char **dict */
17749 6 : CSLDestroy( arg3 );
17750 : }
17751 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17752 : return resultobj;
17753 2 : fail:
17754 2 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17755 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17756 2 : {
17757 : /* %typemap(freearg) char **dict */
17758 2 : CSLDestroy( arg3 );
17759 : }
17760 : return NULL;
17761 : }
17762 :
17763 :
17764 2497 : SWIGINTERN PyObject *_wrap_MajorObject_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17765 2497 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17766 2497 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
17767 2497 : void *argp1 = 0 ;
17768 2497 : int res1 = 0 ;
17769 2497 : PyObject *swig_obj[1] ;
17770 2497 : char *result = 0 ;
17771 :
17772 2497 : if (!args) SWIG_fail;
17773 2497 : swig_obj[0] = args;
17774 2497 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
17775 2497 : if (!SWIG_IsOK(res1)) {
17776 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetDescription" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
17777 : }
17778 2497 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
17779 2497 : {
17780 2497 : const int bLocalUseExceptions = GetUseExceptions();
17781 2497 : if ( bLocalUseExceptions ) {
17782 1258 : pushErrorHandler();
17783 : }
17784 2497 : {
17785 2497 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17786 2497 : result = (char *)GDALMajorObjectShadow_GetDescription(arg1);
17787 2497 : SWIG_PYTHON_THREAD_END_ALLOW;
17788 : }
17789 2497 : if ( bLocalUseExceptions ) {
17790 1258 : popErrorHandler();
17791 : }
17792 : #ifndef SED_HACKS
17793 : if ( bLocalUseExceptions ) {
17794 : CPLErr eclass = CPLGetLastErrorType();
17795 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17796 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17797 : }
17798 : }
17799 : #endif
17800 : }
17801 2497 : resultobj = SWIG_FromCharPtr((const char *)result);
17802 2497 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17803 : return resultobj;
17804 : fail:
17805 : return NULL;
17806 : }
17807 :
17808 :
17809 51 : SWIGINTERN PyObject *_wrap_MajorObject_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17810 51 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17811 51 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
17812 51 : char *arg2 = (char *) 0 ;
17813 51 : void *argp1 = 0 ;
17814 51 : int res1 = 0 ;
17815 51 : int res2 ;
17816 51 : char *buf2 = 0 ;
17817 51 : int alloc2 = 0 ;
17818 51 : PyObject *swig_obj[2] ;
17819 :
17820 51 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_SetDescription", 2, 2, swig_obj)) SWIG_fail;
17821 51 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
17822 51 : if (!SWIG_IsOK(res1)) {
17823 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_SetDescription" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
17824 : }
17825 51 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
17826 51 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
17827 51 : if (!SWIG_IsOK(res2)) {
17828 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_SetDescription" "', argument " "2"" of type '" "char const *""'");
17829 : }
17830 51 : arg2 = reinterpret_cast< char * >(buf2);
17831 51 : {
17832 51 : if (!arg2) {
17833 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
17834 : }
17835 : }
17836 51 : {
17837 51 : const int bLocalUseExceptions = GetUseExceptions();
17838 51 : if ( bLocalUseExceptions ) {
17839 39 : pushErrorHandler();
17840 : }
17841 51 : {
17842 51 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17843 51 : GDALMajorObjectShadow_SetDescription(arg1,(char const *)arg2);
17844 51 : SWIG_PYTHON_THREAD_END_ALLOW;
17845 : }
17846 51 : if ( bLocalUseExceptions ) {
17847 39 : popErrorHandler();
17848 : }
17849 : #ifndef SED_HACKS
17850 : if ( bLocalUseExceptions ) {
17851 : CPLErr eclass = CPLGetLastErrorType();
17852 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17853 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17854 : }
17855 : }
17856 : #endif
17857 : }
17858 51 : resultobj = SWIG_Py_Void();
17859 51 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17860 51 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17861 : return resultobj;
17862 0 : fail:
17863 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17864 : return NULL;
17865 : }
17866 :
17867 :
17868 75 : SWIGINTERN PyObject *_wrap_MajorObject_GetMetadataDomainList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17869 75 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17870 75 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
17871 75 : void *argp1 = 0 ;
17872 75 : int res1 = 0 ;
17873 75 : PyObject *swig_obj[1] ;
17874 75 : char **result = 0 ;
17875 :
17876 75 : if (!args) SWIG_fail;
17877 75 : swig_obj[0] = args;
17878 75 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
17879 75 : if (!SWIG_IsOK(res1)) {
17880 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetMetadataDomainList" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
17881 : }
17882 75 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
17883 75 : {
17884 75 : const int bLocalUseExceptions = GetUseExceptions();
17885 75 : if ( bLocalUseExceptions ) {
17886 39 : pushErrorHandler();
17887 : }
17888 75 : {
17889 75 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17890 75 : result = (char **)GDALMajorObjectShadow_GetMetadataDomainList(arg1);
17891 75 : SWIG_PYTHON_THREAD_END_ALLOW;
17892 : }
17893 75 : if ( bLocalUseExceptions ) {
17894 39 : popErrorHandler();
17895 : }
17896 : #ifndef SED_HACKS
17897 : if ( bLocalUseExceptions ) {
17898 : CPLErr eclass = CPLGetLastErrorType();
17899 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17900 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17901 : }
17902 : }
17903 : #endif
17904 : }
17905 75 : {
17906 : /* %typemap(out) char **CSL -> ( string ) */
17907 75 : bool bErr = false;
17908 75 : resultobj = CSLToList(result, &bErr);
17909 75 : CSLDestroy(result);
17910 75 : if( bErr ) {
17911 0 : SWIG_fail;
17912 : }
17913 : }
17914 75 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17915 : return resultobj;
17916 : fail:
17917 : return NULL;
17918 : }
17919 :
17920 :
17921 7021 : SWIGINTERN PyObject *_wrap_MajorObject_GetMetadata_Dict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17922 7021 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17923 7021 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
17924 7021 : char *arg2 = (char *) "" ;
17925 7021 : void *argp1 = 0 ;
17926 7021 : int res1 = 0 ;
17927 7021 : int res2 ;
17928 7021 : char *buf2 = 0 ;
17929 7021 : int alloc2 = 0 ;
17930 7021 : PyObject *swig_obj[2] ;
17931 7021 : char **result = 0 ;
17932 :
17933 7021 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_GetMetadata_Dict", 1, 2, swig_obj)) SWIG_fail;
17934 7021 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
17935 7021 : if (!SWIG_IsOK(res1)) {
17936 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetMetadata_Dict" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
17937 : }
17938 7021 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
17939 7021 : if (swig_obj[1]) {
17940 6927 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
17941 6927 : if (!SWIG_IsOK(res2)) {
17942 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_GetMetadata_Dict" "', argument " "2"" of type '" "char const *""'");
17943 : }
17944 6927 : arg2 = reinterpret_cast< char * >(buf2);
17945 : }
17946 7021 : {
17947 7021 : const int bLocalUseExceptions = GetUseExceptions();
17948 7021 : if ( bLocalUseExceptions ) {
17949 1723 : pushErrorHandler();
17950 : }
17951 7021 : {
17952 7021 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17953 7021 : result = (char **)GDALMajorObjectShadow_GetMetadata_Dict(arg1,(char const *)arg2);
17954 7021 : SWIG_PYTHON_THREAD_END_ALLOW;
17955 : }
17956 7021 : if ( bLocalUseExceptions ) {
17957 1723 : popErrorHandler();
17958 : }
17959 : #ifndef SED_HACKS
17960 : if ( bLocalUseExceptions ) {
17961 : CPLErr eclass = CPLGetLastErrorType();
17962 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
17963 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
17964 : }
17965 : }
17966 : #endif
17967 : }
17968 7021 : {
17969 : /* %typemap(out) char **dict */
17970 7021 : resultobj = GetCSLStringAsPyDict(result, false);
17971 : }
17972 7021 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17973 7021 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
17974 : return resultobj;
17975 0 : fail:
17976 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17977 : return NULL;
17978 : }
17979 :
17980 :
17981 404 : SWIGINTERN PyObject *_wrap_MajorObject_GetMetadata_List(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17982 404 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
17983 404 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
17984 404 : char *arg2 = (char *) "" ;
17985 404 : void *argp1 = 0 ;
17986 404 : int res1 = 0 ;
17987 404 : int res2 ;
17988 404 : char *buf2 = 0 ;
17989 404 : int alloc2 = 0 ;
17990 404 : PyObject *swig_obj[2] ;
17991 404 : char **result = 0 ;
17992 :
17993 404 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_GetMetadata_List", 1, 2, swig_obj)) SWIG_fail;
17994 404 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
17995 404 : if (!SWIG_IsOK(res1)) {
17996 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetMetadata_List" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
17997 : }
17998 404 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
17999 404 : if (swig_obj[1]) {
18000 361 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
18001 361 : if (!SWIG_IsOK(res2)) {
18002 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_GetMetadata_List" "', argument " "2"" of type '" "char const *""'");
18003 : }
18004 361 : arg2 = reinterpret_cast< char * >(buf2);
18005 : }
18006 404 : {
18007 404 : const int bLocalUseExceptions = GetUseExceptions();
18008 404 : if ( bLocalUseExceptions ) {
18009 116 : pushErrorHandler();
18010 : }
18011 404 : {
18012 404 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18013 404 : result = (char **)GDALMajorObjectShadow_GetMetadata_List(arg1,(char const *)arg2);
18014 404 : SWIG_PYTHON_THREAD_END_ALLOW;
18015 : }
18016 404 : if ( bLocalUseExceptions ) {
18017 116 : popErrorHandler();
18018 : }
18019 : #ifndef SED_HACKS
18020 : if ( bLocalUseExceptions ) {
18021 : CPLErr eclass = CPLGetLastErrorType();
18022 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18023 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18024 : }
18025 : }
18026 : #endif
18027 : }
18028 404 : {
18029 : /* %typemap(out) char **options -> ( string ) */
18030 404 : bool bErr = false;
18031 404 : resultobj = CSLToList(result, &bErr);
18032 404 : if( bErr ) {
18033 0 : SWIG_fail;
18034 : }
18035 : }
18036 404 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18037 404 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18038 : return resultobj;
18039 0 : fail:
18040 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18041 : return NULL;
18042 : }
18043 :
18044 :
18045 : SWIGINTERN PyObject *_wrap_MajorObject_SetMetadata__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18046 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18047 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
18048 : char **arg2 = (char **) 0 ;
18049 : char *arg3 = (char *) "" ;
18050 : void *argp1 = 0 ;
18051 : int res1 = 0 ;
18052 : int res3 ;
18053 : char *buf3 = 0 ;
18054 : int alloc3 = 0 ;
18055 : CPLErr result;
18056 :
18057 : if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
18058 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
18059 : if (!SWIG_IsOK(res1)) {
18060 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_SetMetadata" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
18061 : }
18062 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
18063 : {
18064 : /* %typemap(in) char **dict */
18065 : arg2 = NULL;
18066 : if ( PySequence_Check( swig_obj[1] ) ) {
18067 : int bErr = FALSE;
18068 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
18069 : if ( bErr )
18070 : {
18071 : SWIG_fail;
18072 : }
18073 : }
18074 : else if ( PyMapping_Check( swig_obj[1] ) ) {
18075 : int bErr = FALSE;
18076 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
18077 : if ( bErr )
18078 : {
18079 : SWIG_fail;
18080 : }
18081 : }
18082 : else {
18083 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
18084 : SWIG_fail;
18085 : }
18086 : }
18087 : if (swig_obj[2]) {
18088 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
18089 : if (!SWIG_IsOK(res3)) {
18090 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MajorObject_SetMetadata" "', argument " "3"" of type '" "char const *""'");
18091 : }
18092 : arg3 = reinterpret_cast< char * >(buf3);
18093 : }
18094 : {
18095 : const int bLocalUseExceptions = GetUseExceptions();
18096 : if ( bLocalUseExceptions ) {
18097 : pushErrorHandler();
18098 : }
18099 : {
18100 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18101 : result = (CPLErr)GDALMajorObjectShadow_SetMetadata__SWIG_0(arg1,arg2,(char const *)arg3);
18102 : SWIG_PYTHON_THREAD_END_ALLOW;
18103 : }
18104 : if ( bLocalUseExceptions ) {
18105 : popErrorHandler();
18106 : }
18107 : #ifndef SED_HACKS
18108 : if ( bLocalUseExceptions ) {
18109 : CPLErr eclass = CPLGetLastErrorType();
18110 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18111 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18112 : }
18113 : }
18114 : #endif
18115 : }
18116 : resultobj = SWIG_From_int(static_cast< int >(result));
18117 : {
18118 : /* %typemap(freearg) char **dict */
18119 : CSLDestroy( arg2 );
18120 : }
18121 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18122 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18123 : return resultobj;
18124 : fail:
18125 : {
18126 : /* %typemap(freearg) char **dict */
18127 : CSLDestroy( arg2 );
18128 : }
18129 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18130 : return NULL;
18131 : }
18132 :
18133 :
18134 : SWIGINTERN PyObject *_wrap_MajorObject_SetMetadata__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
18135 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18136 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
18137 : char *arg2 = (char *) 0 ;
18138 : char *arg3 = (char *) "" ;
18139 : void *argp1 = 0 ;
18140 : int res1 = 0 ;
18141 : int res2 ;
18142 : char *buf2 = 0 ;
18143 : int alloc2 = 0 ;
18144 : int res3 ;
18145 : char *buf3 = 0 ;
18146 : int alloc3 = 0 ;
18147 : CPLErr result;
18148 :
18149 : if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
18150 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
18151 : if (!SWIG_IsOK(res1)) {
18152 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_SetMetadata" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
18153 : }
18154 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
18155 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
18156 : if (!SWIG_IsOK(res2)) {
18157 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_SetMetadata" "', argument " "2"" of type '" "char *""'");
18158 : }
18159 : arg2 = reinterpret_cast< char * >(buf2);
18160 : if (swig_obj[2]) {
18161 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
18162 : if (!SWIG_IsOK(res3)) {
18163 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MajorObject_SetMetadata" "', argument " "3"" of type '" "char const *""'");
18164 : }
18165 : arg3 = reinterpret_cast< char * >(buf3);
18166 : }
18167 : {
18168 : const int bLocalUseExceptions = GetUseExceptions();
18169 : if ( bLocalUseExceptions ) {
18170 : pushErrorHandler();
18171 : }
18172 : {
18173 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18174 : result = (CPLErr)GDALMajorObjectShadow_SetMetadata__SWIG_1(arg1,arg2,(char const *)arg3);
18175 : SWIG_PYTHON_THREAD_END_ALLOW;
18176 : }
18177 : if ( bLocalUseExceptions ) {
18178 : popErrorHandler();
18179 : }
18180 : #ifndef SED_HACKS
18181 : if ( bLocalUseExceptions ) {
18182 : CPLErr eclass = CPLGetLastErrorType();
18183 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18184 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18185 : }
18186 : }
18187 : #endif
18188 : }
18189 : resultobj = SWIG_From_int(static_cast< int >(result));
18190 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18191 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18192 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18193 : return resultobj;
18194 : fail:
18195 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18196 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18197 : return NULL;
18198 : }
18199 :
18200 :
18201 281 : SWIGINTERN PyObject *_wrap_MajorObject_SetMetadata(PyObject *self, PyObject *args) {
18202 281 : Py_ssize_t argc;
18203 281 : PyObject *argv[4] = {
18204 : 0
18205 : };
18206 :
18207 281 : if (!(argc = SWIG_Python_UnpackTuple(args, "MajorObject_SetMetadata", 0, 3, argv))) SWIG_fail;
18208 281 : --argc;
18209 281 : if ((argc >= 2) && (argc <= 3)) {
18210 281 : int _v;
18211 281 : void *vptr = 0;
18212 281 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GDALMajorObjectShadow, 0);
18213 301 : _v = SWIG_CheckState(res);
18214 281 : if (_v) {
18215 281 : {
18216 : /* %typecheck(SWIG_TYPECHECK_POINTER) (char **dict) */
18217 : /* Note: we exclude explicitly strings, because they can be considered as a sequence of characters, */
18218 : /* which is not desirable since it makes it impossible to define bindings such as SetMetadata(string) and SetMetadata(array_of_string) */
18219 : /* (see #4816) */
18220 281 : _v = ((PyMapping_Check(argv[1]) || PySequence_Check(argv[1]) ) && !SWIG_CheckState(SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0)) ) ? 1 : 0;
18221 : }
18222 261 : if (_v) {
18223 261 : if (argc <= 2) {
18224 261 : return _wrap_MajorObject_SetMetadata__SWIG_0(self, argc, argv);
18225 : }
18226 111 : int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
18227 111 : _v = SWIG_CheckState(res);
18228 111 : if (_v) {
18229 111 : return _wrap_MajorObject_SetMetadata__SWIG_0(self, argc, argv);
18230 : }
18231 : }
18232 : }
18233 : }
18234 20 : if ((argc >= 2) && (argc <= 3)) {
18235 20 : int _v;
18236 20 : void *vptr = 0;
18237 20 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GDALMajorObjectShadow, 0);
18238 21 : _v = SWIG_CheckState(res);
18239 20 : if (_v) {
18240 20 : int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
18241 20 : _v = SWIG_CheckState(res);
18242 19 : if (_v) {
18243 19 : if (argc <= 2) {
18244 19 : return _wrap_MajorObject_SetMetadata__SWIG_1(self, argc, argv);
18245 : }
18246 15 : int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
18247 15 : _v = SWIG_CheckState(res);
18248 15 : if (_v) {
18249 15 : return _wrap_MajorObject_SetMetadata__SWIG_1(self, argc, argv);
18250 : }
18251 : }
18252 : }
18253 : }
18254 :
18255 0 : fail:
18256 1 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MajorObject_SetMetadata'.\n"
18257 : " Possible C/C++ prototypes are:\n"
18258 : " GDALMajorObjectShadow::SetMetadata(char **,char const *)\n"
18259 : " GDALMajorObjectShadow::SetMetadata(char *,char const *)\n");
18260 : return 0;
18261 : }
18262 :
18263 :
18264 57015 : SWIGINTERN PyObject *_wrap_MajorObject_GetMetadataItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18265 57015 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18266 57015 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
18267 57015 : char *arg2 = (char *) 0 ;
18268 57015 : char *arg3 = (char *) "" ;
18269 57015 : void *argp1 = 0 ;
18270 57015 : int res1 = 0 ;
18271 57015 : int res2 ;
18272 57015 : char *buf2 = 0 ;
18273 57015 : int alloc2 = 0 ;
18274 57015 : int res3 ;
18275 57015 : char *buf3 = 0 ;
18276 57015 : int alloc3 = 0 ;
18277 57015 : PyObject *swig_obj[3] ;
18278 57015 : char *result = 0 ;
18279 :
18280 57015 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_GetMetadataItem", 2, 3, swig_obj)) SWIG_fail;
18281 57015 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
18282 57015 : if (!SWIG_IsOK(res1)) {
18283 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_GetMetadataItem" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
18284 : }
18285 57015 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
18286 57015 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
18287 57015 : if (!SWIG_IsOK(res2)) {
18288 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_GetMetadataItem" "', argument " "2"" of type '" "char const *""'");
18289 : }
18290 57015 : arg2 = reinterpret_cast< char * >(buf2);
18291 57015 : if (swig_obj[2]) {
18292 6948 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
18293 6948 : if (!SWIG_IsOK(res3)) {
18294 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MajorObject_GetMetadataItem" "', argument " "3"" of type '" "char const *""'");
18295 : }
18296 6948 : arg3 = reinterpret_cast< char * >(buf3);
18297 : }
18298 57015 : {
18299 57015 : if (!arg2) {
18300 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
18301 : }
18302 : }
18303 57015 : {
18304 57015 : const int bLocalUseExceptions = GetUseExceptions();
18305 57015 : if ( bLocalUseExceptions ) {
18306 52625 : pushErrorHandler();
18307 : }
18308 57015 : {
18309 57015 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18310 57015 : result = (char *)GDALMajorObjectShadow_GetMetadataItem(arg1,(char const *)arg2,(char const *)arg3);
18311 57015 : SWIG_PYTHON_THREAD_END_ALLOW;
18312 : }
18313 57015 : if ( bLocalUseExceptions ) {
18314 52625 : popErrorHandler();
18315 : }
18316 : #ifndef SED_HACKS
18317 : if ( bLocalUseExceptions ) {
18318 : CPLErr eclass = CPLGetLastErrorType();
18319 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18320 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18321 : }
18322 : }
18323 : #endif
18324 : }
18325 57015 : resultobj = SWIG_FromCharPtr((const char *)result);
18326 57015 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18327 57015 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18328 57017 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18329 : return resultobj;
18330 0 : fail:
18331 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18332 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18333 : return NULL;
18334 : }
18335 :
18336 :
18337 494 : SWIGINTERN PyObject *_wrap_MajorObject_SetMetadataItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18338 494 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18339 494 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
18340 494 : char *arg2 = (char *) 0 ;
18341 494 : char *arg3 = (char *) 0 ;
18342 494 : char *arg4 = (char *) "" ;
18343 494 : void *argp1 = 0 ;
18344 494 : int res1 = 0 ;
18345 494 : int res2 ;
18346 494 : char *buf2 = 0 ;
18347 494 : int alloc2 = 0 ;
18348 494 : int res3 ;
18349 494 : char *buf3 = 0 ;
18350 494 : int alloc3 = 0 ;
18351 494 : int res4 ;
18352 494 : char *buf4 = 0 ;
18353 494 : int alloc4 = 0 ;
18354 494 : PyObject *swig_obj[4] ;
18355 494 : CPLErr result;
18356 :
18357 494 : if (!SWIG_Python_UnpackTuple(args, "MajorObject_SetMetadataItem", 3, 4, swig_obj)) SWIG_fail;
18358 494 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMajorObjectShadow, 0 | 0 );
18359 494 : if (!SWIG_IsOK(res1)) {
18360 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MajorObject_SetMetadataItem" "', argument " "1"" of type '" "GDALMajorObjectShadow *""'");
18361 : }
18362 494 : arg1 = reinterpret_cast< GDALMajorObjectShadow * >(argp1);
18363 494 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
18364 494 : if (!SWIG_IsOK(res2)) {
18365 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MajorObject_SetMetadataItem" "', argument " "2"" of type '" "char const *""'");
18366 : }
18367 494 : arg2 = reinterpret_cast< char * >(buf2);
18368 494 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
18369 494 : if (!SWIG_IsOK(res3)) {
18370 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MajorObject_SetMetadataItem" "', argument " "3"" of type '" "char const *""'");
18371 : }
18372 494 : arg3 = reinterpret_cast< char * >(buf3);
18373 494 : if (swig_obj[3]) {
18374 77 : res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
18375 77 : if (!SWIG_IsOK(res4)) {
18376 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MajorObject_SetMetadataItem" "', argument " "4"" of type '" "char const *""'");
18377 : }
18378 77 : arg4 = reinterpret_cast< char * >(buf4);
18379 : }
18380 494 : {
18381 494 : if (!arg2) {
18382 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
18383 : }
18384 : }
18385 494 : {
18386 494 : const int bLocalUseExceptions = GetUseExceptions();
18387 494 : if ( bLocalUseExceptions ) {
18388 127 : pushErrorHandler();
18389 : }
18390 494 : {
18391 494 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18392 494 : result = (CPLErr)GDALMajorObjectShadow_SetMetadataItem(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
18393 494 : SWIG_PYTHON_THREAD_END_ALLOW;
18394 : }
18395 494 : if ( bLocalUseExceptions ) {
18396 127 : popErrorHandler();
18397 : }
18398 : #ifndef SED_HACKS
18399 : if ( bLocalUseExceptions ) {
18400 : CPLErr eclass = CPLGetLastErrorType();
18401 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18402 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18403 : }
18404 : }
18405 : #endif
18406 : }
18407 494 : resultobj = SWIG_From_int(static_cast< int >(result));
18408 494 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18409 494 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18410 494 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
18411 494 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18412 : return resultobj;
18413 0 : fail:
18414 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18415 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18416 0 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
18417 : return NULL;
18418 : }
18419 :
18420 :
18421 277 : SWIGINTERN PyObject *MajorObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18422 277 : PyObject *obj;
18423 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
18424 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALMajorObjectShadow, SWIG_NewClientData(obj));
18425 277 : return SWIG_Py_Void();
18426 : }
18427 :
18428 98600 : SWIGINTERN PyObject *_wrap_Driver_ShortName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18429 98600 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18430 98600 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
18431 98600 : void *argp1 = 0 ;
18432 98600 : int res1 = 0 ;
18433 98600 : PyObject *swig_obj[1] ;
18434 98600 : char *result = 0 ;
18435 :
18436 98600 : if (!args) SWIG_fail;
18437 98600 : swig_obj[0] = args;
18438 98600 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
18439 98600 : if (!SWIG_IsOK(res1)) {
18440 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Driver_ShortName_get" "', argument " "1"" of type '" "GDALDriverShadow *""'");
18441 : }
18442 98600 : arg1 = reinterpret_cast< GDALDriverShadow * >(argp1);
18443 98600 : {
18444 98600 : const int bLocalUseExceptions = GetUseExceptions();
18445 98600 : if ( bLocalUseExceptions ) {
18446 51474 : pushErrorHandler();
18447 : }
18448 98600 : {
18449 98600 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18450 98600 : result = (char *)GDALDriverShadow_ShortName_get(arg1);
18451 98600 : SWIG_PYTHON_THREAD_END_ALLOW;
18452 : }
18453 98600 : if ( bLocalUseExceptions ) {
18454 51474 : popErrorHandler();
18455 : }
18456 : #ifndef SED_HACKS
18457 : if ( bLocalUseExceptions ) {
18458 : CPLErr eclass = CPLGetLastErrorType();
18459 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18460 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18461 : }
18462 : }
18463 : #endif
18464 : }
18465 98600 : resultobj = SWIG_FromCharPtr((const char *)result);
18466 98600 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18467 : return resultobj;
18468 : fail:
18469 : return NULL;
18470 : }
18471 :
18472 :
18473 17 : SWIGINTERN PyObject *_wrap_Driver_LongName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18474 17 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18475 17 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
18476 17 : void *argp1 = 0 ;
18477 17 : int res1 = 0 ;
18478 17 : PyObject *swig_obj[1] ;
18479 17 : char *result = 0 ;
18480 :
18481 17 : if (!args) SWIG_fail;
18482 17 : swig_obj[0] = args;
18483 17 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
18484 17 : if (!SWIG_IsOK(res1)) {
18485 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Driver_LongName_get" "', argument " "1"" of type '" "GDALDriverShadow *""'");
18486 : }
18487 17 : arg1 = reinterpret_cast< GDALDriverShadow * >(argp1);
18488 17 : {
18489 17 : const int bLocalUseExceptions = GetUseExceptions();
18490 17 : if ( bLocalUseExceptions ) {
18491 0 : pushErrorHandler();
18492 : }
18493 17 : {
18494 17 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18495 17 : result = (char *)GDALDriverShadow_LongName_get(arg1);
18496 17 : SWIG_PYTHON_THREAD_END_ALLOW;
18497 : }
18498 17 : if ( bLocalUseExceptions ) {
18499 0 : popErrorHandler();
18500 : }
18501 : #ifndef SED_HACKS
18502 : if ( bLocalUseExceptions ) {
18503 : CPLErr eclass = CPLGetLastErrorType();
18504 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18505 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18506 : }
18507 : }
18508 : #endif
18509 : }
18510 17 : resultobj = SWIG_FromCharPtr((const char *)result);
18511 17 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18512 : return resultobj;
18513 : fail:
18514 : return NULL;
18515 : }
18516 :
18517 :
18518 0 : SWIGINTERN PyObject *_wrap_Driver_HelpTopic_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18519 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18520 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
18521 0 : void *argp1 = 0 ;
18522 0 : int res1 = 0 ;
18523 0 : PyObject *swig_obj[1] ;
18524 0 : char *result = 0 ;
18525 :
18526 0 : if (!args) SWIG_fail;
18527 0 : swig_obj[0] = args;
18528 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
18529 0 : if (!SWIG_IsOK(res1)) {
18530 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Driver_HelpTopic_get" "', argument " "1"" of type '" "GDALDriverShadow *""'");
18531 : }
18532 0 : arg1 = reinterpret_cast< GDALDriverShadow * >(argp1);
18533 0 : {
18534 0 : const int bLocalUseExceptions = GetUseExceptions();
18535 0 : if ( bLocalUseExceptions ) {
18536 0 : pushErrorHandler();
18537 : }
18538 0 : {
18539 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18540 0 : result = (char *)GDALDriverShadow_HelpTopic_get(arg1);
18541 0 : SWIG_PYTHON_THREAD_END_ALLOW;
18542 : }
18543 0 : if ( bLocalUseExceptions ) {
18544 0 : popErrorHandler();
18545 : }
18546 : #ifndef SED_HACKS
18547 : if ( bLocalUseExceptions ) {
18548 : CPLErr eclass = CPLGetLastErrorType();
18549 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18550 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18551 : }
18552 : }
18553 : #endif
18554 : }
18555 0 : resultobj = SWIG_FromCharPtr((const char *)result);
18556 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18557 : return resultobj;
18558 : fail:
18559 : return NULL;
18560 : }
18561 :
18562 :
18563 17613 : SWIGINTERN PyObject *_wrap_Driver_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18564 17613 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18565 17613 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
18566 17613 : char *arg2 = (char *) 0 ;
18567 17613 : int arg3 ;
18568 17613 : int arg4 ;
18569 17613 : int arg5 = (int) 1 ;
18570 17613 : GDALDataType arg6 = (GDALDataType) GDT_Byte ;
18571 17613 : char **arg7 = (char **) 0 ;
18572 17613 : void *argp1 = 0 ;
18573 17613 : int res1 = 0 ;
18574 17613 : int bToFree2 = 0 ;
18575 17613 : int val3 ;
18576 17613 : int ecode3 = 0 ;
18577 17613 : int val4 ;
18578 17613 : int ecode4 = 0 ;
18579 17613 : int val5 ;
18580 17613 : int ecode5 = 0 ;
18581 17613 : PyObject * obj0 = 0 ;
18582 17613 : PyObject * obj1 = 0 ;
18583 17613 : PyObject * obj2 = 0 ;
18584 17613 : PyObject * obj3 = 0 ;
18585 17613 : PyObject * obj4 = 0 ;
18586 17613 : PyObject * obj5 = 0 ;
18587 17613 : PyObject * obj6 = 0 ;
18588 17613 : char * kwnames[] = {
18589 : (char *)"self", (char *)"utf8_path", (char *)"xsize", (char *)"ysize", (char *)"bands", (char *)"eType", (char *)"options", NULL
18590 : };
18591 17613 : GDALDatasetShadow *result = 0 ;
18592 :
18593 17613 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOO:Driver_Create", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
18594 17613 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
18595 17613 : if (!SWIG_IsOK(res1)) {
18596 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Driver_Create" "', argument " "1"" of type '" "GDALDriverShadow *""'");
18597 : }
18598 17613 : arg1 = reinterpret_cast< GDALDriverShadow * >(argp1);
18599 17613 : {
18600 : /* %typemap(in) (const char *utf8_path) */
18601 17613 : if (PyUnicode_Check(obj1) || PyBytes_Check(obj1))
18602 : {
18603 13841 : arg2 = GDALPythonObjectToCStr( obj1, &bToFree2 );
18604 : }
18605 : else
18606 : {
18607 3772 : arg2 = GDALPythonPathToCStr(obj1, &bToFree2);
18608 :
18609 : }
18610 17613 : if (arg2 == NULL)
18611 : {
18612 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
18613 0 : SWIG_fail;
18614 : }
18615 : }
18616 17613 : ecode3 = SWIG_AsVal_int(obj2, &val3);
18617 17613 : if (!SWIG_IsOK(ecode3)) {
18618 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Driver_Create" "', argument " "3"" of type '" "int""'");
18619 : }
18620 17613 : arg3 = static_cast< int >(val3);
18621 17613 : ecode4 = SWIG_AsVal_int(obj3, &val4);
18622 17613 : if (!SWIG_IsOK(ecode4)) {
18623 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Driver_Create" "', argument " "4"" of type '" "int""'");
18624 : }
18625 17613 : arg4 = static_cast< int >(val4);
18626 17613 : if (obj4) {
18627 15831 : ecode5 = SWIG_AsVal_int(obj4, &val5);
18628 15831 : if (!SWIG_IsOK(ecode5)) {
18629 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Driver_Create" "', argument " "5"" of type '" "int""'");
18630 : }
18631 : arg5 = static_cast< int >(val5);
18632 : }
18633 17613 : if (obj5) {
18634 9456 : {
18635 9456 : if (PyInt_Check(obj5))
18636 : {
18637 9452 : arg6 = static_cast<GDALDataType>(PyInt_AsLong(obj5));
18638 : }
18639 : else
18640 : {
18641 4 : PyObject* gdal_array = PyImport_ImportModule("osgeo.gdal_array");
18642 4 : if (gdal_array)
18643 : {
18644 4 : PyObject* dict = PyModule_GetDict(gdal_array);
18645 4 : PyObject* fn = PyDict_GetItemString(dict, "NumericTypeCodeToGDALTypeCode");
18646 4 : PyObject* type_code = PyObject_CallFunctionObjArgs(fn, obj5, NULL);
18647 :
18648 4 : Py_DECREF(gdal_array);
18649 4 : if (type_code && PyInt_Check(type_code))
18650 : {
18651 2 : arg6 = static_cast<GDALDataType>(PyInt_AsLong(type_code));
18652 2 : Py_DECREF(type_code);
18653 : }
18654 : else
18655 : {
18656 2 : Py_XDECREF(type_code);
18657 2 : PyErr_SetString(PyExc_RuntimeError, "type must be a GDAL data type code or NumPy type");
18658 2 : SWIG_fail;
18659 : }
18660 : }
18661 : else
18662 : {
18663 0 : PyErr_SetString(PyExc_RuntimeError, "gdal_array module is not available; type must be a specified as a GDAL data type code");
18664 0 : SWIG_fail;
18665 : }
18666 : }
18667 : }
18668 : }
18669 17611 : if (obj6) {
18670 4419 : {
18671 : /* %typemap(in) char **dict */
18672 4419 : arg7 = NULL;
18673 4419 : if ( PySequence_Check( obj6 ) ) {
18674 4387 : int bErr = FALSE;
18675 4387 : arg7 = CSLFromPySequence(obj6, &bErr);
18676 4387 : if ( bErr )
18677 : {
18678 0 : SWIG_fail;
18679 : }
18680 : }
18681 32 : else if ( PyMapping_Check( obj6 ) ) {
18682 32 : int bErr = FALSE;
18683 32 : arg7 = CSLFromPyMapping(obj6, &bErr);
18684 32 : if ( bErr )
18685 : {
18686 0 : SWIG_fail;
18687 : }
18688 : }
18689 : else {
18690 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
18691 0 : SWIG_fail;
18692 : }
18693 : }
18694 : }
18695 17611 : {
18696 17611 : if (!arg2) {
18697 17611 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
18698 : }
18699 : }
18700 17611 : {
18701 17611 : const int bLocalUseExceptions = GetUseExceptions();
18702 17611 : if ( bLocalUseExceptions ) {
18703 5814 : pushErrorHandler();
18704 : }
18705 17611 : {
18706 17611 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18707 17611 : result = (GDALDatasetShadow *)GDALDriverShadow_Create(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
18708 17611 : SWIG_PYTHON_THREAD_END_ALLOW;
18709 : }
18710 17611 : if ( bLocalUseExceptions ) {
18711 5814 : popErrorHandler();
18712 : }
18713 : #ifndef SED_HACKS
18714 : if ( bLocalUseExceptions ) {
18715 : CPLErr eclass = CPLGetLastErrorType();
18716 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18717 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18718 : }
18719 : }
18720 : #endif
18721 : }
18722 17611 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
18723 17611 : {
18724 : /* %typemap(freearg) (const char *utf8_path) */
18725 17611 : GDALPythonFreeCStr(arg2, bToFree2);
18726 : }
18727 17611 : {
18728 : /* %typemap(freearg) char **dict */
18729 17611 : CSLDestroy( arg7 );
18730 : }
18731 17659 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18732 : return resultobj;
18733 2 : fail:
18734 2 : {
18735 : /* %typemap(freearg) (const char *utf8_path) */
18736 2 : GDALPythonFreeCStr(arg2, bToFree2);
18737 : }
18738 2 : {
18739 : /* %typemap(freearg) char **dict */
18740 2 : CSLDestroy( arg7 );
18741 : }
18742 : return NULL;
18743 : }
18744 :
18745 :
18746 310 : SWIGINTERN PyObject *_wrap_Driver_CreateVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18747 310 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18748 310 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
18749 310 : char *arg2 = (char *) 0 ;
18750 310 : char **arg3 = (char **) 0 ;
18751 310 : void *argp1 = 0 ;
18752 310 : int res1 = 0 ;
18753 310 : int bToFree2 = 0 ;
18754 310 : PyObject * obj0 = 0 ;
18755 310 : PyObject * obj1 = 0 ;
18756 310 : PyObject * obj2 = 0 ;
18757 310 : char * kwnames[] = {
18758 : (char *)"self", (char *)"utf8_path", (char *)"options", NULL
18759 : };
18760 310 : GDALDatasetShadow *result = 0 ;
18761 :
18762 310 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Driver_CreateVector", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
18763 310 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
18764 310 : if (!SWIG_IsOK(res1)) {
18765 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Driver_CreateVector" "', argument " "1"" of type '" "GDALDriverShadow *""'");
18766 : }
18767 310 : arg1 = reinterpret_cast< GDALDriverShadow * >(argp1);
18768 310 : {
18769 : /* %typemap(in) (const char *utf8_path) */
18770 310 : if (PyUnicode_Check(obj1) || PyBytes_Check(obj1))
18771 : {
18772 252 : arg2 = GDALPythonObjectToCStr( obj1, &bToFree2 );
18773 : }
18774 : else
18775 : {
18776 58 : arg2 = GDALPythonPathToCStr(obj1, &bToFree2);
18777 :
18778 : }
18779 310 : if (arg2 == NULL)
18780 : {
18781 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
18782 0 : SWIG_fail;
18783 : }
18784 : }
18785 310 : if (obj2) {
18786 3 : {
18787 : /* %typemap(in) char **dict */
18788 3 : arg3 = NULL;
18789 3 : if ( PySequence_Check( obj2 ) ) {
18790 3 : int bErr = FALSE;
18791 3 : arg3 = CSLFromPySequence(obj2, &bErr);
18792 3 : if ( bErr )
18793 : {
18794 0 : SWIG_fail;
18795 : }
18796 : }
18797 0 : else if ( PyMapping_Check( obj2 ) ) {
18798 0 : int bErr = FALSE;
18799 0 : arg3 = CSLFromPyMapping(obj2, &bErr);
18800 0 : if ( bErr )
18801 : {
18802 0 : SWIG_fail;
18803 : }
18804 : }
18805 : else {
18806 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
18807 0 : SWIG_fail;
18808 : }
18809 : }
18810 : }
18811 310 : {
18812 310 : if (!arg2) {
18813 310 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
18814 : }
18815 : }
18816 310 : {
18817 310 : const int bLocalUseExceptions = GetUseExceptions();
18818 310 : if ( bLocalUseExceptions ) {
18819 305 : pushErrorHandler();
18820 : }
18821 310 : {
18822 310 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18823 310 : result = (GDALDatasetShadow *)GDALDriverShadow_CreateVector(arg1,(char const *)arg2,arg3);
18824 310 : SWIG_PYTHON_THREAD_END_ALLOW;
18825 : }
18826 310 : if ( bLocalUseExceptions ) {
18827 305 : popErrorHandler();
18828 : }
18829 : #ifndef SED_HACKS
18830 : if ( bLocalUseExceptions ) {
18831 : CPLErr eclass = CPLGetLastErrorType();
18832 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18833 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18834 : }
18835 : }
18836 : #endif
18837 : }
18838 310 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
18839 310 : {
18840 : /* %typemap(freearg) (const char *utf8_path) */
18841 310 : GDALPythonFreeCStr(arg2, bToFree2);
18842 : }
18843 310 : {
18844 : /* %typemap(freearg) char **dict */
18845 310 : CSLDestroy( arg3 );
18846 : }
18847 310 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18848 : return resultobj;
18849 0 : fail:
18850 0 : {
18851 : /* %typemap(freearg) (const char *utf8_path) */
18852 0 : GDALPythonFreeCStr(arg2, bToFree2);
18853 : }
18854 0 : {
18855 : /* %typemap(freearg) char **dict */
18856 0 : CSLDestroy( arg3 );
18857 : }
18858 : return NULL;
18859 : }
18860 :
18861 :
18862 471 : SWIGINTERN PyObject *_wrap_Driver_CreateMultiDimensional(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18863 471 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
18864 471 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
18865 471 : char *arg2 = (char *) 0 ;
18866 471 : char **arg3 = (char **) 0 ;
18867 471 : char **arg4 = (char **) 0 ;
18868 471 : void *argp1 = 0 ;
18869 471 : int res1 = 0 ;
18870 471 : int bToFree2 = 0 ;
18871 471 : PyObject * obj0 = 0 ;
18872 471 : PyObject * obj1 = 0 ;
18873 471 : PyObject * obj2 = 0 ;
18874 471 : PyObject * obj3 = 0 ;
18875 471 : char * kwnames[] = {
18876 : (char *)"self", (char *)"utf8_path", (char *)"root_group_options", (char *)"options", NULL
18877 : };
18878 471 : GDALDatasetShadow *result = 0 ;
18879 :
18880 471 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:Driver_CreateMultiDimensional", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
18881 471 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
18882 471 : if (!SWIG_IsOK(res1)) {
18883 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Driver_CreateMultiDimensional" "', argument " "1"" of type '" "GDALDriverShadow *""'");
18884 : }
18885 471 : arg1 = reinterpret_cast< GDALDriverShadow * >(argp1);
18886 471 : {
18887 : /* %typemap(in) (const char *utf8_path) */
18888 471 : if (PyUnicode_Check(obj1) || PyBytes_Check(obj1))
18889 : {
18890 240 : arg2 = GDALPythonObjectToCStr( obj1, &bToFree2 );
18891 : }
18892 : else
18893 : {
18894 231 : arg2 = GDALPythonPathToCStr(obj1, &bToFree2);
18895 :
18896 : }
18897 471 : if (arg2 == NULL)
18898 : {
18899 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
18900 0 : SWIG_fail;
18901 : }
18902 : }
18903 471 : if (obj2) {
18904 2 : {
18905 : /* %typemap(in) char **dict */
18906 2 : arg3 = NULL;
18907 2 : if ( PySequence_Check( obj2 ) ) {
18908 2 : int bErr = FALSE;
18909 2 : arg3 = CSLFromPySequence(obj2, &bErr);
18910 2 : if ( bErr )
18911 : {
18912 0 : SWIG_fail;
18913 : }
18914 : }
18915 0 : else if ( PyMapping_Check( obj2 ) ) {
18916 0 : int bErr = FALSE;
18917 0 : arg3 = CSLFromPyMapping(obj2, &bErr);
18918 0 : if ( bErr )
18919 : {
18920 0 : SWIG_fail;
18921 : }
18922 : }
18923 : else {
18924 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
18925 0 : SWIG_fail;
18926 : }
18927 : }
18928 : }
18929 471 : if (obj3) {
18930 217 : {
18931 : /* %typemap(in) char **dict */
18932 217 : arg4 = NULL;
18933 217 : if ( PySequence_Check( obj3 ) ) {
18934 217 : int bErr = FALSE;
18935 217 : arg4 = CSLFromPySequence(obj3, &bErr);
18936 217 : if ( bErr )
18937 : {
18938 0 : SWIG_fail;
18939 : }
18940 : }
18941 0 : else if ( PyMapping_Check( obj3 ) ) {
18942 0 : int bErr = FALSE;
18943 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
18944 0 : if ( bErr )
18945 : {
18946 0 : SWIG_fail;
18947 : }
18948 : }
18949 : else {
18950 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
18951 0 : SWIG_fail;
18952 : }
18953 : }
18954 : }
18955 471 : {
18956 471 : if (!arg2) {
18957 471 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
18958 : }
18959 : }
18960 471 : {
18961 471 : const int bLocalUseExceptions = GetUseExceptions();
18962 471 : if ( bLocalUseExceptions ) {
18963 157 : pushErrorHandler();
18964 : }
18965 471 : {
18966 471 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18967 471 : result = (GDALDatasetShadow *)GDALDriverShadow_CreateMultiDimensional(arg1,(char const *)arg2,arg3,arg4);
18968 471 : SWIG_PYTHON_THREAD_END_ALLOW;
18969 : }
18970 471 : if ( bLocalUseExceptions ) {
18971 157 : popErrorHandler();
18972 : }
18973 : #ifndef SED_HACKS
18974 : if ( bLocalUseExceptions ) {
18975 : CPLErr eclass = CPLGetLastErrorType();
18976 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
18977 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
18978 : }
18979 : }
18980 : #endif
18981 : }
18982 471 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
18983 471 : {
18984 : /* %typemap(freearg) (const char *utf8_path) */
18985 471 : GDALPythonFreeCStr(arg2, bToFree2);
18986 : }
18987 471 : {
18988 : /* %typemap(freearg) char **dict */
18989 471 : CSLDestroy( arg3 );
18990 : }
18991 471 : {
18992 : /* %typemap(freearg) char **dict */
18993 471 : CSLDestroy( arg4 );
18994 : }
18995 471 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
18996 : return resultobj;
18997 0 : fail:
18998 0 : {
18999 : /* %typemap(freearg) (const char *utf8_path) */
19000 0 : GDALPythonFreeCStr(arg2, bToFree2);
19001 : }
19002 0 : {
19003 : /* %typemap(freearg) char **dict */
19004 0 : CSLDestroy( arg3 );
19005 : }
19006 0 : {
19007 : /* %typemap(freearg) char **dict */
19008 0 : CSLDestroy( arg4 );
19009 : }
19010 : return NULL;
19011 : }
19012 :
19013 :
19014 3894 : SWIGINTERN PyObject *_wrap_Driver_CreateCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19015 3894 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19016 3894 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
19017 3894 : char *arg2 = (char *) 0 ;
19018 3894 : GDALDatasetShadow *arg3 = (GDALDatasetShadow *) 0 ;
19019 3894 : int arg4 = (int) 1 ;
19020 3894 : char **arg5 = (char **) 0 ;
19021 3894 : GDALProgressFunc arg6 = (GDALProgressFunc) NULL ;
19022 3894 : void *arg7 = (void *) NULL ;
19023 3894 : void *argp1 = 0 ;
19024 3894 : int res1 = 0 ;
19025 3894 : int bToFree2 = 0 ;
19026 3894 : void *argp3 = 0 ;
19027 3894 : int res3 = 0 ;
19028 3894 : int val4 ;
19029 3894 : int ecode4 = 0 ;
19030 3894 : PyObject * obj0 = 0 ;
19031 3894 : PyObject * obj1 = 0 ;
19032 3894 : PyObject * obj2 = 0 ;
19033 3894 : PyObject * obj3 = 0 ;
19034 3894 : PyObject * obj4 = 0 ;
19035 3894 : PyObject * obj5 = 0 ;
19036 3894 : PyObject * obj6 = 0 ;
19037 3894 : char * kwnames[] = {
19038 : (char *)"self", (char *)"utf8_path", (char *)"src", (char *)"strict", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
19039 : };
19040 3894 : GDALDatasetShadow *result = 0 ;
19041 :
19042 : /* %typemap(arginit) ( const char* callback_data=NULL) */
19043 3894 : PyProgressData *psProgressInfo;
19044 3894 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
19045 3894 : psProgressInfo->nLastReported = -1;
19046 3894 : psProgressInfo->psPyCallback = NULL;
19047 3894 : psProgressInfo->psPyCallbackData = NULL;
19048 3894 : arg7 = psProgressInfo;
19049 3894 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOOO:Driver_CreateCopy", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
19050 3894 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
19051 3894 : if (!SWIG_IsOK(res1)) {
19052 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Driver_CreateCopy" "', argument " "1"" of type '" "GDALDriverShadow *""'");
19053 : }
19054 3894 : arg1 = reinterpret_cast< GDALDriverShadow * >(argp1);
19055 3894 : {
19056 : /* %typemap(in) (const char *utf8_path) */
19057 3894 : if (PyUnicode_Check(obj1) || PyBytes_Check(obj1))
19058 : {
19059 3649 : arg2 = GDALPythonObjectToCStr( obj1, &bToFree2 );
19060 : }
19061 : else
19062 : {
19063 245 : arg2 = GDALPythonPathToCStr(obj1, &bToFree2);
19064 :
19065 : }
19066 3894 : if (arg2 == NULL)
19067 : {
19068 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
19069 0 : SWIG_fail;
19070 : }
19071 : }
19072 3894 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
19073 3894 : if (!SWIG_IsOK(res3)) {
19074 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Driver_CreateCopy" "', argument " "3"" of type '" "GDALDatasetShadow *""'");
19075 : }
19076 3894 : arg3 = reinterpret_cast< GDALDatasetShadow * >(argp3);
19077 3894 : if (obj3) {
19078 478 : ecode4 = SWIG_AsVal_int(obj3, &val4);
19079 478 : if (!SWIG_IsOK(ecode4)) {
19080 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Driver_CreateCopy" "', argument " "4"" of type '" "int""'");
19081 : }
19082 : arg4 = static_cast< int >(val4);
19083 : }
19084 3894 : if (obj4) {
19085 1445 : {
19086 : /* %typemap(in) char **dict */
19087 1445 : arg5 = NULL;
19088 1445 : if ( PySequence_Check( obj4 ) ) {
19089 1440 : int bErr = FALSE;
19090 1440 : arg5 = CSLFromPySequence(obj4, &bErr);
19091 1440 : if ( bErr )
19092 : {
19093 0 : SWIG_fail;
19094 : }
19095 : }
19096 5 : else if ( PyMapping_Check( obj4 ) ) {
19097 5 : int bErr = FALSE;
19098 5 : arg5 = CSLFromPyMapping(obj4, &bErr);
19099 5 : if ( bErr )
19100 : {
19101 0 : SWIG_fail;
19102 : }
19103 : }
19104 : else {
19105 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
19106 0 : SWIG_fail;
19107 : }
19108 : }
19109 : }
19110 3894 : if (obj5) {
19111 79 : {
19112 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
19113 : /* callback_func typemap */
19114 :
19115 : /* In some cases 0 is passed instead of None. */
19116 : /* See https://github.com/OSGeo/gdal/pull/219 */
19117 79 : if ( PyLong_Check(obj5) || PyInt_Check(obj5) )
19118 : {
19119 0 : if( PyLong_AsLong(obj5) == 0 )
19120 : {
19121 0 : obj5 = Py_None;
19122 : }
19123 : }
19124 :
19125 79 : if (obj5 && obj5 != Py_None ) {
19126 79 : void* cbfunction = NULL;
19127 79 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj5,
19128 : (void**)&cbfunction,
19129 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
19130 : SWIG_POINTER_EXCEPTION | 0 ));
19131 :
19132 79 : if ( cbfunction == GDALTermProgress ) {
19133 : arg6 = GDALTermProgress;
19134 : } else {
19135 79 : if (!PyCallable_Check(obj5)) {
19136 1 : PyErr_SetString( PyExc_RuntimeError,
19137 : "Object given is not a Python function" );
19138 1 : SWIG_fail;
19139 : }
19140 78 : psProgressInfo->psPyCallback = obj5;
19141 78 : arg6 = PyProgressProxy;
19142 : }
19143 :
19144 : }
19145 :
19146 : }
19147 : }
19148 3893 : if (obj6) {
19149 14 : {
19150 : /* %typemap(in) ( void* callback_data=NULL) */
19151 14 : psProgressInfo->psPyCallbackData = obj6 ;
19152 : }
19153 : }
19154 3893 : {
19155 3893 : if (!arg2) {
19156 3893 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
19157 : }
19158 : }
19159 3893 : {
19160 3893 : if (!arg3) {
19161 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
19162 : }
19163 : }
19164 3893 : {
19165 3893 : const int bLocalUseExceptions = GetUseExceptions();
19166 3893 : if ( bLocalUseExceptions ) {
19167 651 : pushErrorHandler();
19168 : }
19169 3893 : {
19170 3893 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19171 3893 : result = (GDALDatasetShadow *)GDALDriverShadow_CreateCopy(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
19172 3893 : SWIG_PYTHON_THREAD_END_ALLOW;
19173 : }
19174 3893 : if ( bLocalUseExceptions ) {
19175 651 : popErrorHandler();
19176 : }
19177 : #ifndef SED_HACKS
19178 : if ( bLocalUseExceptions ) {
19179 : CPLErr eclass = CPLGetLastErrorType();
19180 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19181 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19182 : }
19183 : }
19184 : #endif
19185 : }
19186 3893 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
19187 3893 : {
19188 : /* %typemap(freearg) (const char *utf8_path) */
19189 3893 : GDALPythonFreeCStr(arg2, bToFree2);
19190 : }
19191 3893 : {
19192 : /* %typemap(freearg) char **dict */
19193 3893 : CSLDestroy( arg5 );
19194 : }
19195 3893 : {
19196 : /* %typemap(freearg) ( void* callback_data=NULL) */
19197 :
19198 3893 : CPLFree(psProgressInfo);
19199 :
19200 : }
19201 3928 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19202 : return resultobj;
19203 1 : fail:
19204 1 : {
19205 : /* %typemap(freearg) (const char *utf8_path) */
19206 1 : GDALPythonFreeCStr(arg2, bToFree2);
19207 : }
19208 1 : {
19209 : /* %typemap(freearg) char **dict */
19210 1 : CSLDestroy( arg5 );
19211 : }
19212 1 : {
19213 : /* %typemap(freearg) ( void* callback_data=NULL) */
19214 :
19215 1 : CPLFree(psProgressInfo);
19216 :
19217 : }
19218 : return NULL;
19219 : }
19220 :
19221 :
19222 2361 : SWIGINTERN PyObject *_wrap_Driver_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19223 2361 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19224 2361 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
19225 2361 : char *arg2 = (char *) 0 ;
19226 2361 : void *argp1 = 0 ;
19227 2361 : int res1 = 0 ;
19228 2361 : int bToFree2 = 0 ;
19229 2361 : PyObject *swig_obj[2] ;
19230 2361 : CPLErr result;
19231 :
19232 2361 : if (!SWIG_Python_UnpackTuple(args, "Driver_Delete", 2, 2, swig_obj)) SWIG_fail;
19233 2361 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
19234 2361 : if (!SWIG_IsOK(res1)) {
19235 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Driver_Delete" "', argument " "1"" of type '" "GDALDriverShadow *""'");
19236 : }
19237 2361 : arg1 = reinterpret_cast< GDALDriverShadow * >(argp1);
19238 2361 : {
19239 : /* %typemap(in) (const char *utf8_path) */
19240 2361 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
19241 : {
19242 2199 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
19243 : }
19244 : else
19245 : {
19246 162 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
19247 :
19248 : }
19249 2361 : if (arg2 == NULL)
19250 : {
19251 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
19252 0 : SWIG_fail;
19253 : }
19254 : }
19255 2361 : {
19256 2361 : if (!arg2) {
19257 2361 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
19258 : }
19259 : }
19260 2361 : {
19261 2361 : const int bLocalUseExceptions = GetUseExceptions();
19262 2361 : if ( bLocalUseExceptions ) {
19263 1323 : pushErrorHandler();
19264 : }
19265 2361 : {
19266 2361 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19267 2361 : result = (CPLErr)GDALDriverShadow_Delete(arg1,(char const *)arg2);
19268 2361 : SWIG_PYTHON_THREAD_END_ALLOW;
19269 : }
19270 2361 : if ( bLocalUseExceptions ) {
19271 1323 : popErrorHandler();
19272 : }
19273 : #ifndef SED_HACKS
19274 : if ( bLocalUseExceptions ) {
19275 : CPLErr eclass = CPLGetLastErrorType();
19276 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19277 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19278 : }
19279 : }
19280 : #endif
19281 : }
19282 2361 : resultobj = SWIG_From_int(static_cast< int >(result));
19283 2361 : {
19284 : /* %typemap(freearg) (const char *utf8_path) */
19285 2361 : GDALPythonFreeCStr(arg2, bToFree2);
19286 : }
19287 2361 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19288 : return resultobj;
19289 0 : fail:
19290 0 : {
19291 : /* %typemap(freearg) (const char *utf8_path) */
19292 2361 : GDALPythonFreeCStr(arg2, bToFree2);
19293 : }
19294 : return NULL;
19295 : }
19296 :
19297 :
19298 173 : SWIGINTERN PyObject *_wrap_Driver_Rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19299 173 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19300 173 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
19301 173 : char *arg2 = (char *) 0 ;
19302 173 : char *arg3 = (char *) 0 ;
19303 173 : void *argp1 = 0 ;
19304 173 : int res1 = 0 ;
19305 173 : int bToFree2 = 0 ;
19306 173 : int bToFree3 = 0 ;
19307 173 : PyObject *swig_obj[3] ;
19308 173 : CPLErr result;
19309 :
19310 173 : if (!SWIG_Python_UnpackTuple(args, "Driver_Rename", 3, 3, swig_obj)) SWIG_fail;
19311 173 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
19312 173 : if (!SWIG_IsOK(res1)) {
19313 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Driver_Rename" "', argument " "1"" of type '" "GDALDriverShadow *""'");
19314 : }
19315 173 : arg1 = reinterpret_cast< GDALDriverShadow * >(argp1);
19316 173 : {
19317 : /* %typemap(in) (const char *utf8_path) */
19318 173 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
19319 : {
19320 171 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
19321 : }
19322 : else
19323 : {
19324 2 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
19325 :
19326 : }
19327 173 : if (arg2 == NULL)
19328 : {
19329 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
19330 0 : SWIG_fail;
19331 : }
19332 : }
19333 173 : {
19334 : /* %typemap(in) (const char *utf8_path) */
19335 173 : if (PyUnicode_Check(swig_obj[2]) || PyBytes_Check(swig_obj[2]))
19336 : {
19337 171 : arg3 = GDALPythonObjectToCStr( swig_obj[2], &bToFree3 );
19338 : }
19339 : else
19340 : {
19341 2 : arg3 = GDALPythonPathToCStr(swig_obj[2], &bToFree3);
19342 :
19343 : }
19344 173 : if (arg3 == NULL)
19345 : {
19346 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
19347 0 : SWIG_fail;
19348 : }
19349 : }
19350 173 : {
19351 173 : if (!arg2) {
19352 173 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
19353 : }
19354 : }
19355 173 : {
19356 173 : if (!arg3) {
19357 173 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
19358 : }
19359 : }
19360 173 : {
19361 173 : const int bLocalUseExceptions = GetUseExceptions();
19362 173 : if ( bLocalUseExceptions ) {
19363 173 : pushErrorHandler();
19364 : }
19365 173 : {
19366 173 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19367 173 : result = (CPLErr)GDALDriverShadow_Rename(arg1,(char const *)arg2,(char const *)arg3);
19368 173 : SWIG_PYTHON_THREAD_END_ALLOW;
19369 : }
19370 173 : if ( bLocalUseExceptions ) {
19371 173 : popErrorHandler();
19372 : }
19373 : #ifndef SED_HACKS
19374 : if ( bLocalUseExceptions ) {
19375 : CPLErr eclass = CPLGetLastErrorType();
19376 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19377 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19378 : }
19379 : }
19380 : #endif
19381 : }
19382 173 : resultobj = SWIG_From_int(static_cast< int >(result));
19383 173 : {
19384 : /* %typemap(freearg) (const char *utf8_path) */
19385 173 : GDALPythonFreeCStr(arg2, bToFree2);
19386 : }
19387 173 : {
19388 : /* %typemap(freearg) (const char *utf8_path) */
19389 173 : GDALPythonFreeCStr(arg3, bToFree3);
19390 : }
19391 173 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19392 : return resultobj;
19393 0 : fail:
19394 0 : {
19395 : /* %typemap(freearg) (const char *utf8_path) */
19396 0 : GDALPythonFreeCStr(arg2, bToFree2);
19397 : }
19398 0 : {
19399 : /* %typemap(freearg) (const char *utf8_path) */
19400 173 : GDALPythonFreeCStr(arg3, bToFree3);
19401 : }
19402 : return NULL;
19403 : }
19404 :
19405 :
19406 3 : SWIGINTERN PyObject *_wrap_Driver_CopyFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19407 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19408 3 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
19409 3 : char *arg2 = (char *) 0 ;
19410 3 : char *arg3 = (char *) 0 ;
19411 3 : void *argp1 = 0 ;
19412 3 : int res1 = 0 ;
19413 3 : int bToFree2 = 0 ;
19414 3 : int bToFree3 = 0 ;
19415 3 : PyObject *swig_obj[3] ;
19416 3 : CPLErr result;
19417 :
19418 3 : if (!SWIG_Python_UnpackTuple(args, "Driver_CopyFiles", 3, 3, swig_obj)) SWIG_fail;
19419 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
19420 3 : if (!SWIG_IsOK(res1)) {
19421 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Driver_CopyFiles" "', argument " "1"" of type '" "GDALDriverShadow *""'");
19422 : }
19423 3 : arg1 = reinterpret_cast< GDALDriverShadow * >(argp1);
19424 3 : {
19425 : /* %typemap(in) (const char *utf8_path) */
19426 3 : if (PyUnicode_Check(swig_obj[1]) || PyBytes_Check(swig_obj[1]))
19427 : {
19428 1 : arg2 = GDALPythonObjectToCStr( swig_obj[1], &bToFree2 );
19429 : }
19430 : else
19431 : {
19432 2 : arg2 = GDALPythonPathToCStr(swig_obj[1], &bToFree2);
19433 :
19434 : }
19435 3 : if (arg2 == NULL)
19436 : {
19437 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
19438 0 : SWIG_fail;
19439 : }
19440 : }
19441 3 : {
19442 : /* %typemap(in) (const char *utf8_path) */
19443 3 : if (PyUnicode_Check(swig_obj[2]) || PyBytes_Check(swig_obj[2]))
19444 : {
19445 1 : arg3 = GDALPythonObjectToCStr( swig_obj[2], &bToFree3 );
19446 : }
19447 : else
19448 : {
19449 2 : arg3 = GDALPythonPathToCStr(swig_obj[2], &bToFree3);
19450 :
19451 : }
19452 3 : if (arg3 == NULL)
19453 : {
19454 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
19455 0 : SWIG_fail;
19456 : }
19457 : }
19458 3 : {
19459 3 : if (!arg2) {
19460 3 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
19461 : }
19462 : }
19463 3 : {
19464 3 : if (!arg3) {
19465 3 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
19466 : }
19467 : }
19468 3 : {
19469 3 : const int bLocalUseExceptions = GetUseExceptions();
19470 3 : if ( bLocalUseExceptions ) {
19471 3 : pushErrorHandler();
19472 : }
19473 3 : {
19474 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19475 3 : result = (CPLErr)GDALDriverShadow_CopyFiles(arg1,(char const *)arg2,(char const *)arg3);
19476 3 : SWIG_PYTHON_THREAD_END_ALLOW;
19477 : }
19478 3 : if ( bLocalUseExceptions ) {
19479 3 : popErrorHandler();
19480 : }
19481 : #ifndef SED_HACKS
19482 : if ( bLocalUseExceptions ) {
19483 : CPLErr eclass = CPLGetLastErrorType();
19484 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19485 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19486 : }
19487 : }
19488 : #endif
19489 : }
19490 3 : resultobj = SWIG_From_int(static_cast< int >(result));
19491 3 : {
19492 : /* %typemap(freearg) (const char *utf8_path) */
19493 3 : GDALPythonFreeCStr(arg2, bToFree2);
19494 : }
19495 3 : {
19496 : /* %typemap(freearg) (const char *utf8_path) */
19497 3 : GDALPythonFreeCStr(arg3, bToFree3);
19498 : }
19499 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19500 : return resultobj;
19501 0 : fail:
19502 0 : {
19503 : /* %typemap(freearg) (const char *utf8_path) */
19504 0 : GDALPythonFreeCStr(arg2, bToFree2);
19505 : }
19506 0 : {
19507 : /* %typemap(freearg) (const char *utf8_path) */
19508 3 : GDALPythonFreeCStr(arg3, bToFree3);
19509 : }
19510 : return NULL;
19511 : }
19512 :
19513 :
19514 2 : SWIGINTERN PyObject *_wrap_Driver_HasOpenOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19515 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19516 2 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
19517 2 : char *arg2 = (char *) 0 ;
19518 2 : void *argp1 = 0 ;
19519 2 : int res1 = 0 ;
19520 2 : int res2 ;
19521 2 : char *buf2 = 0 ;
19522 2 : int alloc2 = 0 ;
19523 2 : PyObject *swig_obj[2] ;
19524 2 : bool result;
19525 :
19526 2 : if (!SWIG_Python_UnpackTuple(args, "Driver_HasOpenOption", 2, 2, swig_obj)) SWIG_fail;
19527 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
19528 2 : if (!SWIG_IsOK(res1)) {
19529 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Driver_HasOpenOption" "', argument " "1"" of type '" "GDALDriverShadow *""'");
19530 : }
19531 2 : arg1 = reinterpret_cast< GDALDriverShadow * >(argp1);
19532 2 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
19533 2 : if (!SWIG_IsOK(res2)) {
19534 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Driver_HasOpenOption" "', argument " "2"" of type '" "char const *""'");
19535 : }
19536 2 : arg2 = reinterpret_cast< char * >(buf2);
19537 2 : {
19538 2 : const int bLocalUseExceptions = GetUseExceptions();
19539 2 : if ( bLocalUseExceptions ) {
19540 0 : pushErrorHandler();
19541 : }
19542 2 : {
19543 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19544 2 : result = (bool)GDALDriverShadow_HasOpenOption(arg1,(char const *)arg2);
19545 2 : SWIG_PYTHON_THREAD_END_ALLOW;
19546 : }
19547 2 : if ( bLocalUseExceptions ) {
19548 0 : popErrorHandler();
19549 : }
19550 : #ifndef SED_HACKS
19551 : if ( bLocalUseExceptions ) {
19552 : CPLErr eclass = CPLGetLastErrorType();
19553 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19554 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19555 : }
19556 : }
19557 : #endif
19558 : }
19559 2 : resultobj = SWIG_From_bool(static_cast< bool >(result));
19560 2 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19561 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19562 : return resultobj;
19563 0 : fail:
19564 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19565 : return NULL;
19566 : }
19567 :
19568 :
19569 6 : SWIGINTERN PyObject *_wrap_Driver_TestCapability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19570 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19571 6 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
19572 6 : char *arg2 = (char *) 0 ;
19573 6 : void *argp1 = 0 ;
19574 6 : int res1 = 0 ;
19575 6 : int res2 ;
19576 6 : char *buf2 = 0 ;
19577 6 : int alloc2 = 0 ;
19578 6 : PyObject *swig_obj[2] ;
19579 6 : bool result;
19580 :
19581 6 : if (!SWIG_Python_UnpackTuple(args, "Driver_TestCapability", 2, 2, swig_obj)) SWIG_fail;
19582 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
19583 6 : if (!SWIG_IsOK(res1)) {
19584 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Driver_TestCapability" "', argument " "1"" of type '" "GDALDriverShadow *""'");
19585 : }
19586 6 : arg1 = reinterpret_cast< GDALDriverShadow * >(argp1);
19587 6 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
19588 6 : if (!SWIG_IsOK(res2)) {
19589 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Driver_TestCapability" "', argument " "2"" of type '" "char const *""'");
19590 : }
19591 6 : arg2 = reinterpret_cast< char * >(buf2);
19592 6 : {
19593 6 : const int bLocalUseExceptions = GetUseExceptions();
19594 6 : if ( bLocalUseExceptions ) {
19595 4 : pushErrorHandler();
19596 : }
19597 6 : {
19598 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19599 6 : result = (bool)GDALDriverShadow_TestCapability(arg1,(char const *)arg2);
19600 6 : SWIG_PYTHON_THREAD_END_ALLOW;
19601 : }
19602 6 : if ( bLocalUseExceptions ) {
19603 4 : popErrorHandler();
19604 : }
19605 : #ifndef SED_HACKS
19606 : if ( bLocalUseExceptions ) {
19607 : CPLErr eclass = CPLGetLastErrorType();
19608 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19609 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19610 : }
19611 : }
19612 : #endif
19613 : }
19614 6 : resultobj = SWIG_From_bool(static_cast< bool >(result));
19615 6 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19616 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19617 : return resultobj;
19618 0 : fail:
19619 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19620 : return NULL;
19621 : }
19622 :
19623 :
19624 93 : SWIGINTERN PyObject *_wrap_Driver_Register(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19625 93 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19626 93 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
19627 93 : void *argp1 = 0 ;
19628 93 : int res1 = 0 ;
19629 93 : PyObject *swig_obj[1] ;
19630 93 : int result;
19631 :
19632 93 : if (!args) SWIG_fail;
19633 93 : swig_obj[0] = args;
19634 93 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
19635 93 : if (!SWIG_IsOK(res1)) {
19636 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Driver_Register" "', argument " "1"" of type '" "GDALDriverShadow *""'");
19637 : }
19638 93 : arg1 = reinterpret_cast< GDALDriverShadow * >(argp1);
19639 93 : {
19640 93 : const int bLocalUseExceptions = GetUseExceptions();
19641 93 : if ( bLocalUseExceptions ) {
19642 17 : pushErrorHandler();
19643 : }
19644 93 : {
19645 93 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19646 93 : result = (int)GDALDriverShadow_Register(arg1);
19647 93 : SWIG_PYTHON_THREAD_END_ALLOW;
19648 : }
19649 93 : if ( bLocalUseExceptions ) {
19650 17 : popErrorHandler();
19651 : }
19652 : #ifndef SED_HACKS
19653 : if ( bLocalUseExceptions ) {
19654 : CPLErr eclass = CPLGetLastErrorType();
19655 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19656 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19657 : }
19658 : }
19659 : #endif
19660 : }
19661 93 : resultobj = SWIG_From_int(static_cast< int >(result));
19662 93 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19663 : return resultobj;
19664 : fail:
19665 : return NULL;
19666 : }
19667 :
19668 :
19669 93 : SWIGINTERN PyObject *_wrap_Driver_Deregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19670 93 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19671 93 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
19672 93 : void *argp1 = 0 ;
19673 93 : int res1 = 0 ;
19674 93 : PyObject *swig_obj[1] ;
19675 :
19676 93 : if (!args) SWIG_fail;
19677 93 : swig_obj[0] = args;
19678 93 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
19679 93 : if (!SWIG_IsOK(res1)) {
19680 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Driver_Deregister" "', argument " "1"" of type '" "GDALDriverShadow *""'");
19681 : }
19682 93 : arg1 = reinterpret_cast< GDALDriverShadow * >(argp1);
19683 93 : {
19684 93 : const int bLocalUseExceptions = GetUseExceptions();
19685 93 : if ( bLocalUseExceptions ) {
19686 17 : pushErrorHandler();
19687 : }
19688 93 : {
19689 93 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19690 93 : GDALDriverShadow_Deregister(arg1);
19691 93 : SWIG_PYTHON_THREAD_END_ALLOW;
19692 : }
19693 93 : if ( bLocalUseExceptions ) {
19694 17 : popErrorHandler();
19695 : }
19696 : #ifndef SED_HACKS
19697 : if ( bLocalUseExceptions ) {
19698 : CPLErr eclass = CPLGetLastErrorType();
19699 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
19700 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
19701 : }
19702 : }
19703 : #endif
19704 : }
19705 93 : resultobj = SWIG_Py_Void();
19706 93 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19707 : return resultobj;
19708 : fail:
19709 : return NULL;
19710 : }
19711 :
19712 :
19713 277 : SWIGINTERN PyObject *Driver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19714 277 : PyObject *obj;
19715 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
19716 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALDriverShadow, SWIG_NewClientData(obj));
19717 277 : return SWIG_Py_Void();
19718 : }
19719 :
19720 0 : SWIGINTERN PyObject *_wrap_ColorEntry_c1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19721 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19722 0 : GDALColorEntry *arg1 = (GDALColorEntry *) 0 ;
19723 0 : short arg2 ;
19724 0 : GDALColorEntry ce1 ;
19725 0 : short val2 ;
19726 0 : int ecode2 = 0 ;
19727 0 : PyObject *swig_obj[2] ;
19728 :
19729 0 : if (!SWIG_Python_UnpackTuple(args, "ColorEntry_c1_set", 2, 2, swig_obj)) SWIG_fail;
19730 0 : {
19731 : /* %typemap(in) GDALColorEntry* */
19732 0 : ce1.c4 = 255;
19733 0 : if (! PySequence_Check(swig_obj[0]) ) {
19734 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
19735 0 : SWIG_fail;
19736 : }
19737 0 : Py_ssize_t size = PySequence_Size(swig_obj[0]);
19738 0 : if ( size > 4 ) {
19739 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too long");
19740 0 : SWIG_fail;
19741 : }
19742 0 : if ( size < 3 ) {
19743 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too short");
19744 0 : SWIG_fail;
19745 : }
19746 0 : if ( !PyArg_ParseTuple( swig_obj[0],"hhh|h", &ce1.c1, &ce1.c2, &ce1.c3, &ce1.c4 ) ) {
19747 0 : PyErr_SetString(PyExc_TypeError, "Invalid values in ColorEntry sequence ");
19748 0 : SWIG_fail;
19749 : }
19750 0 : arg1 = &ce1;
19751 : }
19752 0 : ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
19753 0 : if (!SWIG_IsOK(ecode2)) {
19754 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorEntry_c1_set" "', argument " "2"" of type '" "short""'");
19755 : }
19756 0 : arg2 = static_cast< short >(val2);
19757 0 : {
19758 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19759 0 : if (arg1) (arg1)->c1 = arg2;
19760 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19761 : }
19762 0 : resultobj = SWIG_Py_Void();
19763 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19764 : return resultobj;
19765 : fail:
19766 : return NULL;
19767 : }
19768 :
19769 :
19770 0 : SWIGINTERN PyObject *_wrap_ColorEntry_c1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19771 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19772 0 : GDALColorEntry *arg1 = (GDALColorEntry *) 0 ;
19773 0 : GDALColorEntry ce1 ;
19774 0 : PyObject *swig_obj[1] ;
19775 0 : short result;
19776 :
19777 0 : if (!args) SWIG_fail;
19778 0 : swig_obj[0] = args;
19779 0 : {
19780 : /* %typemap(in) GDALColorEntry* */
19781 0 : ce1.c4 = 255;
19782 0 : if (! PySequence_Check(swig_obj[0]) ) {
19783 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
19784 0 : SWIG_fail;
19785 : }
19786 0 : Py_ssize_t size = PySequence_Size(swig_obj[0]);
19787 0 : if ( size > 4 ) {
19788 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too long");
19789 0 : SWIG_fail;
19790 : }
19791 0 : if ( size < 3 ) {
19792 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too short");
19793 0 : SWIG_fail;
19794 : }
19795 0 : if ( !PyArg_ParseTuple( swig_obj[0],"hhh|h", &ce1.c1, &ce1.c2, &ce1.c3, &ce1.c4 ) ) {
19796 0 : PyErr_SetString(PyExc_TypeError, "Invalid values in ColorEntry sequence ");
19797 0 : SWIG_fail;
19798 : }
19799 0 : arg1 = &ce1;
19800 : }
19801 0 : {
19802 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19803 0 : result = (short) ((arg1)->c1);
19804 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19805 : }
19806 0 : resultobj = SWIG_From_short(static_cast< short >(result));
19807 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19808 : return resultobj;
19809 : fail:
19810 : return NULL;
19811 : }
19812 :
19813 :
19814 0 : SWIGINTERN PyObject *_wrap_ColorEntry_c2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19815 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19816 0 : GDALColorEntry *arg1 = (GDALColorEntry *) 0 ;
19817 0 : short arg2 ;
19818 0 : GDALColorEntry ce1 ;
19819 0 : short val2 ;
19820 0 : int ecode2 = 0 ;
19821 0 : PyObject *swig_obj[2] ;
19822 :
19823 0 : if (!SWIG_Python_UnpackTuple(args, "ColorEntry_c2_set", 2, 2, swig_obj)) SWIG_fail;
19824 0 : {
19825 : /* %typemap(in) GDALColorEntry* */
19826 0 : ce1.c4 = 255;
19827 0 : if (! PySequence_Check(swig_obj[0]) ) {
19828 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
19829 0 : SWIG_fail;
19830 : }
19831 0 : Py_ssize_t size = PySequence_Size(swig_obj[0]);
19832 0 : if ( size > 4 ) {
19833 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too long");
19834 0 : SWIG_fail;
19835 : }
19836 0 : if ( size < 3 ) {
19837 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too short");
19838 0 : SWIG_fail;
19839 : }
19840 0 : if ( !PyArg_ParseTuple( swig_obj[0],"hhh|h", &ce1.c1, &ce1.c2, &ce1.c3, &ce1.c4 ) ) {
19841 0 : PyErr_SetString(PyExc_TypeError, "Invalid values in ColorEntry sequence ");
19842 0 : SWIG_fail;
19843 : }
19844 0 : arg1 = &ce1;
19845 : }
19846 0 : ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
19847 0 : if (!SWIG_IsOK(ecode2)) {
19848 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorEntry_c2_set" "', argument " "2"" of type '" "short""'");
19849 : }
19850 0 : arg2 = static_cast< short >(val2);
19851 0 : {
19852 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19853 0 : if (arg1) (arg1)->c2 = arg2;
19854 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19855 : }
19856 0 : resultobj = SWIG_Py_Void();
19857 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19858 : return resultobj;
19859 : fail:
19860 : return NULL;
19861 : }
19862 :
19863 :
19864 0 : SWIGINTERN PyObject *_wrap_ColorEntry_c2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19865 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19866 0 : GDALColorEntry *arg1 = (GDALColorEntry *) 0 ;
19867 0 : GDALColorEntry ce1 ;
19868 0 : PyObject *swig_obj[1] ;
19869 0 : short result;
19870 :
19871 0 : if (!args) SWIG_fail;
19872 0 : swig_obj[0] = args;
19873 0 : {
19874 : /* %typemap(in) GDALColorEntry* */
19875 0 : ce1.c4 = 255;
19876 0 : if (! PySequence_Check(swig_obj[0]) ) {
19877 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
19878 0 : SWIG_fail;
19879 : }
19880 0 : Py_ssize_t size = PySequence_Size(swig_obj[0]);
19881 0 : if ( size > 4 ) {
19882 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too long");
19883 0 : SWIG_fail;
19884 : }
19885 0 : if ( size < 3 ) {
19886 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too short");
19887 0 : SWIG_fail;
19888 : }
19889 0 : if ( !PyArg_ParseTuple( swig_obj[0],"hhh|h", &ce1.c1, &ce1.c2, &ce1.c3, &ce1.c4 ) ) {
19890 0 : PyErr_SetString(PyExc_TypeError, "Invalid values in ColorEntry sequence ");
19891 0 : SWIG_fail;
19892 : }
19893 0 : arg1 = &ce1;
19894 : }
19895 0 : {
19896 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19897 0 : result = (short) ((arg1)->c2);
19898 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19899 : }
19900 0 : resultobj = SWIG_From_short(static_cast< short >(result));
19901 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19902 : return resultobj;
19903 : fail:
19904 : return NULL;
19905 : }
19906 :
19907 :
19908 0 : SWIGINTERN PyObject *_wrap_ColorEntry_c3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19909 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19910 0 : GDALColorEntry *arg1 = (GDALColorEntry *) 0 ;
19911 0 : short arg2 ;
19912 0 : GDALColorEntry ce1 ;
19913 0 : short val2 ;
19914 0 : int ecode2 = 0 ;
19915 0 : PyObject *swig_obj[2] ;
19916 :
19917 0 : if (!SWIG_Python_UnpackTuple(args, "ColorEntry_c3_set", 2, 2, swig_obj)) SWIG_fail;
19918 0 : {
19919 : /* %typemap(in) GDALColorEntry* */
19920 0 : ce1.c4 = 255;
19921 0 : if (! PySequence_Check(swig_obj[0]) ) {
19922 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
19923 0 : SWIG_fail;
19924 : }
19925 0 : Py_ssize_t size = PySequence_Size(swig_obj[0]);
19926 0 : if ( size > 4 ) {
19927 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too long");
19928 0 : SWIG_fail;
19929 : }
19930 0 : if ( size < 3 ) {
19931 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too short");
19932 0 : SWIG_fail;
19933 : }
19934 0 : if ( !PyArg_ParseTuple( swig_obj[0],"hhh|h", &ce1.c1, &ce1.c2, &ce1.c3, &ce1.c4 ) ) {
19935 0 : PyErr_SetString(PyExc_TypeError, "Invalid values in ColorEntry sequence ");
19936 0 : SWIG_fail;
19937 : }
19938 0 : arg1 = &ce1;
19939 : }
19940 0 : ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
19941 0 : if (!SWIG_IsOK(ecode2)) {
19942 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorEntry_c3_set" "', argument " "2"" of type '" "short""'");
19943 : }
19944 0 : arg2 = static_cast< short >(val2);
19945 0 : {
19946 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19947 0 : if (arg1) (arg1)->c3 = arg2;
19948 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19949 : }
19950 0 : resultobj = SWIG_Py_Void();
19951 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19952 : return resultobj;
19953 : fail:
19954 : return NULL;
19955 : }
19956 :
19957 :
19958 0 : SWIGINTERN PyObject *_wrap_ColorEntry_c3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19959 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
19960 0 : GDALColorEntry *arg1 = (GDALColorEntry *) 0 ;
19961 0 : GDALColorEntry ce1 ;
19962 0 : PyObject *swig_obj[1] ;
19963 0 : short result;
19964 :
19965 0 : if (!args) SWIG_fail;
19966 0 : swig_obj[0] = args;
19967 0 : {
19968 : /* %typemap(in) GDALColorEntry* */
19969 0 : ce1.c4 = 255;
19970 0 : if (! PySequence_Check(swig_obj[0]) ) {
19971 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
19972 0 : SWIG_fail;
19973 : }
19974 0 : Py_ssize_t size = PySequence_Size(swig_obj[0]);
19975 0 : if ( size > 4 ) {
19976 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too long");
19977 0 : SWIG_fail;
19978 : }
19979 0 : if ( size < 3 ) {
19980 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too short");
19981 0 : SWIG_fail;
19982 : }
19983 0 : if ( !PyArg_ParseTuple( swig_obj[0],"hhh|h", &ce1.c1, &ce1.c2, &ce1.c3, &ce1.c4 ) ) {
19984 0 : PyErr_SetString(PyExc_TypeError, "Invalid values in ColorEntry sequence ");
19985 0 : SWIG_fail;
19986 : }
19987 0 : arg1 = &ce1;
19988 : }
19989 0 : {
19990 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19991 0 : result = (short) ((arg1)->c3);
19992 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19993 : }
19994 0 : resultobj = SWIG_From_short(static_cast< short >(result));
19995 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
19996 : return resultobj;
19997 : fail:
19998 : return NULL;
19999 : }
20000 :
20001 :
20002 0 : SWIGINTERN PyObject *_wrap_ColorEntry_c4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20003 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20004 0 : GDALColorEntry *arg1 = (GDALColorEntry *) 0 ;
20005 0 : short arg2 ;
20006 0 : GDALColorEntry ce1 ;
20007 0 : short val2 ;
20008 0 : int ecode2 = 0 ;
20009 0 : PyObject *swig_obj[2] ;
20010 :
20011 0 : if (!SWIG_Python_UnpackTuple(args, "ColorEntry_c4_set", 2, 2, swig_obj)) SWIG_fail;
20012 0 : {
20013 : /* %typemap(in) GDALColorEntry* */
20014 0 : ce1.c4 = 255;
20015 0 : if (! PySequence_Check(swig_obj[0]) ) {
20016 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
20017 0 : SWIG_fail;
20018 : }
20019 0 : Py_ssize_t size = PySequence_Size(swig_obj[0]);
20020 0 : if ( size > 4 ) {
20021 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too long");
20022 0 : SWIG_fail;
20023 : }
20024 0 : if ( size < 3 ) {
20025 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too short");
20026 0 : SWIG_fail;
20027 : }
20028 0 : if ( !PyArg_ParseTuple( swig_obj[0],"hhh|h", &ce1.c1, &ce1.c2, &ce1.c3, &ce1.c4 ) ) {
20029 0 : PyErr_SetString(PyExc_TypeError, "Invalid values in ColorEntry sequence ");
20030 0 : SWIG_fail;
20031 : }
20032 0 : arg1 = &ce1;
20033 : }
20034 0 : ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
20035 0 : if (!SWIG_IsOK(ecode2)) {
20036 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorEntry_c4_set" "', argument " "2"" of type '" "short""'");
20037 : }
20038 0 : arg2 = static_cast< short >(val2);
20039 0 : {
20040 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20041 0 : if (arg1) (arg1)->c4 = arg2;
20042 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20043 : }
20044 0 : resultobj = SWIG_Py_Void();
20045 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20046 : return resultobj;
20047 : fail:
20048 : return NULL;
20049 : }
20050 :
20051 :
20052 0 : SWIGINTERN PyObject *_wrap_ColorEntry_c4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20053 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20054 0 : GDALColorEntry *arg1 = (GDALColorEntry *) 0 ;
20055 0 : GDALColorEntry ce1 ;
20056 0 : PyObject *swig_obj[1] ;
20057 0 : short result;
20058 :
20059 0 : if (!args) SWIG_fail;
20060 0 : swig_obj[0] = args;
20061 0 : {
20062 : /* %typemap(in) GDALColorEntry* */
20063 0 : ce1.c4 = 255;
20064 0 : if (! PySequence_Check(swig_obj[0]) ) {
20065 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
20066 0 : SWIG_fail;
20067 : }
20068 0 : Py_ssize_t size = PySequence_Size(swig_obj[0]);
20069 0 : if ( size > 4 ) {
20070 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too long");
20071 0 : SWIG_fail;
20072 : }
20073 0 : if ( size < 3 ) {
20074 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too short");
20075 0 : SWIG_fail;
20076 : }
20077 0 : if ( !PyArg_ParseTuple( swig_obj[0],"hhh|h", &ce1.c1, &ce1.c2, &ce1.c3, &ce1.c4 ) ) {
20078 0 : PyErr_SetString(PyExc_TypeError, "Invalid values in ColorEntry sequence ");
20079 0 : SWIG_fail;
20080 : }
20081 0 : arg1 = &ce1;
20082 : }
20083 0 : {
20084 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20085 0 : result = (short) ((arg1)->c4);
20086 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20087 : }
20088 0 : resultobj = SWIG_From_short(static_cast< short >(result));
20089 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20090 : return resultobj;
20091 : fail:
20092 : return NULL;
20093 : }
20094 :
20095 :
20096 277 : SWIGINTERN PyObject *ColorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20097 277 : PyObject *obj;
20098 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
20099 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALColorEntry, SWIG_NewClientData(obj));
20100 277 : return SWIG_Py_Void();
20101 : }
20102 :
20103 92 : SWIGINTERN PyObject *_wrap_GCP_GCPX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20104 92 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20105 92 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20106 92 : double arg2 ;
20107 92 : void *argp1 = 0 ;
20108 92 : int res1 = 0 ;
20109 92 : double val2 ;
20110 92 : int ecode2 = 0 ;
20111 92 : PyObject *swig_obj[2] ;
20112 :
20113 92 : if (!SWIG_Python_UnpackTuple(args, "GCP_GCPX_set", 2, 2, swig_obj)) SWIG_fail;
20114 92 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20115 92 : if (!SWIG_IsOK(res1)) {
20116 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GCP_GCPX_set" "', argument " "1"" of type '" "GDAL_GCP *""'");
20117 : }
20118 92 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20119 92 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
20120 92 : if (!SWIG_IsOK(ecode2)) {
20121 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GCP_GCPX_set" "', argument " "2"" of type '" "double""'");
20122 : }
20123 92 : arg2 = static_cast< double >(val2);
20124 92 : {
20125 92 : const int bLocalUseExceptions = GetUseExceptions();
20126 92 : if ( bLocalUseExceptions ) {
20127 91 : pushErrorHandler();
20128 : }
20129 92 : {
20130 92 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20131 92 : GDAL_GCP_GCPX_set(arg1,arg2);
20132 92 : SWIG_PYTHON_THREAD_END_ALLOW;
20133 : }
20134 92 : if ( bLocalUseExceptions ) {
20135 91 : popErrorHandler();
20136 : }
20137 : #ifndef SED_HACKS
20138 : if ( bLocalUseExceptions ) {
20139 : CPLErr eclass = CPLGetLastErrorType();
20140 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20141 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20142 : }
20143 : }
20144 : #endif
20145 : }
20146 92 : resultobj = SWIG_Py_Void();
20147 92 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20148 : return resultobj;
20149 : fail:
20150 : return NULL;
20151 : }
20152 :
20153 :
20154 2205 : SWIGINTERN PyObject *_wrap_GCP_GCPX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20155 2205 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20156 2205 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20157 2205 : void *argp1 = 0 ;
20158 2205 : int res1 = 0 ;
20159 2205 : PyObject *swig_obj[1] ;
20160 2205 : double result;
20161 :
20162 2205 : if (!args) SWIG_fail;
20163 2205 : swig_obj[0] = args;
20164 2205 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20165 2205 : if (!SWIG_IsOK(res1)) {
20166 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GCP_GCPX_get" "', argument " "1"" of type '" "GDAL_GCP *""'");
20167 : }
20168 2205 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20169 2205 : {
20170 2205 : const int bLocalUseExceptions = GetUseExceptions();
20171 2205 : if ( bLocalUseExceptions ) {
20172 2182 : pushErrorHandler();
20173 : }
20174 2205 : {
20175 2205 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20176 2205 : result = (double)GDAL_GCP_GCPX_get(arg1);
20177 2205 : SWIG_PYTHON_THREAD_END_ALLOW;
20178 : }
20179 2205 : if ( bLocalUseExceptions ) {
20180 2182 : popErrorHandler();
20181 : }
20182 : #ifndef SED_HACKS
20183 : if ( bLocalUseExceptions ) {
20184 : CPLErr eclass = CPLGetLastErrorType();
20185 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20186 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20187 : }
20188 : }
20189 : #endif
20190 : }
20191 2205 : resultobj = SWIG_From_double(static_cast< double >(result));
20192 2205 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20193 : return resultobj;
20194 : fail:
20195 : return NULL;
20196 : }
20197 :
20198 :
20199 92 : SWIGINTERN PyObject *_wrap_GCP_GCPY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20200 92 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20201 92 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20202 92 : double arg2 ;
20203 92 : void *argp1 = 0 ;
20204 92 : int res1 = 0 ;
20205 92 : double val2 ;
20206 92 : int ecode2 = 0 ;
20207 92 : PyObject *swig_obj[2] ;
20208 :
20209 92 : if (!SWIG_Python_UnpackTuple(args, "GCP_GCPY_set", 2, 2, swig_obj)) SWIG_fail;
20210 92 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20211 92 : if (!SWIG_IsOK(res1)) {
20212 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GCP_GCPY_set" "', argument " "1"" of type '" "GDAL_GCP *""'");
20213 : }
20214 92 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20215 92 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
20216 92 : if (!SWIG_IsOK(ecode2)) {
20217 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GCP_GCPY_set" "', argument " "2"" of type '" "double""'");
20218 : }
20219 92 : arg2 = static_cast< double >(val2);
20220 92 : {
20221 92 : const int bLocalUseExceptions = GetUseExceptions();
20222 92 : if ( bLocalUseExceptions ) {
20223 91 : pushErrorHandler();
20224 : }
20225 92 : {
20226 92 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20227 92 : GDAL_GCP_GCPY_set(arg1,arg2);
20228 92 : SWIG_PYTHON_THREAD_END_ALLOW;
20229 : }
20230 92 : if ( bLocalUseExceptions ) {
20231 91 : popErrorHandler();
20232 : }
20233 : #ifndef SED_HACKS
20234 : if ( bLocalUseExceptions ) {
20235 : CPLErr eclass = CPLGetLastErrorType();
20236 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20237 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20238 : }
20239 : }
20240 : #endif
20241 : }
20242 92 : resultobj = SWIG_Py_Void();
20243 92 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20244 : return resultobj;
20245 : fail:
20246 : return NULL;
20247 : }
20248 :
20249 :
20250 2205 : SWIGINTERN PyObject *_wrap_GCP_GCPY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20251 2205 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20252 2205 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20253 2205 : void *argp1 = 0 ;
20254 2205 : int res1 = 0 ;
20255 2205 : PyObject *swig_obj[1] ;
20256 2205 : double result;
20257 :
20258 2205 : if (!args) SWIG_fail;
20259 2205 : swig_obj[0] = args;
20260 2205 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20261 2205 : if (!SWIG_IsOK(res1)) {
20262 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GCP_GCPY_get" "', argument " "1"" of type '" "GDAL_GCP *""'");
20263 : }
20264 2205 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20265 2205 : {
20266 2205 : const int bLocalUseExceptions = GetUseExceptions();
20267 2205 : if ( bLocalUseExceptions ) {
20268 2182 : pushErrorHandler();
20269 : }
20270 2205 : {
20271 2205 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20272 2205 : result = (double)GDAL_GCP_GCPY_get(arg1);
20273 2205 : SWIG_PYTHON_THREAD_END_ALLOW;
20274 : }
20275 2205 : if ( bLocalUseExceptions ) {
20276 2182 : popErrorHandler();
20277 : }
20278 : #ifndef SED_HACKS
20279 : if ( bLocalUseExceptions ) {
20280 : CPLErr eclass = CPLGetLastErrorType();
20281 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20282 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20283 : }
20284 : }
20285 : #endif
20286 : }
20287 2205 : resultobj = SWIG_From_double(static_cast< double >(result));
20288 2205 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20289 : return resultobj;
20290 : fail:
20291 : return NULL;
20292 : }
20293 :
20294 :
20295 0 : SWIGINTERN PyObject *_wrap_GCP_GCPZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20296 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20297 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20298 0 : double arg2 ;
20299 0 : void *argp1 = 0 ;
20300 0 : int res1 = 0 ;
20301 0 : double val2 ;
20302 0 : int ecode2 = 0 ;
20303 0 : PyObject *swig_obj[2] ;
20304 :
20305 0 : if (!SWIG_Python_UnpackTuple(args, "GCP_GCPZ_set", 2, 2, swig_obj)) SWIG_fail;
20306 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20307 0 : if (!SWIG_IsOK(res1)) {
20308 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GCP_GCPZ_set" "', argument " "1"" of type '" "GDAL_GCP *""'");
20309 : }
20310 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20311 0 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
20312 0 : if (!SWIG_IsOK(ecode2)) {
20313 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GCP_GCPZ_set" "', argument " "2"" of type '" "double""'");
20314 : }
20315 0 : arg2 = static_cast< double >(val2);
20316 0 : {
20317 0 : const int bLocalUseExceptions = GetUseExceptions();
20318 0 : if ( bLocalUseExceptions ) {
20319 0 : pushErrorHandler();
20320 : }
20321 0 : {
20322 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20323 0 : GDAL_GCP_GCPZ_set(arg1,arg2);
20324 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20325 : }
20326 0 : if ( bLocalUseExceptions ) {
20327 0 : popErrorHandler();
20328 : }
20329 : #ifndef SED_HACKS
20330 : if ( bLocalUseExceptions ) {
20331 : CPLErr eclass = CPLGetLastErrorType();
20332 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20333 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20334 : }
20335 : }
20336 : #endif
20337 : }
20338 0 : resultobj = SWIG_Py_Void();
20339 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20340 : return resultobj;
20341 : fail:
20342 : return NULL;
20343 : }
20344 :
20345 :
20346 42 : SWIGINTERN PyObject *_wrap_GCP_GCPZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20347 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20348 42 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20349 42 : void *argp1 = 0 ;
20350 42 : int res1 = 0 ;
20351 42 : PyObject *swig_obj[1] ;
20352 42 : double result;
20353 :
20354 42 : if (!args) SWIG_fail;
20355 42 : swig_obj[0] = args;
20356 42 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20357 42 : if (!SWIG_IsOK(res1)) {
20358 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GCP_GCPZ_get" "', argument " "1"" of type '" "GDAL_GCP *""'");
20359 : }
20360 42 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20361 42 : {
20362 42 : const int bLocalUseExceptions = GetUseExceptions();
20363 42 : if ( bLocalUseExceptions ) {
20364 29 : pushErrorHandler();
20365 : }
20366 42 : {
20367 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20368 42 : result = (double)GDAL_GCP_GCPZ_get(arg1);
20369 42 : SWIG_PYTHON_THREAD_END_ALLOW;
20370 : }
20371 42 : if ( bLocalUseExceptions ) {
20372 29 : popErrorHandler();
20373 : }
20374 : #ifndef SED_HACKS
20375 : if ( bLocalUseExceptions ) {
20376 : CPLErr eclass = CPLGetLastErrorType();
20377 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20378 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20379 : }
20380 : }
20381 : #endif
20382 : }
20383 42 : resultobj = SWIG_From_double(static_cast< double >(result));
20384 42 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20385 : return resultobj;
20386 : fail:
20387 : return NULL;
20388 : }
20389 :
20390 :
20391 100 : SWIGINTERN PyObject *_wrap_GCP_GCPPixel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20392 100 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20393 100 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20394 100 : double arg2 ;
20395 100 : void *argp1 = 0 ;
20396 100 : int res1 = 0 ;
20397 100 : double val2 ;
20398 100 : int ecode2 = 0 ;
20399 100 : PyObject *swig_obj[2] ;
20400 :
20401 100 : if (!SWIG_Python_UnpackTuple(args, "GCP_GCPPixel_set", 2, 2, swig_obj)) SWIG_fail;
20402 100 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20403 100 : if (!SWIG_IsOK(res1)) {
20404 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GCP_GCPPixel_set" "', argument " "1"" of type '" "GDAL_GCP *""'");
20405 : }
20406 100 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20407 100 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
20408 100 : if (!SWIG_IsOK(ecode2)) {
20409 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GCP_GCPPixel_set" "', argument " "2"" of type '" "double""'");
20410 : }
20411 100 : arg2 = static_cast< double >(val2);
20412 100 : {
20413 100 : const int bLocalUseExceptions = GetUseExceptions();
20414 100 : if ( bLocalUseExceptions ) {
20415 99 : pushErrorHandler();
20416 : }
20417 100 : {
20418 100 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20419 100 : GDAL_GCP_GCPPixel_set(arg1,arg2);
20420 100 : SWIG_PYTHON_THREAD_END_ALLOW;
20421 : }
20422 100 : if ( bLocalUseExceptions ) {
20423 99 : popErrorHandler();
20424 : }
20425 : #ifndef SED_HACKS
20426 : if ( bLocalUseExceptions ) {
20427 : CPLErr eclass = CPLGetLastErrorType();
20428 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20429 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20430 : }
20431 : }
20432 : #endif
20433 : }
20434 100 : resultobj = SWIG_Py_Void();
20435 100 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20436 : return resultobj;
20437 : fail:
20438 : return NULL;
20439 : }
20440 :
20441 :
20442 8554 : SWIGINTERN PyObject *_wrap_GCP_GCPPixel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20443 8554 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20444 8554 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20445 8554 : void *argp1 = 0 ;
20446 8554 : int res1 = 0 ;
20447 8554 : PyObject *swig_obj[1] ;
20448 8554 : double result;
20449 :
20450 8554 : if (!args) SWIG_fail;
20451 8554 : swig_obj[0] = args;
20452 8554 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20453 8554 : if (!SWIG_IsOK(res1)) {
20454 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GCP_GCPPixel_get" "', argument " "1"" of type '" "GDAL_GCP *""'");
20455 : }
20456 8554 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20457 8554 : {
20458 8554 : const int bLocalUseExceptions = GetUseExceptions();
20459 8554 : if ( bLocalUseExceptions ) {
20460 8531 : pushErrorHandler();
20461 : }
20462 8554 : {
20463 8554 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20464 8554 : result = (double)GDAL_GCP_GCPPixel_get(arg1);
20465 8554 : SWIG_PYTHON_THREAD_END_ALLOW;
20466 : }
20467 8554 : if ( bLocalUseExceptions ) {
20468 8531 : popErrorHandler();
20469 : }
20470 : #ifndef SED_HACKS
20471 : if ( bLocalUseExceptions ) {
20472 : CPLErr eclass = CPLGetLastErrorType();
20473 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20474 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20475 : }
20476 : }
20477 : #endif
20478 : }
20479 8554 : resultobj = SWIG_From_double(static_cast< double >(result));
20480 8554 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20481 : return resultobj;
20482 : fail:
20483 : return NULL;
20484 : }
20485 :
20486 :
20487 100 : SWIGINTERN PyObject *_wrap_GCP_GCPLine_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20488 100 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20489 100 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20490 100 : double arg2 ;
20491 100 : void *argp1 = 0 ;
20492 100 : int res1 = 0 ;
20493 100 : double val2 ;
20494 100 : int ecode2 = 0 ;
20495 100 : PyObject *swig_obj[2] ;
20496 :
20497 100 : if (!SWIG_Python_UnpackTuple(args, "GCP_GCPLine_set", 2, 2, swig_obj)) SWIG_fail;
20498 100 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20499 100 : if (!SWIG_IsOK(res1)) {
20500 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GCP_GCPLine_set" "', argument " "1"" of type '" "GDAL_GCP *""'");
20501 : }
20502 100 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20503 100 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
20504 100 : if (!SWIG_IsOK(ecode2)) {
20505 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GCP_GCPLine_set" "', argument " "2"" of type '" "double""'");
20506 : }
20507 100 : arg2 = static_cast< double >(val2);
20508 100 : {
20509 100 : const int bLocalUseExceptions = GetUseExceptions();
20510 100 : if ( bLocalUseExceptions ) {
20511 99 : pushErrorHandler();
20512 : }
20513 100 : {
20514 100 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20515 100 : GDAL_GCP_GCPLine_set(arg1,arg2);
20516 100 : SWIG_PYTHON_THREAD_END_ALLOW;
20517 : }
20518 100 : if ( bLocalUseExceptions ) {
20519 99 : popErrorHandler();
20520 : }
20521 : #ifndef SED_HACKS
20522 : if ( bLocalUseExceptions ) {
20523 : CPLErr eclass = CPLGetLastErrorType();
20524 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20525 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20526 : }
20527 : }
20528 : #endif
20529 : }
20530 100 : resultobj = SWIG_Py_Void();
20531 100 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20532 : return resultobj;
20533 : fail:
20534 : return NULL;
20535 : }
20536 :
20537 :
20538 8554 : SWIGINTERN PyObject *_wrap_GCP_GCPLine_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20539 8554 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20540 8554 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20541 8554 : void *argp1 = 0 ;
20542 8554 : int res1 = 0 ;
20543 8554 : PyObject *swig_obj[1] ;
20544 8554 : double result;
20545 :
20546 8554 : if (!args) SWIG_fail;
20547 8554 : swig_obj[0] = args;
20548 8554 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20549 8554 : if (!SWIG_IsOK(res1)) {
20550 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GCP_GCPLine_get" "', argument " "1"" of type '" "GDAL_GCP *""'");
20551 : }
20552 8554 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20553 8554 : {
20554 8554 : const int bLocalUseExceptions = GetUseExceptions();
20555 8554 : if ( bLocalUseExceptions ) {
20556 8531 : pushErrorHandler();
20557 : }
20558 8554 : {
20559 8554 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20560 8554 : result = (double)GDAL_GCP_GCPLine_get(arg1);
20561 8554 : SWIG_PYTHON_THREAD_END_ALLOW;
20562 : }
20563 8554 : if ( bLocalUseExceptions ) {
20564 8531 : popErrorHandler();
20565 : }
20566 : #ifndef SED_HACKS
20567 : if ( bLocalUseExceptions ) {
20568 : CPLErr eclass = CPLGetLastErrorType();
20569 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20570 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20571 : }
20572 : }
20573 : #endif
20574 : }
20575 8554 : resultobj = SWIG_From_double(static_cast< double >(result));
20576 8554 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20577 : return resultobj;
20578 : fail:
20579 : return NULL;
20580 : }
20581 :
20582 :
20583 1 : SWIGINTERN PyObject *_wrap_GCP_Info_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20584 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20585 1 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20586 1 : char *arg2 = (char *) 0 ;
20587 1 : void *argp1 = 0 ;
20588 1 : int res1 = 0 ;
20589 1 : int res2 ;
20590 1 : char *buf2 = 0 ;
20591 1 : int alloc2 = 0 ;
20592 1 : PyObject *swig_obj[2] ;
20593 :
20594 1 : if (!SWIG_Python_UnpackTuple(args, "GCP_Info_set", 2, 2, swig_obj)) SWIG_fail;
20595 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20596 1 : if (!SWIG_IsOK(res1)) {
20597 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GCP_Info_set" "', argument " "1"" of type '" "GDAL_GCP *""'");
20598 : }
20599 1 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20600 1 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
20601 1 : if (!SWIG_IsOK(res2)) {
20602 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GCP_Info_set" "', argument " "2"" of type '" "char *""'");
20603 : }
20604 1 : arg2 = reinterpret_cast< char * >(buf2);
20605 1 : {
20606 1 : const int bLocalUseExceptions = GetUseExceptions();
20607 1 : if ( bLocalUseExceptions ) {
20608 1 : pushErrorHandler();
20609 : }
20610 1 : {
20611 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20612 1 : GDAL_GCP_Info_set(arg1,arg2);
20613 1 : SWIG_PYTHON_THREAD_END_ALLOW;
20614 : }
20615 1 : if ( bLocalUseExceptions ) {
20616 1 : popErrorHandler();
20617 : }
20618 : #ifndef SED_HACKS
20619 : if ( bLocalUseExceptions ) {
20620 : CPLErr eclass = CPLGetLastErrorType();
20621 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20622 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20623 : }
20624 : }
20625 : #endif
20626 : }
20627 1 : resultobj = SWIG_Py_Void();
20628 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20629 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20630 : return resultobj;
20631 0 : fail:
20632 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20633 : return NULL;
20634 : }
20635 :
20636 :
20637 9 : SWIGINTERN PyObject *_wrap_GCP_Info_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20638 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20639 9 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20640 9 : void *argp1 = 0 ;
20641 9 : int res1 = 0 ;
20642 9 : PyObject *swig_obj[1] ;
20643 9 : char *result = 0 ;
20644 :
20645 9 : if (!args) SWIG_fail;
20646 9 : swig_obj[0] = args;
20647 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20648 9 : if (!SWIG_IsOK(res1)) {
20649 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GCP_Info_get" "', argument " "1"" of type '" "GDAL_GCP *""'");
20650 : }
20651 9 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20652 9 : {
20653 9 : const int bLocalUseExceptions = GetUseExceptions();
20654 9 : if ( bLocalUseExceptions ) {
20655 5 : pushErrorHandler();
20656 : }
20657 9 : {
20658 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20659 9 : result = (char *)GDAL_GCP_Info_get(arg1);
20660 9 : SWIG_PYTHON_THREAD_END_ALLOW;
20661 : }
20662 9 : if ( bLocalUseExceptions ) {
20663 5 : popErrorHandler();
20664 : }
20665 : #ifndef SED_HACKS
20666 : if ( bLocalUseExceptions ) {
20667 : CPLErr eclass = CPLGetLastErrorType();
20668 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20669 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20670 : }
20671 : }
20672 : #endif
20673 : }
20674 9 : resultobj = SWIG_FromCharPtr((const char *)result);
20675 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20676 : return resultobj;
20677 : fail:
20678 : return NULL;
20679 : }
20680 :
20681 :
20682 1 : SWIGINTERN PyObject *_wrap_GCP_Id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20683 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20684 1 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20685 1 : char *arg2 = (char *) 0 ;
20686 1 : void *argp1 = 0 ;
20687 1 : int res1 = 0 ;
20688 1 : int res2 ;
20689 1 : char *buf2 = 0 ;
20690 1 : int alloc2 = 0 ;
20691 1 : PyObject *swig_obj[2] ;
20692 :
20693 1 : if (!SWIG_Python_UnpackTuple(args, "GCP_Id_set", 2, 2, swig_obj)) SWIG_fail;
20694 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20695 1 : if (!SWIG_IsOK(res1)) {
20696 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GCP_Id_set" "', argument " "1"" of type '" "GDAL_GCP *""'");
20697 : }
20698 1 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20699 1 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
20700 1 : if (!SWIG_IsOK(res2)) {
20701 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GCP_Id_set" "', argument " "2"" of type '" "char *""'");
20702 : }
20703 1 : arg2 = reinterpret_cast< char * >(buf2);
20704 1 : {
20705 1 : const int bLocalUseExceptions = GetUseExceptions();
20706 1 : if ( bLocalUseExceptions ) {
20707 1 : pushErrorHandler();
20708 : }
20709 1 : {
20710 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20711 1 : GDAL_GCP_Id_set(arg1,arg2);
20712 1 : SWIG_PYTHON_THREAD_END_ALLOW;
20713 : }
20714 1 : if ( bLocalUseExceptions ) {
20715 1 : popErrorHandler();
20716 : }
20717 : #ifndef SED_HACKS
20718 : if ( bLocalUseExceptions ) {
20719 : CPLErr eclass = CPLGetLastErrorType();
20720 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20721 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20722 : }
20723 : }
20724 : #endif
20725 : }
20726 1 : resultobj = SWIG_Py_Void();
20727 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20728 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20729 : return resultobj;
20730 0 : fail:
20731 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20732 : return NULL;
20733 : }
20734 :
20735 :
20736 9 : SWIGINTERN PyObject *_wrap_GCP_Id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20737 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20738 9 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20739 9 : void *argp1 = 0 ;
20740 9 : int res1 = 0 ;
20741 9 : PyObject *swig_obj[1] ;
20742 9 : char *result = 0 ;
20743 :
20744 9 : if (!args) SWIG_fail;
20745 9 : swig_obj[0] = args;
20746 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20747 9 : if (!SWIG_IsOK(res1)) {
20748 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GCP_Id_get" "', argument " "1"" of type '" "GDAL_GCP *""'");
20749 : }
20750 9 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20751 9 : {
20752 9 : const int bLocalUseExceptions = GetUseExceptions();
20753 9 : if ( bLocalUseExceptions ) {
20754 5 : pushErrorHandler();
20755 : }
20756 9 : {
20757 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20758 9 : result = (char *)GDAL_GCP_Id_get(arg1);
20759 9 : SWIG_PYTHON_THREAD_END_ALLOW;
20760 : }
20761 9 : if ( bLocalUseExceptions ) {
20762 5 : popErrorHandler();
20763 : }
20764 : #ifndef SED_HACKS
20765 : if ( bLocalUseExceptions ) {
20766 : CPLErr eclass = CPLGetLastErrorType();
20767 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20768 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20769 : }
20770 : }
20771 : #endif
20772 : }
20773 9 : resultobj = SWIG_FromCharPtr((const char *)result);
20774 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20775 : return resultobj;
20776 : fail:
20777 : return NULL;
20778 : }
20779 :
20780 :
20781 130 : SWIGINTERN PyObject *_wrap_new_GCP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20782 130 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20783 130 : double arg1 = (double) 0.0 ;
20784 130 : double arg2 = (double) 0.0 ;
20785 130 : double arg3 = (double) 0.0 ;
20786 130 : double arg4 = (double) 0.0 ;
20787 130 : double arg5 = (double) 0.0 ;
20788 130 : char *arg6 = (char *) "" ;
20789 130 : char *arg7 = (char *) "" ;
20790 130 : double val1 ;
20791 130 : int ecode1 = 0 ;
20792 130 : double val2 ;
20793 130 : int ecode2 = 0 ;
20794 130 : double val3 ;
20795 130 : int ecode3 = 0 ;
20796 130 : double val4 ;
20797 130 : int ecode4 = 0 ;
20798 130 : double val5 ;
20799 130 : int ecode5 = 0 ;
20800 130 : int res6 ;
20801 130 : char *buf6 = 0 ;
20802 130 : int alloc6 = 0 ;
20803 130 : int res7 ;
20804 130 : char *buf7 = 0 ;
20805 130 : int alloc7 = 0 ;
20806 130 : PyObject *swig_obj[7] ;
20807 130 : GDAL_GCP *result = 0 ;
20808 :
20809 130 : if (!SWIG_Python_UnpackTuple(args, "new_GCP", 0, 7, swig_obj)) SWIG_fail;
20810 130 : if (swig_obj[0]) {
20811 38 : ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
20812 38 : if (!SWIG_IsOK(ecode1)) {
20813 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GCP" "', argument " "1"" of type '" "double""'");
20814 : }
20815 38 : arg1 = static_cast< double >(val1);
20816 : }
20817 130 : if (swig_obj[1]) {
20818 38 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
20819 38 : if (!SWIG_IsOK(ecode2)) {
20820 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GCP" "', argument " "2"" of type '" "double""'");
20821 : }
20822 38 : arg2 = static_cast< double >(val2);
20823 : }
20824 130 : if (swig_obj[2]) {
20825 38 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
20826 38 : if (!SWIG_IsOK(ecode3)) {
20827 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GCP" "', argument " "3"" of type '" "double""'");
20828 : }
20829 38 : arg3 = static_cast< double >(val3);
20830 : }
20831 130 : if (swig_obj[3]) {
20832 38 : ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
20833 38 : if (!SWIG_IsOK(ecode4)) {
20834 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GCP" "', argument " "4"" of type '" "double""'");
20835 : }
20836 38 : arg4 = static_cast< double >(val4);
20837 : }
20838 130 : if (swig_obj[4]) {
20839 38 : ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
20840 38 : if (!SWIG_IsOK(ecode5)) {
20841 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GCP" "', argument " "5"" of type '" "double""'");
20842 : }
20843 38 : arg5 = static_cast< double >(val5);
20844 : }
20845 130 : if (swig_obj[5]) {
20846 0 : res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
20847 0 : if (!SWIG_IsOK(res6)) {
20848 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GCP" "', argument " "6"" of type '" "char const *""'");
20849 : }
20850 0 : arg6 = reinterpret_cast< char * >(buf6);
20851 : }
20852 130 : if (swig_obj[6]) {
20853 0 : res7 = SWIG_AsCharPtrAndSize(swig_obj[6], &buf7, NULL, &alloc7);
20854 0 : if (!SWIG_IsOK(res7)) {
20855 0 : SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_GCP" "', argument " "7"" of type '" "char const *""'");
20856 : }
20857 0 : arg7 = reinterpret_cast< char * >(buf7);
20858 : }
20859 130 : {
20860 130 : const int bLocalUseExceptions = GetUseExceptions();
20861 130 : if ( bLocalUseExceptions ) {
20862 119 : pushErrorHandler();
20863 : }
20864 130 : {
20865 130 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20866 130 : result = (GDAL_GCP *)new_GDAL_GCP(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,(char const *)arg7);
20867 130 : SWIG_PYTHON_THREAD_END_ALLOW;
20868 : }
20869 130 : if ( bLocalUseExceptions ) {
20870 119 : popErrorHandler();
20871 : }
20872 : #ifndef SED_HACKS
20873 : if ( bLocalUseExceptions ) {
20874 : CPLErr eclass = CPLGetLastErrorType();
20875 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20876 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20877 : }
20878 : }
20879 : #endif
20880 : }
20881 130 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDAL_GCP, SWIG_POINTER_NEW | 0 );
20882 130 : if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
20883 130 : if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
20884 130 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20885 : return resultobj;
20886 0 : fail:
20887 0 : if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
20888 0 : if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
20889 : return NULL;
20890 : }
20891 :
20892 :
20893 3428 : SWIGINTERN PyObject *_wrap_delete_GCP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20894 3428 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20895 3428 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20896 3428 : void *argp1 = 0 ;
20897 3428 : int res1 = 0 ;
20898 3428 : PyObject *swig_obj[1] ;
20899 :
20900 3428 : if (!args) SWIG_fail;
20901 3428 : swig_obj[0] = args;
20902 3428 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, SWIG_POINTER_DISOWN | 0 );
20903 3428 : if (!SWIG_IsOK(res1)) {
20904 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GCP" "', argument " "1"" of type '" "GDAL_GCP *""'");
20905 : }
20906 3428 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20907 3428 : {
20908 3428 : const int bLocalUseExceptions = GetUseExceptions();
20909 3428 : if ( bLocalUseExceptions ) {
20910 3337 : pushErrorHandler();
20911 : }
20912 3428 : {
20913 3428 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20914 3428 : delete_GDAL_GCP(arg1);
20915 3428 : SWIG_PYTHON_THREAD_END_ALLOW;
20916 : }
20917 3428 : if ( bLocalUseExceptions ) {
20918 3337 : popErrorHandler();
20919 : }
20920 : #ifndef SED_HACKS
20921 : if ( bLocalUseExceptions ) {
20922 : CPLErr eclass = CPLGetLastErrorType();
20923 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20924 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20925 : }
20926 : }
20927 : #endif
20928 : }
20929 3428 : resultobj = SWIG_Py_Void();
20930 3428 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20931 : return resultobj;
20932 : fail:
20933 : return NULL;
20934 : }
20935 :
20936 :
20937 277 : SWIGINTERN PyObject *GCP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20938 277 : PyObject *obj;
20939 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
20940 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDAL_GCP, SWIG_NewClientData(obj));
20941 277 : return SWIG_Py_Void();
20942 : }
20943 :
20944 130 : SWIGINTERN PyObject *GCP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20945 130 : return SWIG_Python_InitShadowInstance(args);
20946 : }
20947 :
20948 0 : SWIGINTERN PyObject *_wrap_GDAL_GCP_GCPX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20949 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
20950 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
20951 0 : void *argp1 = 0 ;
20952 0 : int res1 = 0 ;
20953 0 : PyObject *swig_obj[1] ;
20954 0 : double result;
20955 :
20956 0 : if (!args) SWIG_fail;
20957 0 : swig_obj[0] = args;
20958 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
20959 0 : if (!SWIG_IsOK(res1)) {
20960 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDAL_GCP_GCPX_get" "', argument " "1"" of type '" "GDAL_GCP *""'");
20961 : }
20962 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
20963 0 : {
20964 0 : if (!arg1) {
20965 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
20966 : }
20967 : }
20968 0 : {
20969 0 : const int bLocalUseExceptions = GetUseExceptions();
20970 0 : if ( bLocalUseExceptions ) {
20971 0 : pushErrorHandler();
20972 : }
20973 0 : {
20974 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20975 0 : result = (double)GDAL_GCP_GCPX_get(arg1);
20976 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20977 : }
20978 0 : if ( bLocalUseExceptions ) {
20979 0 : popErrorHandler();
20980 : }
20981 : #ifndef SED_HACKS
20982 : if ( bLocalUseExceptions ) {
20983 : CPLErr eclass = CPLGetLastErrorType();
20984 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
20985 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
20986 : }
20987 : }
20988 : #endif
20989 : }
20990 0 : resultobj = SWIG_From_double(static_cast< double >(result));
20991 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
20992 : return resultobj;
20993 : fail:
20994 : return NULL;
20995 : }
20996 :
20997 :
20998 0 : SWIGINTERN PyObject *_wrap_GDAL_GCP_GCPX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20999 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21000 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
21001 0 : double arg2 ;
21002 0 : void *argp1 = 0 ;
21003 0 : int res1 = 0 ;
21004 0 : double val2 ;
21005 0 : int ecode2 = 0 ;
21006 0 : PyObject *swig_obj[2] ;
21007 :
21008 0 : if (!SWIG_Python_UnpackTuple(args, "GDAL_GCP_GCPX_set", 2, 2, swig_obj)) SWIG_fail;
21009 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
21010 0 : if (!SWIG_IsOK(res1)) {
21011 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDAL_GCP_GCPX_set" "', argument " "1"" of type '" "GDAL_GCP *""'");
21012 : }
21013 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
21014 0 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
21015 0 : if (!SWIG_IsOK(ecode2)) {
21016 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GDAL_GCP_GCPX_set" "', argument " "2"" of type '" "double""'");
21017 : }
21018 0 : arg2 = static_cast< double >(val2);
21019 0 : {
21020 0 : if (!arg1) {
21021 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21022 : }
21023 : }
21024 0 : {
21025 0 : const int bLocalUseExceptions = GetUseExceptions();
21026 0 : if ( bLocalUseExceptions ) {
21027 0 : pushErrorHandler();
21028 : }
21029 0 : {
21030 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21031 0 : GDAL_GCP_GCPX_set(arg1,arg2);
21032 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21033 : }
21034 0 : if ( bLocalUseExceptions ) {
21035 0 : popErrorHandler();
21036 : }
21037 : #ifndef SED_HACKS
21038 : if ( bLocalUseExceptions ) {
21039 : CPLErr eclass = CPLGetLastErrorType();
21040 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21041 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21042 : }
21043 : }
21044 : #endif
21045 : }
21046 0 : resultobj = SWIG_Py_Void();
21047 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21048 : return resultobj;
21049 : fail:
21050 : return NULL;
21051 : }
21052 :
21053 :
21054 0 : SWIGINTERN PyObject *_wrap_GDAL_GCP_GCPY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21055 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21056 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
21057 0 : void *argp1 = 0 ;
21058 0 : int res1 = 0 ;
21059 0 : PyObject *swig_obj[1] ;
21060 0 : double result;
21061 :
21062 0 : if (!args) SWIG_fail;
21063 0 : swig_obj[0] = args;
21064 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
21065 0 : if (!SWIG_IsOK(res1)) {
21066 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDAL_GCP_GCPY_get" "', argument " "1"" of type '" "GDAL_GCP *""'");
21067 : }
21068 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
21069 0 : {
21070 0 : if (!arg1) {
21071 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21072 : }
21073 : }
21074 0 : {
21075 0 : const int bLocalUseExceptions = GetUseExceptions();
21076 0 : if ( bLocalUseExceptions ) {
21077 0 : pushErrorHandler();
21078 : }
21079 0 : {
21080 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21081 0 : result = (double)GDAL_GCP_GCPY_get(arg1);
21082 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21083 : }
21084 0 : if ( bLocalUseExceptions ) {
21085 0 : popErrorHandler();
21086 : }
21087 : #ifndef SED_HACKS
21088 : if ( bLocalUseExceptions ) {
21089 : CPLErr eclass = CPLGetLastErrorType();
21090 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21091 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21092 : }
21093 : }
21094 : #endif
21095 : }
21096 0 : resultobj = SWIG_From_double(static_cast< double >(result));
21097 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21098 : return resultobj;
21099 : fail:
21100 : return NULL;
21101 : }
21102 :
21103 :
21104 0 : SWIGINTERN PyObject *_wrap_GDAL_GCP_GCPY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21105 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21106 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
21107 0 : double arg2 ;
21108 0 : void *argp1 = 0 ;
21109 0 : int res1 = 0 ;
21110 0 : double val2 ;
21111 0 : int ecode2 = 0 ;
21112 0 : PyObject *swig_obj[2] ;
21113 :
21114 0 : if (!SWIG_Python_UnpackTuple(args, "GDAL_GCP_GCPY_set", 2, 2, swig_obj)) SWIG_fail;
21115 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
21116 0 : if (!SWIG_IsOK(res1)) {
21117 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDAL_GCP_GCPY_set" "', argument " "1"" of type '" "GDAL_GCP *""'");
21118 : }
21119 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
21120 0 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
21121 0 : if (!SWIG_IsOK(ecode2)) {
21122 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GDAL_GCP_GCPY_set" "', argument " "2"" of type '" "double""'");
21123 : }
21124 0 : arg2 = static_cast< double >(val2);
21125 0 : {
21126 0 : if (!arg1) {
21127 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21128 : }
21129 : }
21130 0 : {
21131 0 : const int bLocalUseExceptions = GetUseExceptions();
21132 0 : if ( bLocalUseExceptions ) {
21133 0 : pushErrorHandler();
21134 : }
21135 0 : {
21136 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21137 0 : GDAL_GCP_GCPY_set(arg1,arg2);
21138 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21139 : }
21140 0 : if ( bLocalUseExceptions ) {
21141 0 : popErrorHandler();
21142 : }
21143 : #ifndef SED_HACKS
21144 : if ( bLocalUseExceptions ) {
21145 : CPLErr eclass = CPLGetLastErrorType();
21146 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21147 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21148 : }
21149 : }
21150 : #endif
21151 : }
21152 0 : resultobj = SWIG_Py_Void();
21153 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21154 : return resultobj;
21155 : fail:
21156 : return NULL;
21157 : }
21158 :
21159 :
21160 0 : SWIGINTERN PyObject *_wrap_GDAL_GCP_GCPZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21161 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21162 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
21163 0 : void *argp1 = 0 ;
21164 0 : int res1 = 0 ;
21165 0 : PyObject *swig_obj[1] ;
21166 0 : double result;
21167 :
21168 0 : if (!args) SWIG_fail;
21169 0 : swig_obj[0] = args;
21170 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
21171 0 : if (!SWIG_IsOK(res1)) {
21172 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDAL_GCP_GCPZ_get" "', argument " "1"" of type '" "GDAL_GCP *""'");
21173 : }
21174 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
21175 0 : {
21176 0 : if (!arg1) {
21177 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21178 : }
21179 : }
21180 0 : {
21181 0 : const int bLocalUseExceptions = GetUseExceptions();
21182 0 : if ( bLocalUseExceptions ) {
21183 0 : pushErrorHandler();
21184 : }
21185 0 : {
21186 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21187 0 : result = (double)GDAL_GCP_GCPZ_get(arg1);
21188 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21189 : }
21190 0 : if ( bLocalUseExceptions ) {
21191 0 : popErrorHandler();
21192 : }
21193 : #ifndef SED_HACKS
21194 : if ( bLocalUseExceptions ) {
21195 : CPLErr eclass = CPLGetLastErrorType();
21196 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21197 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21198 : }
21199 : }
21200 : #endif
21201 : }
21202 0 : resultobj = SWIG_From_double(static_cast< double >(result));
21203 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21204 : return resultobj;
21205 : fail:
21206 : return NULL;
21207 : }
21208 :
21209 :
21210 0 : SWIGINTERN PyObject *_wrap_GDAL_GCP_GCPZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21211 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21212 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
21213 0 : double arg2 ;
21214 0 : void *argp1 = 0 ;
21215 0 : int res1 = 0 ;
21216 0 : double val2 ;
21217 0 : int ecode2 = 0 ;
21218 0 : PyObject *swig_obj[2] ;
21219 :
21220 0 : if (!SWIG_Python_UnpackTuple(args, "GDAL_GCP_GCPZ_set", 2, 2, swig_obj)) SWIG_fail;
21221 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
21222 0 : if (!SWIG_IsOK(res1)) {
21223 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDAL_GCP_GCPZ_set" "', argument " "1"" of type '" "GDAL_GCP *""'");
21224 : }
21225 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
21226 0 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
21227 0 : if (!SWIG_IsOK(ecode2)) {
21228 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GDAL_GCP_GCPZ_set" "', argument " "2"" of type '" "double""'");
21229 : }
21230 0 : arg2 = static_cast< double >(val2);
21231 0 : {
21232 0 : if (!arg1) {
21233 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21234 : }
21235 : }
21236 0 : {
21237 0 : const int bLocalUseExceptions = GetUseExceptions();
21238 0 : if ( bLocalUseExceptions ) {
21239 0 : pushErrorHandler();
21240 : }
21241 0 : {
21242 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21243 0 : GDAL_GCP_GCPZ_set(arg1,arg2);
21244 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21245 : }
21246 0 : if ( bLocalUseExceptions ) {
21247 0 : popErrorHandler();
21248 : }
21249 : #ifndef SED_HACKS
21250 : if ( bLocalUseExceptions ) {
21251 : CPLErr eclass = CPLGetLastErrorType();
21252 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21253 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21254 : }
21255 : }
21256 : #endif
21257 : }
21258 0 : resultobj = SWIG_Py_Void();
21259 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21260 : return resultobj;
21261 : fail:
21262 : return NULL;
21263 : }
21264 :
21265 :
21266 0 : SWIGINTERN PyObject *_wrap_GDAL_GCP_GCPPixel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21267 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21268 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
21269 0 : void *argp1 = 0 ;
21270 0 : int res1 = 0 ;
21271 0 : PyObject *swig_obj[1] ;
21272 0 : double result;
21273 :
21274 0 : if (!args) SWIG_fail;
21275 0 : swig_obj[0] = args;
21276 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
21277 0 : if (!SWIG_IsOK(res1)) {
21278 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDAL_GCP_GCPPixel_get" "', argument " "1"" of type '" "GDAL_GCP *""'");
21279 : }
21280 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
21281 0 : {
21282 0 : if (!arg1) {
21283 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21284 : }
21285 : }
21286 0 : {
21287 0 : const int bLocalUseExceptions = GetUseExceptions();
21288 0 : if ( bLocalUseExceptions ) {
21289 0 : pushErrorHandler();
21290 : }
21291 0 : {
21292 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21293 0 : result = (double)GDAL_GCP_GCPPixel_get(arg1);
21294 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21295 : }
21296 0 : if ( bLocalUseExceptions ) {
21297 0 : popErrorHandler();
21298 : }
21299 : #ifndef SED_HACKS
21300 : if ( bLocalUseExceptions ) {
21301 : CPLErr eclass = CPLGetLastErrorType();
21302 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21303 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21304 : }
21305 : }
21306 : #endif
21307 : }
21308 0 : resultobj = SWIG_From_double(static_cast< double >(result));
21309 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21310 : return resultobj;
21311 : fail:
21312 : return NULL;
21313 : }
21314 :
21315 :
21316 0 : SWIGINTERN PyObject *_wrap_GDAL_GCP_GCPPixel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21317 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21318 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
21319 0 : double arg2 ;
21320 0 : void *argp1 = 0 ;
21321 0 : int res1 = 0 ;
21322 0 : double val2 ;
21323 0 : int ecode2 = 0 ;
21324 0 : PyObject *swig_obj[2] ;
21325 :
21326 0 : if (!SWIG_Python_UnpackTuple(args, "GDAL_GCP_GCPPixel_set", 2, 2, swig_obj)) SWIG_fail;
21327 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
21328 0 : if (!SWIG_IsOK(res1)) {
21329 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDAL_GCP_GCPPixel_set" "', argument " "1"" of type '" "GDAL_GCP *""'");
21330 : }
21331 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
21332 0 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
21333 0 : if (!SWIG_IsOK(ecode2)) {
21334 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GDAL_GCP_GCPPixel_set" "', argument " "2"" of type '" "double""'");
21335 : }
21336 0 : arg2 = static_cast< double >(val2);
21337 0 : {
21338 0 : if (!arg1) {
21339 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21340 : }
21341 : }
21342 0 : {
21343 0 : const int bLocalUseExceptions = GetUseExceptions();
21344 0 : if ( bLocalUseExceptions ) {
21345 0 : pushErrorHandler();
21346 : }
21347 0 : {
21348 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21349 0 : GDAL_GCP_GCPPixel_set(arg1,arg2);
21350 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21351 : }
21352 0 : if ( bLocalUseExceptions ) {
21353 0 : popErrorHandler();
21354 : }
21355 : #ifndef SED_HACKS
21356 : if ( bLocalUseExceptions ) {
21357 : CPLErr eclass = CPLGetLastErrorType();
21358 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21359 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21360 : }
21361 : }
21362 : #endif
21363 : }
21364 0 : resultobj = SWIG_Py_Void();
21365 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21366 : return resultobj;
21367 : fail:
21368 : return NULL;
21369 : }
21370 :
21371 :
21372 0 : SWIGINTERN PyObject *_wrap_GDAL_GCP_GCPLine_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21373 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21374 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
21375 0 : void *argp1 = 0 ;
21376 0 : int res1 = 0 ;
21377 0 : PyObject *swig_obj[1] ;
21378 0 : double result;
21379 :
21380 0 : if (!args) SWIG_fail;
21381 0 : swig_obj[0] = args;
21382 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
21383 0 : if (!SWIG_IsOK(res1)) {
21384 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDAL_GCP_GCPLine_get" "', argument " "1"" of type '" "GDAL_GCP *""'");
21385 : }
21386 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
21387 0 : {
21388 0 : if (!arg1) {
21389 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21390 : }
21391 : }
21392 0 : {
21393 0 : const int bLocalUseExceptions = GetUseExceptions();
21394 0 : if ( bLocalUseExceptions ) {
21395 0 : pushErrorHandler();
21396 : }
21397 0 : {
21398 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21399 0 : result = (double)GDAL_GCP_GCPLine_get(arg1);
21400 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21401 : }
21402 0 : if ( bLocalUseExceptions ) {
21403 0 : popErrorHandler();
21404 : }
21405 : #ifndef SED_HACKS
21406 : if ( bLocalUseExceptions ) {
21407 : CPLErr eclass = CPLGetLastErrorType();
21408 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21409 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21410 : }
21411 : }
21412 : #endif
21413 : }
21414 0 : resultobj = SWIG_From_double(static_cast< double >(result));
21415 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21416 : return resultobj;
21417 : fail:
21418 : return NULL;
21419 : }
21420 :
21421 :
21422 0 : SWIGINTERN PyObject *_wrap_GDAL_GCP_GCPLine_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21423 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21424 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
21425 0 : double arg2 ;
21426 0 : void *argp1 = 0 ;
21427 0 : int res1 = 0 ;
21428 0 : double val2 ;
21429 0 : int ecode2 = 0 ;
21430 0 : PyObject *swig_obj[2] ;
21431 :
21432 0 : if (!SWIG_Python_UnpackTuple(args, "GDAL_GCP_GCPLine_set", 2, 2, swig_obj)) SWIG_fail;
21433 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
21434 0 : if (!SWIG_IsOK(res1)) {
21435 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDAL_GCP_GCPLine_set" "', argument " "1"" of type '" "GDAL_GCP *""'");
21436 : }
21437 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
21438 0 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
21439 0 : if (!SWIG_IsOK(ecode2)) {
21440 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GDAL_GCP_GCPLine_set" "', argument " "2"" of type '" "double""'");
21441 : }
21442 0 : arg2 = static_cast< double >(val2);
21443 0 : {
21444 0 : if (!arg1) {
21445 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21446 : }
21447 : }
21448 0 : {
21449 0 : const int bLocalUseExceptions = GetUseExceptions();
21450 0 : if ( bLocalUseExceptions ) {
21451 0 : pushErrorHandler();
21452 : }
21453 0 : {
21454 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21455 0 : GDAL_GCP_GCPLine_set(arg1,arg2);
21456 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21457 : }
21458 0 : if ( bLocalUseExceptions ) {
21459 0 : popErrorHandler();
21460 : }
21461 : #ifndef SED_HACKS
21462 : if ( bLocalUseExceptions ) {
21463 : CPLErr eclass = CPLGetLastErrorType();
21464 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21465 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21466 : }
21467 : }
21468 : #endif
21469 : }
21470 0 : resultobj = SWIG_Py_Void();
21471 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21472 : return resultobj;
21473 : fail:
21474 : return NULL;
21475 : }
21476 :
21477 :
21478 0 : SWIGINTERN PyObject *_wrap_GDAL_GCP_Info_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21479 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21480 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
21481 0 : void *argp1 = 0 ;
21482 0 : int res1 = 0 ;
21483 0 : PyObject *swig_obj[1] ;
21484 0 : char *result = 0 ;
21485 :
21486 0 : if (!args) SWIG_fail;
21487 0 : swig_obj[0] = args;
21488 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
21489 0 : if (!SWIG_IsOK(res1)) {
21490 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDAL_GCP_Info_get" "', argument " "1"" of type '" "GDAL_GCP *""'");
21491 : }
21492 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
21493 0 : {
21494 0 : if (!arg1) {
21495 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21496 : }
21497 : }
21498 0 : {
21499 0 : const int bLocalUseExceptions = GetUseExceptions();
21500 0 : if ( bLocalUseExceptions ) {
21501 0 : pushErrorHandler();
21502 : }
21503 0 : {
21504 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21505 0 : result = (char *)GDAL_GCP_Info_get(arg1);
21506 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21507 : }
21508 0 : if ( bLocalUseExceptions ) {
21509 0 : popErrorHandler();
21510 : }
21511 : #ifndef SED_HACKS
21512 : if ( bLocalUseExceptions ) {
21513 : CPLErr eclass = CPLGetLastErrorType();
21514 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21515 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21516 : }
21517 : }
21518 : #endif
21519 : }
21520 0 : resultobj = SWIG_FromCharPtr((const char *)result);
21521 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21522 : return resultobj;
21523 : fail:
21524 : return NULL;
21525 : }
21526 :
21527 :
21528 0 : SWIGINTERN PyObject *_wrap_GDAL_GCP_Info_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21529 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21530 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
21531 0 : char *arg2 = (char *) 0 ;
21532 0 : void *argp1 = 0 ;
21533 0 : int res1 = 0 ;
21534 0 : int res2 ;
21535 0 : char *buf2 = 0 ;
21536 0 : int alloc2 = 0 ;
21537 0 : PyObject *swig_obj[2] ;
21538 :
21539 0 : if (!SWIG_Python_UnpackTuple(args, "GDAL_GCP_Info_set", 2, 2, swig_obj)) SWIG_fail;
21540 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
21541 0 : if (!SWIG_IsOK(res1)) {
21542 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDAL_GCP_Info_set" "', argument " "1"" of type '" "GDAL_GCP *""'");
21543 : }
21544 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
21545 0 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
21546 0 : if (!SWIG_IsOK(res2)) {
21547 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GDAL_GCP_Info_set" "', argument " "2"" of type '" "char const *""'");
21548 : }
21549 0 : arg2 = reinterpret_cast< char * >(buf2);
21550 0 : {
21551 0 : if (!arg1) {
21552 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21553 : }
21554 : }
21555 0 : {
21556 0 : const int bLocalUseExceptions = GetUseExceptions();
21557 0 : if ( bLocalUseExceptions ) {
21558 0 : pushErrorHandler();
21559 : }
21560 0 : {
21561 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21562 0 : GDAL_GCP_Info_set(arg1,(char const *)arg2);
21563 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21564 : }
21565 0 : if ( bLocalUseExceptions ) {
21566 0 : popErrorHandler();
21567 : }
21568 : #ifndef SED_HACKS
21569 : if ( bLocalUseExceptions ) {
21570 : CPLErr eclass = CPLGetLastErrorType();
21571 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21572 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21573 : }
21574 : }
21575 : #endif
21576 : }
21577 0 : resultobj = SWIG_Py_Void();
21578 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21579 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21580 : return resultobj;
21581 0 : fail:
21582 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21583 : return NULL;
21584 : }
21585 :
21586 :
21587 0 : SWIGINTERN PyObject *_wrap_GDAL_GCP_Id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21588 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21589 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
21590 0 : void *argp1 = 0 ;
21591 0 : int res1 = 0 ;
21592 0 : PyObject *swig_obj[1] ;
21593 0 : char *result = 0 ;
21594 :
21595 0 : if (!args) SWIG_fail;
21596 0 : swig_obj[0] = args;
21597 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
21598 0 : if (!SWIG_IsOK(res1)) {
21599 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDAL_GCP_Id_get" "', argument " "1"" of type '" "GDAL_GCP *""'");
21600 : }
21601 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
21602 0 : {
21603 0 : if (!arg1) {
21604 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21605 : }
21606 : }
21607 0 : {
21608 0 : const int bLocalUseExceptions = GetUseExceptions();
21609 0 : if ( bLocalUseExceptions ) {
21610 0 : pushErrorHandler();
21611 : }
21612 0 : {
21613 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21614 0 : result = (char *)GDAL_GCP_Id_get(arg1);
21615 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21616 : }
21617 0 : if ( bLocalUseExceptions ) {
21618 0 : popErrorHandler();
21619 : }
21620 : #ifndef SED_HACKS
21621 : if ( bLocalUseExceptions ) {
21622 : CPLErr eclass = CPLGetLastErrorType();
21623 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21624 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21625 : }
21626 : }
21627 : #endif
21628 : }
21629 0 : resultobj = SWIG_FromCharPtr((const char *)result);
21630 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21631 : return resultobj;
21632 : fail:
21633 : return NULL;
21634 : }
21635 :
21636 :
21637 0 : SWIGINTERN PyObject *_wrap_GDAL_GCP_Id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21638 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21639 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
21640 0 : char *arg2 = (char *) 0 ;
21641 0 : void *argp1 = 0 ;
21642 0 : int res1 = 0 ;
21643 0 : int res2 ;
21644 0 : char *buf2 = 0 ;
21645 0 : int alloc2 = 0 ;
21646 0 : PyObject *swig_obj[2] ;
21647 :
21648 0 : if (!SWIG_Python_UnpackTuple(args, "GDAL_GCP_Id_set", 2, 2, swig_obj)) SWIG_fail;
21649 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDAL_GCP, 0 | 0 );
21650 0 : if (!SWIG_IsOK(res1)) {
21651 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDAL_GCP_Id_set" "', argument " "1"" of type '" "GDAL_GCP *""'");
21652 : }
21653 0 : arg1 = reinterpret_cast< GDAL_GCP * >(argp1);
21654 0 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
21655 0 : if (!SWIG_IsOK(res2)) {
21656 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GDAL_GCP_Id_set" "', argument " "2"" of type '" "char const *""'");
21657 : }
21658 0 : arg2 = reinterpret_cast< char * >(buf2);
21659 0 : {
21660 0 : if (!arg1) {
21661 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
21662 : }
21663 : }
21664 0 : {
21665 0 : const int bLocalUseExceptions = GetUseExceptions();
21666 0 : if ( bLocalUseExceptions ) {
21667 0 : pushErrorHandler();
21668 : }
21669 0 : {
21670 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21671 0 : GDAL_GCP_Id_set(arg1,(char const *)arg2);
21672 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21673 : }
21674 0 : if ( bLocalUseExceptions ) {
21675 0 : popErrorHandler();
21676 : }
21677 : #ifndef SED_HACKS
21678 : if ( bLocalUseExceptions ) {
21679 : CPLErr eclass = CPLGetLastErrorType();
21680 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21681 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21682 : }
21683 : }
21684 : #endif
21685 : }
21686 0 : resultobj = SWIG_Py_Void();
21687 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21688 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21689 : return resultobj;
21690 0 : fail:
21691 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21692 : return NULL;
21693 : }
21694 :
21695 :
21696 10 : SWIGINTERN PyObject *_wrap_GCPsToGeoTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21697 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21698 10 : int arg1 ;
21699 10 : GDAL_GCP *arg2 = (GDAL_GCP *) 0 ;
21700 10 : double *arg3 ;
21701 10 : int arg4 = (int) 1 ;
21702 10 : GDAL_GCP *tmpGCPList1 ;
21703 10 : double argout3[6] ;
21704 10 : int val4 ;
21705 10 : int ecode4 = 0 ;
21706 10 : PyObject *swig_obj[2] ;
21707 10 : RETURN_NONE result;
21708 :
21709 10 : {
21710 : /* %typemap(in,numinputs=0) (double argout3[ANY]) */
21711 10 : memset(argout3, 0, sizeof(argout3));
21712 10 : arg3 = argout3;
21713 : }
21714 10 : if (!SWIG_Python_UnpackTuple(args, "GCPsToGeoTransform", 1, 2, swig_obj)) SWIG_fail;
21715 10 : {
21716 : /* %typemap(in,numinputs=1) (int nGCPs, GDAL_GCP const *pGCPs ) */
21717 : /* check if is List */
21718 10 : if ( !PySequence_Check(swig_obj[0]) ) {
21719 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
21720 0 : SWIG_fail;
21721 : }
21722 10 : Py_ssize_t size = PySequence_Size(swig_obj[0]);
21723 10 : if( size > (Py_ssize_t)INT_MAX ) {
21724 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
21725 0 : SWIG_fail;
21726 : }
21727 10 : if( (size_t)size > SIZE_MAX / sizeof(GDAL_GCP) ) {
21728 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
21729 0 : SWIG_fail;
21730 : }
21731 10 : arg1 = (int)size;
21732 10 : tmpGCPList1 = (GDAL_GCP*) malloc(arg1*sizeof(GDAL_GCP));
21733 10 : if( !tmpGCPList1 ) {
21734 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
21735 0 : SWIG_fail;
21736 : }
21737 46 : arg2 = tmpGCPList1;
21738 46 : for( int i = 0; i<arg1; i++ ) {
21739 36 : PyObject *o = PySequence_GetItem(swig_obj[0],i);
21740 36 : GDAL_GCP *item = 0;
21741 36 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&item, SWIGTYPE_p_GDAL_GCP, SWIG_POINTER_EXCEPTION | 0 ));
21742 36 : if ( ! item ) {
21743 0 : Py_DECREF(o);
21744 0 : SWIG_fail;
21745 : }
21746 36 : memcpy( tmpGCPList1 + i, item, sizeof( GDAL_GCP ) );
21747 36 : Py_DECREF(o);
21748 : }
21749 : }
21750 10 : if (swig_obj[1]) {
21751 1 : ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
21752 1 : if (!SWIG_IsOK(ecode4)) {
21753 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GCPsToGeoTransform" "', argument " "4"" of type '" "int""'");
21754 : }
21755 : arg4 = static_cast< int >(val4);
21756 : }
21757 10 : {
21758 10 : const int bLocalUseExceptions = GetUseExceptions();
21759 10 : if ( bLocalUseExceptions ) {
21760 10 : pushErrorHandler();
21761 : }
21762 10 : {
21763 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21764 10 : result = (RETURN_NONE)GDALGCPsToGeoTransform(arg1,(GDAL_GCP const *)arg2,arg3,arg4);
21765 10 : SWIG_PYTHON_THREAD_END_ALLOW;
21766 : }
21767 10 : if ( bLocalUseExceptions ) {
21768 10 : popErrorHandler();
21769 : }
21770 : #ifndef SED_HACKS
21771 : if ( bLocalUseExceptions ) {
21772 : CPLErr eclass = CPLGetLastErrorType();
21773 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21774 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21775 : }
21776 : }
21777 : #endif
21778 : }
21779 : /*%typemap(out) IF_FALSE_RETURN_NONE */
21780 10 : {
21781 : /* %typemap(argout) (double argout[ANY]) */
21782 10 : PyObject *out = CreateTupleFromDoubleArray( arg3, 6 );
21783 : #if SWIG_VERSION >= 0x040300
21784 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
21785 : #else
21786 10 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
21787 : #endif
21788 : }
21789 10 : {
21790 : /* %typemap(freearg) (int nGCPs, GDAL_GCP const *pGCPs ) */
21791 10 : free( arg2 );
21792 : }
21793 10 : {
21794 : /* %typemap(ret) IF_FALSE_RETURN_NONE */
21795 10 : if (result == 0 ) {
21796 4 : Py_XDECREF( resultobj );
21797 4 : resultobj = Py_None;
21798 4 : Py_INCREF(resultobj);
21799 : }
21800 10 : if (resultobj == 0) {
21801 0 : resultobj = Py_None;
21802 0 : Py_INCREF(resultobj);
21803 : }
21804 : }
21805 10 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21806 : return resultobj;
21807 0 : fail:
21808 0 : {
21809 : /* %typemap(freearg) (int nGCPs, GDAL_GCP const *pGCPs ) */
21810 0 : free( arg2 );
21811 : }
21812 0 : return NULL;
21813 : }
21814 :
21815 :
21816 10 : SWIGINTERN PyObject *_wrap_GCPsToHomography(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21817 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21818 10 : int arg1 ;
21819 10 : GDAL_GCP *arg2 = (GDAL_GCP *) 0 ;
21820 10 : double *arg3 ;
21821 10 : GDAL_GCP *tmpGCPList1 ;
21822 10 : double argout3[9] ;
21823 10 : PyObject *swig_obj[1] ;
21824 10 : RETURN_NONE result;
21825 :
21826 10 : {
21827 : /* %typemap(in,numinputs=0) (double argout3[ANY]) */
21828 10 : memset(argout3, 0, sizeof(argout3));
21829 10 : arg3 = argout3;
21830 : }
21831 10 : if (!args) SWIG_fail;
21832 10 : swig_obj[0] = args;
21833 10 : {
21834 : /* %typemap(in,numinputs=1) (int nGCPs, GDAL_GCP const *pGCPs ) */
21835 : /* check if is List */
21836 10 : if ( !PySequence_Check(swig_obj[0]) ) {
21837 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
21838 0 : SWIG_fail;
21839 : }
21840 10 : Py_ssize_t size = PySequence_Size(swig_obj[0]);
21841 10 : if( size > (Py_ssize_t)INT_MAX ) {
21842 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
21843 0 : SWIG_fail;
21844 : }
21845 10 : if( (size_t)size > SIZE_MAX / sizeof(GDAL_GCP) ) {
21846 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
21847 0 : SWIG_fail;
21848 : }
21849 10 : arg1 = (int)size;
21850 10 : tmpGCPList1 = (GDAL_GCP*) malloc(arg1*sizeof(GDAL_GCP));
21851 10 : if( !tmpGCPList1 ) {
21852 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
21853 0 : SWIG_fail;
21854 : }
21855 46 : arg2 = tmpGCPList1;
21856 46 : for( int i = 0; i<arg1; i++ ) {
21857 36 : PyObject *o = PySequence_GetItem(swig_obj[0],i);
21858 36 : GDAL_GCP *item = 0;
21859 36 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&item, SWIGTYPE_p_GDAL_GCP, SWIG_POINTER_EXCEPTION | 0 ));
21860 36 : if ( ! item ) {
21861 0 : Py_DECREF(o);
21862 0 : SWIG_fail;
21863 : }
21864 36 : memcpy( tmpGCPList1 + i, item, sizeof( GDAL_GCP ) );
21865 36 : Py_DECREF(o);
21866 : }
21867 : }
21868 10 : {
21869 10 : const int bLocalUseExceptions = GetUseExceptions();
21870 10 : if ( bLocalUseExceptions ) {
21871 10 : pushErrorHandler();
21872 : }
21873 10 : {
21874 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21875 10 : result = (RETURN_NONE)GDALGCPsToHomography(arg1,(GDAL_GCP const *)arg2,arg3);
21876 10 : SWIG_PYTHON_THREAD_END_ALLOW;
21877 : }
21878 10 : if ( bLocalUseExceptions ) {
21879 10 : popErrorHandler();
21880 : }
21881 : #ifndef SED_HACKS
21882 : if ( bLocalUseExceptions ) {
21883 : CPLErr eclass = CPLGetLastErrorType();
21884 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21885 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21886 : }
21887 : }
21888 : #endif
21889 : }
21890 : /*%typemap(out) IF_FALSE_RETURN_NONE */
21891 10 : {
21892 : /* %typemap(argout) (double argout[ANY]) */
21893 10 : PyObject *out = CreateTupleFromDoubleArray( arg3, 9 );
21894 : #if SWIG_VERSION >= 0x040300
21895 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
21896 : #else
21897 10 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
21898 : #endif
21899 : }
21900 10 : {
21901 : /* %typemap(freearg) (int nGCPs, GDAL_GCP const *pGCPs ) */
21902 10 : free( arg2 );
21903 : }
21904 10 : {
21905 : /* %typemap(ret) IF_FALSE_RETURN_NONE */
21906 10 : if (result == 0 ) {
21907 3 : Py_XDECREF( resultobj );
21908 3 : resultobj = Py_None;
21909 3 : Py_INCREF(resultobj);
21910 : }
21911 10 : if (resultobj == 0) {
21912 0 : resultobj = Py_None;
21913 0 : Py_INCREF(resultobj);
21914 : }
21915 : }
21916 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21917 : return resultobj;
21918 0 : fail:
21919 0 : {
21920 : /* %typemap(freearg) (int nGCPs, GDAL_GCP const *pGCPs ) */
21921 0 : free( arg2 );
21922 : }
21923 0 : return NULL;
21924 : }
21925 :
21926 :
21927 0 : SWIGINTERN PyObject *_wrap_delete_VirtualMem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21928 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21929 0 : CPLVirtualMemShadow *arg1 = (CPLVirtualMemShadow *) 0 ;
21930 0 : void *argp1 = 0 ;
21931 0 : int res1 = 0 ;
21932 0 : PyObject *swig_obj[1] ;
21933 :
21934 0 : if (!args) SWIG_fail;
21935 0 : swig_obj[0] = args;
21936 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CPLVirtualMemShadow, SWIG_POINTER_DISOWN | 0 );
21937 0 : if (!SWIG_IsOK(res1)) {
21938 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VirtualMem" "', argument " "1"" of type '" "CPLVirtualMemShadow *""'");
21939 : }
21940 0 : arg1 = reinterpret_cast< CPLVirtualMemShadow * >(argp1);
21941 0 : {
21942 0 : const int bLocalUseExceptions = GetUseExceptions();
21943 0 : if ( bLocalUseExceptions ) {
21944 0 : pushErrorHandler();
21945 : }
21946 0 : {
21947 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21948 0 : delete_CPLVirtualMemShadow(arg1);
21949 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21950 : }
21951 0 : if ( bLocalUseExceptions ) {
21952 0 : popErrorHandler();
21953 : }
21954 : #ifndef SED_HACKS
21955 : if ( bLocalUseExceptions ) {
21956 : CPLErr eclass = CPLGetLastErrorType();
21957 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
21958 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
21959 : }
21960 : }
21961 : #endif
21962 : }
21963 0 : resultobj = SWIG_Py_Void();
21964 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
21965 : return resultobj;
21966 : fail:
21967 : return NULL;
21968 : }
21969 :
21970 :
21971 0 : SWIGINTERN PyObject *_wrap_VirtualMem_GetAddr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21972 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
21973 0 : CPLVirtualMemShadow *arg1 = (CPLVirtualMemShadow *) 0 ;
21974 0 : void **arg2 = (void **) 0 ;
21975 0 : size_t *arg3 = (size_t *) 0 ;
21976 0 : GDALDataType *arg4 = (GDALDataType *) 0 ;
21977 0 : int *arg5 = (int *) 0 ;
21978 0 : void *argp1 = 0 ;
21979 0 : int res1 = 0 ;
21980 0 : void *ptr2 ;
21981 0 : size_t nsize2 ;
21982 0 : GDALDataType datatype2 ;
21983 0 : int readonly2 ;
21984 0 : PyObject *swig_obj[1] ;
21985 :
21986 0 : {
21987 : /* %typemap(in,numinputs=0) (void** pptr, size_t* pnsize, GDALDataType* pdatatype, int* preadonly) */
21988 0 : arg2 = &ptr2;
21989 0 : arg3 = &nsize2;
21990 0 : arg4 = &datatype2;
21991 0 : arg5 = &readonly2;
21992 : }
21993 0 : if (!args) SWIG_fail;
21994 0 : swig_obj[0] = args;
21995 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CPLVirtualMemShadow, 0 | 0 );
21996 0 : if (!SWIG_IsOK(res1)) {
21997 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VirtualMem_GetAddr" "', argument " "1"" of type '" "CPLVirtualMemShadow *""'");
21998 : }
21999 0 : arg1 = reinterpret_cast< CPLVirtualMemShadow * >(argp1);
22000 0 : {
22001 0 : const int bLocalUseExceptions = GetUseExceptions();
22002 0 : if ( bLocalUseExceptions ) {
22003 0 : pushErrorHandler();
22004 : }
22005 0 : {
22006 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22007 0 : CPLVirtualMemShadow_GetAddr(arg1,arg2,arg3,arg4,arg5);
22008 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22009 : }
22010 0 : if ( bLocalUseExceptions ) {
22011 0 : popErrorHandler();
22012 : }
22013 : #ifndef SED_HACKS
22014 : if ( bLocalUseExceptions ) {
22015 : CPLErr eclass = CPLGetLastErrorType();
22016 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22017 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22018 : }
22019 : }
22020 : #endif
22021 : }
22022 0 : resultobj = SWIG_Py_Void();
22023 0 : {
22024 : /* %typemap(argout) (void** pptr, size_t* pnsize, GDALDataType* pdatatype, int* preadonly)*/
22025 0 : Py_buffer *buf=(Py_buffer*)malloc(sizeof(Py_buffer));
22026 :
22027 0 : if (PyBuffer_FillInfo(buf, swig_obj[0], *(arg2), *(arg3), *(arg5), PyBUF_ND)) {
22028 : // error, handle
22029 : }
22030 0 : if( *(arg4) == GDT_Byte )
22031 : {
22032 0 : buf->format = (char*) "B";
22033 0 : buf->itemsize = 1;
22034 : }
22035 0 : else if( *(arg4) == GDT_Int16 )
22036 : {
22037 0 : buf->format = (char*) "h";
22038 0 : buf->itemsize = 2;
22039 : }
22040 0 : else if( *(arg4) == GDT_UInt16 )
22041 : {
22042 0 : buf->format = (char*) "H";
22043 0 : buf->itemsize = 2;
22044 : }
22045 0 : else if( *(arg4) == GDT_Int32 )
22046 : {
22047 0 : buf->format = (char*) "i";
22048 0 : buf->itemsize = 4;
22049 : }
22050 0 : else if( *(arg4) == GDT_UInt32 )
22051 : {
22052 0 : buf->format = (char*) "I";
22053 0 : buf->itemsize = 4;
22054 : }
22055 0 : else if( *(arg4) == GDT_Float16 )
22056 : {
22057 0 : buf->format = (char*) "f";
22058 0 : buf->itemsize = 2;
22059 : }
22060 0 : else if( *(arg4) == GDT_Float32 )
22061 : {
22062 0 : buf->format = (char*) "f";
22063 0 : buf->itemsize = 4;
22064 : }
22065 0 : else if( *(arg4) == GDT_Float64 )
22066 : {
22067 0 : buf->format = (char*) "F";
22068 0 : buf->itemsize = 8;
22069 : }
22070 : else
22071 : {
22072 0 : buf->format = (char*) "B";
22073 0 : buf->itemsize = 1;
22074 : }
22075 0 : Py_DECREF(resultobj);
22076 0 : resultobj = PyMemoryView_FromBuffer(buf);
22077 : }
22078 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22079 : return resultobj;
22080 : fail:
22081 : return NULL;
22082 : }
22083 :
22084 :
22085 0 : SWIGINTERN PyObject *_wrap_VirtualMem_Pin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22086 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22087 0 : CPLVirtualMemShadow *arg1 = (CPLVirtualMemShadow *) 0 ;
22088 0 : size_t arg2 = (size_t) 0 ;
22089 0 : size_t arg3 = (size_t) 0 ;
22090 0 : int arg4 = (int) 0 ;
22091 0 : void *argp1 = 0 ;
22092 0 : int res1 = 0 ;
22093 0 : size_t val2 ;
22094 0 : int ecode2 = 0 ;
22095 0 : size_t val3 ;
22096 0 : int ecode3 = 0 ;
22097 0 : int val4 ;
22098 0 : int ecode4 = 0 ;
22099 0 : PyObject *swig_obj[4] ;
22100 :
22101 0 : if (!SWIG_Python_UnpackTuple(args, "VirtualMem_Pin", 1, 4, swig_obj)) SWIG_fail;
22102 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CPLVirtualMemShadow, 0 | 0 );
22103 0 : if (!SWIG_IsOK(res1)) {
22104 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VirtualMem_Pin" "', argument " "1"" of type '" "CPLVirtualMemShadow *""'");
22105 : }
22106 0 : arg1 = reinterpret_cast< CPLVirtualMemShadow * >(argp1);
22107 0 : if (swig_obj[1]) {
22108 0 : ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
22109 0 : if (!SWIG_IsOK(ecode2)) {
22110 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VirtualMem_Pin" "', argument " "2"" of type '" "size_t""'");
22111 : }
22112 : arg2 = static_cast< size_t >(val2);
22113 : }
22114 0 : if (swig_obj[2]) {
22115 0 : ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
22116 0 : if (!SWIG_IsOK(ecode3)) {
22117 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VirtualMem_Pin" "', argument " "3"" of type '" "size_t""'");
22118 : }
22119 : arg3 = static_cast< size_t >(val3);
22120 : }
22121 0 : if (swig_obj[3]) {
22122 0 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
22123 0 : if (!SWIG_IsOK(ecode4)) {
22124 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VirtualMem_Pin" "', argument " "4"" of type '" "int""'");
22125 : }
22126 : arg4 = static_cast< int >(val4);
22127 : }
22128 0 : {
22129 0 : const int bLocalUseExceptions = GetUseExceptions();
22130 0 : if ( bLocalUseExceptions ) {
22131 0 : pushErrorHandler();
22132 : }
22133 0 : {
22134 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22135 0 : CPLVirtualMemShadow_Pin(arg1,arg2,arg3,arg4);
22136 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22137 : }
22138 0 : if ( bLocalUseExceptions ) {
22139 0 : popErrorHandler();
22140 : }
22141 : #ifndef SED_HACKS
22142 : if ( bLocalUseExceptions ) {
22143 : CPLErr eclass = CPLGetLastErrorType();
22144 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22145 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22146 : }
22147 : }
22148 : #endif
22149 : }
22150 0 : resultobj = SWIG_Py_Void();
22151 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22152 : return resultobj;
22153 : fail:
22154 : return NULL;
22155 : }
22156 :
22157 :
22158 277 : SWIGINTERN PyObject *VirtualMem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22159 277 : PyObject *obj;
22160 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
22161 277 : SWIG_TypeNewClientData(SWIGTYPE_p_CPLVirtualMemShadow, SWIG_NewClientData(obj));
22162 277 : return SWIG_Py_Void();
22163 : }
22164 :
22165 1 : SWIGINTERN PyObject *_wrap_delete_AsyncReader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22166 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22167 1 : GDALAsyncReaderShadow *arg1 = (GDALAsyncReaderShadow *) 0 ;
22168 1 : void *argp1 = 0 ;
22169 1 : int res1 = 0 ;
22170 1 : PyObject *swig_obj[1] ;
22171 :
22172 1 : if (!args) SWIG_fail;
22173 1 : swig_obj[0] = args;
22174 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAsyncReaderShadow, SWIG_POINTER_DISOWN | 0 );
22175 1 : if (!SWIG_IsOK(res1)) {
22176 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AsyncReader" "', argument " "1"" of type '" "GDALAsyncReaderShadow *""'");
22177 : }
22178 1 : arg1 = reinterpret_cast< GDALAsyncReaderShadow * >(argp1);
22179 1 : {
22180 1 : const int bLocalUseExceptions = GetUseExceptions();
22181 1 : if ( bLocalUseExceptions ) {
22182 1 : pushErrorHandler();
22183 : }
22184 1 : {
22185 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22186 1 : delete_GDALAsyncReaderShadow(arg1);
22187 1 : SWIG_PYTHON_THREAD_END_ALLOW;
22188 : }
22189 1 : if ( bLocalUseExceptions ) {
22190 1 : popErrorHandler();
22191 : }
22192 : #ifndef SED_HACKS
22193 : if ( bLocalUseExceptions ) {
22194 : CPLErr eclass = CPLGetLastErrorType();
22195 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22196 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22197 : }
22198 : }
22199 : #endif
22200 : }
22201 1 : resultobj = SWIG_Py_Void();
22202 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22203 : return resultobj;
22204 : fail:
22205 : return NULL;
22206 : }
22207 :
22208 :
22209 1 : SWIGINTERN PyObject *_wrap_AsyncReader_GetNextUpdatedRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22210 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22211 1 : GDALAsyncReaderShadow *arg1 = (GDALAsyncReaderShadow *) 0 ;
22212 1 : double arg2 ;
22213 1 : int *arg3 = (int *) 0 ;
22214 1 : int *arg4 = (int *) 0 ;
22215 1 : int *arg5 = (int *) 0 ;
22216 1 : int *arg6 = (int *) 0 ;
22217 1 : void *argp1 = 0 ;
22218 1 : int res1 = 0 ;
22219 1 : double val2 ;
22220 1 : int ecode2 = 0 ;
22221 1 : int temp3 ;
22222 1 : int res3 = SWIG_TMPOBJ ;
22223 1 : int temp4 ;
22224 1 : int res4 = SWIG_TMPOBJ ;
22225 1 : int temp5 ;
22226 1 : int res5 = SWIG_TMPOBJ ;
22227 1 : int temp6 ;
22228 1 : int res6 = SWIG_TMPOBJ ;
22229 1 : PyObject *swig_obj[2] ;
22230 1 : GDALAsyncStatusType result;
22231 :
22232 1 : arg3 = &temp3;
22233 1 : arg4 = &temp4;
22234 1 : arg5 = &temp5;
22235 1 : arg6 = &temp6;
22236 1 : if (!SWIG_Python_UnpackTuple(args, "AsyncReader_GetNextUpdatedRegion", 2, 2, swig_obj)) SWIG_fail;
22237 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAsyncReaderShadow, 0 | 0 );
22238 1 : if (!SWIG_IsOK(res1)) {
22239 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AsyncReader_GetNextUpdatedRegion" "', argument " "1"" of type '" "GDALAsyncReaderShadow *""'");
22240 : }
22241 1 : arg1 = reinterpret_cast< GDALAsyncReaderShadow * >(argp1);
22242 1 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
22243 1 : if (!SWIG_IsOK(ecode2)) {
22244 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AsyncReader_GetNextUpdatedRegion" "', argument " "2"" of type '" "double""'");
22245 : }
22246 1 : arg2 = static_cast< double >(val2);
22247 1 : {
22248 1 : const int bLocalUseExceptions = GetUseExceptions();
22249 1 : if ( bLocalUseExceptions ) {
22250 1 : pushErrorHandler();
22251 : }
22252 1 : {
22253 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22254 1 : result = (GDALAsyncStatusType)GDALAsyncReaderShadow_GetNextUpdatedRegion(arg1,arg2,arg3,arg4,arg5,arg6);
22255 1 : SWIG_PYTHON_THREAD_END_ALLOW;
22256 : }
22257 1 : if ( bLocalUseExceptions ) {
22258 1 : popErrorHandler();
22259 : }
22260 : #ifndef SED_HACKS
22261 : if ( bLocalUseExceptions ) {
22262 : CPLErr eclass = CPLGetLastErrorType();
22263 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22264 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22265 : }
22266 : }
22267 : #endif
22268 : }
22269 1 : resultobj = SWIG_From_int(static_cast< int >(result));
22270 1 : if (ReturnSame(SWIG_IsTmpObj(res3))) {
22271 1 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
22272 : } else {
22273 0 : int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22274 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
22275 : }
22276 1 : if (ReturnSame(SWIG_IsTmpObj(res4))) {
22277 1 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
22278 : } else {
22279 0 : int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22280 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
22281 : }
22282 1 : if (ReturnSame(SWIG_IsTmpObj(res5))) {
22283 1 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
22284 : } else {
22285 0 : int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22286 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
22287 : }
22288 1 : if (ReturnSame(SWIG_IsTmpObj(res6))) {
22289 1 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
22290 : } else {
22291 0 : int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22292 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
22293 : }
22294 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22295 : return resultobj;
22296 : fail:
22297 : return NULL;
22298 : }
22299 :
22300 :
22301 1 : SWIGINTERN PyObject *_wrap_AsyncReader_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22302 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22303 1 : GDALAsyncReaderShadow *arg1 = (GDALAsyncReaderShadow *) 0 ;
22304 1 : void **arg2 = (void **) 0 ;
22305 1 : void *argp1 = 0 ;
22306 1 : int res1 = 0 ;
22307 1 : void *pyObject2 = NULL ;
22308 1 : PyObject *swig_obj[1] ;
22309 :
22310 1 : {
22311 : /* %typemap(in,numinputs=0) ( void **outPythonObject ) ( void *pyObject2 = NULL ) */
22312 1 : arg2 = &pyObject2;
22313 : }
22314 1 : if (!args) SWIG_fail;
22315 1 : swig_obj[0] = args;
22316 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAsyncReaderShadow, 0 | 0 );
22317 1 : if (!SWIG_IsOK(res1)) {
22318 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AsyncReader_GetBuffer" "', argument " "1"" of type '" "GDALAsyncReaderShadow *""'");
22319 : }
22320 1 : arg1 = reinterpret_cast< GDALAsyncReaderShadow * >(argp1);
22321 1 : {
22322 1 : const int bLocalUseExceptions = GetUseExceptions();
22323 1 : if ( bLocalUseExceptions ) {
22324 1 : pushErrorHandler();
22325 : }
22326 1 : {
22327 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22328 1 : GDALAsyncReaderShadow_GetBuffer(arg1,arg2);
22329 1 : SWIG_PYTHON_THREAD_END_ALLOW;
22330 : }
22331 1 : if ( bLocalUseExceptions ) {
22332 1 : popErrorHandler();
22333 : }
22334 : #ifndef SED_HACKS
22335 : if ( bLocalUseExceptions ) {
22336 : CPLErr eclass = CPLGetLastErrorType();
22337 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22338 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22339 : }
22340 : }
22341 : #endif
22342 : }
22343 1 : resultobj = SWIG_Py_Void();
22344 1 : {
22345 : /* %typemap(argout) ( void **outPythonObject ) */
22346 1 : Py_XDECREF(resultobj);
22347 1 : if (*arg2)
22348 : {
22349 : resultobj = (PyObject*)*arg2;
22350 : }
22351 : else
22352 : {
22353 0 : resultobj = Py_None;
22354 0 : Py_INCREF(resultobj);
22355 : }
22356 : }
22357 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22358 : return resultobj;
22359 : fail:
22360 : return NULL;
22361 : }
22362 :
22363 :
22364 0 : SWIGINTERN PyObject *_wrap_AsyncReader_LockBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22365 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22366 0 : GDALAsyncReaderShadow *arg1 = (GDALAsyncReaderShadow *) 0 ;
22367 0 : double arg2 ;
22368 0 : void *argp1 = 0 ;
22369 0 : int res1 = 0 ;
22370 0 : double val2 ;
22371 0 : int ecode2 = 0 ;
22372 0 : PyObject *swig_obj[2] ;
22373 0 : int result;
22374 :
22375 0 : if (!SWIG_Python_UnpackTuple(args, "AsyncReader_LockBuffer", 2, 2, swig_obj)) SWIG_fail;
22376 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAsyncReaderShadow, 0 | 0 );
22377 0 : if (!SWIG_IsOK(res1)) {
22378 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AsyncReader_LockBuffer" "', argument " "1"" of type '" "GDALAsyncReaderShadow *""'");
22379 : }
22380 0 : arg1 = reinterpret_cast< GDALAsyncReaderShadow * >(argp1);
22381 0 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
22382 0 : if (!SWIG_IsOK(ecode2)) {
22383 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AsyncReader_LockBuffer" "', argument " "2"" of type '" "double""'");
22384 : }
22385 0 : arg2 = static_cast< double >(val2);
22386 0 : {
22387 0 : const int bLocalUseExceptions = GetUseExceptions();
22388 0 : if ( bLocalUseExceptions ) {
22389 0 : pushErrorHandler();
22390 : }
22391 0 : {
22392 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22393 0 : result = (int)GDALAsyncReaderShadow_LockBuffer(arg1,arg2);
22394 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22395 : }
22396 0 : if ( bLocalUseExceptions ) {
22397 0 : popErrorHandler();
22398 : }
22399 : #ifndef SED_HACKS
22400 : if ( bLocalUseExceptions ) {
22401 : CPLErr eclass = CPLGetLastErrorType();
22402 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22403 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22404 : }
22405 : }
22406 : #endif
22407 : }
22408 0 : resultobj = SWIG_From_int(static_cast< int >(result));
22409 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22410 : return resultobj;
22411 : fail:
22412 : return NULL;
22413 : }
22414 :
22415 :
22416 0 : SWIGINTERN PyObject *_wrap_AsyncReader_UnlockBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22417 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22418 0 : GDALAsyncReaderShadow *arg1 = (GDALAsyncReaderShadow *) 0 ;
22419 0 : void *argp1 = 0 ;
22420 0 : int res1 = 0 ;
22421 0 : PyObject *swig_obj[1] ;
22422 :
22423 0 : if (!args) SWIG_fail;
22424 0 : swig_obj[0] = args;
22425 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAsyncReaderShadow, 0 | 0 );
22426 0 : if (!SWIG_IsOK(res1)) {
22427 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AsyncReader_UnlockBuffer" "', argument " "1"" of type '" "GDALAsyncReaderShadow *""'");
22428 : }
22429 0 : arg1 = reinterpret_cast< GDALAsyncReaderShadow * >(argp1);
22430 0 : {
22431 0 : const int bLocalUseExceptions = GetUseExceptions();
22432 0 : if ( bLocalUseExceptions ) {
22433 0 : pushErrorHandler();
22434 : }
22435 0 : {
22436 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22437 0 : GDALAsyncReaderShadow_UnlockBuffer(arg1);
22438 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22439 : }
22440 0 : if ( bLocalUseExceptions ) {
22441 0 : popErrorHandler();
22442 : }
22443 : #ifndef SED_HACKS
22444 : if ( bLocalUseExceptions ) {
22445 : CPLErr eclass = CPLGetLastErrorType();
22446 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22447 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22448 : }
22449 : }
22450 : #endif
22451 : }
22452 0 : resultobj = SWIG_Py_Void();
22453 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22454 : return resultobj;
22455 : fail:
22456 : return NULL;
22457 : }
22458 :
22459 :
22460 277 : SWIGINTERN PyObject *AsyncReader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22461 277 : PyObject *obj;
22462 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
22463 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALAsyncReaderShadow, SWIG_NewClientData(obj));
22464 277 : return SWIG_Py_Void();
22465 : }
22466 :
22467 19935 : SWIGINTERN PyObject *_wrap_Dataset_RasterXSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22468 19935 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22469 19935 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
22470 19935 : void *argp1 = 0 ;
22471 19935 : int res1 = 0 ;
22472 19935 : PyObject *swig_obj[1] ;
22473 19935 : int result;
22474 :
22475 19935 : if (!args) SWIG_fail;
22476 19935 : swig_obj[0] = args;
22477 19935 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
22478 19935 : if (!SWIG_IsOK(res1)) {
22479 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_RasterXSize_get" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
22480 : }
22481 19935 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
22482 19935 : {
22483 19935 : const int bLocalUseExceptions = GetUseExceptions();
22484 19935 : if ( bLocalUseExceptions ) {
22485 16921 : pushErrorHandler();
22486 : }
22487 19935 : {
22488 19935 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22489 19935 : result = (int)GDALDatasetShadow_RasterXSize_get(arg1);
22490 19935 : SWIG_PYTHON_THREAD_END_ALLOW;
22491 : }
22492 19935 : if ( bLocalUseExceptions ) {
22493 16921 : popErrorHandler();
22494 : }
22495 : #ifndef SED_HACKS
22496 : if ( bLocalUseExceptions ) {
22497 : CPLErr eclass = CPLGetLastErrorType();
22498 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22499 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22500 : }
22501 : }
22502 : #endif
22503 : }
22504 19935 : resultobj = SWIG_From_int(static_cast< int >(result));
22505 19935 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22506 : return resultobj;
22507 : fail:
22508 : return NULL;
22509 : }
22510 :
22511 :
22512 20187 : SWIGINTERN PyObject *_wrap_Dataset_RasterYSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22513 20187 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22514 20187 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
22515 20187 : void *argp1 = 0 ;
22516 20187 : int res1 = 0 ;
22517 20187 : PyObject *swig_obj[1] ;
22518 20187 : int result;
22519 :
22520 20187 : if (!args) SWIG_fail;
22521 20187 : swig_obj[0] = args;
22522 20187 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
22523 20187 : if (!SWIG_IsOK(res1)) {
22524 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_RasterYSize_get" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
22525 : }
22526 20187 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
22527 20187 : {
22528 20187 : const int bLocalUseExceptions = GetUseExceptions();
22529 20187 : if ( bLocalUseExceptions ) {
22530 17352 : pushErrorHandler();
22531 : }
22532 20187 : {
22533 20187 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22534 20187 : result = (int)GDALDatasetShadow_RasterYSize_get(arg1);
22535 20187 : SWIG_PYTHON_THREAD_END_ALLOW;
22536 : }
22537 20187 : if ( bLocalUseExceptions ) {
22538 17352 : popErrorHandler();
22539 : }
22540 : #ifndef SED_HACKS
22541 : if ( bLocalUseExceptions ) {
22542 : CPLErr eclass = CPLGetLastErrorType();
22543 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22544 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22545 : }
22546 : }
22547 : #endif
22548 : }
22549 20187 : resultobj = SWIG_From_int(static_cast< int >(result));
22550 20187 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22551 : return resultobj;
22552 : fail:
22553 : return NULL;
22554 : }
22555 :
22556 :
22557 355538 : SWIGINTERN PyObject *_wrap_Dataset_RasterCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22558 355538 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22559 355538 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
22560 355538 : void *argp1 = 0 ;
22561 355538 : int res1 = 0 ;
22562 355538 : PyObject *swig_obj[1] ;
22563 355538 : int result;
22564 :
22565 355538 : if (!args) SWIG_fail;
22566 355538 : swig_obj[0] = args;
22567 355538 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
22568 355538 : if (!SWIG_IsOK(res1)) {
22569 2 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_RasterCount_get" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
22570 : }
22571 355537 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
22572 355537 : {
22573 355537 : const int bLocalUseExceptions = GetUseExceptions();
22574 355537 : if ( bLocalUseExceptions ) {
22575 340089 : pushErrorHandler();
22576 : }
22577 355537 : {
22578 355537 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22579 355537 : result = (int)GDALDatasetShadow_RasterCount_get(arg1);
22580 355537 : SWIG_PYTHON_THREAD_END_ALLOW;
22581 : }
22582 355537 : if ( bLocalUseExceptions ) {
22583 340089 : popErrorHandler();
22584 : }
22585 : #ifndef SED_HACKS
22586 : if ( bLocalUseExceptions ) {
22587 : CPLErr eclass = CPLGetLastErrorType();
22588 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22589 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22590 : }
22591 : }
22592 : #endif
22593 : }
22594 355537 : resultobj = SWIG_From_int(static_cast< int >(result));
22595 355538 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22596 : return resultobj;
22597 : fail:
22598 : return NULL;
22599 : }
22600 :
22601 :
22602 56619 : SWIGINTERN PyObject *_wrap_delete_Dataset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22603 56619 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22604 56619 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
22605 56619 : void *argp1 = 0 ;
22606 56619 : int res1 = 0 ;
22607 56619 : PyObject *swig_obj[1] ;
22608 :
22609 56619 : if (!args) SWIG_fail;
22610 56619 : swig_obj[0] = args;
22611 56619 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_DISOWN | 0 );
22612 56619 : if (!SWIG_IsOK(res1)) {
22613 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dataset" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
22614 : }
22615 56619 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
22616 56619 : {
22617 56619 : const int bLocalUseExceptions = GetUseExceptions();
22618 56619 : if ( bLocalUseExceptions ) {
22619 25523 : pushErrorHandler();
22620 : }
22621 56619 : {
22622 56619 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22623 56619 : delete_GDALDatasetShadow(arg1);
22624 56619 : SWIG_PYTHON_THREAD_END_ALLOW;
22625 : }
22626 56619 : if ( bLocalUseExceptions ) {
22627 25523 : popErrorHandler();
22628 : }
22629 : #ifndef SED_HACKS
22630 : if ( bLocalUseExceptions ) {
22631 : CPLErr eclass = CPLGetLastErrorType();
22632 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22633 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22634 : }
22635 : }
22636 : #endif
22637 : }
22638 56619 : resultobj = SWIG_Py_Void();
22639 56619 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22640 : return resultobj;
22641 : fail:
22642 : return NULL;
22643 : }
22644 :
22645 :
22646 4 : SWIGINTERN PyObject *_wrap_Dataset_MarkSuppressOnClose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22647 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22648 4 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
22649 4 : void *argp1 = 0 ;
22650 4 : int res1 = 0 ;
22651 4 : PyObject *swig_obj[1] ;
22652 :
22653 4 : if (!args) SWIG_fail;
22654 4 : swig_obj[0] = args;
22655 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
22656 4 : if (!SWIG_IsOK(res1)) {
22657 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_MarkSuppressOnClose" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
22658 : }
22659 4 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
22660 4 : {
22661 4 : const int bLocalUseExceptions = GetUseExceptions();
22662 4 : if ( bLocalUseExceptions ) {
22663 0 : pushErrorHandler();
22664 : }
22665 4 : {
22666 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22667 4 : GDALDatasetShadow_MarkSuppressOnClose(arg1);
22668 4 : SWIG_PYTHON_THREAD_END_ALLOW;
22669 : }
22670 4 : if ( bLocalUseExceptions ) {
22671 0 : popErrorHandler();
22672 : }
22673 : #ifndef SED_HACKS
22674 : if ( bLocalUseExceptions ) {
22675 : CPLErr eclass = CPLGetLastErrorType();
22676 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22677 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22678 : }
22679 : }
22680 : #endif
22681 : }
22682 4 : resultobj = SWIG_Py_Void();
22683 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22684 : return resultobj;
22685 : fail:
22686 : return NULL;
22687 : }
22688 :
22689 :
22690 3992 : SWIGINTERN PyObject *_wrap_Dataset_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22691 3992 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22692 3992 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
22693 3992 : void *argp1 = 0 ;
22694 3992 : int res1 = 0 ;
22695 3992 : PyObject *swig_obj[1] ;
22696 3992 : CPLErr result;
22697 :
22698 3992 : if (!args) SWIG_fail;
22699 3992 : swig_obj[0] = args;
22700 3992 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
22701 3992 : if (!SWIG_IsOK(res1)) {
22702 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_Close" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
22703 : }
22704 3992 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
22705 3992 : {
22706 3992 : const int bLocalUseExceptions = GetUseExceptions();
22707 3992 : if ( bLocalUseExceptions ) {
22708 1405 : pushErrorHandler();
22709 : }
22710 3992 : {
22711 3992 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22712 3992 : result = (CPLErr)GDALDatasetShadow_Close(arg1);
22713 3992 : SWIG_PYTHON_THREAD_END_ALLOW;
22714 : }
22715 3992 : if ( bLocalUseExceptions ) {
22716 1405 : popErrorHandler();
22717 : }
22718 : #ifndef SED_HACKS
22719 : if ( bLocalUseExceptions ) {
22720 : CPLErr eclass = CPLGetLastErrorType();
22721 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22722 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22723 : }
22724 : }
22725 : #endif
22726 : }
22727 3992 : resultobj = SWIG_From_int(static_cast< int >(result));
22728 4004 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22729 : return resultobj;
22730 : fail:
22731 : return NULL;
22732 : }
22733 :
22734 :
22735 12 : SWIGINTERN PyObject *_wrap_Dataset__RunCloseWithoutDestroying(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22736 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22737 12 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
22738 12 : void *argp1 = 0 ;
22739 12 : int res1 = 0 ;
22740 12 : PyObject *swig_obj[1] ;
22741 12 : CPLErr result;
22742 :
22743 12 : if (!args) SWIG_fail;
22744 12 : swig_obj[0] = args;
22745 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
22746 12 : if (!SWIG_IsOK(res1)) {
22747 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset__RunCloseWithoutDestroying" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
22748 : }
22749 12 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
22750 12 : {
22751 12 : const int bLocalUseExceptions = GetUseExceptions();
22752 12 : if ( bLocalUseExceptions ) {
22753 12 : pushErrorHandler();
22754 : }
22755 12 : {
22756 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22757 12 : result = (CPLErr)GDALDatasetShadow__RunCloseWithoutDestroying(arg1);
22758 12 : SWIG_PYTHON_THREAD_END_ALLOW;
22759 : }
22760 12 : if ( bLocalUseExceptions ) {
22761 12 : popErrorHandler();
22762 : }
22763 : #ifndef SED_HACKS
22764 : if ( bLocalUseExceptions ) {
22765 : CPLErr eclass = CPLGetLastErrorType();
22766 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22767 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22768 : }
22769 : }
22770 : #endif
22771 : }
22772 12 : resultobj = SWIG_From_int(static_cast< int >(result));
22773 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22774 : return resultobj;
22775 : fail:
22776 : return NULL;
22777 : }
22778 :
22779 :
22780 1329 : SWIGINTERN PyObject *_wrap_Dataset_GetDriver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22781 1329 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22782 1329 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
22783 1329 : void *argp1 = 0 ;
22784 1329 : int res1 = 0 ;
22785 1329 : PyObject *swig_obj[1] ;
22786 1329 : GDALDriverShadow *result = 0 ;
22787 :
22788 1329 : if (!args) SWIG_fail;
22789 1329 : swig_obj[0] = args;
22790 1329 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
22791 1329 : if (!SWIG_IsOK(res1)) {
22792 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetDriver" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
22793 : }
22794 1329 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
22795 1329 : {
22796 1329 : const int bLocalUseExceptions = GetUseExceptions();
22797 1329 : if ( bLocalUseExceptions ) {
22798 831 : pushErrorHandler();
22799 : }
22800 1329 : {
22801 1329 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22802 1329 : result = (GDALDriverShadow *)GDALDatasetShadow_GetDriver(arg1);
22803 1329 : SWIG_PYTHON_THREAD_END_ALLOW;
22804 : }
22805 1329 : if ( bLocalUseExceptions ) {
22806 831 : popErrorHandler();
22807 : }
22808 : #ifndef SED_HACKS
22809 : if ( bLocalUseExceptions ) {
22810 : CPLErr eclass = CPLGetLastErrorType();
22811 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22812 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22813 : }
22814 : }
22815 : #endif
22816 : }
22817 1329 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
22818 1329 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22819 : return resultobj;
22820 : fail:
22821 : return NULL;
22822 : }
22823 :
22824 :
22825 360581 : SWIGINTERN PyObject *_wrap_Dataset_GetRasterBand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22826 360581 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22827 360581 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
22828 360581 : int arg2 ;
22829 360581 : void *argp1 = 0 ;
22830 360581 : int res1 = 0 ;
22831 360581 : int val2 ;
22832 360581 : int ecode2 = 0 ;
22833 360581 : PyObject *swig_obj[2] ;
22834 360581 : GDALRasterBandShadow *result = 0 ;
22835 :
22836 360581 : if (!SWIG_Python_UnpackTuple(args, "Dataset_GetRasterBand", 2, 2, swig_obj)) SWIG_fail;
22837 360581 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
22838 360581 : if (!SWIG_IsOK(res1)) {
22839 8 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetRasterBand" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
22840 : }
22841 360577 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
22842 360577 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22843 360577 : if (!SWIG_IsOK(ecode2)) {
22844 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_GetRasterBand" "', argument " "2"" of type '" "int""'");
22845 : }
22846 360577 : arg2 = static_cast< int >(val2);
22847 360577 : {
22848 360577 : const int bLocalUseExceptions = GetUseExceptions();
22849 360577 : if ( bLocalUseExceptions ) {
22850 234759 : pushErrorHandler();
22851 : }
22852 360577 : {
22853 360577 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22854 360577 : result = (GDALRasterBandShadow *)GDALDatasetShadow_GetRasterBand(arg1,arg2);
22855 360577 : SWIG_PYTHON_THREAD_END_ALLOW;
22856 : }
22857 360577 : if ( bLocalUseExceptions ) {
22858 234759 : popErrorHandler();
22859 : }
22860 : #ifndef SED_HACKS
22861 : if ( bLocalUseExceptions ) {
22862 : CPLErr eclass = CPLGetLastErrorType();
22863 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22864 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22865 : }
22866 : }
22867 : #endif
22868 : }
22869 360577 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
22870 360581 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22871 : return resultobj;
22872 : fail:
22873 : return NULL;
22874 : }
22875 :
22876 :
22877 5 : SWIGINTERN PyObject *_wrap_Dataset_IsThreadSafe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22878 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22879 5 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
22880 5 : int arg2 ;
22881 5 : void *argp1 = 0 ;
22882 5 : int res1 = 0 ;
22883 5 : int val2 ;
22884 5 : int ecode2 = 0 ;
22885 5 : PyObject *swig_obj[2] ;
22886 5 : bool result;
22887 :
22888 5 : if (!SWIG_Python_UnpackTuple(args, "Dataset_IsThreadSafe", 2, 2, swig_obj)) SWIG_fail;
22889 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
22890 5 : if (!SWIG_IsOK(res1)) {
22891 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_IsThreadSafe" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
22892 : }
22893 5 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
22894 5 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22895 5 : if (!SWIG_IsOK(ecode2)) {
22896 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_IsThreadSafe" "', argument " "2"" of type '" "int""'");
22897 : }
22898 5 : arg2 = static_cast< int >(val2);
22899 5 : {
22900 5 : const int bLocalUseExceptions = GetUseExceptions();
22901 5 : if ( bLocalUseExceptions ) {
22902 5 : pushErrorHandler();
22903 : }
22904 5 : {
22905 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22906 5 : result = (bool)GDALDatasetShadow_IsThreadSafe(arg1,arg2);
22907 5 : SWIG_PYTHON_THREAD_END_ALLOW;
22908 : }
22909 5 : if ( bLocalUseExceptions ) {
22910 5 : popErrorHandler();
22911 : }
22912 : #ifndef SED_HACKS
22913 : if ( bLocalUseExceptions ) {
22914 : CPLErr eclass = CPLGetLastErrorType();
22915 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22916 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22917 : }
22918 : }
22919 : #endif
22920 : }
22921 5 : resultobj = SWIG_From_bool(static_cast< bool >(result));
22922 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22923 : return resultobj;
22924 : fail:
22925 : return NULL;
22926 : }
22927 :
22928 :
22929 8 : SWIGINTERN PyObject *_wrap_Dataset_GetThreadSafeDataset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22930 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22931 8 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
22932 8 : int arg2 ;
22933 8 : void *argp1 = 0 ;
22934 8 : int res1 = 0 ;
22935 8 : int val2 ;
22936 8 : int ecode2 = 0 ;
22937 8 : PyObject *swig_obj[2] ;
22938 8 : GDALDatasetShadow *result = 0 ;
22939 :
22940 8 : if (!SWIG_Python_UnpackTuple(args, "Dataset_GetThreadSafeDataset", 2, 2, swig_obj)) SWIG_fail;
22941 8 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
22942 8 : if (!SWIG_IsOK(res1)) {
22943 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetThreadSafeDataset" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
22944 : }
22945 8 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
22946 8 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22947 8 : if (!SWIG_IsOK(ecode2)) {
22948 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_GetThreadSafeDataset" "', argument " "2"" of type '" "int""'");
22949 : }
22950 8 : arg2 = static_cast< int >(val2);
22951 8 : {
22952 8 : const int bLocalUseExceptions = GetUseExceptions();
22953 8 : if ( bLocalUseExceptions ) {
22954 8 : pushErrorHandler();
22955 : }
22956 8 : {
22957 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22958 8 : result = (GDALDatasetShadow *)GDALDatasetShadow_GetThreadSafeDataset(arg1,arg2);
22959 8 : SWIG_PYTHON_THREAD_END_ALLOW;
22960 : }
22961 8 : if ( bLocalUseExceptions ) {
22962 8 : popErrorHandler();
22963 : }
22964 : #ifndef SED_HACKS
22965 : if ( bLocalUseExceptions ) {
22966 : CPLErr eclass = CPLGetLastErrorType();
22967 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
22968 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
22969 : }
22970 : }
22971 : #endif
22972 : }
22973 8 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
22974 8 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
22975 : return resultobj;
22976 : fail:
22977 : return NULL;
22978 : }
22979 :
22980 :
22981 1265 : SWIGINTERN PyObject *_wrap_Dataset_GetRootGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22982 1265 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
22983 1265 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
22984 1265 : void *argp1 = 0 ;
22985 1265 : int res1 = 0 ;
22986 1265 : PyObject *swig_obj[1] ;
22987 1265 : GDALGroupHS *result = 0 ;
22988 :
22989 1265 : if (!args) SWIG_fail;
22990 1265 : swig_obj[0] = args;
22991 1265 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
22992 1265 : if (!SWIG_IsOK(res1)) {
22993 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetRootGroup" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
22994 : }
22995 1265 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
22996 1265 : {
22997 1265 : const int bLocalUseExceptions = GetUseExceptions();
22998 1265 : if ( bLocalUseExceptions ) {
22999 424 : pushErrorHandler();
23000 : }
23001 1265 : {
23002 1265 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23003 1265 : result = (GDALGroupHS *)GDALDatasetShadow_GetRootGroup(arg1);
23004 1265 : SWIG_PYTHON_THREAD_END_ALLOW;
23005 : }
23006 1265 : if ( bLocalUseExceptions ) {
23007 424 : popErrorHandler();
23008 : }
23009 : #ifndef SED_HACKS
23010 : if ( bLocalUseExceptions ) {
23011 : CPLErr eclass = CPLGetLastErrorType();
23012 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23013 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23014 : }
23015 : }
23016 : #endif
23017 : }
23018 1265 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALGroupHS, SWIG_POINTER_OWN | 0 );
23019 1265 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23020 : return resultobj;
23021 : fail:
23022 : return NULL;
23023 : }
23024 :
23025 :
23026 454 : SWIGINTERN PyObject *_wrap_Dataset_GetProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23027 454 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23028 454 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23029 454 : void *argp1 = 0 ;
23030 454 : int res1 = 0 ;
23031 454 : PyObject *swig_obj[1] ;
23032 454 : char *result = 0 ;
23033 :
23034 454 : if (!args) SWIG_fail;
23035 454 : swig_obj[0] = args;
23036 454 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23037 454 : if (!SWIG_IsOK(res1)) {
23038 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetProjection" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23039 : }
23040 454 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23041 454 : {
23042 454 : const int bLocalUseExceptions = GetUseExceptions();
23043 454 : if ( bLocalUseExceptions ) {
23044 405 : pushErrorHandler();
23045 : }
23046 454 : {
23047 454 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23048 454 : result = (char *)GDALDatasetShadow_GetProjection(arg1);
23049 454 : SWIG_PYTHON_THREAD_END_ALLOW;
23050 : }
23051 454 : if ( bLocalUseExceptions ) {
23052 405 : popErrorHandler();
23053 : }
23054 : #ifndef SED_HACKS
23055 : if ( bLocalUseExceptions ) {
23056 : CPLErr eclass = CPLGetLastErrorType();
23057 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23058 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23059 : }
23060 : }
23061 : #endif
23062 : }
23063 454 : resultobj = SWIG_FromCharPtr((const char *)result);
23064 454 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23065 : return resultobj;
23066 : fail:
23067 : return NULL;
23068 : }
23069 :
23070 :
23071 858 : SWIGINTERN PyObject *_wrap_Dataset_GetProjectionRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23072 858 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23073 858 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23074 858 : void *argp1 = 0 ;
23075 858 : int res1 = 0 ;
23076 858 : PyObject *swig_obj[1] ;
23077 858 : char *result = 0 ;
23078 :
23079 858 : if (!args) SWIG_fail;
23080 858 : swig_obj[0] = args;
23081 858 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23082 858 : if (!SWIG_IsOK(res1)) {
23083 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetProjectionRef" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23084 : }
23085 858 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23086 858 : {
23087 858 : const int bLocalUseExceptions = GetUseExceptions();
23088 858 : if ( bLocalUseExceptions ) {
23089 625 : pushErrorHandler();
23090 : }
23091 858 : {
23092 858 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23093 858 : result = (char *)GDALDatasetShadow_GetProjectionRef(arg1);
23094 858 : SWIG_PYTHON_THREAD_END_ALLOW;
23095 : }
23096 858 : if ( bLocalUseExceptions ) {
23097 625 : popErrorHandler();
23098 : }
23099 : #ifndef SED_HACKS
23100 : if ( bLocalUseExceptions ) {
23101 : CPLErr eclass = CPLGetLastErrorType();
23102 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23103 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23104 : }
23105 : }
23106 : #endif
23107 : }
23108 858 : resultobj = SWIG_FromCharPtr((const char *)result);
23109 858 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23110 : return resultobj;
23111 : fail:
23112 : return NULL;
23113 : }
23114 :
23115 :
23116 3999 : SWIGINTERN PyObject *_wrap_Dataset_GetRefCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23117 3999 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23118 3999 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23119 3999 : void *argp1 = 0 ;
23120 3999 : int res1 = 0 ;
23121 3999 : PyObject *swig_obj[1] ;
23122 3999 : int result;
23123 :
23124 3999 : if (!args) SWIG_fail;
23125 3999 : swig_obj[0] = args;
23126 3999 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23127 3999 : if (!SWIG_IsOK(res1)) {
23128 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetRefCount" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23129 : }
23130 3999 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23131 3999 : {
23132 3999 : const int bLocalUseExceptions = GetUseExceptions();
23133 3999 : if ( bLocalUseExceptions ) {
23134 1419 : pushErrorHandler();
23135 : }
23136 3999 : {
23137 3999 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23138 3999 : result = (int)GDALDatasetShadow_GetRefCount(arg1);
23139 3999 : SWIG_PYTHON_THREAD_END_ALLOW;
23140 : }
23141 3999 : if ( bLocalUseExceptions ) {
23142 1419 : popErrorHandler();
23143 : }
23144 : #ifndef SED_HACKS
23145 : if ( bLocalUseExceptions ) {
23146 : CPLErr eclass = CPLGetLastErrorType();
23147 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23148 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23149 : }
23150 : }
23151 : #endif
23152 : }
23153 3999 : resultobj = SWIG_From_int(static_cast< int >(result));
23154 3999 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23155 : return resultobj;
23156 : fail:
23157 : return NULL;
23158 : }
23159 :
23160 :
23161 0 : SWIGINTERN PyObject *_wrap_Dataset_GetSummaryRefCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23162 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23163 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23164 0 : void *argp1 = 0 ;
23165 0 : int res1 = 0 ;
23166 0 : PyObject *swig_obj[1] ;
23167 0 : int result;
23168 :
23169 0 : if (!args) SWIG_fail;
23170 0 : swig_obj[0] = args;
23171 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23172 0 : if (!SWIG_IsOK(res1)) {
23173 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetSummaryRefCount" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23174 : }
23175 0 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23176 0 : {
23177 0 : const int bLocalUseExceptions = GetUseExceptions();
23178 0 : if ( bLocalUseExceptions ) {
23179 0 : pushErrorHandler();
23180 : }
23181 0 : {
23182 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23183 0 : result = (int)GDALDatasetShadow_GetSummaryRefCount(arg1);
23184 0 : SWIG_PYTHON_THREAD_END_ALLOW;
23185 : }
23186 0 : if ( bLocalUseExceptions ) {
23187 0 : popErrorHandler();
23188 : }
23189 : #ifndef SED_HACKS
23190 : if ( bLocalUseExceptions ) {
23191 : CPLErr eclass = CPLGetLastErrorType();
23192 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23193 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23194 : }
23195 : }
23196 : #endif
23197 : }
23198 0 : resultobj = SWIG_From_int(static_cast< int >(result));
23199 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23200 : return resultobj;
23201 : fail:
23202 : return NULL;
23203 : }
23204 :
23205 :
23206 1250 : SWIGINTERN PyObject *_wrap_Dataset_GetSpatialRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23207 1250 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23208 1250 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23209 1250 : void *argp1 = 0 ;
23210 1250 : int res1 = 0 ;
23211 1250 : PyObject *swig_obj[1] ;
23212 1250 : OSRSpatialReferenceShadow *result = 0 ;
23213 :
23214 1250 : if (!args) SWIG_fail;
23215 1250 : swig_obj[0] = args;
23216 1250 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23217 1250 : if (!SWIG_IsOK(res1)) {
23218 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetSpatialRef" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23219 : }
23220 1250 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23221 1250 : {
23222 1250 : const int bLocalUseExceptions = GetUseExceptions();
23223 1250 : if ( bLocalUseExceptions ) {
23224 989 : pushErrorHandler();
23225 : }
23226 1250 : {
23227 1250 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23228 1250 : result = (OSRSpatialReferenceShadow *)GDALDatasetShadow_GetSpatialRef(arg1);
23229 1250 : SWIG_PYTHON_THREAD_END_ALLOW;
23230 : }
23231 1250 : if ( bLocalUseExceptions ) {
23232 989 : popErrorHandler();
23233 : }
23234 : #ifndef SED_HACKS
23235 : if ( bLocalUseExceptions ) {
23236 : CPLErr eclass = CPLGetLastErrorType();
23237 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23238 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23239 : }
23240 : }
23241 : #endif
23242 : }
23243 1250 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_OWN | 0 );
23244 1250 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23245 : return resultobj;
23246 : fail:
23247 : return NULL;
23248 : }
23249 :
23250 :
23251 1630 : SWIGINTERN PyObject *_wrap_Dataset_SetProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23252 1630 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23253 1630 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23254 1630 : char *arg2 = (char *) 0 ;
23255 1630 : void *argp1 = 0 ;
23256 1630 : int res1 = 0 ;
23257 1630 : int res2 ;
23258 1630 : char *buf2 = 0 ;
23259 1630 : int alloc2 = 0 ;
23260 1630 : PyObject *swig_obj[2] ;
23261 1630 : CPLErr result;
23262 :
23263 1630 : if (!SWIG_Python_UnpackTuple(args, "Dataset_SetProjection", 2, 2, swig_obj)) SWIG_fail;
23264 1630 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23265 1630 : if (!SWIG_IsOK(res1)) {
23266 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_SetProjection" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23267 : }
23268 1630 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23269 1630 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
23270 1630 : if (!SWIG_IsOK(res2)) {
23271 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_SetProjection" "', argument " "2"" of type '" "char const *""'");
23272 : }
23273 1630 : arg2 = reinterpret_cast< char * >(buf2);
23274 1630 : {
23275 1630 : if (!arg2) {
23276 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
23277 : }
23278 : }
23279 1630 : {
23280 1630 : const int bLocalUseExceptions = GetUseExceptions();
23281 1630 : if ( bLocalUseExceptions ) {
23282 743 : pushErrorHandler();
23283 : }
23284 1630 : {
23285 1630 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23286 1630 : result = (CPLErr)GDALDatasetShadow_SetProjection(arg1,(char const *)arg2);
23287 1630 : SWIG_PYTHON_THREAD_END_ALLOW;
23288 : }
23289 1630 : if ( bLocalUseExceptions ) {
23290 743 : popErrorHandler();
23291 : }
23292 : #ifndef SED_HACKS
23293 : if ( bLocalUseExceptions ) {
23294 : CPLErr eclass = CPLGetLastErrorType();
23295 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23296 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23297 : }
23298 : }
23299 : #endif
23300 : }
23301 1630 : resultobj = SWIG_From_int(static_cast< int >(result));
23302 1630 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23303 1630 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23304 : return resultobj;
23305 0 : fail:
23306 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23307 : return NULL;
23308 : }
23309 :
23310 :
23311 321 : SWIGINTERN PyObject *_wrap_Dataset_SetSpatialRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23312 321 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23313 321 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23314 321 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
23315 321 : void *argp1 = 0 ;
23316 321 : int res1 = 0 ;
23317 321 : void *argp2 = 0 ;
23318 321 : int res2 = 0 ;
23319 321 : PyObject *swig_obj[2] ;
23320 321 : CPLErr result;
23321 :
23322 321 : if (!SWIG_Python_UnpackTuple(args, "Dataset_SetSpatialRef", 2, 2, swig_obj)) SWIG_fail;
23323 321 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23324 321 : if (!SWIG_IsOK(res1)) {
23325 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_SetSpatialRef" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23326 : }
23327 321 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23328 321 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
23329 321 : if (!SWIG_IsOK(res2)) {
23330 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_SetSpatialRef" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
23331 : }
23332 321 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
23333 321 : {
23334 321 : const int bLocalUseExceptions = GetUseExceptions();
23335 321 : if ( bLocalUseExceptions ) {
23336 181 : pushErrorHandler();
23337 : }
23338 321 : {
23339 321 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23340 321 : result = (CPLErr)GDALDatasetShadow_SetSpatialRef(arg1,arg2);
23341 321 : SWIG_PYTHON_THREAD_END_ALLOW;
23342 : }
23343 321 : if ( bLocalUseExceptions ) {
23344 181 : popErrorHandler();
23345 : }
23346 : #ifndef SED_HACKS
23347 : if ( bLocalUseExceptions ) {
23348 : CPLErr eclass = CPLGetLastErrorType();
23349 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23350 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23351 : }
23352 : }
23353 : #endif
23354 : }
23355 321 : resultobj = SWIG_From_int(static_cast< int >(result));
23356 321 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23357 : return resultobj;
23358 : fail:
23359 : return NULL;
23360 : }
23361 :
23362 :
23363 4010 : SWIGINTERN PyObject *_wrap_Dataset_GetGeoTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23364 4010 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23365 4010 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23366 4010 : double *arg2 ;
23367 4010 : int *arg3 = (int *) 0 ;
23368 4010 : int *arg4 = (int *) 0 ;
23369 4010 : void *argp1 = 0 ;
23370 4010 : int res1 = 0 ;
23371 4010 : double argout2[6] ;
23372 4010 : int isvalid2 ;
23373 4010 : int val4 ;
23374 4010 : PyObject * obj0 = 0 ;
23375 4010 : PyObject * obj1 = 0 ;
23376 4010 : char * kwnames[] = {
23377 : (char *)"self", (char *)"can_return_null", NULL
23378 : };
23379 :
23380 4010 : {
23381 : /* %typemap(in,numinputs=0) (double argout2[6], int* isvalid2) */
23382 4010 : arg2 = argout2;
23383 4010 : arg3 = &isvalid2;
23384 : }
23385 4010 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Dataset_GetGeoTransform", kwnames, &obj0, &obj1)) SWIG_fail;
23386 4010 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23387 4010 : if (!SWIG_IsOK(res1)) {
23388 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetGeoTransform" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23389 : }
23390 4010 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23391 4010 : if (obj1) {
23392 403 : {
23393 : /* %typemap(in) (int *optional_##int) */
23394 403 : if ( obj1 == Py_None ) {
23395 : arg4 = 0;
23396 : }
23397 403 : else if ( PyArg_Parse( obj1,"i" ,&val4 ) ) {
23398 : arg4 = (int *) &val4;
23399 : }
23400 : else {
23401 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
23402 0 : SWIG_fail;
23403 : }
23404 : }
23405 : }
23406 4010 : {
23407 4010 : const int bLocalUseExceptions = GetUseExceptions();
23408 4010 : if ( bLocalUseExceptions ) {
23409 2726 : pushErrorHandler();
23410 : }
23411 4010 : {
23412 4010 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23413 4010 : GDALDatasetShadow_GetGeoTransform(arg1,arg2,arg3,arg4);
23414 4010 : SWIG_PYTHON_THREAD_END_ALLOW;
23415 : }
23416 4010 : if ( bLocalUseExceptions ) {
23417 2726 : popErrorHandler();
23418 : }
23419 : #ifndef SED_HACKS
23420 : if ( bLocalUseExceptions ) {
23421 : CPLErr eclass = CPLGetLastErrorType();
23422 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23423 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23424 : }
23425 : }
23426 : #endif
23427 : }
23428 4010 : resultobj = SWIG_Py_Void();
23429 4010 : {
23430 : /* %typemap(argout) (double argout[6], int* isvalid) */
23431 4010 : PyObject *r;
23432 4010 : if ( !*arg3 ) {
23433 125 : Py_INCREF(Py_None);
23434 125 : r = Py_None;
23435 : }
23436 : else {
23437 3885 : r = CreateTupleFromDoubleArray(arg2, 6);
23438 : }
23439 : #if 0x040001 >= 0x040300
23440 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
23441 : #else
23442 4010 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
23443 : #endif
23444 : }
23445 4010 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23446 : return resultobj;
23447 : fail:
23448 : return NULL;
23449 : }
23450 :
23451 :
23452 3093 : SWIGINTERN PyObject *_wrap_Dataset_SetGeoTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23453 3093 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23454 3093 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23455 3093 : double *arg2 ;
23456 3093 : void *argp1 = 0 ;
23457 3093 : int res1 = 0 ;
23458 3093 : double argin2[6] ;
23459 3093 : PyObject *swig_obj[2] ;
23460 3093 : CPLErr result;
23461 :
23462 3093 : if (!SWIG_Python_UnpackTuple(args, "Dataset_SetGeoTransform", 2, 2, swig_obj)) SWIG_fail;
23463 3093 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23464 3093 : if (!SWIG_IsOK(res1)) {
23465 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_SetGeoTransform" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23466 : }
23467 3093 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23468 3093 : {
23469 : /* %typemap(in) (double argin2[ANY]) */
23470 3093 : arg2 = argin2;
23471 3093 : if (! PySequence_Check(swig_obj[1]) ) {
23472 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
23473 0 : SWIG_fail;
23474 : }
23475 3093 : Py_ssize_t seq_size = PySequence_Size(swig_obj[1]);
23476 3093 : if ( seq_size != 6 ) {
23477 0 : PyErr_SetString(PyExc_TypeError, "sequence must have length ##size");
23478 0 : SWIG_fail;
23479 : }
23480 21651 : for (unsigned int i=0; i<6; i++) {
23481 18558 : PyObject *o = PySequence_GetItem(swig_obj[1],i);
23482 18558 : double val;
23483 18558 : if ( !PyArg_Parse(o, "d", &val ) ) {
23484 0 : PyErr_SetString(PyExc_TypeError, "not a number");
23485 0 : Py_DECREF(o);
23486 0 : SWIG_fail;
23487 : }
23488 18558 : arg2[i] = val;
23489 18558 : Py_DECREF(o);
23490 : }
23491 : }
23492 3093 : {
23493 3093 : const int bLocalUseExceptions = GetUseExceptions();
23494 3093 : if ( bLocalUseExceptions ) {
23495 1933 : pushErrorHandler();
23496 : }
23497 3093 : {
23498 3093 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23499 3093 : result = (CPLErr)GDALDatasetShadow_SetGeoTransform(arg1,arg2);
23500 3093 : SWIG_PYTHON_THREAD_END_ALLOW;
23501 : }
23502 3093 : if ( bLocalUseExceptions ) {
23503 1933 : popErrorHandler();
23504 : }
23505 : #ifndef SED_HACKS
23506 : if ( bLocalUseExceptions ) {
23507 : CPLErr eclass = CPLGetLastErrorType();
23508 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23509 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23510 : }
23511 : }
23512 : #endif
23513 : }
23514 3093 : resultobj = SWIG_From_int(static_cast< int >(result));
23515 3093 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23516 : return resultobj;
23517 : fail:
23518 : return NULL;
23519 : }
23520 :
23521 :
23522 10 : SWIGINTERN PyObject *_wrap_Dataset_GetExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23523 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23524 10 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23525 10 : double *arg2 ;
23526 10 : int *arg3 = (int *) 0 ;
23527 10 : OSRSpatialReferenceShadow *arg4 = (OSRSpatialReferenceShadow *) NULL ;
23528 10 : void *argp1 = 0 ;
23529 10 : int res1 = 0 ;
23530 10 : double argout2[4] ;
23531 10 : int isvalid2 ;
23532 10 : void *argp4 = 0 ;
23533 10 : int res4 = 0 ;
23534 10 : PyObject * obj0 = 0 ;
23535 10 : PyObject * obj1 = 0 ;
23536 10 : char * kwnames[] = {
23537 : (char *)"self", (char *)"srs", NULL
23538 : };
23539 :
23540 10 : {
23541 : /* %typemap(in,numinputs=0) (double argout2[4], int* isvalid2) */
23542 10 : arg2 = argout2;
23543 10 : arg3 = &isvalid2;
23544 : }
23545 10 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Dataset_GetExtent", kwnames, &obj0, &obj1)) SWIG_fail;
23546 10 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23547 10 : if (!SWIG_IsOK(res1)) {
23548 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetExtent" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23549 : }
23550 10 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23551 10 : if (obj1) {
23552 2 : res4 = SWIG_ConvertPtr(obj1, &argp4,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
23553 2 : if (!SWIG_IsOK(res4)) {
23554 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Dataset_GetExtent" "', argument " "4"" of type '" "OSRSpatialReferenceShadow *""'");
23555 : }
23556 2 : arg4 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp4);
23557 : }
23558 10 : {
23559 10 : const int bLocalUseExceptions = GetUseExceptions();
23560 10 : if ( bLocalUseExceptions ) {
23561 2 : pushErrorHandler();
23562 : }
23563 10 : {
23564 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23565 10 : GDALDatasetShadow_GetExtent(arg1,arg2,arg3,arg4);
23566 10 : SWIG_PYTHON_THREAD_END_ALLOW;
23567 : }
23568 10 : if ( bLocalUseExceptions ) {
23569 2 : popErrorHandler();
23570 : }
23571 : #ifndef SED_HACKS
23572 : if ( bLocalUseExceptions ) {
23573 : CPLErr eclass = CPLGetLastErrorType();
23574 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23575 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23576 : }
23577 : }
23578 : #endif
23579 : }
23580 10 : resultobj = SWIG_Py_Void();
23581 10 : {
23582 : /* %typemap(argout) (double argout[4], int* isvalid) */
23583 10 : PyObject *r;
23584 10 : if ( !*arg3 ) {
23585 3 : Py_INCREF(Py_None);
23586 3 : r = Py_None;
23587 : }
23588 : else {
23589 7 : r = CreateTupleFromDoubleArray(arg2, 4);
23590 : }
23591 : #if 0x040001 >= 0x040300
23592 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
23593 : #else
23594 10 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
23595 : #endif
23596 : }
23597 10 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23598 : return resultobj;
23599 : fail:
23600 : return NULL;
23601 : }
23602 :
23603 :
23604 4 : SWIGINTERN PyObject *_wrap_Dataset_GetExtentWGS84LongLat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23605 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23606 4 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23607 4 : double *arg2 ;
23608 4 : int *arg3 = (int *) 0 ;
23609 4 : void *argp1 = 0 ;
23610 4 : int res1 = 0 ;
23611 4 : double argout2[4] ;
23612 4 : int isvalid2 ;
23613 4 : PyObject *swig_obj[1] ;
23614 :
23615 4 : {
23616 : /* %typemap(in,numinputs=0) (double argout2[4], int* isvalid2) */
23617 4 : arg2 = argout2;
23618 4 : arg3 = &isvalid2;
23619 : }
23620 4 : if (!args) SWIG_fail;
23621 4 : swig_obj[0] = args;
23622 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23623 4 : if (!SWIG_IsOK(res1)) {
23624 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetExtentWGS84LongLat" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23625 : }
23626 4 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23627 4 : {
23628 4 : const int bLocalUseExceptions = GetUseExceptions();
23629 4 : if ( bLocalUseExceptions ) {
23630 2 : pushErrorHandler();
23631 : }
23632 4 : {
23633 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23634 4 : GDALDatasetShadow_GetExtentWGS84LongLat(arg1,arg2,arg3);
23635 4 : SWIG_PYTHON_THREAD_END_ALLOW;
23636 : }
23637 4 : if ( bLocalUseExceptions ) {
23638 2 : 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 4 : resultobj = SWIG_Py_Void();
23650 4 : {
23651 : /* %typemap(argout) (double argout[4], int* isvalid) */
23652 4 : PyObject *r;
23653 4 : if ( !*arg3 ) {
23654 2 : Py_INCREF(Py_None);
23655 2 : r = Py_None;
23656 : }
23657 : else {
23658 2 : r = CreateTupleFromDoubleArray(arg2, 4);
23659 : }
23660 : #if 0x040001 >= 0x040300
23661 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
23662 : #else
23663 4 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
23664 : #endif
23665 : }
23666 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23667 : return resultobj;
23668 : fail:
23669 : return NULL;
23670 : }
23671 :
23672 :
23673 683 : SWIGINTERN PyObject *_wrap_Dataset_BuildOverviews(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23674 683 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23675 683 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23676 683 : char *arg2 = (char *) "NEAREST" ;
23677 683 : int arg3 = (int) 0 ;
23678 683 : int *arg4 = (int *) 0 ;
23679 683 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
23680 683 : void *arg6 = (void *) NULL ;
23681 683 : char **arg7 = (char **) NULL ;
23682 683 : void *argp1 = 0 ;
23683 683 : int res1 = 0 ;
23684 683 : int res2 ;
23685 683 : char *buf2 = 0 ;
23686 683 : int alloc2 = 0 ;
23687 683 : PyObject * obj0 = 0 ;
23688 683 : PyObject * obj1 = 0 ;
23689 683 : PyObject * obj2 = 0 ;
23690 683 : PyObject * obj3 = 0 ;
23691 683 : PyObject * obj4 = 0 ;
23692 683 : PyObject * obj5 = 0 ;
23693 683 : char * kwnames[] = {
23694 : (char *)"self", (char *)"resampling", (char *)"overviewlist", (char *)"callback", (char *)"callback_data", (char *)"options", NULL
23695 : };
23696 683 : int result;
23697 :
23698 : /* %typemap(arginit) ( const char* callback_data=NULL) */
23699 683 : PyProgressData *psProgressInfo;
23700 683 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
23701 683 : psProgressInfo->nLastReported = -1;
23702 683 : psProgressInfo->psPyCallback = NULL;
23703 683 : psProgressInfo->psPyCallbackData = NULL;
23704 683 : arg6 = psProgressInfo;
23705 683 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOO:Dataset_BuildOverviews", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
23706 683 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23707 683 : if (!SWIG_IsOK(res1)) {
23708 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_BuildOverviews" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23709 : }
23710 683 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23711 683 : if (obj1) {
23712 632 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23713 632 : if (!SWIG_IsOK(res2)) {
23714 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_BuildOverviews" "', argument " "2"" of type '" "char const *""'");
23715 : }
23716 632 : arg2 = reinterpret_cast< char * >(buf2);
23717 : }
23718 683 : if (obj2) {
23719 683 : {
23720 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
23721 683 : arg4 = CreateCIntListFromSequence(obj2, &arg3);
23722 683 : if( arg3 < 0 ) {
23723 0 : SWIG_fail;
23724 : }
23725 : }
23726 : }
23727 683 : if (obj3) {
23728 2 : {
23729 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
23730 : /* callback_func typemap */
23731 :
23732 : /* In some cases 0 is passed instead of None. */
23733 : /* See https://github.com/OSGeo/gdal/pull/219 */
23734 2 : if ( PyLong_Check(obj3) || PyInt_Check(obj3) )
23735 : {
23736 0 : if( PyLong_AsLong(obj3) == 0 )
23737 : {
23738 0 : obj3 = Py_None;
23739 : }
23740 : }
23741 :
23742 2 : if (obj3 && obj3 != Py_None ) {
23743 2 : void* cbfunction = NULL;
23744 2 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj3,
23745 : (void**)&cbfunction,
23746 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
23747 : SWIG_POINTER_EXCEPTION | 0 ));
23748 :
23749 2 : if ( cbfunction == GDALTermProgress ) {
23750 : arg5 = GDALTermProgress;
23751 : } else {
23752 2 : if (!PyCallable_Check(obj3)) {
23753 0 : PyErr_SetString( PyExc_RuntimeError,
23754 : "Object given is not a Python function" );
23755 0 : SWIG_fail;
23756 : }
23757 2 : psProgressInfo->psPyCallback = obj3;
23758 2 : arg5 = PyProgressProxy;
23759 : }
23760 :
23761 : }
23762 :
23763 : }
23764 : }
23765 683 : if (obj4) {
23766 2 : {
23767 : /* %typemap(in) ( void* callback_data=NULL) */
23768 2 : psProgressInfo->psPyCallbackData = obj4 ;
23769 : }
23770 : }
23771 683 : if (obj5) {
23772 14 : {
23773 : /* %typemap(in) char **dict */
23774 14 : arg7 = NULL;
23775 14 : if ( PySequence_Check( obj5 ) ) {
23776 14 : int bErr = FALSE;
23777 14 : arg7 = CSLFromPySequence(obj5, &bErr);
23778 14 : if ( bErr )
23779 : {
23780 0 : SWIG_fail;
23781 : }
23782 : }
23783 0 : else if ( PyMapping_Check( obj5 ) ) {
23784 0 : int bErr = FALSE;
23785 0 : arg7 = CSLFromPyMapping(obj5, &bErr);
23786 0 : if ( bErr )
23787 : {
23788 0 : SWIG_fail;
23789 : }
23790 : }
23791 : else {
23792 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
23793 0 : SWIG_fail;
23794 : }
23795 : }
23796 : }
23797 683 : {
23798 683 : const int bLocalUseExceptions = GetUseExceptions();
23799 683 : if ( bLocalUseExceptions ) {
23800 269 : pushErrorHandler();
23801 : }
23802 683 : {
23803 683 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23804 683 : result = (int)GDALDatasetShadow_BuildOverviews(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
23805 683 : SWIG_PYTHON_THREAD_END_ALLOW;
23806 : }
23807 683 : if ( bLocalUseExceptions ) {
23808 269 : popErrorHandler();
23809 : }
23810 : #ifndef SED_HACKS
23811 : if ( bLocalUseExceptions ) {
23812 : CPLErr eclass = CPLGetLastErrorType();
23813 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23814 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23815 : }
23816 : }
23817 : #endif
23818 : }
23819 683 : resultobj = SWIG_From_int(static_cast< int >(result));
23820 683 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23821 683 : {
23822 : /* %typemap(freearg) (int nList, int* pList) */
23823 683 : free(arg4);
23824 : }
23825 683 : {
23826 : /* %typemap(freearg) ( void* callback_data=NULL) */
23827 :
23828 683 : CPLFree(psProgressInfo);
23829 :
23830 : }
23831 683 : {
23832 : /* %typemap(freearg) char **dict */
23833 683 : CSLDestroy( arg7 );
23834 : }
23835 697 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23836 : return resultobj;
23837 0 : fail:
23838 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23839 0 : {
23840 : /* %typemap(freearg) (int nList, int* pList) */
23841 0 : free(arg4);
23842 : }
23843 0 : {
23844 : /* %typemap(freearg) ( void* callback_data=NULL) */
23845 :
23846 0 : CPLFree(psProgressInfo);
23847 :
23848 : }
23849 0 : {
23850 : /* %typemap(freearg) char **dict */
23851 0 : CSLDestroy( arg7 );
23852 : }
23853 : return NULL;
23854 : }
23855 :
23856 :
23857 117 : SWIGINTERN PyObject *_wrap_Dataset_GetGCPCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23858 117 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23859 117 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23860 117 : void *argp1 = 0 ;
23861 117 : int res1 = 0 ;
23862 117 : PyObject *swig_obj[1] ;
23863 117 : int result;
23864 :
23865 117 : if (!args) SWIG_fail;
23866 117 : swig_obj[0] = args;
23867 117 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23868 117 : if (!SWIG_IsOK(res1)) {
23869 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetGCPCount" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23870 : }
23871 117 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23872 117 : {
23873 117 : const int bLocalUseExceptions = GetUseExceptions();
23874 117 : if ( bLocalUseExceptions ) {
23875 68 : pushErrorHandler();
23876 : }
23877 117 : {
23878 117 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23879 117 : result = (int)GDALDatasetShadow_GetGCPCount(arg1);
23880 117 : SWIG_PYTHON_THREAD_END_ALLOW;
23881 : }
23882 117 : if ( bLocalUseExceptions ) {
23883 68 : popErrorHandler();
23884 : }
23885 : #ifndef SED_HACKS
23886 : if ( bLocalUseExceptions ) {
23887 : CPLErr eclass = CPLGetLastErrorType();
23888 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23889 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23890 : }
23891 : }
23892 : #endif
23893 : }
23894 117 : resultobj = SWIG_From_int(static_cast< int >(result));
23895 117 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23896 : return resultobj;
23897 : fail:
23898 : return NULL;
23899 : }
23900 :
23901 :
23902 454 : SWIGINTERN PyObject *_wrap_Dataset_GetGCPProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23903 454 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23904 454 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23905 454 : void *argp1 = 0 ;
23906 454 : int res1 = 0 ;
23907 454 : PyObject *swig_obj[1] ;
23908 454 : char *result = 0 ;
23909 :
23910 454 : if (!args) SWIG_fail;
23911 454 : swig_obj[0] = args;
23912 454 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23913 454 : if (!SWIG_IsOK(res1)) {
23914 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetGCPProjection" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23915 : }
23916 454 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23917 454 : {
23918 454 : const int bLocalUseExceptions = GetUseExceptions();
23919 454 : if ( bLocalUseExceptions ) {
23920 436 : pushErrorHandler();
23921 : }
23922 454 : {
23923 454 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23924 454 : result = (char *)GDALDatasetShadow_GetGCPProjection(arg1);
23925 454 : SWIG_PYTHON_THREAD_END_ALLOW;
23926 : }
23927 454 : if ( bLocalUseExceptions ) {
23928 436 : popErrorHandler();
23929 : }
23930 : #ifndef SED_HACKS
23931 : if ( bLocalUseExceptions ) {
23932 : CPLErr eclass = CPLGetLastErrorType();
23933 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23934 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23935 : }
23936 : }
23937 : #endif
23938 : }
23939 454 : resultobj = SWIG_FromCharPtr((const char *)result);
23940 454 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23941 : return resultobj;
23942 : fail:
23943 : return NULL;
23944 : }
23945 :
23946 :
23947 426 : SWIGINTERN PyObject *_wrap_Dataset_GetGCPSpatialRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23948 426 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23949 426 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23950 426 : void *argp1 = 0 ;
23951 426 : int res1 = 0 ;
23952 426 : PyObject *swig_obj[1] ;
23953 426 : OSRSpatialReferenceShadow *result = 0 ;
23954 :
23955 426 : if (!args) SWIG_fail;
23956 426 : swig_obj[0] = args;
23957 426 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
23958 426 : if (!SWIG_IsOK(res1)) {
23959 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetGCPSpatialRef" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
23960 : }
23961 426 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
23962 426 : {
23963 426 : const int bLocalUseExceptions = GetUseExceptions();
23964 426 : if ( bLocalUseExceptions ) {
23965 412 : pushErrorHandler();
23966 : }
23967 426 : {
23968 426 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23969 426 : result = (OSRSpatialReferenceShadow *)GDALDatasetShadow_GetGCPSpatialRef(arg1);
23970 426 : SWIG_PYTHON_THREAD_END_ALLOW;
23971 : }
23972 426 : if ( bLocalUseExceptions ) {
23973 412 : popErrorHandler();
23974 : }
23975 : #ifndef SED_HACKS
23976 : if ( bLocalUseExceptions ) {
23977 : CPLErr eclass = CPLGetLastErrorType();
23978 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
23979 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
23980 : }
23981 : }
23982 : #endif
23983 : }
23984 426 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_OWN | 0 );
23985 426 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
23986 : return resultobj;
23987 : fail:
23988 : return NULL;
23989 : }
23990 :
23991 :
23992 528 : SWIGINTERN PyObject *_wrap_Dataset_GetGCPs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23993 528 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
23994 528 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
23995 528 : int *arg2 = (int *) 0 ;
23996 528 : GDAL_GCP **arg3 = (GDAL_GCP **) 0 ;
23997 528 : void *argp1 = 0 ;
23998 528 : int res1 = 0 ;
23999 528 : int nGCPs2 = 0 ;
24000 528 : GDAL_GCP *pGCPs2 = 0 ;
24001 528 : PyObject *swig_obj[1] ;
24002 :
24003 528 : {
24004 : /* %typemap(in,numinputs=0) (int *nGCPs2, GDAL_GCP const **pGCPs2 ) */
24005 528 : arg2 = &nGCPs2;
24006 528 : arg3 = &pGCPs2;
24007 : }
24008 528 : if (!args) SWIG_fail;
24009 528 : swig_obj[0] = args;
24010 528 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
24011 528 : if (!SWIG_IsOK(res1)) {
24012 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetGCPs" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
24013 : }
24014 528 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
24015 528 : {
24016 528 : const int bLocalUseExceptions = GetUseExceptions();
24017 528 : if ( bLocalUseExceptions ) {
24018 495 : pushErrorHandler();
24019 : }
24020 528 : {
24021 528 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24022 528 : GDALDatasetShadow_GetGCPs(arg1,arg2,(GDAL_GCP const **)arg3);
24023 528 : SWIG_PYTHON_THREAD_END_ALLOW;
24024 : }
24025 528 : if ( bLocalUseExceptions ) {
24026 495 : popErrorHandler();
24027 : }
24028 : #ifndef SED_HACKS
24029 : if ( bLocalUseExceptions ) {
24030 : CPLErr eclass = CPLGetLastErrorType();
24031 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24032 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24033 : }
24034 : }
24035 : #endif
24036 : }
24037 528 : resultobj = SWIG_Py_Void();
24038 528 : {
24039 : /* %typemap(argout) (int *nGCPs, GDAL_GCP const **pGCPs ) */
24040 528 : PyObject *dict = PyTuple_New( *arg2 );
24041 3826 : for( int i = 0; i < *arg2; i++ ) {
24042 6596 : GDAL_GCP *o = new_GDAL_GCP( (*arg3)[i].dfGCPX,
24043 : (*arg3)[i].dfGCPY,
24044 : (*arg3)[i].dfGCPZ,
24045 : (*arg3)[i].dfGCPPixel,
24046 : (*arg3)[i].dfGCPLine,
24047 3298 : (*arg3)[i].pszInfo,
24048 3298 : (*arg3)[i].pszId );
24049 :
24050 3298 : PyTuple_SetItem(dict, i,
24051 : SWIG_NewPointerObj((void*)o,SWIGTYPE_p_GDAL_GCP,1) );
24052 : }
24053 528 : Py_DECREF(resultobj);
24054 528 : resultobj = dict;
24055 : }
24056 528 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24057 : return resultobj;
24058 : fail:
24059 : return NULL;
24060 : }
24061 :
24062 :
24063 28 : SWIGINTERN PyObject *_wrap_Dataset__SetGCPs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24064 28 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24065 28 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
24066 28 : int arg2 ;
24067 28 : GDAL_GCP *arg3 = (GDAL_GCP *) 0 ;
24068 28 : char *arg4 = (char *) 0 ;
24069 28 : void *argp1 = 0 ;
24070 28 : int res1 = 0 ;
24071 28 : GDAL_GCP *tmpGCPList2 ;
24072 28 : int res4 ;
24073 28 : char *buf4 = 0 ;
24074 28 : int alloc4 = 0 ;
24075 28 : PyObject *swig_obj[3] ;
24076 28 : CPLErr result;
24077 :
24078 28 : if (!SWIG_Python_UnpackTuple(args, "Dataset__SetGCPs", 3, 3, swig_obj)) SWIG_fail;
24079 28 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
24080 28 : if (!SWIG_IsOK(res1)) {
24081 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset__SetGCPs" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
24082 : }
24083 28 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
24084 28 : {
24085 : /* %typemap(in,numinputs=1) (int nGCPs, GDAL_GCP const *pGCPs ) */
24086 : /* check if is List */
24087 28 : if ( !PySequence_Check(swig_obj[1]) ) {
24088 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
24089 0 : SWIG_fail;
24090 : }
24091 28 : Py_ssize_t size = PySequence_Size(swig_obj[1]);
24092 28 : if( size > (Py_ssize_t)INT_MAX ) {
24093 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
24094 0 : SWIG_fail;
24095 : }
24096 28 : if( (size_t)size > SIZE_MAX / sizeof(GDAL_GCP) ) {
24097 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
24098 0 : SWIG_fail;
24099 : }
24100 28 : arg2 = (int)size;
24101 28 : tmpGCPList2 = (GDAL_GCP*) malloc(arg2*sizeof(GDAL_GCP));
24102 28 : if( !tmpGCPList2 ) {
24103 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
24104 0 : SWIG_fail;
24105 : }
24106 91 : arg3 = tmpGCPList2;
24107 91 : for( int i = 0; i<arg2; i++ ) {
24108 63 : PyObject *o = PySequence_GetItem(swig_obj[1],i);
24109 63 : GDAL_GCP *item = 0;
24110 63 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&item, SWIGTYPE_p_GDAL_GCP, SWIG_POINTER_EXCEPTION | 0 ));
24111 63 : if ( ! item ) {
24112 0 : Py_DECREF(o);
24113 0 : SWIG_fail;
24114 : }
24115 63 : memcpy( tmpGCPList2 + i, item, sizeof( GDAL_GCP ) );
24116 63 : Py_DECREF(o);
24117 : }
24118 : }
24119 28 : res4 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf4, NULL, &alloc4);
24120 28 : if (!SWIG_IsOK(res4)) {
24121 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Dataset__SetGCPs" "', argument " "4"" of type '" "char const *""'");
24122 : }
24123 28 : arg4 = reinterpret_cast< char * >(buf4);
24124 28 : {
24125 28 : const int bLocalUseExceptions = GetUseExceptions();
24126 28 : if ( bLocalUseExceptions ) {
24127 14 : pushErrorHandler();
24128 : }
24129 28 : {
24130 28 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24131 28 : result = (CPLErr)GDALDatasetShadow_SetGCPs(arg1,arg2,(GDAL_GCP const *)arg3,(char const *)arg4);
24132 28 : SWIG_PYTHON_THREAD_END_ALLOW;
24133 : }
24134 28 : if ( bLocalUseExceptions ) {
24135 14 : popErrorHandler();
24136 : }
24137 : #ifndef SED_HACKS
24138 : if ( bLocalUseExceptions ) {
24139 : CPLErr eclass = CPLGetLastErrorType();
24140 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24141 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24142 : }
24143 : }
24144 : #endif
24145 : }
24146 28 : resultobj = SWIG_From_int(static_cast< int >(result));
24147 28 : {
24148 : /* %typemap(freearg) (int nGCPs, GDAL_GCP const *pGCPs ) */
24149 28 : free( arg3 );
24150 : }
24151 28 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24152 28 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24153 : return resultobj;
24154 0 : fail:
24155 0 : {
24156 : /* %typemap(freearg) (int nGCPs, GDAL_GCP const *pGCPs ) */
24157 0 : free( arg3 );
24158 : }
24159 0 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24160 : return NULL;
24161 : }
24162 :
24163 :
24164 9 : SWIGINTERN PyObject *_wrap_Dataset__SetGCPs2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24165 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24166 9 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
24167 9 : int arg2 ;
24168 9 : GDAL_GCP *arg3 = (GDAL_GCP *) 0 ;
24169 9 : OSRSpatialReferenceShadow *arg4 = (OSRSpatialReferenceShadow *) 0 ;
24170 9 : void *argp1 = 0 ;
24171 9 : int res1 = 0 ;
24172 9 : GDAL_GCP *tmpGCPList2 ;
24173 9 : void *argp4 = 0 ;
24174 9 : int res4 = 0 ;
24175 9 : PyObject *swig_obj[3] ;
24176 9 : CPLErr result;
24177 :
24178 9 : if (!SWIG_Python_UnpackTuple(args, "Dataset__SetGCPs2", 3, 3, swig_obj)) SWIG_fail;
24179 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
24180 9 : if (!SWIG_IsOK(res1)) {
24181 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset__SetGCPs2" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
24182 : }
24183 9 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
24184 9 : {
24185 : /* %typemap(in,numinputs=1) (int nGCPs, GDAL_GCP const *pGCPs ) */
24186 : /* check if is List */
24187 9 : if ( !PySequence_Check(swig_obj[1]) ) {
24188 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
24189 0 : SWIG_fail;
24190 : }
24191 9 : Py_ssize_t size = PySequence_Size(swig_obj[1]);
24192 9 : if( size > (Py_ssize_t)INT_MAX ) {
24193 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
24194 0 : SWIG_fail;
24195 : }
24196 9 : if( (size_t)size > SIZE_MAX / sizeof(GDAL_GCP) ) {
24197 0 : PyErr_SetString(PyExc_RuntimeError, "too big sequence");
24198 0 : SWIG_fail;
24199 : }
24200 9 : arg2 = (int)size;
24201 9 : tmpGCPList2 = (GDAL_GCP*) malloc(arg2*sizeof(GDAL_GCP));
24202 9 : if( !tmpGCPList2 ) {
24203 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
24204 0 : SWIG_fail;
24205 : }
24206 21871 : arg3 = tmpGCPList2;
24207 21871 : for( int i = 0; i<arg2; i++ ) {
24208 21862 : PyObject *o = PySequence_GetItem(swig_obj[1],i);
24209 21862 : GDAL_GCP *item = 0;
24210 21862 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&item, SWIGTYPE_p_GDAL_GCP, SWIG_POINTER_EXCEPTION | 0 ));
24211 21862 : if ( ! item ) {
24212 0 : Py_DECREF(o);
24213 0 : SWIG_fail;
24214 : }
24215 21862 : memcpy( tmpGCPList2 + i, item, sizeof( GDAL_GCP ) );
24216 21862 : Py_DECREF(o);
24217 : }
24218 : }
24219 9 : res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
24220 9 : if (!SWIG_IsOK(res4)) {
24221 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Dataset__SetGCPs2" "', argument " "4"" of type '" "OSRSpatialReferenceShadow *""'");
24222 : }
24223 9 : arg4 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp4);
24224 9 : {
24225 9 : const int bLocalUseExceptions = GetUseExceptions();
24226 9 : if ( bLocalUseExceptions ) {
24227 1 : pushErrorHandler();
24228 : }
24229 9 : {
24230 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24231 9 : result = (CPLErr)GDALDatasetShadow_SetGCPs2(arg1,arg2,(GDAL_GCP const *)arg3,arg4);
24232 9 : SWIG_PYTHON_THREAD_END_ALLOW;
24233 : }
24234 9 : if ( bLocalUseExceptions ) {
24235 1 : popErrorHandler();
24236 : }
24237 : #ifndef SED_HACKS
24238 : if ( bLocalUseExceptions ) {
24239 : CPLErr eclass = CPLGetLastErrorType();
24240 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24241 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24242 : }
24243 : }
24244 : #endif
24245 : }
24246 9 : resultobj = SWIG_From_int(static_cast< int >(result));
24247 9 : {
24248 : /* %typemap(freearg) (int nGCPs, GDAL_GCP const *pGCPs ) */
24249 9 : free( arg3 );
24250 : }
24251 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24252 : return resultobj;
24253 0 : fail:
24254 0 : {
24255 : /* %typemap(freearg) (int nGCPs, GDAL_GCP const *pGCPs ) */
24256 0 : free( arg3 );
24257 : }
24258 0 : return NULL;
24259 : }
24260 :
24261 :
24262 1623 : SWIGINTERN PyObject *_wrap_Dataset_FlushCache(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24263 1623 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24264 1623 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
24265 1623 : void *argp1 = 0 ;
24266 1623 : int res1 = 0 ;
24267 1623 : PyObject *swig_obj[1] ;
24268 1623 : CPLErr result;
24269 :
24270 1623 : if (!args) SWIG_fail;
24271 1623 : swig_obj[0] = args;
24272 1623 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
24273 1623 : if (!SWIG_IsOK(res1)) {
24274 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_FlushCache" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
24275 : }
24276 1623 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
24277 1623 : {
24278 1623 : const int bLocalUseExceptions = GetUseExceptions();
24279 1623 : if ( bLocalUseExceptions ) {
24280 399 : pushErrorHandler();
24281 : }
24282 1623 : {
24283 1623 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24284 1623 : result = (CPLErr)GDALDatasetShadow_FlushCache(arg1);
24285 1623 : SWIG_PYTHON_THREAD_END_ALLOW;
24286 : }
24287 1623 : if ( bLocalUseExceptions ) {
24288 399 : popErrorHandler();
24289 : }
24290 : #ifndef SED_HACKS
24291 : if ( bLocalUseExceptions ) {
24292 : CPLErr eclass = CPLGetLastErrorType();
24293 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24294 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24295 : }
24296 : }
24297 : #endif
24298 : }
24299 1623 : resultobj = SWIG_From_int(static_cast< int >(result));
24300 1625 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24301 : return resultobj;
24302 : fail:
24303 : return NULL;
24304 : }
24305 :
24306 :
24307 32 : SWIGINTERN PyObject *_wrap_Dataset_AddBand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24308 32 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24309 32 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
24310 32 : GDALDataType arg2 = (GDALDataType) GDT_Byte ;
24311 32 : char **arg3 = (char **) 0 ;
24312 32 : void *argp1 = 0 ;
24313 32 : int res1 = 0 ;
24314 32 : PyObject * obj0 = 0 ;
24315 32 : PyObject * obj1 = 0 ;
24316 32 : PyObject * obj2 = 0 ;
24317 32 : char * kwnames[] = {
24318 : (char *)"self", (char *)"datatype", (char *)"options", NULL
24319 : };
24320 32 : CPLErr result;
24321 :
24322 32 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:Dataset_AddBand", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
24323 32 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
24324 32 : if (!SWIG_IsOK(res1)) {
24325 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_AddBand" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
24326 : }
24327 32 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
24328 32 : if (obj1) {
24329 26 : {
24330 : // %typemap(in) GDALDataType
24331 26 : int val = 0;
24332 26 : int ecode = SWIG_AsVal_int(obj1, &val);
24333 26 : if (!SWIG_IsOK(ecode)) {
24334 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
24335 : }
24336 26 : if( val < GDT_Unknown || val >= GDT_TypeCount )
24337 : {
24338 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
24339 : }
24340 : arg2 = static_cast<GDALDataType>(val);
24341 : }
24342 : }
24343 32 : if (obj2) {
24344 15 : {
24345 : /* %typemap(in) char **dict */
24346 15 : arg3 = NULL;
24347 15 : if ( PySequence_Check( obj2 ) ) {
24348 15 : int bErr = FALSE;
24349 15 : arg3 = CSLFromPySequence(obj2, &bErr);
24350 15 : if ( bErr )
24351 : {
24352 0 : SWIG_fail;
24353 : }
24354 : }
24355 0 : else if ( PyMapping_Check( obj2 ) ) {
24356 0 : int bErr = FALSE;
24357 0 : arg3 = CSLFromPyMapping(obj2, &bErr);
24358 0 : if ( bErr )
24359 : {
24360 0 : SWIG_fail;
24361 : }
24362 : }
24363 : else {
24364 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
24365 0 : SWIG_fail;
24366 : }
24367 : }
24368 : }
24369 32 : {
24370 32 : const int bLocalUseExceptions = GetUseExceptions();
24371 32 : if ( bLocalUseExceptions ) {
24372 22 : pushErrorHandler();
24373 : }
24374 32 : {
24375 32 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24376 32 : result = (CPLErr)GDALDatasetShadow_AddBand(arg1,arg2,arg3);
24377 32 : SWIG_PYTHON_THREAD_END_ALLOW;
24378 : }
24379 32 : if ( bLocalUseExceptions ) {
24380 22 : popErrorHandler();
24381 : }
24382 : #ifndef SED_HACKS
24383 : if ( bLocalUseExceptions ) {
24384 : CPLErr eclass = CPLGetLastErrorType();
24385 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24386 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24387 : }
24388 : }
24389 : #endif
24390 : }
24391 32 : resultobj = SWIG_From_int(static_cast< int >(result));
24392 32 : {
24393 : /* %typemap(freearg) char **dict */
24394 32 : CSLDestroy( arg3 );
24395 : }
24396 40 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24397 : return resultobj;
24398 0 : fail:
24399 0 : {
24400 : /* %typemap(freearg) char **dict */
24401 0 : CSLDestroy( arg3 );
24402 : }
24403 : return NULL;
24404 : }
24405 :
24406 :
24407 60 : SWIGINTERN PyObject *_wrap_Dataset_CreateMaskBand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24408 60 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24409 60 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
24410 60 : int arg2 ;
24411 60 : void *argp1 = 0 ;
24412 60 : int res1 = 0 ;
24413 60 : int val2 ;
24414 60 : int ecode2 = 0 ;
24415 60 : PyObject *swig_obj[2] ;
24416 60 : CPLErr result;
24417 :
24418 60 : if (!SWIG_Python_UnpackTuple(args, "Dataset_CreateMaskBand", 2, 2, swig_obj)) SWIG_fail;
24419 60 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
24420 60 : if (!SWIG_IsOK(res1)) {
24421 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_CreateMaskBand" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
24422 : }
24423 60 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
24424 60 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24425 60 : if (!SWIG_IsOK(ecode2)) {
24426 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_CreateMaskBand" "', argument " "2"" of type '" "int""'");
24427 : }
24428 60 : arg2 = static_cast< int >(val2);
24429 60 : {
24430 60 : const int bLocalUseExceptions = GetUseExceptions();
24431 60 : if ( bLocalUseExceptions ) {
24432 22 : pushErrorHandler();
24433 : }
24434 60 : {
24435 60 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24436 60 : result = (CPLErr)GDALDatasetShadow_CreateMaskBand(arg1,arg2);
24437 60 : SWIG_PYTHON_THREAD_END_ALLOW;
24438 : }
24439 60 : if ( bLocalUseExceptions ) {
24440 22 : popErrorHandler();
24441 : }
24442 : #ifndef SED_HACKS
24443 : if ( bLocalUseExceptions ) {
24444 : CPLErr eclass = CPLGetLastErrorType();
24445 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24446 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24447 : }
24448 : }
24449 : #endif
24450 : }
24451 60 : resultobj = SWIG_From_int(static_cast< int >(result));
24452 62 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24453 : return resultobj;
24454 : fail:
24455 : return NULL;
24456 : }
24457 :
24458 :
24459 460 : SWIGINTERN PyObject *_wrap_Dataset_GetFileList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24460 460 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24461 460 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
24462 460 : void *argp1 = 0 ;
24463 460 : int res1 = 0 ;
24464 460 : PyObject *swig_obj[1] ;
24465 460 : char **result = 0 ;
24466 :
24467 460 : if (!args) SWIG_fail;
24468 460 : swig_obj[0] = args;
24469 460 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
24470 460 : if (!SWIG_IsOK(res1)) {
24471 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetFileList" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
24472 : }
24473 460 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
24474 460 : {
24475 460 : const int bLocalUseExceptions = GetUseExceptions();
24476 460 : if ( bLocalUseExceptions ) {
24477 315 : pushErrorHandler();
24478 : }
24479 460 : {
24480 460 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24481 460 : result = (char **)GDALDatasetShadow_GetFileList(arg1);
24482 460 : SWIG_PYTHON_THREAD_END_ALLOW;
24483 : }
24484 460 : if ( bLocalUseExceptions ) {
24485 315 : popErrorHandler();
24486 : }
24487 : #ifndef SED_HACKS
24488 : if ( bLocalUseExceptions ) {
24489 : CPLErr eclass = CPLGetLastErrorType();
24490 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24491 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24492 : }
24493 : }
24494 : #endif
24495 : }
24496 460 : {
24497 : /* %typemap(out) char **CSL -> ( string ) */
24498 460 : bool bErr = false;
24499 460 : resultobj = CSLToList(result, &bErr);
24500 460 : CSLDestroy(result);
24501 460 : if( bErr ) {
24502 0 : SWIG_fail;
24503 : }
24504 : }
24505 462 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24506 : return resultobj;
24507 : fail:
24508 : return NULL;
24509 : }
24510 :
24511 :
24512 176516 : SWIGINTERN PyObject *_wrap_Dataset_WriteRaster(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24513 176516 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24514 176516 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
24515 176516 : int arg2 ;
24516 176516 : int arg3 ;
24517 176516 : int arg4 ;
24518 176516 : int arg5 ;
24519 176516 : GIntBig arg6 ;
24520 176516 : char *arg7 = (char *) 0 ;
24521 176516 : int *arg8 = (int *) 0 ;
24522 176516 : int *arg9 = (int *) 0 ;
24523 176516 : GDALDataType *arg10 = (GDALDataType *) 0 ;
24524 176516 : int arg11 = (int) 0 ;
24525 176516 : int *arg12 = (int *) 0 ;
24526 176516 : GIntBig *arg13 = (GIntBig *) 0 ;
24527 176516 : GIntBig *arg14 = (GIntBig *) 0 ;
24528 176516 : GIntBig *arg15 = (GIntBig *) 0 ;
24529 176516 : void *argp1 = 0 ;
24530 176516 : int res1 = 0 ;
24531 176516 : int val2 ;
24532 176516 : int ecode2 = 0 ;
24533 176516 : int val3 ;
24534 176516 : int ecode3 = 0 ;
24535 176516 : int val4 ;
24536 176516 : int ecode4 = 0 ;
24537 176516 : int val5 ;
24538 176516 : int ecode5 = 0 ;
24539 176516 : int alloc6 = 0 ;
24540 176516 : bool viewIsValid6 = false ;
24541 176516 : Py_buffer view6 ;
24542 176516 : int val8 ;
24543 176516 : int val9 ;
24544 176516 : GDALDataType val10 ;
24545 176516 : GIntBig val13 ;
24546 176516 : GIntBig val14 ;
24547 176516 : GIntBig val15 ;
24548 176516 : PyObject * obj0 = 0 ;
24549 176516 : PyObject * obj1 = 0 ;
24550 176516 : PyObject * obj2 = 0 ;
24551 176516 : PyObject * obj3 = 0 ;
24552 176516 : PyObject * obj4 = 0 ;
24553 176516 : PyObject * obj5 = 0 ;
24554 176516 : PyObject * obj6 = 0 ;
24555 176516 : PyObject * obj7 = 0 ;
24556 176516 : PyObject * obj8 = 0 ;
24557 176516 : PyObject * obj9 = 0 ;
24558 176516 : PyObject * obj10 = 0 ;
24559 176516 : PyObject * obj11 = 0 ;
24560 176516 : PyObject * obj12 = 0 ;
24561 176516 : char * kwnames[] = {
24562 : (char *)"self", (char *)"xoff", (char *)"yoff", (char *)"xsize", (char *)"ysize", (char *)"buf_len", (char *)"buf_xsize", (char *)"buf_ysize", (char *)"buf_type", (char *)"band_list", (char *)"buf_pixel_space", (char *)"buf_line_space", (char *)"buf_band_space", NULL
24563 : };
24564 176516 : CPLErr result;
24565 :
24566 176516 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|OOOOOOO:Dataset_WriteRaster", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12)) SWIG_fail;
24567 176516 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
24568 176516 : if (!SWIG_IsOK(res1)) {
24569 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_WriteRaster" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
24570 : }
24571 176516 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
24572 176516 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24573 176516 : if (!SWIG_IsOK(ecode2)) {
24574 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_WriteRaster" "', argument " "2"" of type '" "int""'");
24575 : }
24576 176516 : arg2 = static_cast< int >(val2);
24577 176516 : ecode3 = SWIG_AsVal_int(obj2, &val3);
24578 176516 : if (!SWIG_IsOK(ecode3)) {
24579 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dataset_WriteRaster" "', argument " "3"" of type '" "int""'");
24580 : }
24581 176516 : arg3 = static_cast< int >(val3);
24582 176516 : ecode4 = SWIG_AsVal_int(obj3, &val4);
24583 176516 : if (!SWIG_IsOK(ecode4)) {
24584 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dataset_WriteRaster" "', argument " "4"" of type '" "int""'");
24585 : }
24586 176516 : arg4 = static_cast< int >(val4);
24587 176516 : ecode5 = SWIG_AsVal_int(obj4, &val5);
24588 176516 : if (!SWIG_IsOK(ecode5)) {
24589 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Dataset_WriteRaster" "', argument " "5"" of type '" "int""'");
24590 : }
24591 176516 : arg5 = static_cast< int >(val5);
24592 176516 : {
24593 : /* %typemap(in,numinputs=1) (GIntBig nLen, char *pBuf ) */
24594 176516 : char* ptr = NULL;
24595 176516 : if( !GetBufferAsCharPtrGIntBigSize(obj5, &arg6, &ptr, &alloc6, &viewIsValid6, &view6) ) {
24596 1 : SWIG_fail;
24597 : }
24598 176515 : arg7 = (char *)ptr;
24599 : }
24600 176515 : if (obj6) {
24601 176515 : {
24602 : /* %typemap(in) (int *optional_##int) */
24603 176515 : if ( obj6 == Py_None ) {
24604 : arg8 = 0;
24605 : }
24606 176515 : else if ( PyArg_Parse( obj6,"i" ,&val8 ) ) {
24607 : arg8 = (int *) &val8;
24608 : }
24609 : else {
24610 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
24611 0 : SWIG_fail;
24612 : }
24613 : }
24614 : }
24615 176515 : if (obj7) {
24616 176515 : {
24617 : /* %typemap(in) (int *optional_##int) */
24618 176515 : if ( obj7 == Py_None ) {
24619 : arg9 = 0;
24620 : }
24621 176515 : else if ( PyArg_Parse( obj7,"i" ,&val9 ) ) {
24622 : arg9 = (int *) &val9;
24623 : }
24624 : else {
24625 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
24626 0 : SWIG_fail;
24627 : }
24628 : }
24629 : }
24630 176515 : if (obj8) {
24631 176515 : {
24632 : /* %typemap(in) (GDALDataType *optional_GDALDataType) */
24633 176515 : int intval = 0;
24634 176515 : if ( obj8 == Py_None ) {
24635 : arg10 = NULL;
24636 : }
24637 353030 : else if ( SWIG_IsOK(SWIG_AsVal_int(obj8, &intval)) ) {
24638 176515 : if( intval < GDT_Unknown || intval >= GDT_TypeCount )
24639 : {
24640 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
24641 : }
24642 176515 : val10 = static_cast<GDALDataType>(intval);
24643 176515 : arg10 = &val10;
24644 : }
24645 : else {
24646 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
24647 0 : SWIG_fail;
24648 : }
24649 : }
24650 : }
24651 176515 : if (obj9) {
24652 176515 : {
24653 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
24654 176515 : arg12 = CreateCIntListFromSequence(obj9, &arg11);
24655 176515 : if( arg11 < 0 ) {
24656 0 : SWIG_fail;
24657 : }
24658 : }
24659 : }
24660 176515 : if (obj10) {
24661 176515 : {
24662 : /* %typemap(in) (GIntBig *optional_##GIntBig) */
24663 176515 : if ( obj10 == Py_None ) {
24664 : arg13 = 0;
24665 : }
24666 24 : else if ( PyArg_Parse( obj10,"L" ,&val13 ) ) {
24667 : arg13 = (GIntBig *) &val13;
24668 : }
24669 : else {
24670 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
24671 0 : SWIG_fail;
24672 : }
24673 : }
24674 : }
24675 176515 : if (obj11) {
24676 176515 : {
24677 : /* %typemap(in) (GIntBig *optional_##GIntBig) */
24678 176515 : if ( obj11 == Py_None ) {
24679 : arg14 = 0;
24680 : }
24681 12 : else if ( PyArg_Parse( obj11,"L" ,&val14 ) ) {
24682 : arg14 = (GIntBig *) &val14;
24683 : }
24684 : else {
24685 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
24686 0 : SWIG_fail;
24687 : }
24688 : }
24689 : }
24690 176515 : if (obj12) {
24691 176515 : {
24692 : /* %typemap(in) (GIntBig *optional_##GIntBig) */
24693 176515 : if ( obj12 == Py_None ) {
24694 : arg15 = 0;
24695 : }
24696 24 : else if ( PyArg_Parse( obj12,"L" ,&val15 ) ) {
24697 : arg15 = (GIntBig *) &val15;
24698 : }
24699 : else {
24700 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
24701 0 : SWIG_fail;
24702 : }
24703 : }
24704 : }
24705 176515 : {
24706 176515 : const int bLocalUseExceptions = GetUseExceptions();
24707 176515 : if ( bLocalUseExceptions ) {
24708 172462 : pushErrorHandler();
24709 : }
24710 176515 : {
24711 176515 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24712 176515 : result = (CPLErr)GDALDatasetShadow_WriteRaster(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
24713 176515 : SWIG_PYTHON_THREAD_END_ALLOW;
24714 : }
24715 176515 : if ( bLocalUseExceptions ) {
24716 172462 : popErrorHandler();
24717 : }
24718 : #ifndef SED_HACKS
24719 : if ( bLocalUseExceptions ) {
24720 : CPLErr eclass = CPLGetLastErrorType();
24721 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24722 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24723 : }
24724 : }
24725 : #endif
24726 : }
24727 176515 : resultobj = SWIG_From_int(static_cast< int >(result));
24728 176515 : {
24729 : /* %typemap(freearg) (GIntBig *nLen, char *pBuf ) */
24730 176515 : if( viewIsValid6 ) {
24731 175505 : PyBuffer_Release(&view6);
24732 : }
24733 1010 : else if (ReturnSame(alloc6) == SWIG_NEWOBJ ) {
24734 1010 : delete[] arg7;
24735 : }
24736 : }
24737 176515 : {
24738 : /* %typemap(freearg) (int nList, int* pList) */
24739 176515 : free(arg12);
24740 : }
24741 176518 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24742 : return resultobj;
24743 1 : fail:
24744 1 : {
24745 : /* %typemap(freearg) (GIntBig *nLen, char *pBuf ) */
24746 1 : if( viewIsValid6 ) {
24747 0 : PyBuffer_Release(&view6);
24748 : }
24749 1 : else if (ReturnSame(alloc6) == SWIG_NEWOBJ ) {
24750 0 : delete[] arg7;
24751 : }
24752 : }
24753 1 : {
24754 : /* %typemap(freearg) (int nList, int* pList) */
24755 1 : free(arg12);
24756 : }
24757 1 : return NULL;
24758 : }
24759 :
24760 :
24761 1 : SWIGINTERN PyObject *_wrap_Dataset_AdviseRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24762 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24763 1 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
24764 1 : int arg2 ;
24765 1 : int arg3 ;
24766 1 : int arg4 ;
24767 1 : int arg5 ;
24768 1 : int *arg6 = (int *) 0 ;
24769 1 : int *arg7 = (int *) 0 ;
24770 1 : GDALDataType *arg8 = (GDALDataType *) 0 ;
24771 1 : int arg9 = (int) 0 ;
24772 1 : int *arg10 = (int *) 0 ;
24773 1 : char **arg11 = (char **) NULL ;
24774 1 : void *argp1 = 0 ;
24775 1 : int res1 = 0 ;
24776 1 : int val2 ;
24777 1 : int ecode2 = 0 ;
24778 1 : int val3 ;
24779 1 : int ecode3 = 0 ;
24780 1 : int val4 ;
24781 1 : int ecode4 = 0 ;
24782 1 : int val5 ;
24783 1 : int ecode5 = 0 ;
24784 1 : void *argp6 = 0 ;
24785 1 : int res6 = 0 ;
24786 1 : void *argp7 = 0 ;
24787 1 : int res7 = 0 ;
24788 1 : int val8 ;
24789 1 : PyObject *swig_obj[10] ;
24790 1 : CPLErr result;
24791 :
24792 1 : if (!SWIG_Python_UnpackTuple(args, "Dataset_AdviseRead", 5, 10, swig_obj)) SWIG_fail;
24793 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
24794 1 : if (!SWIG_IsOK(res1)) {
24795 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_AdviseRead" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
24796 : }
24797 1 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
24798 1 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24799 1 : if (!SWIG_IsOK(ecode2)) {
24800 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_AdviseRead" "', argument " "2"" of type '" "int""'");
24801 : }
24802 1 : arg2 = static_cast< int >(val2);
24803 1 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
24804 1 : if (!SWIG_IsOK(ecode3)) {
24805 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dataset_AdviseRead" "', argument " "3"" of type '" "int""'");
24806 : }
24807 1 : arg3 = static_cast< int >(val3);
24808 1 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
24809 1 : if (!SWIG_IsOK(ecode4)) {
24810 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dataset_AdviseRead" "', argument " "4"" of type '" "int""'");
24811 : }
24812 1 : arg4 = static_cast< int >(val4);
24813 1 : ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
24814 1 : if (!SWIG_IsOK(ecode5)) {
24815 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Dataset_AdviseRead" "', argument " "5"" of type '" "int""'");
24816 : }
24817 1 : arg5 = static_cast< int >(val5);
24818 1 : if (swig_obj[5]) {
24819 0 : res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_int, 0 | 0 );
24820 0 : if (!SWIG_IsOK(res6)) {
24821 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Dataset_AdviseRead" "', argument " "6"" of type '" "int *""'");
24822 : }
24823 0 : arg6 = reinterpret_cast< int * >(argp6);
24824 : }
24825 1 : if (swig_obj[6]) {
24826 0 : res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_int, 0 | 0 );
24827 0 : if (!SWIG_IsOK(res7)) {
24828 0 : SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Dataset_AdviseRead" "', argument " "7"" of type '" "int *""'");
24829 : }
24830 0 : arg7 = reinterpret_cast< int * >(argp7);
24831 : }
24832 1 : if (swig_obj[7]) {
24833 0 : {
24834 : /* %typemap(in) (int *optional_##int) */
24835 0 : if ( swig_obj[7] == Py_None ) {
24836 : arg8 = 0;
24837 : }
24838 0 : else if ( PyArg_Parse( swig_obj[7],"i" ,&val8 ) ) {
24839 : arg8 = (GDALDataType *) &val8;
24840 : }
24841 : else {
24842 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
24843 0 : SWIG_fail;
24844 : }
24845 : }
24846 : }
24847 1 : if (swig_obj[8]) {
24848 0 : {
24849 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
24850 0 : arg10 = CreateCIntListFromSequence(swig_obj[8], &arg9);
24851 0 : if( arg9 < 0 ) {
24852 0 : SWIG_fail;
24853 : }
24854 : }
24855 : }
24856 1 : if (swig_obj[9]) {
24857 0 : {
24858 : /* %typemap(in) char **dict */
24859 0 : arg11 = NULL;
24860 0 : if ( PySequence_Check( swig_obj[9] ) ) {
24861 0 : int bErr = FALSE;
24862 0 : arg11 = CSLFromPySequence(swig_obj[9], &bErr);
24863 0 : if ( bErr )
24864 : {
24865 0 : SWIG_fail;
24866 : }
24867 : }
24868 0 : else if ( PyMapping_Check( swig_obj[9] ) ) {
24869 0 : int bErr = FALSE;
24870 0 : arg11 = CSLFromPyMapping(swig_obj[9], &bErr);
24871 0 : if ( bErr )
24872 : {
24873 0 : SWIG_fail;
24874 : }
24875 : }
24876 : else {
24877 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
24878 0 : SWIG_fail;
24879 : }
24880 : }
24881 : }
24882 1 : {
24883 1 : const int bLocalUseExceptions = GetUseExceptions();
24884 1 : if ( bLocalUseExceptions ) {
24885 0 : pushErrorHandler();
24886 : }
24887 1 : {
24888 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24889 1 : result = (CPLErr)GDALDatasetShadow_AdviseRead(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
24890 1 : SWIG_PYTHON_THREAD_END_ALLOW;
24891 : }
24892 1 : if ( bLocalUseExceptions ) {
24893 0 : popErrorHandler();
24894 : }
24895 : #ifndef SED_HACKS
24896 : if ( bLocalUseExceptions ) {
24897 : CPLErr eclass = CPLGetLastErrorType();
24898 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
24899 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
24900 : }
24901 : }
24902 : #endif
24903 : }
24904 1 : resultobj = SWIG_From_int(static_cast< int >(result));
24905 1 : {
24906 : /* %typemap(freearg) (int nList, int* pList) */
24907 1 : free(arg10);
24908 : }
24909 1 : {
24910 : /* %typemap(freearg) char **dict */
24911 1 : CSLDestroy( arg11 );
24912 : }
24913 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
24914 : return resultobj;
24915 0 : fail:
24916 0 : {
24917 : /* %typemap(freearg) (int nList, int* pList) */
24918 0 : free(arg10);
24919 : }
24920 0 : {
24921 : /* %typemap(freearg) char **dict */
24922 0 : CSLDestroy( arg11 );
24923 : }
24924 : return NULL;
24925 : }
24926 :
24927 :
24928 2 : SWIGINTERN PyObject *_wrap_Dataset_BeginAsyncReader(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24929 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
24930 2 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
24931 2 : int arg2 ;
24932 2 : int arg3 ;
24933 2 : int arg4 ;
24934 2 : int arg5 ;
24935 2 : size_t arg6 ;
24936 2 : char *arg7 = (char *) 0 ;
24937 2 : void *arg8 = (void *) 0 ;
24938 2 : int arg9 ;
24939 2 : int arg10 ;
24940 2 : GDALDataType arg11 = (GDALDataType) (GDALDataType) 0 ;
24941 2 : int arg12 = (int) 0 ;
24942 2 : int *arg13 = (int *) 0 ;
24943 2 : int arg14 = (int) 0 ;
24944 2 : int arg15 = (int) 0 ;
24945 2 : int arg16 = (int) 0 ;
24946 2 : char **arg17 = (char **) 0 ;
24947 2 : void *argp1 = 0 ;
24948 2 : int res1 = 0 ;
24949 2 : int val2 ;
24950 2 : int ecode2 = 0 ;
24951 2 : int val3 ;
24952 2 : int ecode3 = 0 ;
24953 2 : int val4 ;
24954 2 : int ecode4 = 0 ;
24955 2 : int val5 ;
24956 2 : int ecode5 = 0 ;
24957 2 : int val9 ;
24958 2 : int ecode9 = 0 ;
24959 2 : int val10 ;
24960 2 : int ecode10 = 0 ;
24961 2 : int val14 ;
24962 2 : int ecode14 = 0 ;
24963 2 : int val15 ;
24964 2 : int ecode15 = 0 ;
24965 2 : int val16 ;
24966 2 : int ecode16 = 0 ;
24967 2 : PyObject * obj0 = 0 ;
24968 2 : PyObject * obj1 = 0 ;
24969 2 : PyObject * obj2 = 0 ;
24970 2 : PyObject * obj3 = 0 ;
24971 2 : PyObject * obj4 = 0 ;
24972 2 : PyObject * obj5 = 0 ;
24973 2 : PyObject * obj6 = 0 ;
24974 2 : PyObject * obj7 = 0 ;
24975 2 : PyObject * obj8 = 0 ;
24976 2 : PyObject * obj9 = 0 ;
24977 2 : PyObject * obj10 = 0 ;
24978 2 : PyObject * obj11 = 0 ;
24979 2 : PyObject * obj12 = 0 ;
24980 2 : PyObject * obj13 = 0 ;
24981 2 : char * kwnames[] = {
24982 : (char *)"self", (char *)"xOff", (char *)"yOff", (char *)"xSize", (char *)"ySize", (char *)"buf_len", (char *)"buf_xsize", (char *)"buf_ysize", (char *)"bufType", (char *)"band_list", (char *)"nPixelSpace", (char *)"nLineSpace", (char *)"nBandSpace", (char *)"options", NULL
24983 : };
24984 2 : GDALAsyncReaderShadow *result = 0 ;
24985 :
24986 2 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO|OOOOOO:Dataset_BeginAsyncReader", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13)) SWIG_fail;
24987 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
24988 2 : if (!SWIG_IsOK(res1)) {
24989 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_BeginAsyncReader" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
24990 : }
24991 2 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
24992 2 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24993 2 : if (!SWIG_IsOK(ecode2)) {
24994 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_BeginAsyncReader" "', argument " "2"" of type '" "int""'");
24995 : }
24996 2 : arg2 = static_cast< int >(val2);
24997 2 : ecode3 = SWIG_AsVal_int(obj2, &val3);
24998 2 : if (!SWIG_IsOK(ecode3)) {
24999 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dataset_BeginAsyncReader" "', argument " "3"" of type '" "int""'");
25000 : }
25001 2 : arg3 = static_cast< int >(val3);
25002 2 : ecode4 = SWIG_AsVal_int(obj3, &val4);
25003 2 : if (!SWIG_IsOK(ecode4)) {
25004 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dataset_BeginAsyncReader" "', argument " "4"" of type '" "int""'");
25005 : }
25006 2 : arg4 = static_cast< int >(val4);
25007 2 : ecode5 = SWIG_AsVal_int(obj4, &val5);
25008 2 : if (!SWIG_IsOK(ecode5)) {
25009 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Dataset_BeginAsyncReader" "', argument " "5"" of type '" "int""'");
25010 : }
25011 2 : arg5 = static_cast< int >(val5);
25012 2 : {
25013 : /* %typemap(in,numinputs=1) (size_t nLenKeepObject, char *pBufKeepObject, void* pyObject) */
25014 2 : if (PyBytes_Check(obj5))
25015 : {
25016 2 : Py_ssize_t safeLen = 0;
25017 2 : PyBytes_AsStringAndSize(obj5, (char**) &arg7, &safeLen);
25018 2 : arg6 = safeLen;
25019 2 : arg8 = obj5;
25020 : }
25021 : else
25022 : {
25023 0 : PyErr_SetString(PyExc_TypeError, "not a bytes");
25024 0 : SWIG_fail;
25025 : }
25026 : }
25027 2 : ecode9 = SWIG_AsVal_int(obj6, &val9);
25028 2 : if (!SWIG_IsOK(ecode9)) {
25029 0 : SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Dataset_BeginAsyncReader" "', argument " "9"" of type '" "int""'");
25030 : }
25031 2 : arg9 = static_cast< int >(val9);
25032 2 : ecode10 = SWIG_AsVal_int(obj7, &val10);
25033 2 : if (!SWIG_IsOK(ecode10)) {
25034 0 : SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Dataset_BeginAsyncReader" "', argument " "10"" of type '" "int""'");
25035 : }
25036 2 : arg10 = static_cast< int >(val10);
25037 2 : if (obj8) {
25038 2 : {
25039 : // %typemap(in) GDALDataType
25040 2 : int val = 0;
25041 2 : int ecode = SWIG_AsVal_int(obj8, &val);
25042 2 : if (!SWIG_IsOK(ecode)) {
25043 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
25044 : }
25045 2 : if( val < GDT_Unknown || val >= GDT_TypeCount )
25046 : {
25047 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
25048 : }
25049 : arg11 = static_cast<GDALDataType>(val);
25050 : }
25051 : }
25052 2 : if (obj9) {
25053 2 : {
25054 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
25055 2 : arg13 = CreateCIntListFromSequence(obj9, &arg12);
25056 2 : if( arg12 < 0 ) {
25057 0 : SWIG_fail;
25058 : }
25059 : }
25060 : }
25061 2 : if (obj10) {
25062 2 : ecode14 = SWIG_AsVal_int(obj10, &val14);
25063 2 : if (!SWIG_IsOK(ecode14)) {
25064 0 : SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Dataset_BeginAsyncReader" "', argument " "14"" of type '" "int""'");
25065 : }
25066 : arg14 = static_cast< int >(val14);
25067 : }
25068 2 : if (obj11) {
25069 2 : ecode15 = SWIG_AsVal_int(obj11, &val15);
25070 2 : if (!SWIG_IsOK(ecode15)) {
25071 0 : SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Dataset_BeginAsyncReader" "', argument " "15"" of type '" "int""'");
25072 : }
25073 : arg15 = static_cast< int >(val15);
25074 : }
25075 2 : if (obj12) {
25076 2 : ecode16 = SWIG_AsVal_int(obj12, &val16);
25077 2 : if (!SWIG_IsOK(ecode16)) {
25078 0 : SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Dataset_BeginAsyncReader" "', argument " "16"" of type '" "int""'");
25079 : }
25080 : arg16 = static_cast< int >(val16);
25081 : }
25082 2 : if (obj13) {
25083 2 : {
25084 : /* %typemap(in) char **dict */
25085 2 : arg17 = NULL;
25086 2 : if ( PySequence_Check( obj13 ) ) {
25087 2 : int bErr = FALSE;
25088 2 : arg17 = CSLFromPySequence(obj13, &bErr);
25089 2 : if ( bErr )
25090 : {
25091 0 : SWIG_fail;
25092 : }
25093 : }
25094 0 : else if ( PyMapping_Check( obj13 ) ) {
25095 0 : int bErr = FALSE;
25096 0 : arg17 = CSLFromPyMapping(obj13, &bErr);
25097 0 : if ( bErr )
25098 : {
25099 0 : SWIG_fail;
25100 : }
25101 : }
25102 : else {
25103 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
25104 0 : SWIG_fail;
25105 : }
25106 : }
25107 : }
25108 2 : {
25109 2 : const int bLocalUseExceptions = GetUseExceptions();
25110 2 : if ( bLocalUseExceptions ) {
25111 2 : pushErrorHandler();
25112 : }
25113 2 : {
25114 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25115 2 : result = (GDALAsyncReaderShadow *)GDALDatasetShadow_BeginAsyncReader(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
25116 2 : SWIG_PYTHON_THREAD_END_ALLOW;
25117 : }
25118 2 : if ( bLocalUseExceptions ) {
25119 2 : popErrorHandler();
25120 : }
25121 : #ifndef SED_HACKS
25122 : if ( bLocalUseExceptions ) {
25123 : CPLErr eclass = CPLGetLastErrorType();
25124 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25125 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25126 : }
25127 : }
25128 : #endif
25129 : }
25130 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALAsyncReaderShadow, SWIG_POINTER_OWN | 0 );
25131 2 : {
25132 : /* %typemap(freearg) (int nList, int* pList) */
25133 2 : free(arg13);
25134 : }
25135 2 : {
25136 : /* %typemap(freearg) char **dict */
25137 2 : CSLDestroy( arg17 );
25138 : }
25139 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25140 : return resultobj;
25141 0 : fail:
25142 0 : {
25143 : /* %typemap(freearg) (int nList, int* pList) */
25144 0 : free(arg13);
25145 : }
25146 0 : {
25147 : /* %typemap(freearg) char **dict */
25148 0 : CSLDestroy( arg17 );
25149 : }
25150 : return NULL;
25151 : }
25152 :
25153 :
25154 1 : SWIGINTERN PyObject *_wrap_Dataset_EndAsyncReader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25155 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25156 1 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
25157 1 : GDALAsyncReaderShadow *arg2 = (GDALAsyncReaderShadow *) 0 ;
25158 1 : void *argp1 = 0 ;
25159 1 : int res1 = 0 ;
25160 1 : void *argp2 = 0 ;
25161 1 : int res2 = 0 ;
25162 1 : PyObject *swig_obj[2] ;
25163 :
25164 1 : if (!SWIG_Python_UnpackTuple(args, "Dataset_EndAsyncReader", 2, 2, swig_obj)) SWIG_fail;
25165 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
25166 1 : if (!SWIG_IsOK(res1)) {
25167 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_EndAsyncReader" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
25168 : }
25169 1 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
25170 1 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALAsyncReaderShadow, 0 | 0 );
25171 1 : if (!SWIG_IsOK(res2)) {
25172 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_EndAsyncReader" "', argument " "2"" of type '" "GDALAsyncReaderShadow *""'");
25173 : }
25174 1 : arg2 = reinterpret_cast< GDALAsyncReaderShadow * >(argp2);
25175 1 : {
25176 1 : const int bLocalUseExceptions = GetUseExceptions();
25177 1 : if ( bLocalUseExceptions ) {
25178 1 : pushErrorHandler();
25179 : }
25180 1 : {
25181 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25182 1 : GDALDatasetShadow_EndAsyncReader(arg1,arg2);
25183 1 : SWIG_PYTHON_THREAD_END_ALLOW;
25184 : }
25185 1 : if ( bLocalUseExceptions ) {
25186 1 : popErrorHandler();
25187 : }
25188 : #ifndef SED_HACKS
25189 : if ( bLocalUseExceptions ) {
25190 : CPLErr eclass = CPLGetLastErrorType();
25191 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25192 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25193 : }
25194 : }
25195 : #endif
25196 : }
25197 1 : resultobj = SWIG_Py_Void();
25198 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25199 : return resultobj;
25200 : fail:
25201 : return NULL;
25202 : }
25203 :
25204 :
25205 3 : SWIGINTERN PyObject *_wrap_Dataset_GetVirtualMem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25206 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25207 3 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
25208 3 : GDALRWFlag arg2 ;
25209 3 : int arg3 ;
25210 3 : int arg4 ;
25211 3 : int arg5 ;
25212 3 : int arg6 ;
25213 3 : int arg7 ;
25214 3 : int arg8 ;
25215 3 : GDALDataType arg9 ;
25216 3 : int arg10 ;
25217 3 : int *arg11 = (int *) 0 ;
25218 3 : int arg12 ;
25219 3 : size_t arg13 ;
25220 3 : size_t arg14 ;
25221 3 : char **arg15 = (char **) NULL ;
25222 3 : void *argp1 = 0 ;
25223 3 : int res1 = 0 ;
25224 3 : int val2 ;
25225 3 : int ecode2 = 0 ;
25226 3 : int val3 ;
25227 3 : int ecode3 = 0 ;
25228 3 : int val4 ;
25229 3 : int ecode4 = 0 ;
25230 3 : int val5 ;
25231 3 : int ecode5 = 0 ;
25232 3 : int val6 ;
25233 3 : int ecode6 = 0 ;
25234 3 : int val7 ;
25235 3 : int ecode7 = 0 ;
25236 3 : int val8 ;
25237 3 : int ecode8 = 0 ;
25238 3 : int val12 ;
25239 3 : int ecode12 = 0 ;
25240 3 : size_t val13 ;
25241 3 : int ecode13 = 0 ;
25242 3 : size_t val14 ;
25243 3 : int ecode14 = 0 ;
25244 3 : PyObject * obj0 = 0 ;
25245 3 : PyObject * obj1 = 0 ;
25246 3 : PyObject * obj2 = 0 ;
25247 3 : PyObject * obj3 = 0 ;
25248 3 : PyObject * obj4 = 0 ;
25249 3 : PyObject * obj5 = 0 ;
25250 3 : PyObject * obj6 = 0 ;
25251 3 : PyObject * obj7 = 0 ;
25252 3 : PyObject * obj8 = 0 ;
25253 3 : PyObject * obj9 = 0 ;
25254 3 : PyObject * obj10 = 0 ;
25255 3 : PyObject * obj11 = 0 ;
25256 3 : PyObject * obj12 = 0 ;
25257 3 : PyObject * obj13 = 0 ;
25258 3 : char * kwnames[] = {
25259 : (char *)"self", (char *)"eRWFlag", (char *)"nXOff", (char *)"nYOff", (char *)"nXSize", (char *)"nYSize", (char *)"nBufXSize", (char *)"nBufYSize", (char *)"eBufType", (char *)"band_list", (char *)"bIsBandSequential", (char *)"nCacheSize", (char *)"nPageSizeHint", (char *)"options", NULL
25260 : };
25261 3 : CPLVirtualMemShadow *result = 0 ;
25262 :
25263 3 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOOOO|O:Dataset_GetVirtualMem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13)) SWIG_fail;
25264 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
25265 3 : if (!SWIG_IsOK(res1)) {
25266 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetVirtualMem" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
25267 : }
25268 3 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
25269 3 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25270 3 : if (!SWIG_IsOK(ecode2)) {
25271 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_GetVirtualMem" "', argument " "2"" of type '" "GDALRWFlag""'");
25272 : }
25273 3 : arg2 = static_cast< GDALRWFlag >(val2);
25274 3 : ecode3 = SWIG_AsVal_int(obj2, &val3);
25275 3 : if (!SWIG_IsOK(ecode3)) {
25276 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dataset_GetVirtualMem" "', argument " "3"" of type '" "int""'");
25277 : }
25278 3 : arg3 = static_cast< int >(val3);
25279 3 : ecode4 = SWIG_AsVal_int(obj3, &val4);
25280 3 : if (!SWIG_IsOK(ecode4)) {
25281 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dataset_GetVirtualMem" "', argument " "4"" of type '" "int""'");
25282 : }
25283 3 : arg4 = static_cast< int >(val4);
25284 3 : ecode5 = SWIG_AsVal_int(obj4, &val5);
25285 3 : if (!SWIG_IsOK(ecode5)) {
25286 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Dataset_GetVirtualMem" "', argument " "5"" of type '" "int""'");
25287 : }
25288 3 : arg5 = static_cast< int >(val5);
25289 3 : ecode6 = SWIG_AsVal_int(obj5, &val6);
25290 3 : if (!SWIG_IsOK(ecode6)) {
25291 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Dataset_GetVirtualMem" "', argument " "6"" of type '" "int""'");
25292 : }
25293 3 : arg6 = static_cast< int >(val6);
25294 3 : ecode7 = SWIG_AsVal_int(obj6, &val7);
25295 3 : if (!SWIG_IsOK(ecode7)) {
25296 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Dataset_GetVirtualMem" "', argument " "7"" of type '" "int""'");
25297 : }
25298 3 : arg7 = static_cast< int >(val7);
25299 3 : ecode8 = SWIG_AsVal_int(obj7, &val8);
25300 3 : if (!SWIG_IsOK(ecode8)) {
25301 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Dataset_GetVirtualMem" "', argument " "8"" of type '" "int""'");
25302 : }
25303 3 : arg8 = static_cast< int >(val8);
25304 3 : {
25305 : // %typemap(in) GDALDataType
25306 3 : int val = 0;
25307 3 : int ecode = SWIG_AsVal_int(obj8, &val);
25308 3 : if (!SWIG_IsOK(ecode)) {
25309 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
25310 : }
25311 3 : if( val < GDT_Unknown || val >= GDT_TypeCount )
25312 : {
25313 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
25314 : }
25315 3 : arg9 = static_cast<GDALDataType>(val);
25316 : }
25317 3 : {
25318 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
25319 3 : arg11 = CreateCIntListFromSequence(obj9, &arg10);
25320 3 : if( arg10 < 0 ) {
25321 0 : SWIG_fail;
25322 : }
25323 : }
25324 3 : ecode12 = SWIG_AsVal_int(obj10, &val12);
25325 3 : if (!SWIG_IsOK(ecode12)) {
25326 0 : SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Dataset_GetVirtualMem" "', argument " "12"" of type '" "int""'");
25327 : }
25328 3 : arg12 = static_cast< int >(val12);
25329 3 : ecode13 = SWIG_AsVal_size_t(obj11, &val13);
25330 3 : if (!SWIG_IsOK(ecode13)) {
25331 0 : SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Dataset_GetVirtualMem" "', argument " "13"" of type '" "size_t""'");
25332 : }
25333 3 : arg13 = static_cast< size_t >(val13);
25334 3 : ecode14 = SWIG_AsVal_size_t(obj12, &val14);
25335 3 : if (!SWIG_IsOK(ecode14)) {
25336 0 : SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Dataset_GetVirtualMem" "', argument " "14"" of type '" "size_t""'");
25337 : }
25338 3 : arg14 = static_cast< size_t >(val14);
25339 3 : if (obj13) {
25340 0 : {
25341 : /* %typemap(in) char **dict */
25342 0 : arg15 = NULL;
25343 0 : if ( PySequence_Check( obj13 ) ) {
25344 0 : int bErr = FALSE;
25345 0 : arg15 = CSLFromPySequence(obj13, &bErr);
25346 0 : if ( bErr )
25347 : {
25348 0 : SWIG_fail;
25349 : }
25350 : }
25351 0 : else if ( PyMapping_Check( obj13 ) ) {
25352 0 : int bErr = FALSE;
25353 0 : arg15 = CSLFromPyMapping(obj13, &bErr);
25354 0 : if ( bErr )
25355 : {
25356 0 : SWIG_fail;
25357 : }
25358 : }
25359 : else {
25360 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
25361 0 : SWIG_fail;
25362 : }
25363 : }
25364 : }
25365 3 : {
25366 3 : const int bLocalUseExceptions = GetUseExceptions();
25367 3 : if ( bLocalUseExceptions ) {
25368 3 : pushErrorHandler();
25369 : }
25370 3 : {
25371 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25372 3 : result = (CPLVirtualMemShadow *)GDALDatasetShadow_GetVirtualMem(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
25373 3 : SWIG_PYTHON_THREAD_END_ALLOW;
25374 : }
25375 3 : if ( bLocalUseExceptions ) {
25376 3 : popErrorHandler();
25377 : }
25378 : #ifndef SED_HACKS
25379 : if ( bLocalUseExceptions ) {
25380 : CPLErr eclass = CPLGetLastErrorType();
25381 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25382 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25383 : }
25384 : }
25385 : #endif
25386 : }
25387 3 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CPLVirtualMemShadow, SWIG_POINTER_OWN | 0 );
25388 3 : {
25389 : /* %typemap(freearg) (int nList, int* pList) */
25390 3 : free(arg11);
25391 : }
25392 3 : {
25393 : /* %typemap(freearg) char **dict */
25394 3 : CSLDestroy( arg15 );
25395 : }
25396 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25397 : return resultobj;
25398 0 : fail:
25399 0 : {
25400 : /* %typemap(freearg) (int nList, int* pList) */
25401 0 : free(arg11);
25402 : }
25403 0 : {
25404 : /* %typemap(freearg) char **dict */
25405 0 : CSLDestroy( arg15 );
25406 : }
25407 : return NULL;
25408 : }
25409 :
25410 :
25411 3 : SWIGINTERN PyObject *_wrap_Dataset_GetTiledVirtualMem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25412 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25413 3 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
25414 3 : GDALRWFlag arg2 ;
25415 3 : int arg3 ;
25416 3 : int arg4 ;
25417 3 : int arg5 ;
25418 3 : int arg6 ;
25419 3 : int arg7 ;
25420 3 : int arg8 ;
25421 3 : GDALDataType arg9 ;
25422 3 : int arg10 ;
25423 3 : int *arg11 = (int *) 0 ;
25424 3 : GDALTileOrganization arg12 ;
25425 3 : size_t arg13 ;
25426 3 : char **arg14 = (char **) NULL ;
25427 3 : void *argp1 = 0 ;
25428 3 : int res1 = 0 ;
25429 3 : int val2 ;
25430 3 : int ecode2 = 0 ;
25431 3 : int val3 ;
25432 3 : int ecode3 = 0 ;
25433 3 : int val4 ;
25434 3 : int ecode4 = 0 ;
25435 3 : int val5 ;
25436 3 : int ecode5 = 0 ;
25437 3 : int val6 ;
25438 3 : int ecode6 = 0 ;
25439 3 : int val7 ;
25440 3 : int ecode7 = 0 ;
25441 3 : int val8 ;
25442 3 : int ecode8 = 0 ;
25443 3 : int val12 ;
25444 3 : int ecode12 = 0 ;
25445 3 : size_t val13 ;
25446 3 : int ecode13 = 0 ;
25447 3 : PyObject * obj0 = 0 ;
25448 3 : PyObject * obj1 = 0 ;
25449 3 : PyObject * obj2 = 0 ;
25450 3 : PyObject * obj3 = 0 ;
25451 3 : PyObject * obj4 = 0 ;
25452 3 : PyObject * obj5 = 0 ;
25453 3 : PyObject * obj6 = 0 ;
25454 3 : PyObject * obj7 = 0 ;
25455 3 : PyObject * obj8 = 0 ;
25456 3 : PyObject * obj9 = 0 ;
25457 3 : PyObject * obj10 = 0 ;
25458 3 : PyObject * obj11 = 0 ;
25459 3 : PyObject * obj12 = 0 ;
25460 3 : char * kwnames[] = {
25461 : (char *)"self", (char *)"eRWFlag", (char *)"nXOff", (char *)"nYOff", (char *)"nXSize", (char *)"nYSize", (char *)"nTileXSize", (char *)"nTileYSize", (char *)"eBufType", (char *)"band_list", (char *)"eTileOrganization", (char *)"nCacheSize", (char *)"options", NULL
25462 : };
25463 3 : CPLVirtualMemShadow *result = 0 ;
25464 :
25465 3 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOOO|O:Dataset_GetTiledVirtualMem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12)) SWIG_fail;
25466 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
25467 3 : if (!SWIG_IsOK(res1)) {
25468 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetTiledVirtualMem" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
25469 : }
25470 3 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
25471 3 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25472 3 : if (!SWIG_IsOK(ecode2)) {
25473 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_GetTiledVirtualMem" "', argument " "2"" of type '" "GDALRWFlag""'");
25474 : }
25475 3 : arg2 = static_cast< GDALRWFlag >(val2);
25476 3 : ecode3 = SWIG_AsVal_int(obj2, &val3);
25477 3 : if (!SWIG_IsOK(ecode3)) {
25478 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dataset_GetTiledVirtualMem" "', argument " "3"" of type '" "int""'");
25479 : }
25480 3 : arg3 = static_cast< int >(val3);
25481 3 : ecode4 = SWIG_AsVal_int(obj3, &val4);
25482 3 : if (!SWIG_IsOK(ecode4)) {
25483 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dataset_GetTiledVirtualMem" "', argument " "4"" of type '" "int""'");
25484 : }
25485 3 : arg4 = static_cast< int >(val4);
25486 3 : ecode5 = SWIG_AsVal_int(obj4, &val5);
25487 3 : if (!SWIG_IsOK(ecode5)) {
25488 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Dataset_GetTiledVirtualMem" "', argument " "5"" of type '" "int""'");
25489 : }
25490 3 : arg5 = static_cast< int >(val5);
25491 3 : ecode6 = SWIG_AsVal_int(obj5, &val6);
25492 3 : if (!SWIG_IsOK(ecode6)) {
25493 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Dataset_GetTiledVirtualMem" "', argument " "6"" of type '" "int""'");
25494 : }
25495 3 : arg6 = static_cast< int >(val6);
25496 3 : ecode7 = SWIG_AsVal_int(obj6, &val7);
25497 3 : if (!SWIG_IsOK(ecode7)) {
25498 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Dataset_GetTiledVirtualMem" "', argument " "7"" of type '" "int""'");
25499 : }
25500 3 : arg7 = static_cast< int >(val7);
25501 3 : ecode8 = SWIG_AsVal_int(obj7, &val8);
25502 3 : if (!SWIG_IsOK(ecode8)) {
25503 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Dataset_GetTiledVirtualMem" "', argument " "8"" of type '" "int""'");
25504 : }
25505 3 : arg8 = static_cast< int >(val8);
25506 3 : {
25507 : // %typemap(in) GDALDataType
25508 3 : int val = 0;
25509 3 : int ecode = SWIG_AsVal_int(obj8, &val);
25510 3 : if (!SWIG_IsOK(ecode)) {
25511 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
25512 : }
25513 3 : if( val < GDT_Unknown || val >= GDT_TypeCount )
25514 : {
25515 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
25516 : }
25517 3 : arg9 = static_cast<GDALDataType>(val);
25518 : }
25519 3 : {
25520 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
25521 3 : arg11 = CreateCIntListFromSequence(obj9, &arg10);
25522 3 : if( arg10 < 0 ) {
25523 0 : SWIG_fail;
25524 : }
25525 : }
25526 3 : ecode12 = SWIG_AsVal_int(obj10, &val12);
25527 3 : if (!SWIG_IsOK(ecode12)) {
25528 0 : SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Dataset_GetTiledVirtualMem" "', argument " "12"" of type '" "GDALTileOrganization""'");
25529 : }
25530 3 : arg12 = static_cast< GDALTileOrganization >(val12);
25531 3 : ecode13 = SWIG_AsVal_size_t(obj11, &val13);
25532 3 : if (!SWIG_IsOK(ecode13)) {
25533 0 : SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Dataset_GetTiledVirtualMem" "', argument " "13"" of type '" "size_t""'");
25534 : }
25535 3 : arg13 = static_cast< size_t >(val13);
25536 3 : if (obj12) {
25537 0 : {
25538 : /* %typemap(in) char **dict */
25539 0 : arg14 = NULL;
25540 0 : if ( PySequence_Check( obj12 ) ) {
25541 0 : int bErr = FALSE;
25542 0 : arg14 = CSLFromPySequence(obj12, &bErr);
25543 0 : if ( bErr )
25544 : {
25545 0 : SWIG_fail;
25546 : }
25547 : }
25548 0 : else if ( PyMapping_Check( obj12 ) ) {
25549 0 : int bErr = FALSE;
25550 0 : arg14 = CSLFromPyMapping(obj12, &bErr);
25551 0 : if ( bErr )
25552 : {
25553 0 : SWIG_fail;
25554 : }
25555 : }
25556 : else {
25557 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
25558 0 : SWIG_fail;
25559 : }
25560 : }
25561 : }
25562 3 : {
25563 3 : const int bLocalUseExceptions = GetUseExceptions();
25564 3 : if ( bLocalUseExceptions ) {
25565 3 : pushErrorHandler();
25566 : }
25567 3 : {
25568 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25569 3 : result = (CPLVirtualMemShadow *)GDALDatasetShadow_GetTiledVirtualMem(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
25570 3 : SWIG_PYTHON_THREAD_END_ALLOW;
25571 : }
25572 3 : if ( bLocalUseExceptions ) {
25573 3 : popErrorHandler();
25574 : }
25575 : #ifndef SED_HACKS
25576 : if ( bLocalUseExceptions ) {
25577 : CPLErr eclass = CPLGetLastErrorType();
25578 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25579 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25580 : }
25581 : }
25582 : #endif
25583 : }
25584 3 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CPLVirtualMemShadow, SWIG_POINTER_OWN | 0 );
25585 3 : {
25586 : /* %typemap(freearg) (int nList, int* pList) */
25587 3 : free(arg11);
25588 : }
25589 3 : {
25590 : /* %typemap(freearg) char **dict */
25591 3 : CSLDestroy( arg14 );
25592 : }
25593 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25594 : return resultobj;
25595 0 : fail:
25596 0 : {
25597 : /* %typemap(freearg) (int nList, int* pList) */
25598 0 : free(arg11);
25599 : }
25600 0 : {
25601 : /* %typemap(freearg) char **dict */
25602 0 : CSLDestroy( arg14 );
25603 : }
25604 : return NULL;
25605 : }
25606 :
25607 :
25608 6225 : SWIGINTERN PyObject *_wrap_Dataset_CreateLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25609 6225 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25610 6225 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
25611 6225 : char *arg2 = (char *) 0 ;
25612 6225 : OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) NULL ;
25613 6225 : OGRwkbGeometryType arg4 = (OGRwkbGeometryType) wkbUnknown ;
25614 6225 : char **arg5 = (char **) 0 ;
25615 6225 : void *argp1 = 0 ;
25616 6225 : int res1 = 0 ;
25617 6225 : int res2 ;
25618 6225 : char *buf2 = 0 ;
25619 6225 : int alloc2 = 0 ;
25620 6225 : void *argp3 = 0 ;
25621 6225 : int res3 = 0 ;
25622 6225 : int val4 ;
25623 6225 : int ecode4 = 0 ;
25624 6225 : PyObject * obj0 = 0 ;
25625 6225 : PyObject * obj1 = 0 ;
25626 6225 : PyObject * obj2 = 0 ;
25627 6225 : PyObject * obj3 = 0 ;
25628 6225 : PyObject * obj4 = 0 ;
25629 6225 : char * kwnames[] = {
25630 : (char *)"self", (char *)"name", (char *)"srs", (char *)"geom_type", (char *)"options", NULL
25631 : };
25632 6225 : OGRLayerShadow *result = 0 ;
25633 :
25634 6225 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:Dataset_CreateLayer", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
25635 6225 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
25636 6225 : if (!SWIG_IsOK(res1)) {
25637 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_CreateLayer" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
25638 : }
25639 6225 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
25640 6225 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
25641 6225 : if (!SWIG_IsOK(res2)) {
25642 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_CreateLayer" "', argument " "2"" of type '" "char const *""'");
25643 : }
25644 6225 : arg2 = reinterpret_cast< char * >(buf2);
25645 6225 : if (obj2) {
25646 1330 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
25647 1330 : if (!SWIG_IsOK(res3)) {
25648 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Dataset_CreateLayer" "', argument " "3"" of type '" "OSRSpatialReferenceShadow *""'");
25649 : }
25650 1330 : arg3 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp3);
25651 : }
25652 6225 : if (obj3) {
25653 1941 : ecode4 = SWIG_AsVal_int(obj3, &val4);
25654 1941 : if (!SWIG_IsOK(ecode4)) {
25655 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dataset_CreateLayer" "', argument " "4"" of type '" "OGRwkbGeometryType""'");
25656 : }
25657 1941 : arg4 = static_cast< OGRwkbGeometryType >(val4);
25658 : }
25659 6225 : if (obj4) {
25660 1229 : {
25661 : /* %typemap(in) char **dict */
25662 1229 : arg5 = NULL;
25663 1229 : if ( PySequence_Check( obj4 ) ) {
25664 1197 : int bErr = FALSE;
25665 1197 : arg5 = CSLFromPySequence(obj4, &bErr);
25666 1197 : if ( bErr )
25667 : {
25668 0 : SWIG_fail;
25669 : }
25670 : }
25671 32 : else if ( PyMapping_Check( obj4 ) ) {
25672 32 : int bErr = FALSE;
25673 32 : arg5 = CSLFromPyMapping(obj4, &bErr);
25674 32 : if ( bErr )
25675 : {
25676 0 : SWIG_fail;
25677 : }
25678 : }
25679 : else {
25680 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
25681 0 : SWIG_fail;
25682 : }
25683 : }
25684 : }
25685 6225 : {
25686 6225 : const int bLocalUseExceptions = GetUseExceptions();
25687 6225 : if ( bLocalUseExceptions ) {
25688 2159 : pushErrorHandler();
25689 : }
25690 6225 : {
25691 6225 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25692 6225 : result = (OGRLayerShadow *)GDALDatasetShadow_CreateLayer(arg1,(char const *)arg2,arg3,arg4,arg5);
25693 6225 : SWIG_PYTHON_THREAD_END_ALLOW;
25694 : }
25695 6225 : if ( bLocalUseExceptions ) {
25696 2159 : popErrorHandler();
25697 : }
25698 : #ifndef SED_HACKS
25699 : if ( bLocalUseExceptions ) {
25700 : CPLErr eclass = CPLGetLastErrorType();
25701 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25702 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25703 : }
25704 : }
25705 : #endif
25706 : }
25707 6225 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
25708 6225 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25709 6225 : {
25710 : /* %typemap(freearg) char **dict */
25711 6225 : CSLDestroy( arg5 );
25712 : }
25713 6285 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25714 : return resultobj;
25715 0 : fail:
25716 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25717 0 : {
25718 : /* %typemap(freearg) char **dict */
25719 0 : CSLDestroy( arg5 );
25720 : }
25721 : return NULL;
25722 : }
25723 :
25724 :
25725 14 : SWIGINTERN PyObject *_wrap_Dataset_CreateLayerFromGeomFieldDefn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25726 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25727 14 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
25728 14 : char *arg2 = (char *) 0 ;
25729 14 : OGRGeomFieldDefnShadow *arg3 = (OGRGeomFieldDefnShadow *) 0 ;
25730 14 : char **arg4 = (char **) 0 ;
25731 14 : void *argp1 = 0 ;
25732 14 : int res1 = 0 ;
25733 14 : int res2 ;
25734 14 : char *buf2 = 0 ;
25735 14 : int alloc2 = 0 ;
25736 14 : void *argp3 = 0 ;
25737 14 : int res3 = 0 ;
25738 14 : PyObject *swig_obj[4] ;
25739 14 : OGRLayerShadow *result = 0 ;
25740 :
25741 14 : if (!SWIG_Python_UnpackTuple(args, "Dataset_CreateLayerFromGeomFieldDefn", 3, 4, swig_obj)) SWIG_fail;
25742 14 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
25743 14 : if (!SWIG_IsOK(res1)) {
25744 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_CreateLayerFromGeomFieldDefn" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
25745 : }
25746 14 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
25747 14 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
25748 14 : if (!SWIG_IsOK(res2)) {
25749 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_CreateLayerFromGeomFieldDefn" "', argument " "2"" of type '" "char const *""'");
25750 : }
25751 14 : arg2 = reinterpret_cast< char * >(buf2);
25752 14 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_OGRGeomFieldDefnShadow, 0 | 0 );
25753 14 : if (!SWIG_IsOK(res3)) {
25754 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Dataset_CreateLayerFromGeomFieldDefn" "', argument " "3"" of type '" "OGRGeomFieldDefnShadow *""'");
25755 : }
25756 14 : arg3 = reinterpret_cast< OGRGeomFieldDefnShadow * >(argp3);
25757 14 : if (swig_obj[3]) {
25758 7 : {
25759 : /* %typemap(in) char **dict */
25760 7 : arg4 = NULL;
25761 7 : if ( PySequence_Check( swig_obj[3] ) ) {
25762 7 : int bErr = FALSE;
25763 7 : arg4 = CSLFromPySequence(swig_obj[3], &bErr);
25764 7 : if ( bErr )
25765 : {
25766 0 : SWIG_fail;
25767 : }
25768 : }
25769 0 : else if ( PyMapping_Check( swig_obj[3] ) ) {
25770 0 : int bErr = FALSE;
25771 0 : arg4 = CSLFromPyMapping(swig_obj[3], &bErr);
25772 0 : if ( bErr )
25773 : {
25774 0 : SWIG_fail;
25775 : }
25776 : }
25777 : else {
25778 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
25779 0 : SWIG_fail;
25780 : }
25781 : }
25782 : }
25783 14 : {
25784 14 : const int bLocalUseExceptions = GetUseExceptions();
25785 14 : if ( bLocalUseExceptions ) {
25786 9 : pushErrorHandler();
25787 : }
25788 14 : {
25789 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25790 14 : result = (OGRLayerShadow *)GDALDatasetShadow_CreateLayerFromGeomFieldDefn(arg1,(char const *)arg2,arg3,arg4);
25791 14 : SWIG_PYTHON_THREAD_END_ALLOW;
25792 : }
25793 14 : if ( bLocalUseExceptions ) {
25794 9 : popErrorHandler();
25795 : }
25796 : #ifndef SED_HACKS
25797 : if ( bLocalUseExceptions ) {
25798 : CPLErr eclass = CPLGetLastErrorType();
25799 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25800 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25801 : }
25802 : }
25803 : #endif
25804 : }
25805 14 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
25806 14 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25807 14 : {
25808 : /* %typemap(freearg) char **dict */
25809 14 : CSLDestroy( arg4 );
25810 : }
25811 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25812 : return resultobj;
25813 0 : fail:
25814 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25815 0 : {
25816 : /* %typemap(freearg) char **dict */
25817 0 : CSLDestroy( arg4 );
25818 : }
25819 : return NULL;
25820 : }
25821 :
25822 :
25823 18 : SWIGINTERN PyObject *_wrap_Dataset_CopyLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25824 18 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25825 18 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
25826 18 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
25827 18 : char *arg3 = (char *) 0 ;
25828 18 : char **arg4 = (char **) 0 ;
25829 18 : void *argp1 = 0 ;
25830 18 : int res1 = 0 ;
25831 18 : void *argp2 = 0 ;
25832 18 : int res2 = 0 ;
25833 18 : int res3 ;
25834 18 : char *buf3 = 0 ;
25835 18 : int alloc3 = 0 ;
25836 18 : PyObject * obj0 = 0 ;
25837 18 : PyObject * obj1 = 0 ;
25838 18 : PyObject * obj2 = 0 ;
25839 18 : PyObject * obj3 = 0 ;
25840 18 : char * kwnames[] = {
25841 : (char *)"self", (char *)"src_layer", (char *)"new_name", (char *)"options", NULL
25842 : };
25843 18 : OGRLayerShadow *result = 0 ;
25844 :
25845 18 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Dataset_CopyLayer", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
25846 18 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
25847 18 : if (!SWIG_IsOK(res1)) {
25848 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_CopyLayer" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
25849 : }
25850 18 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
25851 18 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
25852 18 : if (!SWIG_IsOK(res2)) {
25853 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_CopyLayer" "', argument " "2"" of type '" "OGRLayerShadow *""'");
25854 : }
25855 18 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
25856 18 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
25857 18 : if (!SWIG_IsOK(res3)) {
25858 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Dataset_CopyLayer" "', argument " "3"" of type '" "char const *""'");
25859 : }
25860 18 : arg3 = reinterpret_cast< char * >(buf3);
25861 18 : if (obj3) {
25862 4 : {
25863 : /* %typemap(in) char **dict */
25864 4 : arg4 = NULL;
25865 4 : if ( PySequence_Check( obj3 ) ) {
25866 4 : int bErr = FALSE;
25867 4 : arg4 = CSLFromPySequence(obj3, &bErr);
25868 4 : if ( bErr )
25869 : {
25870 0 : SWIG_fail;
25871 : }
25872 : }
25873 0 : else if ( PyMapping_Check( obj3 ) ) {
25874 0 : int bErr = FALSE;
25875 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
25876 0 : if ( bErr )
25877 : {
25878 0 : SWIG_fail;
25879 : }
25880 : }
25881 : else {
25882 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
25883 0 : SWIG_fail;
25884 : }
25885 : }
25886 : }
25887 18 : {
25888 18 : if (!arg2) {
25889 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
25890 : }
25891 : }
25892 18 : {
25893 18 : const int bLocalUseExceptions = GetUseExceptions();
25894 18 : if ( bLocalUseExceptions ) {
25895 14 : pushErrorHandler();
25896 : }
25897 18 : {
25898 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25899 18 : result = (OGRLayerShadow *)GDALDatasetShadow_CopyLayer(arg1,arg2,(char const *)arg3,arg4);
25900 18 : SWIG_PYTHON_THREAD_END_ALLOW;
25901 : }
25902 18 : if ( bLocalUseExceptions ) {
25903 14 : popErrorHandler();
25904 : }
25905 : #ifndef SED_HACKS
25906 : if ( bLocalUseExceptions ) {
25907 : CPLErr eclass = CPLGetLastErrorType();
25908 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25909 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25910 : }
25911 : }
25912 : #endif
25913 : }
25914 18 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
25915 18 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
25916 18 : {
25917 : /* %typemap(freearg) char **dict */
25918 18 : CSLDestroy( arg4 );
25919 : }
25920 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25921 : return resultobj;
25922 0 : fail:
25923 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
25924 0 : {
25925 : /* %typemap(freearg) char **dict */
25926 0 : CSLDestroy( arg4 );
25927 : }
25928 : return NULL;
25929 : }
25930 :
25931 :
25932 41 : SWIGINTERN PyObject *_wrap_Dataset_DeleteLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25933 41 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
25934 41 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
25935 41 : int arg2 ;
25936 41 : void *argp1 = 0 ;
25937 41 : int res1 = 0 ;
25938 41 : int val2 ;
25939 41 : int ecode2 = 0 ;
25940 41 : PyObject *swig_obj[2] ;
25941 41 : OGRErr result;
25942 :
25943 41 : if (!SWIG_Python_UnpackTuple(args, "Dataset_DeleteLayer", 2, 2, swig_obj)) SWIG_fail;
25944 41 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
25945 41 : if (!SWIG_IsOK(res1)) {
25946 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_DeleteLayer" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
25947 : }
25948 41 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
25949 41 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25950 41 : if (!SWIG_IsOK(ecode2)) {
25951 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_DeleteLayer" "', argument " "2"" of type '" "int""'");
25952 : }
25953 41 : arg2 = static_cast< int >(val2);
25954 41 : {
25955 41 : const int bLocalUseExceptions = GetUseExceptions();
25956 41 : if ( bLocalUseExceptions ) {
25957 7 : pushErrorHandler();
25958 : }
25959 41 : {
25960 41 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25961 41 : result = (OGRErr)GDALDatasetShadow_DeleteLayer(arg1,arg2);
25962 41 : SWIG_PYTHON_THREAD_END_ALLOW;
25963 : }
25964 41 : if ( bLocalUseExceptions ) {
25965 7 : popErrorHandler();
25966 : }
25967 : #ifndef SED_HACKS
25968 : if ( bLocalUseExceptions ) {
25969 : CPLErr eclass = CPLGetLastErrorType();
25970 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
25971 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
25972 : }
25973 : }
25974 : #endif
25975 : }
25976 41 : {
25977 : /* %typemap(out) OGRErr */
25978 59 : if ( result != 0 && GetUseExceptions()) {
25979 2 : const char* pszMessage = CPLGetLastErrorMsg();
25980 2 : if( pszMessage[0] != '\0' )
25981 2 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
25982 : else
25983 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
25984 2 : SWIG_fail;
25985 : }
25986 : }
25987 39 : {
25988 : /* %typemap(ret) OGRErr */
25989 39 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
25990 39 : resultobj = PyInt_FromLong( result );
25991 : }
25992 : }
25993 41 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
25994 : return resultobj;
25995 : fail:
25996 : return NULL;
25997 : }
25998 :
25999 :
26000 91 : SWIGINTERN PyObject *_wrap_Dataset_IsLayerPrivate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26001 91 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26002 91 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26003 91 : int arg2 ;
26004 91 : void *argp1 = 0 ;
26005 91 : int res1 = 0 ;
26006 91 : int val2 ;
26007 91 : int ecode2 = 0 ;
26008 91 : PyObject *swig_obj[2] ;
26009 91 : bool result;
26010 :
26011 91 : if (!SWIG_Python_UnpackTuple(args, "Dataset_IsLayerPrivate", 2, 2, swig_obj)) SWIG_fail;
26012 91 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26013 91 : if (!SWIG_IsOK(res1)) {
26014 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_IsLayerPrivate" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26015 : }
26016 91 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26017 91 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
26018 91 : if (!SWIG_IsOK(ecode2)) {
26019 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_IsLayerPrivate" "', argument " "2"" of type '" "int""'");
26020 : }
26021 91 : arg2 = static_cast< int >(val2);
26022 91 : {
26023 91 : const int bLocalUseExceptions = GetUseExceptions();
26024 91 : if ( bLocalUseExceptions ) {
26025 85 : pushErrorHandler();
26026 : }
26027 91 : {
26028 91 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26029 91 : result = (bool)GDALDatasetShadow_IsLayerPrivate(arg1,arg2);
26030 91 : SWIG_PYTHON_THREAD_END_ALLOW;
26031 : }
26032 91 : if ( bLocalUseExceptions ) {
26033 85 : popErrorHandler();
26034 : }
26035 : #ifndef SED_HACKS
26036 : if ( bLocalUseExceptions ) {
26037 : CPLErr eclass = CPLGetLastErrorType();
26038 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26039 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26040 : }
26041 : }
26042 : #endif
26043 : }
26044 91 : resultobj = SWIG_From_bool(static_cast< bool >(result));
26045 91 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26046 : return resultobj;
26047 : fail:
26048 : return NULL;
26049 : }
26050 :
26051 :
26052 1917 : SWIGINTERN PyObject *_wrap_Dataset_GetNextFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26053 1917 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26054 1917 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26055 1917 : bool arg2 = (bool) true ;
26056 1917 : bool arg3 = (bool) false ;
26057 1917 : OGRLayerShadow **arg4 = (OGRLayerShadow **) NULL ;
26058 1917 : double *arg5 = (double *) NULL ;
26059 1917 : GDALProgressFunc arg6 = (GDALProgressFunc) NULL ;
26060 1917 : void *arg7 = (void *) NULL ;
26061 1917 : void *argp1 = 0 ;
26062 1917 : int res1 = 0 ;
26063 1917 : bool val2 ;
26064 1917 : int ecode2 = 0 ;
26065 1917 : bool val3 ;
26066 1917 : int ecode3 = 0 ;
26067 1917 : OGRLayerShadow *poBelongingLayer4 = NULL ;
26068 1917 : double dfProgressPct4 = 0 ;
26069 1917 : PyObject * obj0 = 0 ;
26070 1917 : PyObject * obj1 = 0 ;
26071 1917 : PyObject * obj2 = 0 ;
26072 1917 : PyObject * obj3 = 0 ;
26073 1917 : PyObject * obj4 = 0 ;
26074 1917 : char * kwnames[] = {
26075 : (char *)"self", (char *)"include_layer", (char *)"include_pct", (char *)"callback", (char *)"callback_data", NULL
26076 : };
26077 1917 : OGRFeatureShadow *result = 0 ;
26078 :
26079 : /* %typemap(arginit) ( const char* callback_data=NULL) */
26080 1917 : PyProgressData *psProgressInfo;
26081 1917 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
26082 1917 : psProgressInfo->nLastReported = -1;
26083 1917 : psProgressInfo->psPyCallback = NULL;
26084 1917 : psProgressInfo->psPyCallbackData = NULL;
26085 1917 : arg7 = psProgressInfo;
26086 1917 : {
26087 : /* %typemap(in) (OGRLayerShadow** ppoBelongingLayer, double* pdfProgressPct) */
26088 1917 : arg4 = &poBelongingLayer4;
26089 1917 : arg5 = &dfProgressPct4;
26090 : }
26091 1917 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOO:Dataset_GetNextFeature", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
26092 1917 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26093 1917 : if (!SWIG_IsOK(res1)) {
26094 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetNextFeature" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26095 : }
26096 1917 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26097 1917 : if (obj1) {
26098 6 : ecode2 = SWIG_AsVal_bool(obj1, &val2);
26099 6 : if (!SWIG_IsOK(ecode2)) {
26100 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_GetNextFeature" "', argument " "2"" of type '" "bool""'");
26101 : }
26102 : arg2 = static_cast< bool >(val2);
26103 : }
26104 1917 : if (obj2) {
26105 76 : ecode3 = SWIG_AsVal_bool(obj2, &val3);
26106 76 : if (!SWIG_IsOK(ecode3)) {
26107 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dataset_GetNextFeature" "', argument " "3"" of type '" "bool""'");
26108 : }
26109 : arg3 = static_cast< bool >(val3);
26110 : }
26111 1917 : if (obj3) {
26112 2 : {
26113 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
26114 : /* callback_func typemap */
26115 :
26116 : /* In some cases 0 is passed instead of None. */
26117 : /* See https://github.com/OSGeo/gdal/pull/219 */
26118 2 : if ( PyLong_Check(obj3) || PyInt_Check(obj3) )
26119 : {
26120 0 : if( PyLong_AsLong(obj3) == 0 )
26121 : {
26122 0 : obj3 = Py_None;
26123 : }
26124 : }
26125 :
26126 2 : if (obj3 && obj3 != Py_None ) {
26127 2 : void* cbfunction = NULL;
26128 2 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj3,
26129 : (void**)&cbfunction,
26130 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
26131 : SWIG_POINTER_EXCEPTION | 0 ));
26132 :
26133 2 : if ( cbfunction == GDALTermProgress ) {
26134 : arg6 = GDALTermProgress;
26135 : } else {
26136 2 : if (!PyCallable_Check(obj3)) {
26137 0 : PyErr_SetString( PyExc_RuntimeError,
26138 : "Object given is not a Python function" );
26139 0 : SWIG_fail;
26140 : }
26141 2 : psProgressInfo->psPyCallback = obj3;
26142 2 : arg6 = PyProgressProxy;
26143 : }
26144 :
26145 : }
26146 :
26147 : }
26148 : }
26149 1917 : if (obj4) {
26150 1 : {
26151 : /* %typemap(in) ( void* callback_data=NULL) */
26152 1 : psProgressInfo->psPyCallbackData = obj4 ;
26153 : }
26154 : }
26155 1917 : {
26156 : /* %typemap(check) (OGRLayerShadow** ppoBelongingLayer, double* pdfProgressPct) */
26157 1917 : if( !arg3 )
26158 1841 : arg5 = NULL;
26159 : }
26160 1917 : {
26161 1917 : const int bLocalUseExceptions = GetUseExceptions();
26162 1917 : if ( bLocalUseExceptions ) {
26163 104 : pushErrorHandler();
26164 : }
26165 1917 : {
26166 1917 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26167 1917 : result = (OGRFeatureShadow *)GDALDatasetShadow_GetNextFeature(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
26168 1917 : SWIG_PYTHON_THREAD_END_ALLOW;
26169 : }
26170 1917 : if ( bLocalUseExceptions ) {
26171 104 : popErrorHandler();
26172 : }
26173 : #ifndef SED_HACKS
26174 : if ( bLocalUseExceptions ) {
26175 : CPLErr eclass = CPLGetLastErrorType();
26176 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26177 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26178 : }
26179 : }
26180 : #endif
26181 : }
26182 1917 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_OWN | 0 );
26183 1917 : {
26184 : /* %typemap(argout) (OGRLayerShadow** ppoBelongingLayer, double* pdfProgressPct) */
26185 :
26186 1917 : if( arg2 )
26187 : {
26188 1911 : if( resultobj == Py_None )
26189 : {
26190 35 : resultobj = PyList_New(1);
26191 35 : PyList_SetItem(resultobj, 0, Py_None);
26192 : }
26193 :
26194 1911 : PyObject* r;
26195 1911 : if ( !*arg4 ) {
26196 35 : r = Py_None;
26197 35 : Py_INCREF(Py_None);
26198 : }
26199 : else {
26200 1876 : r = SWIG_NewPointerObj(SWIG_as_voidptr( *arg4), SWIGTYPE_p_OGRLayerShadow, 0 );
26201 : }
26202 : #if SWIG_VERSION >= 0x040300
26203 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
26204 : #else
26205 1911 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
26206 : #endif
26207 : }
26208 :
26209 1917 : if( arg3 )
26210 : {
26211 76 : if( resultobj == Py_None )
26212 : {
26213 2 : resultobj = PyList_New(1);
26214 2 : PyList_SetItem(resultobj, 0, Py_None);
26215 : }
26216 76 : PyObject* r = PyFloat_FromDouble( *arg5);
26217 : #if SWIG_VERSION >= 0x040300
26218 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
26219 : #else
26220 76 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
26221 : #endif
26222 : }
26223 :
26224 : }
26225 1917 : {
26226 : /* %typemap(freearg) ( void* callback_data=NULL) */
26227 :
26228 1917 : CPLFree(psProgressInfo);
26229 :
26230 : }
26231 1917 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26232 : return resultobj;
26233 0 : fail:
26234 0 : {
26235 : /* %typemap(freearg) ( void* callback_data=NULL) */
26236 :
26237 0 : CPLFree(psProgressInfo);
26238 :
26239 : }
26240 : return NULL;
26241 : }
26242 :
26243 :
26244 127 : SWIGINTERN PyObject *_wrap_Dataset_TestCapability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26245 127 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26246 127 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26247 127 : char *arg2 = (char *) 0 ;
26248 127 : void *argp1 = 0 ;
26249 127 : int res1 = 0 ;
26250 127 : int res2 ;
26251 127 : char *buf2 = 0 ;
26252 127 : int alloc2 = 0 ;
26253 127 : PyObject *swig_obj[2] ;
26254 127 : bool result;
26255 :
26256 127 : if (!SWIG_Python_UnpackTuple(args, "Dataset_TestCapability", 2, 2, swig_obj)) SWIG_fail;
26257 127 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26258 127 : if (!SWIG_IsOK(res1)) {
26259 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_TestCapability" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26260 : }
26261 127 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26262 127 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
26263 127 : if (!SWIG_IsOK(res2)) {
26264 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_TestCapability" "', argument " "2"" of type '" "char const *""'");
26265 : }
26266 127 : arg2 = reinterpret_cast< char * >(buf2);
26267 127 : {
26268 127 : const int bLocalUseExceptions = GetUseExceptions();
26269 127 : if ( bLocalUseExceptions ) {
26270 50 : pushErrorHandler();
26271 : }
26272 127 : {
26273 127 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26274 127 : result = (bool)GDALDatasetShadow_TestCapability(arg1,(char const *)arg2);
26275 127 : SWIG_PYTHON_THREAD_END_ALLOW;
26276 : }
26277 127 : if ( bLocalUseExceptions ) {
26278 50 : popErrorHandler();
26279 : }
26280 : #ifndef SED_HACKS
26281 : if ( bLocalUseExceptions ) {
26282 : CPLErr eclass = CPLGetLastErrorType();
26283 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26284 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26285 : }
26286 : }
26287 : #endif
26288 : }
26289 127 : resultobj = SWIG_From_bool(static_cast< bool >(result));
26290 127 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26291 127 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26292 : return resultobj;
26293 0 : fail:
26294 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26295 : return NULL;
26296 : }
26297 :
26298 :
26299 9996 : SWIGINTERN PyObject *_wrap_Dataset_ExecuteSQL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26300 9996 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26301 9996 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26302 9996 : char *arg2 = (char *) 0 ;
26303 9996 : OGRGeometryShadow *arg3 = (OGRGeometryShadow *) NULL ;
26304 9996 : char *arg4 = (char *) "" ;
26305 9996 : void *argp1 = 0 ;
26306 9996 : int res1 = 0 ;
26307 9996 : int res2 ;
26308 9996 : char *buf2 = 0 ;
26309 9996 : int alloc2 = 0 ;
26310 9996 : void *argp3 = 0 ;
26311 9996 : int res3 = 0 ;
26312 9996 : int res4 ;
26313 9996 : char *buf4 = 0 ;
26314 9996 : int alloc4 = 0 ;
26315 9996 : PyObject * obj0 = 0 ;
26316 9996 : PyObject * obj1 = 0 ;
26317 9996 : PyObject * obj2 = 0 ;
26318 9996 : PyObject * obj3 = 0 ;
26319 9996 : char * kwnames[] = {
26320 : (char *)"self", (char *)"statement", (char *)"spatialFilter", (char *)"dialect", NULL
26321 : };
26322 9996 : OGRLayerShadow *result = 0 ;
26323 :
26324 9996 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:Dataset_ExecuteSQL", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
26325 9996 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26326 9996 : if (!SWIG_IsOK(res1)) {
26327 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_ExecuteSQL" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26328 : }
26329 9996 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26330 9996 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26331 9996 : if (!SWIG_IsOK(res2)) {
26332 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_ExecuteSQL" "', argument " "2"" of type '" "char const *""'");
26333 : }
26334 9996 : arg2 = reinterpret_cast< char * >(buf2);
26335 9996 : if (obj2) {
26336 9996 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRGeometryShadow, 0 | 0 );
26337 9996 : if (!SWIG_IsOK(res3)) {
26338 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Dataset_ExecuteSQL" "', argument " "3"" of type '" "OGRGeometryShadow *""'");
26339 : }
26340 9996 : arg3 = reinterpret_cast< OGRGeometryShadow * >(argp3);
26341 : }
26342 9996 : if (obj3) {
26343 9996 : res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
26344 9996 : if (!SWIG_IsOK(res4)) {
26345 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Dataset_ExecuteSQL" "', argument " "4"" of type '" "char const *""'");
26346 : }
26347 9996 : arg4 = reinterpret_cast< char * >(buf4);
26348 : }
26349 9996 : {
26350 9996 : if (!arg2) {
26351 131 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
26352 : }
26353 : }
26354 9865 : {
26355 9865 : const int bLocalUseExceptions = GetUseExceptions();
26356 9865 : if ( bLocalUseExceptions ) {
26357 0 : pushErrorHandler();
26358 : }
26359 9865 : {
26360 9865 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26361 9865 : result = (OGRLayerShadow *)GDALDatasetShadow_ExecuteSQL(arg1,(char const *)arg2,arg3,(char const *)arg4);
26362 9865 : SWIG_PYTHON_THREAD_END_ALLOW;
26363 : }
26364 9865 : if ( bLocalUseExceptions ) {
26365 0 : popErrorHandler();
26366 : }
26367 : #ifndef SED_HACKS
26368 : if ( bLocalUseExceptions ) {
26369 : CPLErr eclass = CPLGetLastErrorType();
26370 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26371 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26372 : }
26373 : }
26374 : #endif
26375 : }
26376 9865 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
26377 9865 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26378 9865 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
26379 9996 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26380 : return resultobj;
26381 131 : fail:
26382 131 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26383 131 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
26384 : return NULL;
26385 : }
26386 :
26387 :
26388 2821 : SWIGINTERN PyObject *_wrap_Dataset_ReleaseResultSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26389 2821 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26390 2821 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26391 2821 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
26392 2821 : void *argp1 = 0 ;
26393 2821 : int res1 = 0 ;
26394 2821 : int res2 = 0 ;
26395 2821 : PyObject *swig_obj[2] ;
26396 :
26397 2821 : if (!SWIG_Python_UnpackTuple(args, "Dataset_ReleaseResultSet", 2, 2, swig_obj)) SWIG_fail;
26398 2821 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26399 2821 : if (!SWIG_IsOK(res1)) {
26400 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_ReleaseResultSet" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26401 : }
26402 2821 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26403 2821 : res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_OGRLayerShadow, SWIG_POINTER_DISOWN | 0 );
26404 2821 : if (!SWIG_IsOK(res2)) {
26405 4 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_ReleaseResultSet" "', argument " "2"" of type '" "OGRLayerShadow *""'");
26406 : }
26407 2819 : {
26408 2819 : const int bLocalUseExceptions = GetUseExceptions();
26409 2819 : if ( bLocalUseExceptions ) {
26410 783 : pushErrorHandler();
26411 : }
26412 2819 : {
26413 2819 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26414 2819 : GDALDatasetShadow_ReleaseResultSet(arg1,arg2);
26415 2819 : SWIG_PYTHON_THREAD_END_ALLOW;
26416 : }
26417 2819 : if ( bLocalUseExceptions ) {
26418 783 : popErrorHandler();
26419 : }
26420 : #ifndef SED_HACKS
26421 : if ( bLocalUseExceptions ) {
26422 : CPLErr eclass = CPLGetLastErrorType();
26423 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26424 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26425 : }
26426 : }
26427 : #endif
26428 : }
26429 2819 : resultobj = SWIG_Py_Void();
26430 2821 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26431 : return resultobj;
26432 : fail:
26433 : return NULL;
26434 : }
26435 :
26436 :
26437 6 : SWIGINTERN PyObject *_wrap_Dataset_GetStyleTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26438 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26439 6 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26440 6 : void *argp1 = 0 ;
26441 6 : int res1 = 0 ;
26442 6 : PyObject *swig_obj[1] ;
26443 6 : OGRStyleTableShadow *result = 0 ;
26444 :
26445 6 : if (!args) SWIG_fail;
26446 6 : swig_obj[0] = args;
26447 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26448 6 : if (!SWIG_IsOK(res1)) {
26449 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetStyleTable" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26450 : }
26451 6 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26452 6 : {
26453 6 : const int bLocalUseExceptions = GetUseExceptions();
26454 6 : if ( bLocalUseExceptions ) {
26455 5 : pushErrorHandler();
26456 : }
26457 6 : {
26458 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26459 6 : result = (OGRStyleTableShadow *)GDALDatasetShadow_GetStyleTable(arg1);
26460 6 : SWIG_PYTHON_THREAD_END_ALLOW;
26461 : }
26462 6 : if ( bLocalUseExceptions ) {
26463 5 : popErrorHandler();
26464 : }
26465 : #ifndef SED_HACKS
26466 : if ( bLocalUseExceptions ) {
26467 : CPLErr eclass = CPLGetLastErrorType();
26468 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26469 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26470 : }
26471 : }
26472 : #endif
26473 : }
26474 6 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
26475 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26476 : return resultobj;
26477 : fail:
26478 : return NULL;
26479 : }
26480 :
26481 :
26482 7 : SWIGINTERN PyObject *_wrap_Dataset_SetStyleTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26483 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26484 7 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26485 7 : OGRStyleTableShadow *arg2 = (OGRStyleTableShadow *) 0 ;
26486 7 : void *argp1 = 0 ;
26487 7 : int res1 = 0 ;
26488 7 : void *argp2 = 0 ;
26489 7 : int res2 = 0 ;
26490 7 : PyObject *swig_obj[2] ;
26491 :
26492 7 : if (!SWIG_Python_UnpackTuple(args, "Dataset_SetStyleTable", 2, 2, swig_obj)) SWIG_fail;
26493 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26494 7 : if (!SWIG_IsOK(res1)) {
26495 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_SetStyleTable" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26496 : }
26497 7 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26498 7 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRStyleTableShadow, 0 | 0 );
26499 7 : if (!SWIG_IsOK(res2)) {
26500 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_SetStyleTable" "', argument " "2"" of type '" "OGRStyleTableShadow *""'");
26501 : }
26502 7 : arg2 = reinterpret_cast< OGRStyleTableShadow * >(argp2);
26503 7 : {
26504 7 : const int bLocalUseExceptions = GetUseExceptions();
26505 7 : if ( bLocalUseExceptions ) {
26506 6 : pushErrorHandler();
26507 : }
26508 7 : {
26509 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26510 7 : GDALDatasetShadow_SetStyleTable(arg1,arg2);
26511 7 : SWIG_PYTHON_THREAD_END_ALLOW;
26512 : }
26513 7 : if ( bLocalUseExceptions ) {
26514 6 : popErrorHandler();
26515 : }
26516 : #ifndef SED_HACKS
26517 : if ( bLocalUseExceptions ) {
26518 : CPLErr eclass = CPLGetLastErrorType();
26519 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26520 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26521 : }
26522 : }
26523 : #endif
26524 : }
26525 7 : resultobj = SWIG_Py_Void();
26526 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26527 : return resultobj;
26528 : fail:
26529 : return NULL;
26530 : }
26531 :
26532 :
26533 9527 : SWIGINTERN PyObject *_wrap_Dataset_GetLayerByIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26534 9527 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26535 9527 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26536 9527 : int arg2 = (int) 0 ;
26537 9527 : void *argp1 = 0 ;
26538 9527 : int res1 = 0 ;
26539 9527 : int val2 ;
26540 9527 : int ecode2 = 0 ;
26541 9527 : PyObject *swig_obj[2] ;
26542 9527 : OGRLayerShadow *result = 0 ;
26543 :
26544 9527 : if (!SWIG_Python_UnpackTuple(args, "Dataset_GetLayerByIndex", 1, 2, swig_obj)) SWIG_fail;
26545 9527 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26546 9527 : if (!SWIG_IsOK(res1)) {
26547 14 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetLayerByIndex" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26548 : }
26549 9520 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26550 9520 : if (swig_obj[1]) {
26551 9520 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
26552 9520 : if (!SWIG_IsOK(ecode2)) {
26553 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_GetLayerByIndex" "', argument " "2"" of type '" "int""'");
26554 : }
26555 : arg2 = static_cast< int >(val2);
26556 : }
26557 9520 : {
26558 9520 : const int bLocalUseExceptions = GetUseExceptions();
26559 9520 : if ( bLocalUseExceptions ) {
26560 5505 : pushErrorHandler();
26561 : }
26562 9520 : {
26563 9520 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26564 9520 : result = (OGRLayerShadow *)GDALDatasetShadow_GetLayerByIndex(arg1,arg2);
26565 9520 : SWIG_PYTHON_THREAD_END_ALLOW;
26566 : }
26567 9520 : if ( bLocalUseExceptions ) {
26568 5505 : popErrorHandler();
26569 : }
26570 : #ifndef SED_HACKS
26571 : if ( bLocalUseExceptions ) {
26572 : CPLErr eclass = CPLGetLastErrorType();
26573 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26574 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26575 : }
26576 : }
26577 : #endif
26578 : }
26579 9520 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
26580 9527 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26581 : return resultobj;
26582 : fail:
26583 : return NULL;
26584 : }
26585 :
26586 :
26587 2730 : SWIGINTERN PyObject *_wrap_Dataset_GetLayerByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26588 2730 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26589 2730 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26590 2730 : char *arg2 = (char *) 0 ;
26591 2730 : void *argp1 = 0 ;
26592 2730 : int res1 = 0 ;
26593 2730 : int res2 ;
26594 2730 : char *buf2 = 0 ;
26595 2730 : int alloc2 = 0 ;
26596 2730 : PyObject *swig_obj[2] ;
26597 2730 : OGRLayerShadow *result = 0 ;
26598 :
26599 2730 : if (!SWIG_Python_UnpackTuple(args, "Dataset_GetLayerByName", 2, 2, swig_obj)) SWIG_fail;
26600 2730 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26601 2730 : if (!SWIG_IsOK(res1)) {
26602 2 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetLayerByName" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26603 : }
26604 2729 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26605 2729 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
26606 2729 : if (!SWIG_IsOK(res2)) {
26607 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_GetLayerByName" "', argument " "2"" of type '" "char const *""'");
26608 : }
26609 2729 : arg2 = reinterpret_cast< char * >(buf2);
26610 2729 : {
26611 2729 : const int bLocalUseExceptions = GetUseExceptions();
26612 2729 : if ( bLocalUseExceptions ) {
26613 425 : pushErrorHandler();
26614 : }
26615 2729 : {
26616 2729 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26617 2729 : result = (OGRLayerShadow *)GDALDatasetShadow_GetLayerByName(arg1,(char const *)arg2);
26618 2729 : SWIG_PYTHON_THREAD_END_ALLOW;
26619 : }
26620 2729 : if ( bLocalUseExceptions ) {
26621 425 : popErrorHandler();
26622 : }
26623 : #ifndef SED_HACKS
26624 : if ( bLocalUseExceptions ) {
26625 : CPLErr eclass = CPLGetLastErrorType();
26626 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26627 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26628 : }
26629 : }
26630 : #endif
26631 : }
26632 2729 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
26633 2729 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26634 2730 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26635 : return resultobj;
26636 1 : fail:
26637 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26638 : return NULL;
26639 : }
26640 :
26641 :
26642 14 : SWIGINTERN PyObject *_wrap_Dataset_ResetReading(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26643 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26644 14 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26645 14 : void *argp1 = 0 ;
26646 14 : int res1 = 0 ;
26647 14 : PyObject *swig_obj[1] ;
26648 :
26649 14 : if (!args) SWIG_fail;
26650 14 : swig_obj[0] = args;
26651 14 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26652 14 : if (!SWIG_IsOK(res1)) {
26653 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_ResetReading" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26654 : }
26655 14 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26656 14 : {
26657 14 : const int bLocalUseExceptions = GetUseExceptions();
26658 14 : if ( bLocalUseExceptions ) {
26659 9 : pushErrorHandler();
26660 : }
26661 14 : {
26662 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26663 14 : GDALDatasetShadow_ResetReading(arg1);
26664 14 : SWIG_PYTHON_THREAD_END_ALLOW;
26665 : }
26666 14 : if ( bLocalUseExceptions ) {
26667 9 : popErrorHandler();
26668 : }
26669 : #ifndef SED_HACKS
26670 : if ( bLocalUseExceptions ) {
26671 : CPLErr eclass = CPLGetLastErrorType();
26672 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26673 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26674 : }
26675 : }
26676 : #endif
26677 : }
26678 14 : resultobj = SWIG_Py_Void();
26679 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26680 : return resultobj;
26681 : fail:
26682 : return NULL;
26683 : }
26684 :
26685 :
26686 1448 : SWIGINTERN PyObject *_wrap_Dataset_GetLayerCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26687 1448 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26688 1448 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26689 1448 : void *argp1 = 0 ;
26690 1448 : int res1 = 0 ;
26691 1448 : PyObject *swig_obj[1] ;
26692 1448 : int result;
26693 :
26694 1448 : if (!args) SWIG_fail;
26695 1448 : swig_obj[0] = args;
26696 1448 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26697 1448 : if (!SWIG_IsOK(res1)) {
26698 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetLayerCount" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26699 : }
26700 1448 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26701 1448 : {
26702 1448 : const int bLocalUseExceptions = GetUseExceptions();
26703 1448 : if ( bLocalUseExceptions ) {
26704 472 : pushErrorHandler();
26705 : }
26706 1448 : {
26707 1448 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26708 1448 : result = (int)GDALDatasetShadow_GetLayerCount(arg1);
26709 1448 : SWIG_PYTHON_THREAD_END_ALLOW;
26710 : }
26711 1448 : if ( bLocalUseExceptions ) {
26712 472 : popErrorHandler();
26713 : }
26714 : #ifndef SED_HACKS
26715 : if ( bLocalUseExceptions ) {
26716 : CPLErr eclass = CPLGetLastErrorType();
26717 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26718 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26719 : }
26720 : }
26721 : #endif
26722 : }
26723 1448 : resultobj = SWIG_From_int(static_cast< int >(result));
26724 1448 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26725 : return resultobj;
26726 : fail:
26727 : return NULL;
26728 : }
26729 :
26730 :
26731 6 : SWIGINTERN PyObject *_wrap_Dataset_AbortSQL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26732 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26733 6 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26734 6 : void *argp1 = 0 ;
26735 6 : int res1 = 0 ;
26736 6 : PyObject *swig_obj[1] ;
26737 6 : OGRErr result;
26738 :
26739 6 : if (!args) SWIG_fail;
26740 6 : swig_obj[0] = args;
26741 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26742 6 : if (!SWIG_IsOK(res1)) {
26743 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_AbortSQL" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26744 : }
26745 6 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26746 6 : {
26747 6 : const int bLocalUseExceptions = GetUseExceptions();
26748 6 : if ( bLocalUseExceptions ) {
26749 6 : pushErrorHandler();
26750 : }
26751 6 : {
26752 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26753 6 : result = (OGRErr)GDALDatasetShadow_AbortSQL(arg1);
26754 6 : SWIG_PYTHON_THREAD_END_ALLOW;
26755 : }
26756 6 : if ( bLocalUseExceptions ) {
26757 6 : popErrorHandler();
26758 : }
26759 : #ifndef SED_HACKS
26760 : if ( bLocalUseExceptions ) {
26761 : CPLErr eclass = CPLGetLastErrorType();
26762 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26763 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26764 : }
26765 : }
26766 : #endif
26767 : }
26768 6 : {
26769 : /* %typemap(out) OGRErr */
26770 6 : if ( result != 0 && GetUseExceptions()) {
26771 0 : const char* pszMessage = CPLGetLastErrorMsg();
26772 0 : if( pszMessage[0] != '\0' )
26773 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
26774 : else
26775 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
26776 0 : SWIG_fail;
26777 : }
26778 : }
26779 6 : {
26780 : /* %typemap(ret) OGRErr */
26781 6 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
26782 6 : resultobj = PyInt_FromLong( result );
26783 : }
26784 : }
26785 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26786 : return resultobj;
26787 : fail:
26788 : return NULL;
26789 : }
26790 :
26791 :
26792 105 : SWIGINTERN PyObject *_wrap_Dataset_StartTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26793 105 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26794 105 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26795 105 : int arg2 = (int) FALSE ;
26796 105 : void *argp1 = 0 ;
26797 105 : int res1 = 0 ;
26798 105 : int val2 ;
26799 105 : int ecode2 = 0 ;
26800 105 : PyObject * obj0 = 0 ;
26801 105 : PyObject * obj1 = 0 ;
26802 105 : char * kwnames[] = {
26803 : (char *)"self", (char *)"force", NULL
26804 : };
26805 105 : OGRErr result;
26806 :
26807 105 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Dataset_StartTransaction", kwnames, &obj0, &obj1)) SWIG_fail;
26808 105 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26809 105 : if (!SWIG_IsOK(res1)) {
26810 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_StartTransaction" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26811 : }
26812 105 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26813 105 : if (obj1) {
26814 17 : ecode2 = SWIG_AsVal_int(obj1, &val2);
26815 17 : if (!SWIG_IsOK(ecode2)) {
26816 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_StartTransaction" "', argument " "2"" of type '" "int""'");
26817 : }
26818 : arg2 = static_cast< int >(val2);
26819 : }
26820 105 : {
26821 105 : const int bLocalUseExceptions = GetUseExceptions();
26822 105 : if ( bLocalUseExceptions ) {
26823 0 : pushErrorHandler();
26824 : }
26825 105 : {
26826 105 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26827 105 : result = (OGRErr)GDALDatasetShadow_StartTransaction(arg1,arg2);
26828 105 : SWIG_PYTHON_THREAD_END_ALLOW;
26829 : }
26830 105 : if ( bLocalUseExceptions ) {
26831 0 : popErrorHandler();
26832 : }
26833 : #ifndef SED_HACKS
26834 : if ( bLocalUseExceptions ) {
26835 : CPLErr eclass = CPLGetLastErrorType();
26836 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26837 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26838 : }
26839 : }
26840 : #endif
26841 : }
26842 105 : {
26843 : /* %typemap(out) OGRErr */
26844 119 : if ( result != 0 && GetUseExceptions()) {
26845 0 : const char* pszMessage = CPLGetLastErrorMsg();
26846 0 : if( pszMessage[0] != '\0' )
26847 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
26848 : else
26849 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
26850 0 : SWIG_fail;
26851 : }
26852 : }
26853 105 : {
26854 : /* %typemap(ret) OGRErr */
26855 105 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
26856 105 : resultobj = PyInt_FromLong( result );
26857 : }
26858 : }
26859 105 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26860 : return resultobj;
26861 : fail:
26862 : return NULL;
26863 : }
26864 :
26865 :
26866 76 : SWIGINTERN PyObject *_wrap_Dataset_CommitTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26867 76 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26868 76 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26869 76 : void *argp1 = 0 ;
26870 76 : int res1 = 0 ;
26871 76 : PyObject *swig_obj[1] ;
26872 76 : OGRErr result;
26873 :
26874 76 : if (!args) SWIG_fail;
26875 76 : swig_obj[0] = args;
26876 76 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26877 76 : if (!SWIG_IsOK(res1)) {
26878 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_CommitTransaction" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26879 : }
26880 76 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26881 76 : {
26882 76 : const int bLocalUseExceptions = GetUseExceptions();
26883 76 : if ( bLocalUseExceptions ) {
26884 0 : pushErrorHandler();
26885 : }
26886 76 : {
26887 76 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26888 76 : result = (OGRErr)GDALDatasetShadow_CommitTransaction(arg1);
26889 76 : SWIG_PYTHON_THREAD_END_ALLOW;
26890 : }
26891 76 : if ( bLocalUseExceptions ) {
26892 0 : popErrorHandler();
26893 : }
26894 : #ifndef SED_HACKS
26895 : if ( bLocalUseExceptions ) {
26896 : CPLErr eclass = CPLGetLastErrorType();
26897 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26898 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26899 : }
26900 : }
26901 : #endif
26902 : }
26903 76 : {
26904 : /* %typemap(out) OGRErr */
26905 85 : if ( result != 0 && GetUseExceptions()) {
26906 0 : const char* pszMessage = CPLGetLastErrorMsg();
26907 0 : if( pszMessage[0] != '\0' )
26908 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
26909 : else
26910 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
26911 0 : SWIG_fail;
26912 : }
26913 : }
26914 76 : {
26915 : /* %typemap(ret) OGRErr */
26916 76 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
26917 76 : resultobj = PyInt_FromLong( result );
26918 : }
26919 : }
26920 76 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26921 : return resultobj;
26922 : fail:
26923 : return NULL;
26924 : }
26925 :
26926 :
26927 44 : SWIGINTERN PyObject *_wrap_Dataset_RollbackTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26928 44 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26929 44 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26930 44 : void *argp1 = 0 ;
26931 44 : int res1 = 0 ;
26932 44 : PyObject *swig_obj[1] ;
26933 44 : OGRErr result;
26934 :
26935 44 : if (!args) SWIG_fail;
26936 44 : swig_obj[0] = args;
26937 44 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26938 44 : if (!SWIG_IsOK(res1)) {
26939 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_RollbackTransaction" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
26940 : }
26941 44 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
26942 44 : {
26943 44 : const int bLocalUseExceptions = GetUseExceptions();
26944 44 : if ( bLocalUseExceptions ) {
26945 0 : pushErrorHandler();
26946 : }
26947 44 : {
26948 44 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26949 44 : result = (OGRErr)GDALDatasetShadow_RollbackTransaction(arg1);
26950 44 : SWIG_PYTHON_THREAD_END_ALLOW;
26951 : }
26952 44 : if ( bLocalUseExceptions ) {
26953 0 : popErrorHandler();
26954 : }
26955 : #ifndef SED_HACKS
26956 : if ( bLocalUseExceptions ) {
26957 : CPLErr eclass = CPLGetLastErrorType();
26958 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
26959 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
26960 : }
26961 : }
26962 : #endif
26963 : }
26964 44 : {
26965 : /* %typemap(out) OGRErr */
26966 54 : if ( result != 0 && GetUseExceptions()) {
26967 0 : const char* pszMessage = CPLGetLastErrorMsg();
26968 0 : if( pszMessage[0] != '\0' )
26969 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
26970 : else
26971 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
26972 0 : SWIG_fail;
26973 : }
26974 : }
26975 44 : {
26976 : /* %typemap(ret) OGRErr */
26977 44 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
26978 44 : resultobj = PyInt_FromLong( result );
26979 : }
26980 : }
26981 44 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
26982 : return resultobj;
26983 : fail:
26984 : return NULL;
26985 : }
26986 :
26987 :
26988 2 : SWIGINTERN PyObject *_wrap_Dataset_ClearStatistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26989 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
26990 2 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
26991 2 : void *argp1 = 0 ;
26992 2 : int res1 = 0 ;
26993 2 : PyObject *swig_obj[1] ;
26994 :
26995 2 : if (!args) SWIG_fail;
26996 2 : swig_obj[0] = args;
26997 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
26998 2 : if (!SWIG_IsOK(res1)) {
26999 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_ClearStatistics" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
27000 : }
27001 2 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
27002 2 : {
27003 2 : const int bLocalUseExceptions = GetUseExceptions();
27004 2 : if ( bLocalUseExceptions ) {
27005 1 : pushErrorHandler();
27006 : }
27007 2 : {
27008 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27009 2 : GDALDatasetShadow_ClearStatistics(arg1);
27010 2 : SWIG_PYTHON_THREAD_END_ALLOW;
27011 : }
27012 2 : if ( bLocalUseExceptions ) {
27013 1 : popErrorHandler();
27014 : }
27015 : #ifndef SED_HACKS
27016 : if ( bLocalUseExceptions ) {
27017 : CPLErr eclass = CPLGetLastErrorType();
27018 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27019 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27020 : }
27021 : }
27022 : #endif
27023 : }
27024 2 : resultobj = SWIG_Py_Void();
27025 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27026 : return resultobj;
27027 : fail:
27028 : return NULL;
27029 : }
27030 :
27031 :
27032 34 : SWIGINTERN PyObject *_wrap_Dataset_GetFieldDomainNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27033 34 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27034 34 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
27035 34 : char **arg2 = (char **) 0 ;
27036 34 : void *argp1 = 0 ;
27037 34 : int res1 = 0 ;
27038 34 : PyObject *swig_obj[2] ;
27039 34 : char **result = 0 ;
27040 :
27041 34 : if (!SWIG_Python_UnpackTuple(args, "Dataset_GetFieldDomainNames", 1, 2, swig_obj)) SWIG_fail;
27042 34 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
27043 34 : if (!SWIG_IsOK(res1)) {
27044 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetFieldDomainNames" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
27045 : }
27046 34 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
27047 34 : if (swig_obj[1]) {
27048 0 : {
27049 : /* %typemap(in) char **dict */
27050 0 : arg2 = NULL;
27051 0 : if ( PySequence_Check( swig_obj[1] ) ) {
27052 0 : int bErr = FALSE;
27053 0 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
27054 0 : if ( bErr )
27055 : {
27056 0 : SWIG_fail;
27057 : }
27058 : }
27059 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
27060 0 : int bErr = FALSE;
27061 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
27062 0 : if ( bErr )
27063 : {
27064 0 : SWIG_fail;
27065 : }
27066 : }
27067 : else {
27068 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
27069 0 : SWIG_fail;
27070 : }
27071 : }
27072 : }
27073 34 : {
27074 34 : const int bLocalUseExceptions = GetUseExceptions();
27075 34 : if ( bLocalUseExceptions ) {
27076 24 : pushErrorHandler();
27077 : }
27078 34 : {
27079 34 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27080 34 : result = (char **)GDALDatasetShadow_GetFieldDomainNames(arg1,arg2);
27081 34 : SWIG_PYTHON_THREAD_END_ALLOW;
27082 : }
27083 34 : if ( bLocalUseExceptions ) {
27084 24 : popErrorHandler();
27085 : }
27086 : #ifndef SED_HACKS
27087 : if ( bLocalUseExceptions ) {
27088 : CPLErr eclass = CPLGetLastErrorType();
27089 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27090 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27091 : }
27092 : }
27093 : #endif
27094 : }
27095 34 : {
27096 : /* %typemap(out) char **CSL -> ( string ) */
27097 34 : bool bErr = false;
27098 34 : resultobj = CSLToList(result, &bErr);
27099 34 : CSLDestroy(result);
27100 34 : if( bErr ) {
27101 0 : SWIG_fail;
27102 : }
27103 : }
27104 34 : {
27105 : /* %typemap(freearg) char **dict */
27106 34 : CSLDestroy( arg2 );
27107 : }
27108 34 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27109 : return resultobj;
27110 0 : fail:
27111 0 : {
27112 : /* %typemap(freearg) char **dict */
27113 0 : CSLDestroy( arg2 );
27114 : }
27115 : return NULL;
27116 : }
27117 :
27118 :
27119 131 : SWIGINTERN PyObject *_wrap_Dataset_GetFieldDomain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27120 131 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27121 131 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
27122 131 : char *arg2 = (char *) 0 ;
27123 131 : void *argp1 = 0 ;
27124 131 : int res1 = 0 ;
27125 131 : int res2 ;
27126 131 : char *buf2 = 0 ;
27127 131 : int alloc2 = 0 ;
27128 131 : PyObject *swig_obj[2] ;
27129 131 : OGRFieldDomainShadow *result = 0 ;
27130 :
27131 131 : if (!SWIG_Python_UnpackTuple(args, "Dataset_GetFieldDomain", 2, 2, swig_obj)) SWIG_fail;
27132 131 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
27133 131 : if (!SWIG_IsOK(res1)) {
27134 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetFieldDomain" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
27135 : }
27136 131 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
27137 131 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
27138 131 : if (!SWIG_IsOK(res2)) {
27139 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_GetFieldDomain" "', argument " "2"" of type '" "char const *""'");
27140 : }
27141 131 : arg2 = reinterpret_cast< char * >(buf2);
27142 131 : {
27143 131 : if (!arg2) {
27144 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
27145 : }
27146 : }
27147 130 : {
27148 130 : const int bLocalUseExceptions = GetUseExceptions();
27149 130 : if ( bLocalUseExceptions ) {
27150 82 : pushErrorHandler();
27151 : }
27152 130 : {
27153 130 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27154 130 : result = (OGRFieldDomainShadow *)GDALDatasetShadow_GetFieldDomain(arg1,(char const *)arg2);
27155 130 : SWIG_PYTHON_THREAD_END_ALLOW;
27156 : }
27157 130 : if ( bLocalUseExceptions ) {
27158 82 : popErrorHandler();
27159 : }
27160 : #ifndef SED_HACKS
27161 : if ( bLocalUseExceptions ) {
27162 : CPLErr eclass = CPLGetLastErrorType();
27163 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27164 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27165 : }
27166 : }
27167 : #endif
27168 : }
27169 130 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
27170 130 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
27171 131 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27172 : return resultobj;
27173 1 : fail:
27174 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
27175 : return NULL;
27176 : }
27177 :
27178 :
27179 38 : SWIGINTERN PyObject *_wrap_Dataset_AddFieldDomain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27180 38 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27181 38 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
27182 38 : OGRFieldDomainShadow *arg2 = (OGRFieldDomainShadow *) 0 ;
27183 38 : void *argp1 = 0 ;
27184 38 : int res1 = 0 ;
27185 38 : void *argp2 = 0 ;
27186 38 : int res2 = 0 ;
27187 38 : PyObject *swig_obj[2] ;
27188 38 : bool result;
27189 :
27190 38 : if (!SWIG_Python_UnpackTuple(args, "Dataset_AddFieldDomain", 2, 2, swig_obj)) SWIG_fail;
27191 38 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
27192 38 : if (!SWIG_IsOK(res1)) {
27193 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_AddFieldDomain" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
27194 : }
27195 38 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
27196 38 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
27197 38 : if (!SWIG_IsOK(res2)) {
27198 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_AddFieldDomain" "', argument " "2"" of type '" "OGRFieldDomainShadow *""'");
27199 : }
27200 38 : arg2 = reinterpret_cast< OGRFieldDomainShadow * >(argp2);
27201 38 : {
27202 38 : if (!arg2) {
27203 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
27204 : }
27205 : }
27206 37 : {
27207 37 : const int bLocalUseExceptions = GetUseExceptions();
27208 37 : if ( bLocalUseExceptions ) {
27209 19 : pushErrorHandler();
27210 : }
27211 37 : {
27212 37 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27213 37 : result = (bool)GDALDatasetShadow_AddFieldDomain(arg1,arg2);
27214 37 : SWIG_PYTHON_THREAD_END_ALLOW;
27215 : }
27216 37 : if ( bLocalUseExceptions ) {
27217 19 : popErrorHandler();
27218 : }
27219 : #ifndef SED_HACKS
27220 : if ( bLocalUseExceptions ) {
27221 : CPLErr eclass = CPLGetLastErrorType();
27222 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27223 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27224 : }
27225 : }
27226 : #endif
27227 : }
27228 37 : resultobj = SWIG_From_bool(static_cast< bool >(result));
27229 44 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27230 : return resultobj;
27231 : fail:
27232 : return NULL;
27233 : }
27234 :
27235 :
27236 25 : SWIGINTERN PyObject *_wrap_Dataset_DeleteFieldDomain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27237 25 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27238 25 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
27239 25 : char *arg2 = (char *) 0 ;
27240 25 : void *argp1 = 0 ;
27241 25 : int res1 = 0 ;
27242 25 : int res2 ;
27243 25 : char *buf2 = 0 ;
27244 25 : int alloc2 = 0 ;
27245 25 : PyObject *swig_obj[2] ;
27246 25 : bool result;
27247 :
27248 25 : if (!SWIG_Python_UnpackTuple(args, "Dataset_DeleteFieldDomain", 2, 2, swig_obj)) SWIG_fail;
27249 25 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
27250 25 : if (!SWIG_IsOK(res1)) {
27251 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_DeleteFieldDomain" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
27252 : }
27253 25 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
27254 25 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
27255 25 : if (!SWIG_IsOK(res2)) {
27256 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_DeleteFieldDomain" "', argument " "2"" of type '" "char const *""'");
27257 : }
27258 25 : arg2 = reinterpret_cast< char * >(buf2);
27259 25 : {
27260 25 : if (!arg2) {
27261 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
27262 : }
27263 : }
27264 25 : {
27265 25 : const int bLocalUseExceptions = GetUseExceptions();
27266 25 : if ( bLocalUseExceptions ) {
27267 8 : pushErrorHandler();
27268 : }
27269 25 : {
27270 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27271 25 : result = (bool)GDALDatasetShadow_DeleteFieldDomain(arg1,(char const *)arg2);
27272 25 : SWIG_PYTHON_THREAD_END_ALLOW;
27273 : }
27274 25 : if ( bLocalUseExceptions ) {
27275 8 : popErrorHandler();
27276 : }
27277 : #ifndef SED_HACKS
27278 : if ( bLocalUseExceptions ) {
27279 : CPLErr eclass = CPLGetLastErrorType();
27280 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27281 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27282 : }
27283 : }
27284 : #endif
27285 : }
27286 25 : resultobj = SWIG_From_bool(static_cast< bool >(result));
27287 25 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
27288 25 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27289 : return resultobj;
27290 0 : fail:
27291 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
27292 : return NULL;
27293 : }
27294 :
27295 :
27296 7 : SWIGINTERN PyObject *_wrap_Dataset_UpdateFieldDomain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27297 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27298 7 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
27299 7 : OGRFieldDomainShadow *arg2 = (OGRFieldDomainShadow *) 0 ;
27300 7 : void *argp1 = 0 ;
27301 7 : int res1 = 0 ;
27302 7 : void *argp2 = 0 ;
27303 7 : int res2 = 0 ;
27304 7 : PyObject *swig_obj[2] ;
27305 7 : bool result;
27306 :
27307 7 : if (!SWIG_Python_UnpackTuple(args, "Dataset_UpdateFieldDomain", 2, 2, swig_obj)) SWIG_fail;
27308 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
27309 7 : if (!SWIG_IsOK(res1)) {
27310 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_UpdateFieldDomain" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
27311 : }
27312 7 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
27313 7 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OGRFieldDomainShadow, 0 | 0 );
27314 7 : if (!SWIG_IsOK(res2)) {
27315 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_UpdateFieldDomain" "', argument " "2"" of type '" "OGRFieldDomainShadow *""'");
27316 : }
27317 7 : arg2 = reinterpret_cast< OGRFieldDomainShadow * >(argp2);
27318 7 : {
27319 7 : if (!arg2) {
27320 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
27321 : }
27322 : }
27323 7 : {
27324 7 : const int bLocalUseExceptions = GetUseExceptions();
27325 7 : if ( bLocalUseExceptions ) {
27326 4 : pushErrorHandler();
27327 : }
27328 7 : {
27329 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27330 7 : result = (bool)GDALDatasetShadow_UpdateFieldDomain(arg1,arg2);
27331 7 : SWIG_PYTHON_THREAD_END_ALLOW;
27332 : }
27333 7 : if ( bLocalUseExceptions ) {
27334 4 : popErrorHandler();
27335 : }
27336 : #ifndef SED_HACKS
27337 : if ( bLocalUseExceptions ) {
27338 : CPLErr eclass = CPLGetLastErrorType();
27339 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27340 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27341 : }
27342 : }
27343 : #endif
27344 : }
27345 7 : resultobj = SWIG_From_bool(static_cast< bool >(result));
27346 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27347 : return resultobj;
27348 : fail:
27349 : return NULL;
27350 : }
27351 :
27352 :
27353 46 : SWIGINTERN PyObject *_wrap_Dataset_GetRelationshipNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27354 46 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27355 46 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
27356 46 : char **arg2 = (char **) 0 ;
27357 46 : void *argp1 = 0 ;
27358 46 : int res1 = 0 ;
27359 46 : PyObject *swig_obj[2] ;
27360 46 : char **result = 0 ;
27361 :
27362 46 : if (!SWIG_Python_UnpackTuple(args, "Dataset_GetRelationshipNames", 1, 2, swig_obj)) SWIG_fail;
27363 46 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
27364 46 : if (!SWIG_IsOK(res1)) {
27365 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetRelationshipNames" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
27366 : }
27367 46 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
27368 46 : if (swig_obj[1]) {
27369 0 : {
27370 : /* %typemap(in) char **dict */
27371 0 : arg2 = NULL;
27372 0 : if ( PySequence_Check( swig_obj[1] ) ) {
27373 0 : int bErr = FALSE;
27374 0 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
27375 0 : if ( bErr )
27376 : {
27377 0 : SWIG_fail;
27378 : }
27379 : }
27380 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
27381 0 : int bErr = FALSE;
27382 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
27383 0 : if ( bErr )
27384 : {
27385 0 : SWIG_fail;
27386 : }
27387 : }
27388 : else {
27389 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
27390 0 : SWIG_fail;
27391 : }
27392 : }
27393 : }
27394 46 : {
27395 46 : const int bLocalUseExceptions = GetUseExceptions();
27396 46 : if ( bLocalUseExceptions ) {
27397 7 : pushErrorHandler();
27398 : }
27399 46 : {
27400 46 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27401 46 : result = (char **)GDALDatasetShadow_GetRelationshipNames(arg1,arg2);
27402 46 : SWIG_PYTHON_THREAD_END_ALLOW;
27403 : }
27404 46 : if ( bLocalUseExceptions ) {
27405 7 : popErrorHandler();
27406 : }
27407 : #ifndef SED_HACKS
27408 : if ( bLocalUseExceptions ) {
27409 : CPLErr eclass = CPLGetLastErrorType();
27410 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27411 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27412 : }
27413 : }
27414 : #endif
27415 : }
27416 46 : {
27417 : /* %typemap(out) char **CSL -> ( string ) */
27418 46 : bool bErr = false;
27419 46 : resultobj = CSLToList(result, &bErr);
27420 46 : CSLDestroy(result);
27421 46 : if( bErr ) {
27422 0 : SWIG_fail;
27423 : }
27424 : }
27425 46 : {
27426 : /* %typemap(freearg) char **dict */
27427 46 : CSLDestroy( arg2 );
27428 : }
27429 46 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27430 : return resultobj;
27431 0 : fail:
27432 0 : {
27433 : /* %typemap(freearg) char **dict */
27434 0 : CSLDestroy( arg2 );
27435 : }
27436 : return NULL;
27437 : }
27438 :
27439 :
27440 52 : SWIGINTERN PyObject *_wrap_Dataset_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27441 52 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27442 52 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
27443 52 : char *arg2 = (char *) 0 ;
27444 52 : void *argp1 = 0 ;
27445 52 : int res1 = 0 ;
27446 52 : int res2 ;
27447 52 : char *buf2 = 0 ;
27448 52 : int alloc2 = 0 ;
27449 52 : PyObject *swig_obj[2] ;
27450 52 : GDALRelationshipShadow *result = 0 ;
27451 :
27452 52 : if (!SWIG_Python_UnpackTuple(args, "Dataset_GetRelationship", 2, 2, swig_obj)) SWIG_fail;
27453 52 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
27454 52 : if (!SWIG_IsOK(res1)) {
27455 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_GetRelationship" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
27456 : }
27457 52 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
27458 52 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
27459 52 : if (!SWIG_IsOK(res2)) {
27460 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_GetRelationship" "', argument " "2"" of type '" "char const *""'");
27461 : }
27462 52 : arg2 = reinterpret_cast< char * >(buf2);
27463 52 : {
27464 52 : if (!arg2) {
27465 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
27466 : }
27467 : }
27468 52 : {
27469 52 : const int bLocalUseExceptions = GetUseExceptions();
27470 52 : if ( bLocalUseExceptions ) {
27471 10 : pushErrorHandler();
27472 : }
27473 52 : {
27474 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27475 52 : result = (GDALRelationshipShadow *)GDALDatasetShadow_GetRelationship(arg1,(char const *)arg2);
27476 52 : SWIG_PYTHON_THREAD_END_ALLOW;
27477 : }
27478 52 : if ( bLocalUseExceptions ) {
27479 10 : popErrorHandler();
27480 : }
27481 : #ifndef SED_HACKS
27482 : if ( bLocalUseExceptions ) {
27483 : CPLErr eclass = CPLGetLastErrorType();
27484 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27485 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27486 : }
27487 : }
27488 : #endif
27489 : }
27490 52 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
27491 52 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
27492 52 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27493 : return resultobj;
27494 0 : fail:
27495 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
27496 : return NULL;
27497 : }
27498 :
27499 :
27500 42 : SWIGINTERN PyObject *_wrap_Dataset_AddRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27501 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27502 42 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
27503 42 : GDALRelationshipShadow *arg2 = (GDALRelationshipShadow *) 0 ;
27504 42 : void *argp1 = 0 ;
27505 42 : int res1 = 0 ;
27506 42 : void *argp2 = 0 ;
27507 42 : int res2 = 0 ;
27508 42 : PyObject *swig_obj[2] ;
27509 42 : bool result;
27510 :
27511 42 : if (!SWIG_Python_UnpackTuple(args, "Dataset_AddRelationship", 2, 2, swig_obj)) SWIG_fail;
27512 42 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
27513 42 : if (!SWIG_IsOK(res1)) {
27514 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_AddRelationship" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
27515 : }
27516 42 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
27517 42 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
27518 42 : if (!SWIG_IsOK(res2)) {
27519 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_AddRelationship" "', argument " "2"" of type '" "GDALRelationshipShadow *""'");
27520 : }
27521 42 : arg2 = reinterpret_cast< GDALRelationshipShadow * >(argp2);
27522 42 : {
27523 42 : if (!arg2) {
27524 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
27525 : }
27526 : }
27527 42 : {
27528 42 : const int bLocalUseExceptions = GetUseExceptions();
27529 42 : if ( bLocalUseExceptions ) {
27530 0 : pushErrorHandler();
27531 : }
27532 42 : {
27533 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27534 42 : result = (bool)GDALDatasetShadow_AddRelationship(arg1,arg2);
27535 42 : SWIG_PYTHON_THREAD_END_ALLOW;
27536 : }
27537 42 : if ( bLocalUseExceptions ) {
27538 0 : popErrorHandler();
27539 : }
27540 : #ifndef SED_HACKS
27541 : if ( bLocalUseExceptions ) {
27542 : CPLErr eclass = CPLGetLastErrorType();
27543 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27544 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27545 : }
27546 : }
27547 : #endif
27548 : }
27549 42 : resultobj = SWIG_From_bool(static_cast< bool >(result));
27550 42 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27551 : return resultobj;
27552 : fail:
27553 : return NULL;
27554 : }
27555 :
27556 :
27557 6 : SWIGINTERN PyObject *_wrap_Dataset_DeleteRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27558 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27559 6 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
27560 6 : char *arg2 = (char *) 0 ;
27561 6 : void *argp1 = 0 ;
27562 6 : int res1 = 0 ;
27563 6 : int res2 ;
27564 6 : char *buf2 = 0 ;
27565 6 : int alloc2 = 0 ;
27566 6 : PyObject *swig_obj[2] ;
27567 6 : bool result;
27568 :
27569 6 : if (!SWIG_Python_UnpackTuple(args, "Dataset_DeleteRelationship", 2, 2, swig_obj)) SWIG_fail;
27570 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
27571 6 : if (!SWIG_IsOK(res1)) {
27572 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_DeleteRelationship" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
27573 : }
27574 6 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
27575 6 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
27576 6 : if (!SWIG_IsOK(res2)) {
27577 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_DeleteRelationship" "', argument " "2"" of type '" "char const *""'");
27578 : }
27579 6 : arg2 = reinterpret_cast< char * >(buf2);
27580 6 : {
27581 6 : if (!arg2) {
27582 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
27583 : }
27584 : }
27585 6 : {
27586 6 : const int bLocalUseExceptions = GetUseExceptions();
27587 6 : if ( bLocalUseExceptions ) {
27588 0 : pushErrorHandler();
27589 : }
27590 6 : {
27591 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27592 6 : result = (bool)GDALDatasetShadow_DeleteRelationship(arg1,(char const *)arg2);
27593 6 : SWIG_PYTHON_THREAD_END_ALLOW;
27594 : }
27595 6 : if ( bLocalUseExceptions ) {
27596 0 : popErrorHandler();
27597 : }
27598 : #ifndef SED_HACKS
27599 : if ( bLocalUseExceptions ) {
27600 : CPLErr eclass = CPLGetLastErrorType();
27601 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27602 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27603 : }
27604 : }
27605 : #endif
27606 : }
27607 6 : resultobj = SWIG_From_bool(static_cast< bool >(result));
27608 6 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
27609 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27610 : return resultobj;
27611 0 : fail:
27612 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
27613 : return NULL;
27614 : }
27615 :
27616 :
27617 9 : SWIGINTERN PyObject *_wrap_Dataset_UpdateRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27618 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27619 9 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
27620 9 : GDALRelationshipShadow *arg2 = (GDALRelationshipShadow *) 0 ;
27621 9 : void *argp1 = 0 ;
27622 9 : int res1 = 0 ;
27623 9 : void *argp2 = 0 ;
27624 9 : int res2 = 0 ;
27625 9 : PyObject *swig_obj[2] ;
27626 9 : bool result;
27627 :
27628 9 : if (!SWIG_Python_UnpackTuple(args, "Dataset_UpdateRelationship", 2, 2, swig_obj)) SWIG_fail;
27629 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
27630 9 : if (!SWIG_IsOK(res1)) {
27631 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_UpdateRelationship" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
27632 : }
27633 9 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
27634 9 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
27635 9 : if (!SWIG_IsOK(res2)) {
27636 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dataset_UpdateRelationship" "', argument " "2"" of type '" "GDALRelationshipShadow *""'");
27637 : }
27638 9 : arg2 = reinterpret_cast< GDALRelationshipShadow * >(argp2);
27639 9 : {
27640 9 : if (!arg2) {
27641 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
27642 : }
27643 : }
27644 9 : {
27645 9 : const int bLocalUseExceptions = GetUseExceptions();
27646 9 : if ( bLocalUseExceptions ) {
27647 0 : pushErrorHandler();
27648 : }
27649 9 : {
27650 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27651 9 : result = (bool)GDALDatasetShadow_UpdateRelationship(arg1,arg2);
27652 9 : SWIG_PYTHON_THREAD_END_ALLOW;
27653 : }
27654 9 : if ( bLocalUseExceptions ) {
27655 0 : popErrorHandler();
27656 : }
27657 : #ifndef SED_HACKS
27658 : if ( bLocalUseExceptions ) {
27659 : CPLErr eclass = CPLGetLastErrorType();
27660 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27661 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27662 : }
27663 : }
27664 : #endif
27665 : }
27666 9 : resultobj = SWIG_From_bool(static_cast< bool >(result));
27667 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27668 : return resultobj;
27669 : fail:
27670 : return NULL;
27671 : }
27672 :
27673 :
27674 14 : SWIGINTERN PyObject *_wrap_Dataset_AsMDArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27675 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27676 14 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
27677 14 : char **arg2 = (char **) NULL ;
27678 14 : void *argp1 = 0 ;
27679 14 : int res1 = 0 ;
27680 14 : PyObject *swig_obj[2] ;
27681 14 : GDALMDArrayHS *result = 0 ;
27682 :
27683 14 : if (!SWIG_Python_UnpackTuple(args, "Dataset_AsMDArray", 1, 2, swig_obj)) SWIG_fail;
27684 14 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
27685 14 : if (!SWIG_IsOK(res1)) {
27686 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_AsMDArray" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
27687 : }
27688 14 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
27689 14 : if (swig_obj[1]) {
27690 11 : {
27691 : /* %typemap(in) char **dict */
27692 11 : arg2 = NULL;
27693 11 : if ( PySequence_Check( swig_obj[1] ) ) {
27694 11 : int bErr = FALSE;
27695 11 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
27696 11 : if ( bErr )
27697 : {
27698 0 : SWIG_fail;
27699 : }
27700 : }
27701 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
27702 0 : int bErr = FALSE;
27703 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
27704 0 : if ( bErr )
27705 : {
27706 0 : SWIG_fail;
27707 : }
27708 : }
27709 : else {
27710 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
27711 0 : SWIG_fail;
27712 : }
27713 : }
27714 : }
27715 14 : {
27716 14 : const int bLocalUseExceptions = GetUseExceptions();
27717 14 : if ( bLocalUseExceptions ) {
27718 3 : pushErrorHandler();
27719 : }
27720 14 : {
27721 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27722 14 : result = (GDALMDArrayHS *)GDALDatasetShadow_AsMDArray(arg1,arg2);
27723 14 : SWIG_PYTHON_THREAD_END_ALLOW;
27724 : }
27725 14 : if ( bLocalUseExceptions ) {
27726 3 : popErrorHandler();
27727 : }
27728 : #ifndef SED_HACKS
27729 : if ( bLocalUseExceptions ) {
27730 : CPLErr eclass = CPLGetLastErrorType();
27731 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
27732 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
27733 : }
27734 : }
27735 : #endif
27736 : }
27737 14 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_OWN | 0 );
27738 14 : {
27739 : /* %typemap(freearg) char **dict */
27740 14 : CSLDestroy( arg2 );
27741 : }
27742 20 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
27743 : return resultobj;
27744 0 : fail:
27745 0 : {
27746 : /* %typemap(freearg) char **dict */
27747 0 : CSLDestroy( arg2 );
27748 : }
27749 : return NULL;
27750 : }
27751 :
27752 :
27753 176670 : SWIGINTERN PyObject *_wrap_Dataset_ReadRaster1(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27754 176670 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
27755 176670 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
27756 176670 : double arg2 ;
27757 176670 : double arg3 ;
27758 176670 : double arg4 ;
27759 176670 : double arg5 ;
27760 176670 : void **arg6 = (void **) 0 ;
27761 176670 : int *arg7 = (int *) 0 ;
27762 176670 : int *arg8 = (int *) 0 ;
27763 176670 : GDALDataType *arg9 = (GDALDataType *) 0 ;
27764 176670 : int arg10 = (int) 0 ;
27765 176670 : int *arg11 = (int *) 0 ;
27766 176670 : GIntBig *arg12 = (GIntBig *) 0 ;
27767 176670 : GIntBig *arg13 = (GIntBig *) 0 ;
27768 176670 : GIntBig *arg14 = (GIntBig *) 0 ;
27769 176670 : GDALRIOResampleAlg arg15 = (GDALRIOResampleAlg) GRIORA_NearestNeighbour ;
27770 176670 : GDALProgressFunc arg16 = (GDALProgressFunc) NULL ;
27771 176670 : void *arg17 = (void *) NULL ;
27772 176670 : void *arg18 = (void *) NULL ;
27773 176670 : void *argp1 = 0 ;
27774 176670 : int res1 = 0 ;
27775 176670 : double val2 ;
27776 176670 : int ecode2 = 0 ;
27777 176670 : double val3 ;
27778 176670 : int ecode3 = 0 ;
27779 176670 : double val4 ;
27780 176670 : int ecode4 = 0 ;
27781 176670 : double val5 ;
27782 176670 : int ecode5 = 0 ;
27783 176670 : void *pyObject6 = NULL ;
27784 176670 : int val7 ;
27785 176670 : int val8 ;
27786 176670 : GDALDataType val9 ;
27787 176670 : GIntBig val12 ;
27788 176670 : GIntBig val13 ;
27789 176670 : GIntBig val14 ;
27790 176670 : PyObject * obj0 = 0 ;
27791 176670 : PyObject * obj1 = 0 ;
27792 176670 : PyObject * obj2 = 0 ;
27793 176670 : PyObject * obj3 = 0 ;
27794 176670 : PyObject * obj4 = 0 ;
27795 176670 : PyObject * obj5 = 0 ;
27796 176670 : PyObject * obj6 = 0 ;
27797 176670 : PyObject * obj7 = 0 ;
27798 176670 : PyObject * obj8 = 0 ;
27799 176670 : PyObject * obj9 = 0 ;
27800 176670 : PyObject * obj10 = 0 ;
27801 176670 : PyObject * obj11 = 0 ;
27802 176670 : PyObject * obj12 = 0 ;
27803 176670 : PyObject * obj13 = 0 ;
27804 176670 : PyObject * obj14 = 0 ;
27805 176670 : PyObject * obj15 = 0 ;
27806 176670 : char * kwnames[] = {
27807 : (char *)"self", (char *)"xoff", (char *)"yoff", (char *)"xsize", (char *)"ysize", (char *)"buf_xsize", (char *)"buf_ysize", (char *)"buf_type", (char *)"band_list", (char *)"buf_pixel_space", (char *)"buf_line_space", (char *)"buf_band_space", (char *)"resample_alg", (char *)"callback", (char *)"callback_data", (char *)"inputOutputBuf", NULL
27808 : };
27809 176670 : CPLErr result;
27810 :
27811 : /* %typemap(arginit) ( const char* callback_data=NULL) */
27812 176670 : PyProgressData *psProgressInfo;
27813 176670 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
27814 176670 : psProgressInfo->nLastReported = -1;
27815 176670 : psProgressInfo->psPyCallback = NULL;
27816 176670 : psProgressInfo->psPyCallbackData = NULL;
27817 176670 : arg17 = psProgressInfo;
27818 176670 : {
27819 : /* %typemap(in,numinputs=0) ( void **outPythonObject ) ( void *pyObject6 = NULL ) */
27820 176670 : arg6 = &pyObject6;
27821 : }
27822 176670 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OOOOOOOOOOO:Dataset_ReadRaster1", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15)) SWIG_fail;
27823 176670 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
27824 176670 : if (!SWIG_IsOK(res1)) {
27825 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dataset_ReadRaster1" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
27826 : }
27827 176670 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
27828 176670 : ecode2 = SWIG_AsVal_double(obj1, &val2);
27829 176670 : if (!SWIG_IsOK(ecode2)) {
27830 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dataset_ReadRaster1" "', argument " "2"" of type '" "double""'");
27831 : }
27832 176670 : arg2 = static_cast< double >(val2);
27833 176670 : ecode3 = SWIG_AsVal_double(obj2, &val3);
27834 176670 : if (!SWIG_IsOK(ecode3)) {
27835 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dataset_ReadRaster1" "', argument " "3"" of type '" "double""'");
27836 : }
27837 176670 : arg3 = static_cast< double >(val3);
27838 176670 : ecode4 = SWIG_AsVal_double(obj3, &val4);
27839 176670 : if (!SWIG_IsOK(ecode4)) {
27840 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Dataset_ReadRaster1" "', argument " "4"" of type '" "double""'");
27841 : }
27842 176670 : arg4 = static_cast< double >(val4);
27843 176670 : ecode5 = SWIG_AsVal_double(obj4, &val5);
27844 176670 : if (!SWIG_IsOK(ecode5)) {
27845 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Dataset_ReadRaster1" "', argument " "5"" of type '" "double""'");
27846 : }
27847 176670 : arg5 = static_cast< double >(val5);
27848 176670 : if (obj5) {
27849 176670 : {
27850 : /* %typemap(in) (int *optional_##int) */
27851 176670 : if ( obj5 == Py_None ) {
27852 : arg7 = 0;
27853 : }
27854 176670 : else if ( PyArg_Parse( obj5,"i" ,&val7 ) ) {
27855 : arg7 = (int *) &val7;
27856 : }
27857 : else {
27858 2 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
27859 2 : SWIG_fail;
27860 : }
27861 : }
27862 : }
27863 176668 : if (obj6) {
27864 176668 : {
27865 : /* %typemap(in) (int *optional_##int) */
27866 176668 : if ( obj6 == Py_None ) {
27867 : arg8 = 0;
27868 : }
27869 176668 : else if ( PyArg_Parse( obj6,"i" ,&val8 ) ) {
27870 : arg8 = (int *) &val8;
27871 : }
27872 : else {
27873 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
27874 0 : SWIG_fail;
27875 : }
27876 : }
27877 : }
27878 176668 : if (obj7) {
27879 176668 : {
27880 : /* %typemap(in) (GDALDataType *optional_GDALDataType) */
27881 176668 : int intval = 0;
27882 176668 : if ( obj7 == Py_None ) {
27883 : arg9 = NULL;
27884 : }
27885 353336 : else if ( SWIG_IsOK(SWIG_AsVal_int(obj7, &intval)) ) {
27886 176668 : if( intval < GDT_Unknown || intval >= GDT_TypeCount )
27887 : {
27888 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
27889 : }
27890 176668 : val9 = static_cast<GDALDataType>(intval);
27891 176668 : arg9 = &val9;
27892 : }
27893 : else {
27894 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
27895 0 : SWIG_fail;
27896 : }
27897 : }
27898 : }
27899 176668 : if (obj8) {
27900 176668 : {
27901 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
27902 176668 : arg11 = CreateCIntListFromSequence(obj8, &arg10);
27903 176668 : if( arg10 < 0 ) {
27904 0 : SWIG_fail;
27905 : }
27906 : }
27907 : }
27908 176668 : if (obj9) {
27909 176668 : {
27910 : /* %typemap(in) (GIntBig *optional_##GIntBig) */
27911 176668 : if ( obj9 == Py_None ) {
27912 : arg12 = 0;
27913 : }
27914 1111 : else if ( PyArg_Parse( obj9,"L" ,&val12 ) ) {
27915 : arg12 = (GIntBig *) &val12;
27916 : }
27917 : else {
27918 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
27919 0 : SWIG_fail;
27920 : }
27921 : }
27922 : }
27923 176668 : if (obj10) {
27924 176668 : {
27925 : /* %typemap(in) (GIntBig *optional_##GIntBig) */
27926 176668 : if ( obj10 == Py_None ) {
27927 : arg13 = 0;
27928 : }
27929 39 : else if ( PyArg_Parse( obj10,"L" ,&val13 ) ) {
27930 : arg13 = (GIntBig *) &val13;
27931 : }
27932 : else {
27933 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
27934 0 : SWIG_fail;
27935 : }
27936 : }
27937 : }
27938 176668 : if (obj11) {
27939 176668 : {
27940 : /* %typemap(in) (GIntBig *optional_##GIntBig) */
27941 176668 : if ( obj11 == Py_None ) {
27942 : arg14 = 0;
27943 : }
27944 1089 : else if ( PyArg_Parse( obj11,"L" ,&val14 ) ) {
27945 : arg14 = (GIntBig *) &val14;
27946 : }
27947 : else {
27948 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
27949 0 : SWIG_fail;
27950 : }
27951 : }
27952 : }
27953 176668 : if (obj12) {
27954 176668 : {
27955 : // %typemap(in) GDALRIOResampleAlg
27956 176668 : int val = 0;
27957 176668 : int ecode = SWIG_AsVal_int(obj12, &val);
27958 176668 : if (!SWIG_IsOK(ecode)) {
27959 1 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALRIOResampleAlg");
27960 : }
27961 176667 : if( val < 0 ||
27962 176666 : ( val >= static_cast<int>(GRIORA_RESERVED_START) &&
27963 176665 : val <= static_cast<int>(GRIORA_RESERVED_END) ) ||
27964 : val > static_cast<int>(GRIORA_LAST) )
27965 : {
27966 2 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for resample_alg");
27967 : }
27968 : arg15 = static_cast< GDALRIOResampleAlg >(val);
27969 : }
27970 : }
27971 176665 : if (obj13) {
27972 176665 : {
27973 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
27974 : /* callback_func typemap */
27975 :
27976 : /* In some cases 0 is passed instead of None. */
27977 : /* See https://github.com/OSGeo/gdal/pull/219 */
27978 176665 : if ( PyLong_Check(obj13) || PyInt_Check(obj13) )
27979 : {
27980 0 : if( PyLong_AsLong(obj13) == 0 )
27981 : {
27982 0 : obj13 = Py_None;
27983 : }
27984 : }
27985 :
27986 176665 : if (obj13 && obj13 != Py_None ) {
27987 19 : void* cbfunction = NULL;
27988 19 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj13,
27989 : (void**)&cbfunction,
27990 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
27991 : SWIG_POINTER_EXCEPTION | 0 ));
27992 :
27993 19 : if ( cbfunction == GDALTermProgress ) {
27994 : arg16 = GDALTermProgress;
27995 : } else {
27996 19 : if (!PyCallable_Check(obj13)) {
27997 0 : PyErr_SetString( PyExc_RuntimeError,
27998 : "Object given is not a Python function" );
27999 0 : SWIG_fail;
28000 : }
28001 19 : psProgressInfo->psPyCallback = obj13;
28002 19 : arg16 = PyProgressProxy;
28003 : }
28004 :
28005 : }
28006 :
28007 : }
28008 : }
28009 176665 : if (obj14) {
28010 176665 : {
28011 : /* %typemap(in) ( void* callback_data=NULL) */
28012 176665 : psProgressInfo->psPyCallbackData = obj14 ;
28013 : }
28014 : }
28015 176665 : if (obj15) {
28016 176665 : {
28017 : /* %typemap(in) ( void *inPythonObject ) */
28018 176665 : arg18 = obj15;
28019 : }
28020 : }
28021 176665 : {
28022 176665 : const int bLocalUseExceptions = GetUseExceptions();
28023 176665 : if ( bLocalUseExceptions ) {
28024 169663 : pushErrorHandler();
28025 : }
28026 176665 : {
28027 176665 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28028 176665 : result = (CPLErr)GDALDatasetShadow_ReadRaster1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
28029 176665 : SWIG_PYTHON_THREAD_END_ALLOW;
28030 : }
28031 176665 : if ( bLocalUseExceptions ) {
28032 169663 : popErrorHandler();
28033 : }
28034 : #ifndef SED_HACKS
28035 : if ( bLocalUseExceptions ) {
28036 : CPLErr eclass = CPLGetLastErrorType();
28037 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28038 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28039 : }
28040 : }
28041 : #endif
28042 : }
28043 176665 : resultobj = SWIG_From_int(static_cast< int >(result));
28044 176665 : {
28045 : /* %typemap(argout) ( void **outPythonObject ) */
28046 176665 : Py_XDECREF(resultobj);
28047 176665 : if (*arg6)
28048 : {
28049 : resultobj = (PyObject*)*arg6;
28050 : }
28051 : else
28052 : {
28053 1312 : resultobj = Py_None;
28054 1312 : Py_INCREF(resultobj);
28055 : }
28056 : }
28057 176665 : {
28058 : /* %typemap(freearg) (int nList, int* pList) */
28059 176665 : free(arg11);
28060 : }
28061 176665 : {
28062 : /* %typemap(freearg) ( void* callback_data=NULL) */
28063 :
28064 176665 : CPLFree(psProgressInfo);
28065 :
28066 : }
28067 176932 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28068 : return resultobj;
28069 5 : fail:
28070 5 : {
28071 : /* %typemap(freearg) (int nList, int* pList) */
28072 5 : free(arg11);
28073 : }
28074 5 : {
28075 : /* %typemap(freearg) ( void* callback_data=NULL) */
28076 :
28077 5 : CPLFree(psProgressInfo);
28078 :
28079 : }
28080 : return NULL;
28081 : }
28082 :
28083 :
28084 277 : SWIGINTERN PyObject *Dataset_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28085 277 : PyObject *obj;
28086 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
28087 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALDatasetShadow, SWIG_NewClientData(obj));
28088 277 : return SWIG_Py_Void();
28089 : }
28090 :
28091 13 : SWIGINTERN PyObject *_wrap_RATDateTime_nYear_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28092 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28093 13 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28094 13 : int arg2 ;
28095 13 : void *argp1 = 0 ;
28096 13 : int res1 = 0 ;
28097 13 : int val2 ;
28098 13 : int ecode2 = 0 ;
28099 13 : PyObject *swig_obj[2] ;
28100 :
28101 13 : if (!SWIG_Python_UnpackTuple(args, "RATDateTime_nYear_set", 2, 2, swig_obj)) SWIG_fail;
28102 13 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28103 13 : if (!SWIG_IsOK(res1)) {
28104 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_nYear_set" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28105 : }
28106 13 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28107 13 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
28108 13 : if (!SWIG_IsOK(ecode2)) {
28109 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RATDateTime_nYear_set" "', argument " "2"" of type '" "int""'");
28110 : }
28111 13 : arg2 = static_cast< int >(val2);
28112 13 : {
28113 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28114 13 : if (arg1) (arg1)->nYear = arg2;
28115 13 : SWIG_PYTHON_THREAD_END_ALLOW;
28116 : }
28117 13 : resultobj = SWIG_Py_Void();
28118 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28119 : return resultobj;
28120 : fail:
28121 : return NULL;
28122 : }
28123 :
28124 :
28125 3 : SWIGINTERN PyObject *_wrap_RATDateTime_nYear_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28126 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28127 3 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28128 3 : void *argp1 = 0 ;
28129 3 : int res1 = 0 ;
28130 3 : PyObject *swig_obj[1] ;
28131 3 : int result;
28132 :
28133 3 : if (!args) SWIG_fail;
28134 3 : swig_obj[0] = args;
28135 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28136 3 : if (!SWIG_IsOK(res1)) {
28137 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_nYear_get" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28138 : }
28139 3 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28140 3 : {
28141 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28142 3 : result = (int) ((arg1)->nYear);
28143 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28144 : }
28145 3 : resultobj = SWIG_From_int(static_cast< int >(result));
28146 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28147 : return resultobj;
28148 : fail:
28149 : return NULL;
28150 : }
28151 :
28152 :
28153 13 : SWIGINTERN PyObject *_wrap_RATDateTime_nMonth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28154 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28155 13 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28156 13 : int arg2 ;
28157 13 : void *argp1 = 0 ;
28158 13 : int res1 = 0 ;
28159 13 : int val2 ;
28160 13 : int ecode2 = 0 ;
28161 13 : PyObject *swig_obj[2] ;
28162 :
28163 13 : if (!SWIG_Python_UnpackTuple(args, "RATDateTime_nMonth_set", 2, 2, swig_obj)) SWIG_fail;
28164 13 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28165 13 : if (!SWIG_IsOK(res1)) {
28166 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_nMonth_set" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28167 : }
28168 13 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28169 13 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
28170 13 : if (!SWIG_IsOK(ecode2)) {
28171 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RATDateTime_nMonth_set" "', argument " "2"" of type '" "int""'");
28172 : }
28173 13 : arg2 = static_cast< int >(val2);
28174 13 : {
28175 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28176 13 : if (arg1) (arg1)->nMonth = arg2;
28177 13 : SWIG_PYTHON_THREAD_END_ALLOW;
28178 : }
28179 13 : resultobj = SWIG_Py_Void();
28180 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28181 : return resultobj;
28182 : fail:
28183 : return NULL;
28184 : }
28185 :
28186 :
28187 3 : SWIGINTERN PyObject *_wrap_RATDateTime_nMonth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28188 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28189 3 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28190 3 : void *argp1 = 0 ;
28191 3 : int res1 = 0 ;
28192 3 : PyObject *swig_obj[1] ;
28193 3 : int result;
28194 :
28195 3 : if (!args) SWIG_fail;
28196 3 : swig_obj[0] = args;
28197 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28198 3 : if (!SWIG_IsOK(res1)) {
28199 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_nMonth_get" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28200 : }
28201 3 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28202 3 : {
28203 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28204 3 : result = (int) ((arg1)->nMonth);
28205 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28206 : }
28207 3 : resultobj = SWIG_From_int(static_cast< int >(result));
28208 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28209 : return resultobj;
28210 : fail:
28211 : return NULL;
28212 : }
28213 :
28214 :
28215 13 : SWIGINTERN PyObject *_wrap_RATDateTime_nDay_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28216 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28217 13 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28218 13 : int arg2 ;
28219 13 : void *argp1 = 0 ;
28220 13 : int res1 = 0 ;
28221 13 : int val2 ;
28222 13 : int ecode2 = 0 ;
28223 13 : PyObject *swig_obj[2] ;
28224 :
28225 13 : if (!SWIG_Python_UnpackTuple(args, "RATDateTime_nDay_set", 2, 2, swig_obj)) SWIG_fail;
28226 13 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28227 13 : if (!SWIG_IsOK(res1)) {
28228 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_nDay_set" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28229 : }
28230 13 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28231 13 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
28232 13 : if (!SWIG_IsOK(ecode2)) {
28233 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RATDateTime_nDay_set" "', argument " "2"" of type '" "int""'");
28234 : }
28235 13 : arg2 = static_cast< int >(val2);
28236 13 : {
28237 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28238 13 : if (arg1) (arg1)->nDay = arg2;
28239 13 : SWIG_PYTHON_THREAD_END_ALLOW;
28240 : }
28241 13 : resultobj = SWIG_Py_Void();
28242 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28243 : return resultobj;
28244 : fail:
28245 : return NULL;
28246 : }
28247 :
28248 :
28249 3 : SWIGINTERN PyObject *_wrap_RATDateTime_nDay_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28250 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28251 3 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28252 3 : void *argp1 = 0 ;
28253 3 : int res1 = 0 ;
28254 3 : PyObject *swig_obj[1] ;
28255 3 : int result;
28256 :
28257 3 : if (!args) SWIG_fail;
28258 3 : swig_obj[0] = args;
28259 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28260 3 : if (!SWIG_IsOK(res1)) {
28261 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_nDay_get" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28262 : }
28263 3 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28264 3 : {
28265 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28266 3 : result = (int) ((arg1)->nDay);
28267 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28268 : }
28269 3 : resultobj = SWIG_From_int(static_cast< int >(result));
28270 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28271 : return resultobj;
28272 : fail:
28273 : return NULL;
28274 : }
28275 :
28276 :
28277 13 : SWIGINTERN PyObject *_wrap_RATDateTime_nHour_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28278 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28279 13 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28280 13 : int arg2 ;
28281 13 : void *argp1 = 0 ;
28282 13 : int res1 = 0 ;
28283 13 : int val2 ;
28284 13 : int ecode2 = 0 ;
28285 13 : PyObject *swig_obj[2] ;
28286 :
28287 13 : if (!SWIG_Python_UnpackTuple(args, "RATDateTime_nHour_set", 2, 2, swig_obj)) SWIG_fail;
28288 13 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28289 13 : if (!SWIG_IsOK(res1)) {
28290 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_nHour_set" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28291 : }
28292 13 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28293 13 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
28294 13 : if (!SWIG_IsOK(ecode2)) {
28295 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RATDateTime_nHour_set" "', argument " "2"" of type '" "int""'");
28296 : }
28297 13 : arg2 = static_cast< int >(val2);
28298 13 : {
28299 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28300 13 : if (arg1) (arg1)->nHour = arg2;
28301 13 : SWIG_PYTHON_THREAD_END_ALLOW;
28302 : }
28303 13 : resultobj = SWIG_Py_Void();
28304 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28305 : return resultobj;
28306 : fail:
28307 : return NULL;
28308 : }
28309 :
28310 :
28311 3 : SWIGINTERN PyObject *_wrap_RATDateTime_nHour_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28312 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28313 3 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28314 3 : void *argp1 = 0 ;
28315 3 : int res1 = 0 ;
28316 3 : PyObject *swig_obj[1] ;
28317 3 : int result;
28318 :
28319 3 : if (!args) SWIG_fail;
28320 3 : swig_obj[0] = args;
28321 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28322 3 : if (!SWIG_IsOK(res1)) {
28323 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_nHour_get" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28324 : }
28325 3 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28326 3 : {
28327 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28328 3 : result = (int) ((arg1)->nHour);
28329 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28330 : }
28331 3 : resultobj = SWIG_From_int(static_cast< int >(result));
28332 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28333 : return resultobj;
28334 : fail:
28335 : return NULL;
28336 : }
28337 :
28338 :
28339 13 : SWIGINTERN PyObject *_wrap_RATDateTime_nMinute_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28340 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28341 13 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28342 13 : int arg2 ;
28343 13 : void *argp1 = 0 ;
28344 13 : int res1 = 0 ;
28345 13 : int val2 ;
28346 13 : int ecode2 = 0 ;
28347 13 : PyObject *swig_obj[2] ;
28348 :
28349 13 : if (!SWIG_Python_UnpackTuple(args, "RATDateTime_nMinute_set", 2, 2, swig_obj)) SWIG_fail;
28350 13 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28351 13 : if (!SWIG_IsOK(res1)) {
28352 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_nMinute_set" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28353 : }
28354 13 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28355 13 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
28356 13 : if (!SWIG_IsOK(ecode2)) {
28357 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RATDateTime_nMinute_set" "', argument " "2"" of type '" "int""'");
28358 : }
28359 13 : arg2 = static_cast< int >(val2);
28360 13 : {
28361 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28362 13 : if (arg1) (arg1)->nMinute = arg2;
28363 13 : SWIG_PYTHON_THREAD_END_ALLOW;
28364 : }
28365 13 : resultobj = SWIG_Py_Void();
28366 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28367 : return resultobj;
28368 : fail:
28369 : return NULL;
28370 : }
28371 :
28372 :
28373 3 : SWIGINTERN PyObject *_wrap_RATDateTime_nMinute_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28374 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28375 3 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28376 3 : void *argp1 = 0 ;
28377 3 : int res1 = 0 ;
28378 3 : PyObject *swig_obj[1] ;
28379 3 : int result;
28380 :
28381 3 : if (!args) SWIG_fail;
28382 3 : swig_obj[0] = args;
28383 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28384 3 : if (!SWIG_IsOK(res1)) {
28385 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_nMinute_get" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28386 : }
28387 3 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28388 3 : {
28389 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28390 3 : result = (int) ((arg1)->nMinute);
28391 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28392 : }
28393 3 : resultobj = SWIG_From_int(static_cast< int >(result));
28394 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28395 : return resultobj;
28396 : fail:
28397 : return NULL;
28398 : }
28399 :
28400 :
28401 13 : SWIGINTERN PyObject *_wrap_RATDateTime_fSecond_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28402 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28403 13 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28404 13 : float arg2 ;
28405 13 : void *argp1 = 0 ;
28406 13 : int res1 = 0 ;
28407 13 : float val2 ;
28408 13 : int ecode2 = 0 ;
28409 13 : PyObject *swig_obj[2] ;
28410 :
28411 13 : if (!SWIG_Python_UnpackTuple(args, "RATDateTime_fSecond_set", 2, 2, swig_obj)) SWIG_fail;
28412 13 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28413 13 : if (!SWIG_IsOK(res1)) {
28414 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_fSecond_set" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28415 : }
28416 13 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28417 13 : ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
28418 13 : if (!SWIG_IsOK(ecode2)) {
28419 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RATDateTime_fSecond_set" "', argument " "2"" of type '" "float""'");
28420 : }
28421 13 : arg2 = static_cast< float >(val2);
28422 13 : {
28423 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28424 13 : if (arg1) (arg1)->fSecond = arg2;
28425 13 : SWIG_PYTHON_THREAD_END_ALLOW;
28426 : }
28427 13 : resultobj = SWIG_Py_Void();
28428 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28429 : return resultobj;
28430 : fail:
28431 : return NULL;
28432 : }
28433 :
28434 :
28435 6 : SWIGINTERN PyObject *_wrap_RATDateTime_fSecond_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28436 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28437 6 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28438 6 : void *argp1 = 0 ;
28439 6 : int res1 = 0 ;
28440 6 : PyObject *swig_obj[1] ;
28441 6 : float result;
28442 :
28443 6 : if (!args) SWIG_fail;
28444 6 : swig_obj[0] = args;
28445 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28446 6 : if (!SWIG_IsOK(res1)) {
28447 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_fSecond_get" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28448 : }
28449 6 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28450 6 : {
28451 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28452 6 : result = (float) ((arg1)->fSecond);
28453 6 : SWIG_PYTHON_THREAD_END_ALLOW;
28454 : }
28455 6 : resultobj = SWIG_From_float(static_cast< float >(result));
28456 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28457 : return resultobj;
28458 : fail:
28459 : return NULL;
28460 : }
28461 :
28462 :
28463 19 : SWIGINTERN PyObject *_wrap_RATDateTime_nTimeZoneHour_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28464 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28465 19 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28466 19 : int arg2 ;
28467 19 : void *argp1 = 0 ;
28468 19 : int res1 = 0 ;
28469 19 : int val2 ;
28470 19 : int ecode2 = 0 ;
28471 19 : PyObject *swig_obj[2] ;
28472 :
28473 19 : if (!SWIG_Python_UnpackTuple(args, "RATDateTime_nTimeZoneHour_set", 2, 2, swig_obj)) SWIG_fail;
28474 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28475 19 : if (!SWIG_IsOK(res1)) {
28476 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_nTimeZoneHour_set" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28477 : }
28478 19 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28479 19 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
28480 19 : if (!SWIG_IsOK(ecode2)) {
28481 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RATDateTime_nTimeZoneHour_set" "', argument " "2"" of type '" "int""'");
28482 : }
28483 19 : arg2 = static_cast< int >(val2);
28484 19 : {
28485 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28486 19 : if (arg1) (arg1)->nTimeZoneHour = arg2;
28487 19 : SWIG_PYTHON_THREAD_END_ALLOW;
28488 : }
28489 19 : resultobj = SWIG_Py_Void();
28490 19 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28491 : return resultobj;
28492 : fail:
28493 : return NULL;
28494 : }
28495 :
28496 :
28497 3 : SWIGINTERN PyObject *_wrap_RATDateTime_nTimeZoneHour_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28498 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28499 3 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28500 3 : void *argp1 = 0 ;
28501 3 : int res1 = 0 ;
28502 3 : PyObject *swig_obj[1] ;
28503 3 : int result;
28504 :
28505 3 : if (!args) SWIG_fail;
28506 3 : swig_obj[0] = args;
28507 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28508 3 : if (!SWIG_IsOK(res1)) {
28509 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_nTimeZoneHour_get" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28510 : }
28511 3 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28512 3 : {
28513 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28514 3 : result = (int) ((arg1)->nTimeZoneHour);
28515 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28516 : }
28517 3 : resultobj = SWIG_From_int(static_cast< int >(result));
28518 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28519 : return resultobj;
28520 : fail:
28521 : return NULL;
28522 : }
28523 :
28524 :
28525 19 : SWIGINTERN PyObject *_wrap_RATDateTime_nTimeZoneMinute_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28526 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28527 19 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28528 19 : int arg2 ;
28529 19 : void *argp1 = 0 ;
28530 19 : int res1 = 0 ;
28531 19 : int val2 ;
28532 19 : int ecode2 = 0 ;
28533 19 : PyObject *swig_obj[2] ;
28534 :
28535 19 : if (!SWIG_Python_UnpackTuple(args, "RATDateTime_nTimeZoneMinute_set", 2, 2, swig_obj)) SWIG_fail;
28536 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28537 19 : if (!SWIG_IsOK(res1)) {
28538 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_nTimeZoneMinute_set" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28539 : }
28540 19 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28541 19 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
28542 19 : if (!SWIG_IsOK(ecode2)) {
28543 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RATDateTime_nTimeZoneMinute_set" "', argument " "2"" of type '" "int""'");
28544 : }
28545 19 : arg2 = static_cast< int >(val2);
28546 19 : {
28547 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28548 19 : if (arg1) (arg1)->nTimeZoneMinute = arg2;
28549 19 : SWIG_PYTHON_THREAD_END_ALLOW;
28550 : }
28551 19 : resultobj = SWIG_Py_Void();
28552 19 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28553 : return resultobj;
28554 : fail:
28555 : return NULL;
28556 : }
28557 :
28558 :
28559 3 : SWIGINTERN PyObject *_wrap_RATDateTime_nTimeZoneMinute_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28560 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28561 3 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28562 3 : void *argp1 = 0 ;
28563 3 : int res1 = 0 ;
28564 3 : PyObject *swig_obj[1] ;
28565 3 : int result;
28566 :
28567 3 : if (!args) SWIG_fail;
28568 3 : swig_obj[0] = args;
28569 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28570 3 : if (!SWIG_IsOK(res1)) {
28571 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_nTimeZoneMinute_get" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28572 : }
28573 3 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28574 3 : {
28575 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28576 3 : result = (int) ((arg1)->nTimeZoneMinute);
28577 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28578 : }
28579 3 : resultobj = SWIG_From_int(static_cast< int >(result));
28580 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28581 : return resultobj;
28582 : fail:
28583 : return NULL;
28584 : }
28585 :
28586 :
28587 19 : SWIGINTERN PyObject *_wrap_RATDateTime_bPositiveTimeZone_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28588 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28589 19 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28590 19 : bool arg2 ;
28591 19 : void *argp1 = 0 ;
28592 19 : int res1 = 0 ;
28593 19 : bool val2 ;
28594 19 : int ecode2 = 0 ;
28595 19 : PyObject *swig_obj[2] ;
28596 :
28597 19 : if (!SWIG_Python_UnpackTuple(args, "RATDateTime_bPositiveTimeZone_set", 2, 2, swig_obj)) SWIG_fail;
28598 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28599 19 : if (!SWIG_IsOK(res1)) {
28600 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_bPositiveTimeZone_set" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28601 : }
28602 19 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28603 19 : ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
28604 19 : if (!SWIG_IsOK(ecode2)) {
28605 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RATDateTime_bPositiveTimeZone_set" "', argument " "2"" of type '" "bool""'");
28606 : }
28607 19 : arg2 = static_cast< bool >(val2);
28608 19 : {
28609 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28610 19 : if (arg1) (arg1)->bPositiveTimeZone = arg2;
28611 19 : SWIG_PYTHON_THREAD_END_ALLOW;
28612 : }
28613 19 : resultobj = SWIG_Py_Void();
28614 19 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28615 : return resultobj;
28616 : fail:
28617 : return NULL;
28618 : }
28619 :
28620 :
28621 3 : SWIGINTERN PyObject *_wrap_RATDateTime_bPositiveTimeZone_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28622 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28623 3 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28624 3 : void *argp1 = 0 ;
28625 3 : int res1 = 0 ;
28626 3 : PyObject *swig_obj[1] ;
28627 3 : bool result;
28628 :
28629 3 : if (!args) SWIG_fail;
28630 3 : swig_obj[0] = args;
28631 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28632 3 : if (!SWIG_IsOK(res1)) {
28633 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_bPositiveTimeZone_get" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28634 : }
28635 3 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28636 3 : {
28637 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28638 3 : result = (bool) ((arg1)->bPositiveTimeZone);
28639 3 : SWIG_PYTHON_THREAD_END_ALLOW;
28640 : }
28641 3 : resultobj = SWIG_From_bool(static_cast< bool >(result));
28642 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28643 : return resultobj;
28644 : fail:
28645 : return NULL;
28646 : }
28647 :
28648 :
28649 15 : SWIGINTERN PyObject *_wrap_RATDateTime_bIsValid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28650 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28651 15 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28652 15 : bool arg2 ;
28653 15 : void *argp1 = 0 ;
28654 15 : int res1 = 0 ;
28655 15 : bool val2 ;
28656 15 : int ecode2 = 0 ;
28657 15 : PyObject *swig_obj[2] ;
28658 :
28659 15 : if (!SWIG_Python_UnpackTuple(args, "RATDateTime_bIsValid_set", 2, 2, swig_obj)) SWIG_fail;
28660 15 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28661 15 : if (!SWIG_IsOK(res1)) {
28662 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_bIsValid_set" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28663 : }
28664 15 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28665 15 : ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
28666 15 : if (!SWIG_IsOK(ecode2)) {
28667 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RATDateTime_bIsValid_set" "', argument " "2"" of type '" "bool""'");
28668 : }
28669 15 : arg2 = static_cast< bool >(val2);
28670 15 : {
28671 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28672 15 : if (arg1) (arg1)->bIsValid = arg2;
28673 15 : SWIG_PYTHON_THREAD_END_ALLOW;
28674 : }
28675 15 : resultobj = SWIG_Py_Void();
28676 15 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28677 : return resultobj;
28678 : fail:
28679 : return NULL;
28680 : }
28681 :
28682 :
28683 7 : SWIGINTERN PyObject *_wrap_RATDateTime_bIsValid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28684 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28685 7 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28686 7 : void *argp1 = 0 ;
28687 7 : int res1 = 0 ;
28688 7 : PyObject *swig_obj[1] ;
28689 7 : bool result;
28690 :
28691 7 : if (!args) SWIG_fail;
28692 7 : swig_obj[0] = args;
28693 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, 0 | 0 );
28694 7 : if (!SWIG_IsOK(res1)) {
28695 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RATDateTime_bIsValid_get" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28696 : }
28697 7 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28698 7 : {
28699 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28700 7 : result = (bool) ((arg1)->bIsValid);
28701 7 : SWIG_PYTHON_THREAD_END_ALLOW;
28702 : }
28703 7 : resultobj = SWIG_From_bool(static_cast< bool >(result));
28704 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28705 : return resultobj;
28706 : fail:
28707 : return NULL;
28708 : }
28709 :
28710 :
28711 16 : SWIGINTERN PyObject *_wrap_new_RATDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28712 16 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28713 16 : GDALRATDateTime *result = 0 ;
28714 :
28715 16 : if (!SWIG_Python_UnpackTuple(args, "new_RATDateTime", 0, 0, 0)) SWIG_fail;
28716 16 : {
28717 16 : const int bLocalUseExceptions = GetUseExceptions();
28718 16 : if ( bLocalUseExceptions ) {
28719 16 : pushErrorHandler();
28720 : }
28721 16 : {
28722 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28723 16 : result = (GDALRATDateTime *)new GDALRATDateTime();
28724 16 : SWIG_PYTHON_THREAD_END_ALLOW;
28725 : }
28726 16 : if ( bLocalUseExceptions ) {
28727 16 : popErrorHandler();
28728 : }
28729 : #ifndef SED_HACKS
28730 : if ( bLocalUseExceptions ) {
28731 : CPLErr eclass = CPLGetLastErrorType();
28732 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28733 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28734 : }
28735 : }
28736 : #endif
28737 : }
28738 16 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALRATDateTime, SWIG_POINTER_NEW | 0 );
28739 16 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28740 : return resultobj;
28741 0 : fail:
28742 0 : return NULL;
28743 : }
28744 :
28745 :
28746 32 : SWIGINTERN PyObject *_wrap_delete_RATDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28747 32 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28748 32 : GDALRATDateTime *arg1 = (GDALRATDateTime *) 0 ;
28749 32 : void *argp1 = 0 ;
28750 32 : int res1 = 0 ;
28751 32 : PyObject *swig_obj[1] ;
28752 :
28753 32 : if (!args) SWIG_fail;
28754 32 : swig_obj[0] = args;
28755 32 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRATDateTime, SWIG_POINTER_DISOWN | 0 );
28756 32 : if (!SWIG_IsOK(res1)) {
28757 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RATDateTime" "', argument " "1"" of type '" "GDALRATDateTime *""'");
28758 : }
28759 32 : arg1 = reinterpret_cast< GDALRATDateTime * >(argp1);
28760 32 : {
28761 32 : const int bLocalUseExceptions = GetUseExceptions();
28762 32 : if ( bLocalUseExceptions ) {
28763 32 : pushErrorHandler();
28764 : }
28765 32 : {
28766 32 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28767 32 : delete arg1;
28768 32 : SWIG_PYTHON_THREAD_END_ALLOW;
28769 : }
28770 32 : if ( bLocalUseExceptions ) {
28771 32 : popErrorHandler();
28772 : }
28773 : #ifndef SED_HACKS
28774 : if ( bLocalUseExceptions ) {
28775 : CPLErr eclass = CPLGetLastErrorType();
28776 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28777 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28778 : }
28779 : }
28780 : #endif
28781 : }
28782 32 : resultobj = SWIG_Py_Void();
28783 32 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28784 : return resultobj;
28785 : fail:
28786 : return NULL;
28787 : }
28788 :
28789 :
28790 277 : SWIGINTERN PyObject *RATDateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28791 277 : PyObject *obj;
28792 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
28793 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALRATDateTime, SWIG_NewClientData(obj));
28794 277 : return SWIG_Py_Void();
28795 : }
28796 :
28797 16 : SWIGINTERN PyObject *RATDateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28798 16 : return SWIG_Python_InitShadowInstance(args);
28799 : }
28800 :
28801 24 : SWIGINTERN PyObject *_wrap_new_RasterAttributeTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28802 24 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28803 24 : GDALRasterAttributeTableShadow *result = 0 ;
28804 :
28805 24 : if (!SWIG_Python_UnpackTuple(args, "new_RasterAttributeTable", 0, 0, 0)) SWIG_fail;
28806 24 : {
28807 24 : const int bLocalUseExceptions = GetUseExceptions();
28808 24 : if ( bLocalUseExceptions ) {
28809 22 : pushErrorHandler();
28810 : }
28811 24 : {
28812 24 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28813 24 : result = (GDALRasterAttributeTableShadow *)new_GDALRasterAttributeTableShadow();
28814 24 : SWIG_PYTHON_THREAD_END_ALLOW;
28815 : }
28816 24 : if ( bLocalUseExceptions ) {
28817 22 : popErrorHandler();
28818 : }
28819 : #ifndef SED_HACKS
28820 : if ( bLocalUseExceptions ) {
28821 : CPLErr eclass = CPLGetLastErrorType();
28822 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28823 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28824 : }
28825 : }
28826 : #endif
28827 : }
28828 24 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALRasterAttributeTableShadow, SWIG_POINTER_NEW | 0 );
28829 24 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28830 : return resultobj;
28831 0 : fail:
28832 0 : return NULL;
28833 : }
28834 :
28835 :
28836 32 : SWIGINTERN PyObject *_wrap_delete_RasterAttributeTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28837 32 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28838 32 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
28839 32 : void *argp1 = 0 ;
28840 32 : int res1 = 0 ;
28841 32 : PyObject *swig_obj[1] ;
28842 :
28843 32 : if (!args) SWIG_fail;
28844 32 : swig_obj[0] = args;
28845 32 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, SWIG_POINTER_DISOWN | 0 );
28846 32 : if (!SWIG_IsOK(res1)) {
28847 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RasterAttributeTable" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
28848 : }
28849 32 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
28850 32 : {
28851 32 : const int bLocalUseExceptions = GetUseExceptions();
28852 32 : if ( bLocalUseExceptions ) {
28853 30 : pushErrorHandler();
28854 : }
28855 32 : {
28856 32 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28857 32 : delete_GDALRasterAttributeTableShadow(arg1);
28858 32 : SWIG_PYTHON_THREAD_END_ALLOW;
28859 : }
28860 32 : if ( bLocalUseExceptions ) {
28861 30 : popErrorHandler();
28862 : }
28863 : #ifndef SED_HACKS
28864 : if ( bLocalUseExceptions ) {
28865 : CPLErr eclass = CPLGetLastErrorType();
28866 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28867 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28868 : }
28869 : }
28870 : #endif
28871 : }
28872 32 : resultobj = SWIG_Py_Void();
28873 32 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28874 : return resultobj;
28875 : fail:
28876 : return NULL;
28877 : }
28878 :
28879 :
28880 6 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28881 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28882 6 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
28883 6 : void *argp1 = 0 ;
28884 6 : int res1 = 0 ;
28885 6 : PyObject *swig_obj[1] ;
28886 6 : GDALRasterAttributeTableShadow *result = 0 ;
28887 :
28888 6 : if (!args) SWIG_fail;
28889 6 : swig_obj[0] = args;
28890 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
28891 6 : if (!SWIG_IsOK(res1)) {
28892 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_Clone" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
28893 : }
28894 6 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
28895 6 : {
28896 6 : const int bLocalUseExceptions = GetUseExceptions();
28897 6 : if ( bLocalUseExceptions ) {
28898 6 : pushErrorHandler();
28899 : }
28900 6 : {
28901 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28902 6 : result = (GDALRasterAttributeTableShadow *)GDALRasterAttributeTableShadow_Clone(arg1);
28903 6 : SWIG_PYTHON_THREAD_END_ALLOW;
28904 : }
28905 6 : if ( bLocalUseExceptions ) {
28906 6 : popErrorHandler();
28907 : }
28908 : #ifndef SED_HACKS
28909 : if ( bLocalUseExceptions ) {
28910 : CPLErr eclass = CPLGetLastErrorType();
28911 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28912 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28913 : }
28914 : }
28915 : #endif
28916 : }
28917 6 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALRasterAttributeTableShadow, SWIG_POINTER_OWN | 0 );
28918 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28919 : return resultobj;
28920 : fail:
28921 : return NULL;
28922 : }
28923 :
28924 :
28925 60 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetColumnCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28926 60 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28927 60 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
28928 60 : void *argp1 = 0 ;
28929 60 : int res1 = 0 ;
28930 60 : PyObject *swig_obj[1] ;
28931 60 : int result;
28932 :
28933 60 : if (!args) SWIG_fail;
28934 60 : swig_obj[0] = args;
28935 60 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
28936 60 : if (!SWIG_IsOK(res1)) {
28937 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetColumnCount" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
28938 : }
28939 60 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
28940 60 : {
28941 60 : const int bLocalUseExceptions = GetUseExceptions();
28942 60 : if ( bLocalUseExceptions ) {
28943 51 : pushErrorHandler();
28944 : }
28945 60 : {
28946 60 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28947 60 : result = (int)GDALRasterAttributeTableShadow_GetColumnCount(arg1);
28948 60 : SWIG_PYTHON_THREAD_END_ALLOW;
28949 : }
28950 60 : if ( bLocalUseExceptions ) {
28951 51 : popErrorHandler();
28952 : }
28953 : #ifndef SED_HACKS
28954 : if ( bLocalUseExceptions ) {
28955 : CPLErr eclass = CPLGetLastErrorType();
28956 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
28957 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
28958 : }
28959 : }
28960 : #endif
28961 : }
28962 60 : resultobj = SWIG_From_int(static_cast< int >(result));
28963 60 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
28964 : return resultobj;
28965 : fail:
28966 : return NULL;
28967 : }
28968 :
28969 :
28970 124 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetNameOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28971 124 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
28972 124 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
28973 124 : int arg2 ;
28974 124 : void *argp1 = 0 ;
28975 124 : int res1 = 0 ;
28976 124 : int val2 ;
28977 124 : int ecode2 = 0 ;
28978 124 : PyObject *swig_obj[2] ;
28979 124 : char *result = 0 ;
28980 :
28981 124 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_GetNameOfCol", 2, 2, swig_obj)) SWIG_fail;
28982 124 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
28983 124 : if (!SWIG_IsOK(res1)) {
28984 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetNameOfCol" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
28985 : }
28986 124 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
28987 124 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
28988 124 : if (!SWIG_IsOK(ecode2)) {
28989 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_GetNameOfCol" "', argument " "2"" of type '" "int""'");
28990 : }
28991 124 : arg2 = static_cast< int >(val2);
28992 124 : {
28993 124 : const int bLocalUseExceptions = GetUseExceptions();
28994 124 : if ( bLocalUseExceptions ) {
28995 121 : pushErrorHandler();
28996 : }
28997 124 : {
28998 124 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28999 124 : result = (char *)GDALRasterAttributeTableShadow_GetNameOfCol(arg1,arg2);
29000 124 : SWIG_PYTHON_THREAD_END_ALLOW;
29001 : }
29002 124 : if ( bLocalUseExceptions ) {
29003 121 : popErrorHandler();
29004 : }
29005 : #ifndef SED_HACKS
29006 : if ( bLocalUseExceptions ) {
29007 : CPLErr eclass = CPLGetLastErrorType();
29008 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29009 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29010 : }
29011 : }
29012 : #endif
29013 : }
29014 124 : resultobj = SWIG_FromCharPtr((const char *)result);
29015 124 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29016 : return resultobj;
29017 : fail:
29018 : return NULL;
29019 : }
29020 :
29021 :
29022 67 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetUsageOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29023 67 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29024 67 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
29025 67 : int arg2 ;
29026 67 : void *argp1 = 0 ;
29027 67 : int res1 = 0 ;
29028 67 : int val2 ;
29029 67 : int ecode2 = 0 ;
29030 67 : PyObject *swig_obj[2] ;
29031 67 : GDALRATFieldUsage result;
29032 :
29033 67 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_GetUsageOfCol", 2, 2, swig_obj)) SWIG_fail;
29034 67 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
29035 67 : if (!SWIG_IsOK(res1)) {
29036 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetUsageOfCol" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
29037 : }
29038 67 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
29039 67 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
29040 67 : if (!SWIG_IsOK(ecode2)) {
29041 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_GetUsageOfCol" "', argument " "2"" of type '" "int""'");
29042 : }
29043 67 : arg2 = static_cast< int >(val2);
29044 67 : {
29045 67 : const int bLocalUseExceptions = GetUseExceptions();
29046 67 : if ( bLocalUseExceptions ) {
29047 67 : pushErrorHandler();
29048 : }
29049 67 : {
29050 67 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29051 67 : result = (GDALRATFieldUsage)GDALRasterAttributeTableShadow_GetUsageOfCol(arg1,arg2);
29052 67 : SWIG_PYTHON_THREAD_END_ALLOW;
29053 : }
29054 67 : if ( bLocalUseExceptions ) {
29055 67 : popErrorHandler();
29056 : }
29057 : #ifndef SED_HACKS
29058 : if ( bLocalUseExceptions ) {
29059 : CPLErr eclass = CPLGetLastErrorType();
29060 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29061 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29062 : }
29063 : }
29064 : #endif
29065 : }
29066 67 : resultobj = SWIG_From_int(static_cast< int >(result));
29067 67 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29068 : return resultobj;
29069 : fail:
29070 : return NULL;
29071 : }
29072 :
29073 :
29074 288 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetTypeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29075 288 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29076 288 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
29077 288 : int arg2 ;
29078 288 : void *argp1 = 0 ;
29079 288 : int res1 = 0 ;
29080 288 : int val2 ;
29081 288 : int ecode2 = 0 ;
29082 288 : PyObject *swig_obj[2] ;
29083 288 : GDALRATFieldType result;
29084 :
29085 288 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_GetTypeOfCol", 2, 2, swig_obj)) SWIG_fail;
29086 288 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
29087 288 : if (!SWIG_IsOK(res1)) {
29088 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetTypeOfCol" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
29089 : }
29090 288 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
29091 288 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
29092 288 : if (!SWIG_IsOK(ecode2)) {
29093 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_GetTypeOfCol" "', argument " "2"" of type '" "int""'");
29094 : }
29095 288 : arg2 = static_cast< int >(val2);
29096 288 : {
29097 288 : const int bLocalUseExceptions = GetUseExceptions();
29098 288 : if ( bLocalUseExceptions ) {
29099 273 : pushErrorHandler();
29100 : }
29101 288 : {
29102 288 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29103 288 : result = (GDALRATFieldType)GDALRasterAttributeTableShadow_GetTypeOfCol(arg1,arg2);
29104 288 : SWIG_PYTHON_THREAD_END_ALLOW;
29105 : }
29106 288 : if ( bLocalUseExceptions ) {
29107 273 : popErrorHandler();
29108 : }
29109 : #ifndef SED_HACKS
29110 : if ( bLocalUseExceptions ) {
29111 : CPLErr eclass = CPLGetLastErrorType();
29112 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29113 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29114 : }
29115 : }
29116 : #endif
29117 : }
29118 288 : resultobj = SWIG_From_int(static_cast< int >(result));
29119 288 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29120 : return resultobj;
29121 : fail:
29122 : return NULL;
29123 : }
29124 :
29125 :
29126 13 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetColOfUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29127 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29128 13 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
29129 13 : GDALRATFieldUsage arg2 ;
29130 13 : void *argp1 = 0 ;
29131 13 : int res1 = 0 ;
29132 13 : int val2 ;
29133 13 : int ecode2 = 0 ;
29134 13 : PyObject *swig_obj[2] ;
29135 13 : int result;
29136 :
29137 13 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_GetColOfUsage", 2, 2, swig_obj)) SWIG_fail;
29138 13 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
29139 13 : if (!SWIG_IsOK(res1)) {
29140 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetColOfUsage" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
29141 : }
29142 13 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
29143 13 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
29144 13 : if (!SWIG_IsOK(ecode2)) {
29145 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_GetColOfUsage" "', argument " "2"" of type '" "GDALRATFieldUsage""'");
29146 : }
29147 13 : arg2 = static_cast< GDALRATFieldUsage >(val2);
29148 13 : {
29149 13 : const int bLocalUseExceptions = GetUseExceptions();
29150 13 : if ( bLocalUseExceptions ) {
29151 13 : pushErrorHandler();
29152 : }
29153 13 : {
29154 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29155 13 : result = (int)GDALRasterAttributeTableShadow_GetColOfUsage(arg1,arg2);
29156 13 : SWIG_PYTHON_THREAD_END_ALLOW;
29157 : }
29158 13 : if ( bLocalUseExceptions ) {
29159 13 : popErrorHandler();
29160 : }
29161 : #ifndef SED_HACKS
29162 : if ( bLocalUseExceptions ) {
29163 : CPLErr eclass = CPLGetLastErrorType();
29164 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29165 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29166 : }
29167 : }
29168 : #endif
29169 : }
29170 13 : resultobj = SWIG_From_int(static_cast< int >(result));
29171 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29172 : return resultobj;
29173 : fail:
29174 : return NULL;
29175 : }
29176 :
29177 :
29178 246 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetRowCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29179 246 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29180 246 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
29181 246 : void *argp1 = 0 ;
29182 246 : int res1 = 0 ;
29183 246 : PyObject *swig_obj[1] ;
29184 246 : int result;
29185 :
29186 246 : if (!args) SWIG_fail;
29187 246 : swig_obj[0] = args;
29188 246 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
29189 246 : if (!SWIG_IsOK(res1)) {
29190 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetRowCount" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
29191 : }
29192 246 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
29193 246 : {
29194 246 : const int bLocalUseExceptions = GetUseExceptions();
29195 246 : if ( bLocalUseExceptions ) {
29196 245 : pushErrorHandler();
29197 : }
29198 246 : {
29199 246 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29200 246 : result = (int)GDALRasterAttributeTableShadow_GetRowCount(arg1);
29201 246 : SWIG_PYTHON_THREAD_END_ALLOW;
29202 : }
29203 246 : if ( bLocalUseExceptions ) {
29204 245 : popErrorHandler();
29205 : }
29206 : #ifndef SED_HACKS
29207 : if ( bLocalUseExceptions ) {
29208 : CPLErr eclass = CPLGetLastErrorType();
29209 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29210 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29211 : }
29212 : }
29213 : #endif
29214 : }
29215 246 : resultobj = SWIG_From_int(static_cast< int >(result));
29216 246 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29217 : return resultobj;
29218 : fail:
29219 : return NULL;
29220 : }
29221 :
29222 :
29223 115 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetValueAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29224 115 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29225 115 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
29226 115 : int arg2 ;
29227 115 : int arg3 ;
29228 115 : void *argp1 = 0 ;
29229 115 : int res1 = 0 ;
29230 115 : int val2 ;
29231 115 : int ecode2 = 0 ;
29232 115 : int val3 ;
29233 115 : int ecode3 = 0 ;
29234 115 : PyObject *swig_obj[3] ;
29235 115 : char *result = 0 ;
29236 :
29237 115 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_GetValueAsString", 3, 3, swig_obj)) SWIG_fail;
29238 115 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
29239 115 : if (!SWIG_IsOK(res1)) {
29240 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetValueAsString" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
29241 : }
29242 115 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
29243 115 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
29244 115 : if (!SWIG_IsOK(ecode2)) {
29245 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_GetValueAsString" "', argument " "2"" of type '" "int""'");
29246 : }
29247 115 : arg2 = static_cast< int >(val2);
29248 115 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
29249 115 : if (!SWIG_IsOK(ecode3)) {
29250 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_GetValueAsString" "', argument " "3"" of type '" "int""'");
29251 : }
29252 115 : arg3 = static_cast< int >(val3);
29253 115 : {
29254 115 : const int bLocalUseExceptions = GetUseExceptions();
29255 115 : if ( bLocalUseExceptions ) {
29256 108 : pushErrorHandler();
29257 : }
29258 115 : {
29259 115 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29260 115 : result = (char *)GDALRasterAttributeTableShadow_GetValueAsString(arg1,arg2,arg3);
29261 115 : SWIG_PYTHON_THREAD_END_ALLOW;
29262 : }
29263 115 : if ( bLocalUseExceptions ) {
29264 108 : popErrorHandler();
29265 : }
29266 : #ifndef SED_HACKS
29267 : if ( bLocalUseExceptions ) {
29268 : CPLErr eclass = CPLGetLastErrorType();
29269 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29270 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29271 : }
29272 : }
29273 : #endif
29274 : }
29275 115 : resultobj = SWIG_FromCharPtr((const char *)result);
29276 127 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29277 : return resultobj;
29278 : fail:
29279 : return NULL;
29280 : }
29281 :
29282 :
29283 179 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetValueAsInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29284 179 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29285 179 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
29286 179 : int arg2 ;
29287 179 : int arg3 ;
29288 179 : void *argp1 = 0 ;
29289 179 : int res1 = 0 ;
29290 179 : int val2 ;
29291 179 : int ecode2 = 0 ;
29292 179 : int val3 ;
29293 179 : int ecode3 = 0 ;
29294 179 : PyObject *swig_obj[3] ;
29295 179 : int result;
29296 :
29297 179 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_GetValueAsInt", 3, 3, swig_obj)) SWIG_fail;
29298 179 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
29299 179 : if (!SWIG_IsOK(res1)) {
29300 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetValueAsInt" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
29301 : }
29302 179 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
29303 179 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
29304 179 : if (!SWIG_IsOK(ecode2)) {
29305 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_GetValueAsInt" "', argument " "2"" of type '" "int""'");
29306 : }
29307 179 : arg2 = static_cast< int >(val2);
29308 179 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
29309 179 : if (!SWIG_IsOK(ecode3)) {
29310 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_GetValueAsInt" "', argument " "3"" of type '" "int""'");
29311 : }
29312 179 : arg3 = static_cast< int >(val3);
29313 179 : {
29314 179 : const int bLocalUseExceptions = GetUseExceptions();
29315 179 : if ( bLocalUseExceptions ) {
29316 175 : pushErrorHandler();
29317 : }
29318 179 : {
29319 179 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29320 179 : result = (int)GDALRasterAttributeTableShadow_GetValueAsInt(arg1,arg2,arg3);
29321 179 : SWIG_PYTHON_THREAD_END_ALLOW;
29322 : }
29323 179 : if ( bLocalUseExceptions ) {
29324 175 : popErrorHandler();
29325 : }
29326 : #ifndef SED_HACKS
29327 : if ( bLocalUseExceptions ) {
29328 : CPLErr eclass = CPLGetLastErrorType();
29329 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29330 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29331 : }
29332 : }
29333 : #endif
29334 : }
29335 179 : resultobj = SWIG_From_int(static_cast< int >(result));
29336 195 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29337 : return resultobj;
29338 : fail:
29339 : return NULL;
29340 : }
29341 :
29342 :
29343 105 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29344 105 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29345 105 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
29346 105 : int arg2 ;
29347 105 : int arg3 ;
29348 105 : void *argp1 = 0 ;
29349 105 : int res1 = 0 ;
29350 105 : int val2 ;
29351 105 : int ecode2 = 0 ;
29352 105 : int val3 ;
29353 105 : int ecode3 = 0 ;
29354 105 : PyObject *swig_obj[3] ;
29355 105 : double result;
29356 :
29357 105 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_GetValueAsDouble", 3, 3, swig_obj)) SWIG_fail;
29358 105 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
29359 105 : if (!SWIG_IsOK(res1)) {
29360 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetValueAsDouble" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
29361 : }
29362 105 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
29363 105 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
29364 105 : if (!SWIG_IsOK(ecode2)) {
29365 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_GetValueAsDouble" "', argument " "2"" of type '" "int""'");
29366 : }
29367 105 : arg2 = static_cast< int >(val2);
29368 105 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
29369 105 : if (!SWIG_IsOK(ecode3)) {
29370 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_GetValueAsDouble" "', argument " "3"" of type '" "int""'");
29371 : }
29372 105 : arg3 = static_cast< int >(val3);
29373 105 : {
29374 105 : const int bLocalUseExceptions = GetUseExceptions();
29375 105 : if ( bLocalUseExceptions ) {
29376 102 : pushErrorHandler();
29377 : }
29378 105 : {
29379 105 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29380 105 : result = (double)GDALRasterAttributeTableShadow_GetValueAsDouble(arg1,arg2,arg3);
29381 105 : SWIG_PYTHON_THREAD_END_ALLOW;
29382 : }
29383 105 : if ( bLocalUseExceptions ) {
29384 102 : popErrorHandler();
29385 : }
29386 : #ifndef SED_HACKS
29387 : if ( bLocalUseExceptions ) {
29388 : CPLErr eclass = CPLGetLastErrorType();
29389 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29390 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29391 : }
29392 : }
29393 : #endif
29394 : }
29395 105 : resultobj = SWIG_From_double(static_cast< double >(result));
29396 121 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29397 : return resultobj;
29398 : fail:
29399 : return NULL;
29400 : }
29401 :
29402 :
29403 22 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetValueAsBoolean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29404 22 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29405 22 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
29406 22 : int arg2 ;
29407 22 : int arg3 ;
29408 22 : void *argp1 = 0 ;
29409 22 : int res1 = 0 ;
29410 22 : int val2 ;
29411 22 : int ecode2 = 0 ;
29412 22 : int val3 ;
29413 22 : int ecode3 = 0 ;
29414 22 : PyObject *swig_obj[3] ;
29415 22 : bool result;
29416 :
29417 22 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_GetValueAsBoolean", 3, 3, swig_obj)) SWIG_fail;
29418 22 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
29419 22 : if (!SWIG_IsOK(res1)) {
29420 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetValueAsBoolean" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
29421 : }
29422 22 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
29423 22 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
29424 22 : if (!SWIG_IsOK(ecode2)) {
29425 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_GetValueAsBoolean" "', argument " "2"" of type '" "int""'");
29426 : }
29427 22 : arg2 = static_cast< int >(val2);
29428 22 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
29429 22 : if (!SWIG_IsOK(ecode3)) {
29430 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_GetValueAsBoolean" "', argument " "3"" of type '" "int""'");
29431 : }
29432 22 : arg3 = static_cast< int >(val3);
29433 22 : {
29434 22 : const int bLocalUseExceptions = GetUseExceptions();
29435 22 : if ( bLocalUseExceptions ) {
29436 20 : pushErrorHandler();
29437 : }
29438 22 : {
29439 22 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29440 22 : result = (bool)GDALRasterAttributeTableShadow_GetValueAsBoolean(arg1,arg2,arg3);
29441 22 : SWIG_PYTHON_THREAD_END_ALLOW;
29442 : }
29443 22 : if ( bLocalUseExceptions ) {
29444 20 : popErrorHandler();
29445 : }
29446 : #ifndef SED_HACKS
29447 : if ( bLocalUseExceptions ) {
29448 : CPLErr eclass = CPLGetLastErrorType();
29449 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29450 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29451 : }
29452 : }
29453 : #endif
29454 : }
29455 22 : resultobj = SWIG_From_bool(static_cast< bool >(result));
29456 36 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29457 : return resultobj;
29458 : fail:
29459 : return NULL;
29460 : }
29461 :
29462 :
29463 16 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetValueAsDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29464 16 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29465 16 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
29466 16 : int arg2 ;
29467 16 : int arg3 ;
29468 16 : void *argp1 = 0 ;
29469 16 : int res1 = 0 ;
29470 16 : int val2 ;
29471 16 : int ecode2 = 0 ;
29472 16 : int val3 ;
29473 16 : int ecode3 = 0 ;
29474 16 : PyObject *swig_obj[3] ;
29475 16 : GDALRATDateTime result;
29476 :
29477 16 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_GetValueAsDateTime", 3, 3, swig_obj)) SWIG_fail;
29478 16 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
29479 16 : if (!SWIG_IsOK(res1)) {
29480 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetValueAsDateTime" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
29481 : }
29482 16 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
29483 16 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
29484 16 : if (!SWIG_IsOK(ecode2)) {
29485 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_GetValueAsDateTime" "', argument " "2"" of type '" "int""'");
29486 : }
29487 16 : arg2 = static_cast< int >(val2);
29488 16 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
29489 16 : if (!SWIG_IsOK(ecode3)) {
29490 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_GetValueAsDateTime" "', argument " "3"" of type '" "int""'");
29491 : }
29492 16 : arg3 = static_cast< int >(val3);
29493 16 : {
29494 16 : const int bLocalUseExceptions = GetUseExceptions();
29495 16 : if ( bLocalUseExceptions ) {
29496 16 : pushErrorHandler();
29497 : }
29498 16 : {
29499 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29500 16 : result = GDALRasterAttributeTableShadow_GetValueAsDateTime(arg1,arg2,arg3);
29501 16 : SWIG_PYTHON_THREAD_END_ALLOW;
29502 : }
29503 16 : if ( bLocalUseExceptions ) {
29504 16 : popErrorHandler();
29505 : }
29506 : #ifndef SED_HACKS
29507 : if ( bLocalUseExceptions ) {
29508 : CPLErr eclass = CPLGetLastErrorType();
29509 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29510 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29511 : }
29512 : }
29513 : #endif
29514 : }
29515 16 : resultobj = SWIG_NewPointerObj((new GDALRATDateTime(static_cast< const GDALRATDateTime& >(result))), SWIGTYPE_p_GDALRATDateTime, SWIG_POINTER_OWN | 0 );
29516 34 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29517 : return resultobj;
29518 : fail:
29519 : return NULL;
29520 : }
29521 :
29522 :
29523 14 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetValueAsWKBGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29524 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29525 14 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
29526 14 : int arg2 ;
29527 14 : int arg3 ;
29528 14 : size_t *arg4 = (size_t *) 0 ;
29529 14 : char **arg5 = (char **) 0 ;
29530 14 : void *argp1 = 0 ;
29531 14 : int res1 = 0 ;
29532 14 : int val2 ;
29533 14 : int ecode2 = 0 ;
29534 14 : int val3 ;
29535 14 : int ecode3 = 0 ;
29536 14 : size_t nLen4 = 0 ;
29537 14 : char *pBuf4 = 0 ;
29538 14 : PyObject *swig_obj[3] ;
29539 14 : CPLErr result;
29540 :
29541 14 : {
29542 : /* %typemap(in,numinputs=0) (size_t *nLen4, char **pBuf4 ) */
29543 14 : arg4 = &nLen4;
29544 14 : arg5 = &pBuf4;
29545 : }
29546 14 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_GetValueAsWKBGeometry", 3, 3, swig_obj)) SWIG_fail;
29547 14 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
29548 14 : if (!SWIG_IsOK(res1)) {
29549 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetValueAsWKBGeometry" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
29550 : }
29551 14 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
29552 14 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
29553 14 : if (!SWIG_IsOK(ecode2)) {
29554 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_GetValueAsWKBGeometry" "', argument " "2"" of type '" "int""'");
29555 : }
29556 14 : arg2 = static_cast< int >(val2);
29557 14 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
29558 14 : if (!SWIG_IsOK(ecode3)) {
29559 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_GetValueAsWKBGeometry" "', argument " "3"" of type '" "int""'");
29560 : }
29561 14 : arg3 = static_cast< int >(val3);
29562 14 : {
29563 14 : const int bLocalUseExceptions = GetUseExceptions();
29564 14 : if ( bLocalUseExceptions ) {
29565 14 : pushErrorHandler();
29566 : }
29567 14 : {
29568 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29569 14 : result = (CPLErr)GDALRasterAttributeTableShadow_GetValueAsWKBGeometry(arg1,arg2,arg3,arg4,arg5);
29570 14 : SWIG_PYTHON_THREAD_END_ALLOW;
29571 : }
29572 14 : if ( bLocalUseExceptions ) {
29573 14 : popErrorHandler();
29574 : }
29575 : #ifndef SED_HACKS
29576 : if ( bLocalUseExceptions ) {
29577 : CPLErr eclass = CPLGetLastErrorType();
29578 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29579 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29580 : }
29581 : }
29582 : #endif
29583 : }
29584 14 : resultobj = SWIG_From_int(static_cast< int >(result));
29585 14 : {
29586 : /* %typemap(argout) (size_t *nLen, char **pBuf ) */
29587 14 : Py_XDECREF(resultobj);
29588 14 : if( *arg5 ) {
29589 14 : resultobj = PyByteArray_FromStringAndSize( *arg5, *arg4 );
29590 : }
29591 : else {
29592 0 : resultobj = Py_None;
29593 0 : Py_INCREF(Py_None);
29594 : }
29595 : }
29596 14 : {
29597 : /* %typemap(freearg) (size_t *nLen, char **pBuf ) */
29598 14 : VSIFree( *arg5 );
29599 : }
29600 32 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29601 : return resultobj;
29602 0 : fail:
29603 0 : {
29604 : /* %typemap(freearg) (size_t *nLen, char **pBuf ) */
29605 0 : VSIFree( *arg5 );
29606 : }
29607 : return NULL;
29608 : }
29609 :
29610 :
29611 14 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_SetValueAsWKBGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29612 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29613 14 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
29614 14 : int arg2 ;
29615 14 : int arg3 ;
29616 14 : int arg4 ;
29617 14 : char *arg5 = (char *) 0 ;
29618 14 : void *argp1 = 0 ;
29619 14 : int res1 = 0 ;
29620 14 : int val2 ;
29621 14 : int ecode2 = 0 ;
29622 14 : int val3 ;
29623 14 : int ecode3 = 0 ;
29624 14 : int alloc4 = 0 ;
29625 14 : bool viewIsValid4 = false ;
29626 14 : Py_buffer view4 ;
29627 14 : PyObject *swig_obj[4] ;
29628 14 : CPLErr result;
29629 :
29630 14 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_SetValueAsWKBGeometry", 4, 4, swig_obj)) SWIG_fail;
29631 14 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
29632 14 : if (!SWIG_IsOK(res1)) {
29633 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_SetValueAsWKBGeometry" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
29634 : }
29635 14 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
29636 14 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
29637 14 : if (!SWIG_IsOK(ecode2)) {
29638 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_SetValueAsWKBGeometry" "', argument " "2"" of type '" "int""'");
29639 : }
29640 14 : arg2 = static_cast< int >(val2);
29641 14 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
29642 14 : if (!SWIG_IsOK(ecode3)) {
29643 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_SetValueAsWKBGeometry" "', argument " "3"" of type '" "int""'");
29644 : }
29645 14 : arg3 = static_cast< int >(val3);
29646 14 : {
29647 : /* %typemap(in,numinputs=1) (int nLen, char *pBuf ) */
29648 14 : char* ptr = NULL;
29649 14 : if( !GetBufferAsCharPtrIntSize(swig_obj[3], &arg4, &ptr, &alloc4, &viewIsValid4, &view4) ) {
29650 0 : SWIG_fail;
29651 : }
29652 14 : arg5 = (char *)ptr;
29653 : }
29654 14 : {
29655 14 : const int bLocalUseExceptions = GetUseExceptions();
29656 14 : if ( bLocalUseExceptions ) {
29657 14 : pushErrorHandler();
29658 : }
29659 14 : {
29660 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29661 14 : result = (CPLErr)GDALRasterAttributeTableShadow_SetValueAsWKBGeometry(arg1,arg2,arg3,arg4,arg5);
29662 14 : SWIG_PYTHON_THREAD_END_ALLOW;
29663 : }
29664 14 : if ( bLocalUseExceptions ) {
29665 14 : popErrorHandler();
29666 : }
29667 : #ifndef SED_HACKS
29668 : if ( bLocalUseExceptions ) {
29669 : CPLErr eclass = CPLGetLastErrorType();
29670 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29671 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29672 : }
29673 : }
29674 : #endif
29675 : }
29676 14 : resultobj = SWIG_From_int(static_cast< int >(result));
29677 14 : {
29678 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
29679 14 : if( viewIsValid4 ) {
29680 14 : PyBuffer_Release(&view4);
29681 : }
29682 0 : else if (ReturnSame(alloc4) == SWIG_NEWOBJ ) {
29683 0 : delete[] arg5;
29684 : }
29685 : }
29686 28 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29687 : return resultobj;
29688 0 : fail:
29689 0 : {
29690 : /* %typemap(freearg) (int *nLen, char *pBuf ) */
29691 0 : if( viewIsValid4 ) {
29692 0 : PyBuffer_Release(&view4);
29693 : }
29694 14 : else if (ReturnSame(alloc4) == SWIG_NEWOBJ ) {
29695 : delete[] arg5;
29696 : }
29697 : }
29698 : return NULL;
29699 : }
29700 :
29701 :
29702 9 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_ReadValuesIOAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29703 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29704 9 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
29705 9 : int arg2 ;
29706 9 : int arg3 ;
29707 9 : int arg4 ;
29708 9 : char **arg5 = (char **) 0 ;
29709 9 : void *argp1 = 0 ;
29710 9 : int res1 = 0 ;
29711 9 : int val2 ;
29712 9 : int ecode2 = 0 ;
29713 9 : int val3 ;
29714 9 : int ecode3 = 0 ;
29715 9 : int iLength4 ;
29716 9 : PyObject *swig_obj[4] ;
29717 9 : CPLErr result;
29718 :
29719 9 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_ReadValuesIOAsString", 4, 4, swig_obj)) SWIG_fail;
29720 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
29721 9 : if (!SWIG_IsOK(res1)) {
29722 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_ReadValuesIOAsString" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
29723 : }
29724 9 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
29725 9 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
29726 9 : if (!SWIG_IsOK(ecode2)) {
29727 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_ReadValuesIOAsString" "', argument " "2"" of type '" "int""'");
29728 : }
29729 9 : arg2 = static_cast< int >(val2);
29730 9 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
29731 9 : if (!SWIG_IsOK(ecode3)) {
29732 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_ReadValuesIOAsString" "', argument " "3"" of type '" "int""'");
29733 : }
29734 9 : arg3 = static_cast< int >(val3);
29735 9 : {
29736 : /* %typemap(in,numinputs=1) (int iLength4, char **ppszData) (int iLength4) */
29737 9 : if ( !PyArg_Parse(swig_obj[3],"i",&iLength4) )
29738 : {
29739 0 : PyErr_SetString(PyExc_TypeError, "not a integer");
29740 0 : SWIG_fail;
29741 : }
29742 9 : if( iLength4 <= 0 || iLength4 > INT_MAX - 1 )
29743 : {
29744 1 : PyErr_SetString(PyExc_TypeError, "invalid length");
29745 1 : SWIG_fail;
29746 : }
29747 8 : arg4 = iLength4;
29748 8 : arg5 = (char**)VSICalloc(iLength4 + 1, sizeof(char*));
29749 8 : if( !arg5 )
29750 : {
29751 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
29752 0 : SWIG_fail;
29753 : }
29754 : }
29755 8 : {
29756 8 : const int bLocalUseExceptions = GetUseExceptions();
29757 8 : if ( bLocalUseExceptions ) {
29758 8 : pushErrorHandler();
29759 : }
29760 8 : {
29761 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29762 8 : result = (CPLErr)GDALRasterAttributeTableShadow_ReadValuesIOAsString(arg1,arg2,arg3,arg4,arg5);
29763 8 : SWIG_PYTHON_THREAD_END_ALLOW;
29764 : }
29765 8 : if ( bLocalUseExceptions ) {
29766 8 : popErrorHandler();
29767 : }
29768 : #ifndef SED_HACKS
29769 : if ( bLocalUseExceptions ) {
29770 : CPLErr eclass = CPLGetLastErrorType();
29771 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29772 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29773 : }
29774 : }
29775 : #endif
29776 : }
29777 8 : resultobj = SWIG_From_int(static_cast< int >(result));
29778 8 : {
29779 : /* %typemap(argout) (int iLength, char **ppszData) */
29780 8 : Py_DECREF(resultobj);
29781 8 : PyObject *out = PyList_New( arg4 );
29782 8 : if( !out ) {
29783 0 : SWIG_fail;
29784 : }
29785 27 : for( int i=0; i<arg4; i++ ) {
29786 19 : if( arg5[i] )
29787 : {
29788 13 : PyObject *val = GDALPythonObjectFromCStr( arg5[i] );
29789 13 : PyList_SetItem( out, i, val );
29790 : }
29791 : else
29792 : {
29793 6 : Py_INCREF(Py_None);
29794 6 : PyList_SetItem( out, i, Py_None );
29795 : }
29796 : }
29797 8 : resultobj = out;
29798 : }
29799 8 : {
29800 : /* %typemap(freearg) (int iLength, char **ppszData) */
29801 8 : CSLDestroy(arg5);
29802 : }
29803 17 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29804 : return resultobj;
29805 1 : fail:
29806 1 : {
29807 : /* %typemap(freearg) (int iLength, char **ppszData) */
29808 1 : CSLDestroy(arg5);
29809 : }
29810 : return NULL;
29811 : }
29812 :
29813 :
29814 11 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_ReadValuesIOAsInteger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29815 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29816 11 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
29817 11 : int arg2 ;
29818 11 : int arg3 ;
29819 11 : int arg4 ;
29820 11 : int *arg5 = (int *) 0 ;
29821 11 : void *argp1 = 0 ;
29822 11 : int res1 = 0 ;
29823 11 : int val2 ;
29824 11 : int ecode2 = 0 ;
29825 11 : int val3 ;
29826 11 : int ecode3 = 0 ;
29827 11 : int iLength4 ;
29828 11 : PyObject *swig_obj[4] ;
29829 11 : CPLErr result;
29830 :
29831 11 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_ReadValuesIOAsInteger", 4, 4, swig_obj)) SWIG_fail;
29832 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
29833 11 : if (!SWIG_IsOK(res1)) {
29834 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_ReadValuesIOAsInteger" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
29835 : }
29836 11 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
29837 11 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
29838 11 : if (!SWIG_IsOK(ecode2)) {
29839 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_ReadValuesIOAsInteger" "', argument " "2"" of type '" "int""'");
29840 : }
29841 11 : arg2 = static_cast< int >(val2);
29842 11 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
29843 11 : if (!SWIG_IsOK(ecode3)) {
29844 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_ReadValuesIOAsInteger" "', argument " "3"" of type '" "int""'");
29845 : }
29846 11 : arg3 = static_cast< int >(val3);
29847 11 : {
29848 : /* %typemap(in,numinputs=1) (int iLength4, int *pnData) (int iLength4) */
29849 11 : if ( !PyArg_Parse(swig_obj[3],"i",&iLength4) ) {
29850 0 : PyErr_SetString(PyExc_TypeError, "not a integer");
29851 0 : SWIG_fail;
29852 : }
29853 11 : if( iLength4 <= 0 )
29854 : {
29855 1 : PyErr_SetString(PyExc_TypeError, "invalid length");
29856 1 : SWIG_fail;
29857 : }
29858 10 : arg4 = iLength4;
29859 10 : arg5 = (int*)VSICalloc(iLength4, sizeof(int));
29860 10 : if( !arg5 )
29861 : {
29862 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
29863 0 : SWIG_fail;
29864 : }
29865 : }
29866 10 : {
29867 10 : const int bLocalUseExceptions = GetUseExceptions();
29868 10 : if ( bLocalUseExceptions ) {
29869 10 : pushErrorHandler();
29870 : }
29871 10 : {
29872 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29873 10 : result = (CPLErr)GDALRasterAttributeTableShadow_ReadValuesIOAsInteger(arg1,arg2,arg3,arg4,arg5);
29874 10 : SWIG_PYTHON_THREAD_END_ALLOW;
29875 : }
29876 10 : if ( bLocalUseExceptions ) {
29877 10 : popErrorHandler();
29878 : }
29879 : #ifndef SED_HACKS
29880 : if ( bLocalUseExceptions ) {
29881 : CPLErr eclass = CPLGetLastErrorType();
29882 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29883 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29884 : }
29885 : }
29886 : #endif
29887 : }
29888 10 : resultobj = SWIG_From_int(static_cast< int >(result));
29889 10 : {
29890 : /* %typemap(argout) (int iLength, int *pnData) */
29891 10 : Py_DECREF(resultobj);
29892 10 : PyObject *out = PyList_New( arg4 );
29893 10 : if( !out ) {
29894 0 : SWIG_fail;
29895 : }
29896 39 : for( int i=0; i<arg4; i++ ) {
29897 29 : PyObject *val = PyLong_FromLong( (arg5)[i] );
29898 29 : PyList_SetItem( out, i, val );
29899 : }
29900 10 : resultobj = out;
29901 : }
29902 10 : {
29903 : /* %typemap(freearg) (int iLength, int *pnData) */
29904 10 : CPLFree(arg5);
29905 : }
29906 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
29907 : return resultobj;
29908 1 : fail:
29909 1 : {
29910 : /* %typemap(freearg) (int iLength, int *pnData) */
29911 1 : CPLFree(arg5);
29912 : }
29913 : return NULL;
29914 : }
29915 :
29916 :
29917 9 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_ReadValuesIOAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29918 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
29919 9 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
29920 9 : int arg2 ;
29921 9 : int arg3 ;
29922 9 : int arg4 ;
29923 9 : double *arg5 = (double *) 0 ;
29924 9 : void *argp1 = 0 ;
29925 9 : int res1 = 0 ;
29926 9 : int val2 ;
29927 9 : int ecode2 = 0 ;
29928 9 : int val3 ;
29929 9 : int ecode3 = 0 ;
29930 9 : int iLength4 ;
29931 9 : PyObject *swig_obj[4] ;
29932 9 : CPLErr result;
29933 :
29934 9 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_ReadValuesIOAsDouble", 4, 4, swig_obj)) SWIG_fail;
29935 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
29936 9 : if (!SWIG_IsOK(res1)) {
29937 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_ReadValuesIOAsDouble" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
29938 : }
29939 9 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
29940 9 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
29941 9 : if (!SWIG_IsOK(ecode2)) {
29942 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_ReadValuesIOAsDouble" "', argument " "2"" of type '" "int""'");
29943 : }
29944 9 : arg2 = static_cast< int >(val2);
29945 9 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
29946 9 : if (!SWIG_IsOK(ecode3)) {
29947 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_ReadValuesIOAsDouble" "', argument " "3"" of type '" "int""'");
29948 : }
29949 9 : arg3 = static_cast< int >(val3);
29950 9 : {
29951 : /* %typemap(in,numinputs=1) (int iLength4, double *pdfData) (int iLength4) */
29952 9 : if ( !PyArg_Parse(swig_obj[3],"i",&iLength4) ) {
29953 0 : PyErr_SetString(PyExc_TypeError, "not a integer");
29954 0 : SWIG_fail;
29955 : }
29956 9 : if( iLength4 <= 0 )
29957 : {
29958 1 : PyErr_SetString(PyExc_TypeError, "invalid length");
29959 1 : SWIG_fail;
29960 : }
29961 8 : arg4 = iLength4;
29962 8 : arg5 = (double*)CPLCalloc(iLength4, sizeof(double));
29963 8 : if( !arg5 )
29964 : {
29965 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
29966 0 : SWIG_fail;
29967 : }
29968 : }
29969 8 : {
29970 8 : const int bLocalUseExceptions = GetUseExceptions();
29971 8 : if ( bLocalUseExceptions ) {
29972 8 : pushErrorHandler();
29973 : }
29974 8 : {
29975 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29976 8 : result = (CPLErr)GDALRasterAttributeTableShadow_ReadValuesIOAsDouble(arg1,arg2,arg3,arg4,arg5);
29977 8 : SWIG_PYTHON_THREAD_END_ALLOW;
29978 : }
29979 8 : if ( bLocalUseExceptions ) {
29980 8 : popErrorHandler();
29981 : }
29982 : #ifndef SED_HACKS
29983 : if ( bLocalUseExceptions ) {
29984 : CPLErr eclass = CPLGetLastErrorType();
29985 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
29986 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
29987 : }
29988 : }
29989 : #endif
29990 : }
29991 8 : resultobj = SWIG_From_int(static_cast< int >(result));
29992 8 : {
29993 : /* %typemap(argout) (int iLength, double *pdfData) */
29994 8 : Py_DECREF(resultobj);
29995 8 : PyObject *out = PyList_New( arg4 );
29996 8 : if( !out ) {
29997 0 : SWIG_fail;
29998 : }
29999 27 : for( int i=0; i<arg4; i++ ) {
30000 19 : PyObject *val = PyFloat_FromDouble( (arg5)[i] );
30001 19 : PyList_SetItem( out, i, val );
30002 : }
30003 8 : resultobj = out;
30004 : }
30005 8 : {
30006 : /* %typemap(freearg) (int iLength, double *pdfData) */
30007 8 : CPLFree(arg5);
30008 : }
30009 17 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30010 : return resultobj;
30011 1 : fail:
30012 1 : {
30013 : /* %typemap(freearg) (int iLength, double *pdfData) */
30014 1 : CPLFree(arg5);
30015 : }
30016 : return NULL;
30017 : }
30018 :
30019 :
30020 8 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_ReadValuesIOAsBoolean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30021 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30022 8 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30023 8 : int arg2 ;
30024 8 : int arg3 ;
30025 8 : int arg4 ;
30026 8 : bool *arg5 = (bool *) 0 ;
30027 8 : void *argp1 = 0 ;
30028 8 : int res1 = 0 ;
30029 8 : int val2 ;
30030 8 : int ecode2 = 0 ;
30031 8 : int val3 ;
30032 8 : int ecode3 = 0 ;
30033 8 : int iLength4 ;
30034 8 : PyObject *swig_obj[4] ;
30035 8 : CPLErr result;
30036 :
30037 8 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_ReadValuesIOAsBoolean", 4, 4, swig_obj)) SWIG_fail;
30038 8 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30039 8 : if (!SWIG_IsOK(res1)) {
30040 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_ReadValuesIOAsBoolean" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30041 : }
30042 8 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30043 8 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30044 8 : if (!SWIG_IsOK(ecode2)) {
30045 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_ReadValuesIOAsBoolean" "', argument " "2"" of type '" "int""'");
30046 : }
30047 8 : arg2 = static_cast< int >(val2);
30048 8 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
30049 8 : if (!SWIG_IsOK(ecode3)) {
30050 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_ReadValuesIOAsBoolean" "', argument " "3"" of type '" "int""'");
30051 : }
30052 8 : arg3 = static_cast< int >(val3);
30053 8 : {
30054 : /* %typemap(in,numinputs=1) (int iLength4, bool *pbData) (int iLength4) */
30055 8 : if ( !PyArg_Parse(swig_obj[3],"i",&iLength4) ) {
30056 0 : PyErr_SetString(PyExc_TypeError, "not a integer");
30057 0 : SWIG_fail;
30058 : }
30059 8 : if( iLength4 <= 0 )
30060 : {
30061 1 : PyErr_SetString(PyExc_TypeError, "invalid length");
30062 1 : SWIG_fail;
30063 : }
30064 7 : arg4 = iLength4;
30065 7 : arg5 = (bool*)VSICalloc(iLength4, sizeof(bool));
30066 7 : if( !arg5 )
30067 : {
30068 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
30069 0 : SWIG_fail;
30070 : }
30071 : }
30072 7 : {
30073 7 : const int bLocalUseExceptions = GetUseExceptions();
30074 7 : if ( bLocalUseExceptions ) {
30075 7 : pushErrorHandler();
30076 : }
30077 7 : {
30078 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30079 7 : result = (CPLErr)GDALRasterAttributeTableShadow_ReadValuesIOAsBoolean(arg1,arg2,arg3,arg4,arg5);
30080 7 : SWIG_PYTHON_THREAD_END_ALLOW;
30081 : }
30082 7 : if ( bLocalUseExceptions ) {
30083 7 : popErrorHandler();
30084 : }
30085 : #ifndef SED_HACKS
30086 : if ( bLocalUseExceptions ) {
30087 : CPLErr eclass = CPLGetLastErrorType();
30088 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30089 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30090 : }
30091 : }
30092 : #endif
30093 : }
30094 7 : resultobj = SWIG_From_int(static_cast< int >(result));
30095 7 : {
30096 : /* %typemap(argout) (int iLength, bool *pbData) */
30097 7 : Py_DECREF(resultobj);
30098 7 : PyObject *out = PyList_New( arg4 );
30099 7 : if( !out ) {
30100 0 : SWIG_fail;
30101 : }
30102 28 : for( int i=0; i<arg4; i++ ) {
30103 21 : PyObject *val = PyBool_FromLong( (arg5)[i] );
30104 21 : PyList_SetItem( out, i, val );
30105 : }
30106 7 : resultobj = out;
30107 : }
30108 7 : {
30109 : /* %typemap(freearg) (int iLength, bool *pbData) */
30110 7 : CPLFree(arg5);
30111 : }
30112 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30113 : return resultobj;
30114 1 : fail:
30115 1 : {
30116 : /* %typemap(freearg) (int iLength, bool *pbData) */
30117 1 : CPLFree(arg5);
30118 : }
30119 : return NULL;
30120 : }
30121 :
30122 :
30123 66 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_SetValueAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30124 66 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30125 66 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30126 66 : int arg2 ;
30127 66 : int arg3 ;
30128 66 : char *arg4 = (char *) 0 ;
30129 66 : void *argp1 = 0 ;
30130 66 : int res1 = 0 ;
30131 66 : int val2 ;
30132 66 : int ecode2 = 0 ;
30133 66 : int val3 ;
30134 66 : int ecode3 = 0 ;
30135 66 : PyObject *str4 = 0 ;
30136 66 : int bToFree4 = 0 ;
30137 66 : PyObject *swig_obj[4] ;
30138 :
30139 66 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_SetValueAsString", 4, 4, swig_obj)) SWIG_fail;
30140 66 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30141 66 : if (!SWIG_IsOK(res1)) {
30142 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_SetValueAsString" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30143 : }
30144 66 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30145 66 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30146 66 : if (!SWIG_IsOK(ecode2)) {
30147 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_SetValueAsString" "', argument " "2"" of type '" "int""'");
30148 : }
30149 66 : arg2 = static_cast< int >(val2);
30150 66 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
30151 66 : if (!SWIG_IsOK(ecode3)) {
30152 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_SetValueAsString" "', argument " "3"" of type '" "int""'");
30153 : }
30154 66 : arg3 = static_cast< int >(val3);
30155 66 : {
30156 : /* %typemap(in) (tostring argin) */
30157 66 : str4 = PyObject_Str( swig_obj[3] );
30158 66 : if ( str4 == 0 ) {
30159 0 : PyErr_SetString( PyExc_RuntimeError, "Unable to format argument as string");
30160 0 : SWIG_fail;
30161 : }
30162 :
30163 66 : arg4 = GDALPythonObjectToCStr(str4, &bToFree4);
30164 : }
30165 66 : {
30166 66 : const int bLocalUseExceptions = GetUseExceptions();
30167 66 : if ( bLocalUseExceptions ) {
30168 60 : pushErrorHandler();
30169 : }
30170 66 : {
30171 66 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30172 66 : GDALRasterAttributeTableShadow_SetValueAsString(arg1,arg2,arg3,(char const *)arg4);
30173 66 : SWIG_PYTHON_THREAD_END_ALLOW;
30174 : }
30175 66 : if ( bLocalUseExceptions ) {
30176 60 : popErrorHandler();
30177 : }
30178 : #ifndef SED_HACKS
30179 : if ( bLocalUseExceptions ) {
30180 : CPLErr eclass = CPLGetLastErrorType();
30181 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30182 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30183 : }
30184 : }
30185 : #endif
30186 : }
30187 66 : resultobj = SWIG_Py_Void();
30188 66 : {
30189 : /* %typemap(freearg) (tostring argin) */
30190 66 : if ( str4 != NULL)
30191 : {
30192 66 : Py_DECREF(str4);
30193 : }
30194 66 : GDALPythonFreeCStr(arg4, bToFree4);
30195 : }
30196 70 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30197 : return resultobj;
30198 0 : fail:
30199 0 : {
30200 : /* %typemap(freearg) (tostring argin) */
30201 0 : if ( str4 != NULL)
30202 : {
30203 0 : Py_DECREF(str4);
30204 : }
30205 66 : GDALPythonFreeCStr(arg4, bToFree4);
30206 : }
30207 : return NULL;
30208 : }
30209 :
30210 :
30211 64 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_SetValueAsInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30212 64 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30213 64 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30214 64 : int arg2 ;
30215 64 : int arg3 ;
30216 64 : int arg4 ;
30217 64 : void *argp1 = 0 ;
30218 64 : int res1 = 0 ;
30219 64 : int val2 ;
30220 64 : int ecode2 = 0 ;
30221 64 : int val3 ;
30222 64 : int ecode3 = 0 ;
30223 64 : int val4 ;
30224 64 : int ecode4 = 0 ;
30225 64 : PyObject *swig_obj[4] ;
30226 :
30227 64 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_SetValueAsInt", 4, 4, swig_obj)) SWIG_fail;
30228 64 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30229 64 : if (!SWIG_IsOK(res1)) {
30230 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_SetValueAsInt" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30231 : }
30232 64 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30233 64 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30234 64 : if (!SWIG_IsOK(ecode2)) {
30235 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_SetValueAsInt" "', argument " "2"" of type '" "int""'");
30236 : }
30237 64 : arg2 = static_cast< int >(val2);
30238 64 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
30239 64 : if (!SWIG_IsOK(ecode3)) {
30240 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_SetValueAsInt" "', argument " "3"" of type '" "int""'");
30241 : }
30242 64 : arg3 = static_cast< int >(val3);
30243 64 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
30244 64 : if (!SWIG_IsOK(ecode4)) {
30245 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RasterAttributeTable_SetValueAsInt" "', argument " "4"" of type '" "int""'");
30246 : }
30247 64 : arg4 = static_cast< int >(val4);
30248 64 : {
30249 64 : const int bLocalUseExceptions = GetUseExceptions();
30250 64 : if ( bLocalUseExceptions ) {
30251 62 : pushErrorHandler();
30252 : }
30253 64 : {
30254 64 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30255 64 : GDALRasterAttributeTableShadow_SetValueAsInt(arg1,arg2,arg3,arg4);
30256 64 : SWIG_PYTHON_THREAD_END_ALLOW;
30257 : }
30258 64 : if ( bLocalUseExceptions ) {
30259 62 : popErrorHandler();
30260 : }
30261 : #ifndef SED_HACKS
30262 : if ( bLocalUseExceptions ) {
30263 : CPLErr eclass = CPLGetLastErrorType();
30264 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30265 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30266 : }
30267 : }
30268 : #endif
30269 : }
30270 64 : resultobj = SWIG_Py_Void();
30271 70 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30272 : return resultobj;
30273 : fail:
30274 : return NULL;
30275 : }
30276 :
30277 :
30278 50 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30279 50 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30280 50 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30281 50 : int arg2 ;
30282 50 : int arg3 ;
30283 50 : double arg4 ;
30284 50 : void *argp1 = 0 ;
30285 50 : int res1 = 0 ;
30286 50 : int val2 ;
30287 50 : int ecode2 = 0 ;
30288 50 : int val3 ;
30289 50 : int ecode3 = 0 ;
30290 50 : double val4 ;
30291 50 : int ecode4 = 0 ;
30292 50 : PyObject *swig_obj[4] ;
30293 :
30294 50 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_SetValueAsDouble", 4, 4, swig_obj)) SWIG_fail;
30295 50 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30296 50 : if (!SWIG_IsOK(res1)) {
30297 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_SetValueAsDouble" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30298 : }
30299 50 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30300 50 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30301 50 : if (!SWIG_IsOK(ecode2)) {
30302 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_SetValueAsDouble" "', argument " "2"" of type '" "int""'");
30303 : }
30304 50 : arg2 = static_cast< int >(val2);
30305 50 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
30306 50 : if (!SWIG_IsOK(ecode3)) {
30307 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_SetValueAsDouble" "', argument " "3"" of type '" "int""'");
30308 : }
30309 50 : arg3 = static_cast< int >(val3);
30310 50 : ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
30311 50 : if (!SWIG_IsOK(ecode4)) {
30312 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RasterAttributeTable_SetValueAsDouble" "', argument " "4"" of type '" "double""'");
30313 : }
30314 50 : arg4 = static_cast< double >(val4);
30315 50 : {
30316 50 : const int bLocalUseExceptions = GetUseExceptions();
30317 50 : if ( bLocalUseExceptions ) {
30318 48 : pushErrorHandler();
30319 : }
30320 50 : {
30321 50 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30322 50 : GDALRasterAttributeTableShadow_SetValueAsDouble(arg1,arg2,arg3,arg4);
30323 50 : SWIG_PYTHON_THREAD_END_ALLOW;
30324 : }
30325 50 : if ( bLocalUseExceptions ) {
30326 48 : popErrorHandler();
30327 : }
30328 : #ifndef SED_HACKS
30329 : if ( bLocalUseExceptions ) {
30330 : CPLErr eclass = CPLGetLastErrorType();
30331 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30332 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30333 : }
30334 : }
30335 : #endif
30336 : }
30337 50 : resultobj = SWIG_Py_Void();
30338 56 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30339 : return resultobj;
30340 : fail:
30341 : return NULL;
30342 : }
30343 :
30344 :
30345 27 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_SetValueAsBoolean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30346 27 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30347 27 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30348 27 : int arg2 ;
30349 27 : int arg3 ;
30350 27 : bool arg4 ;
30351 27 : void *argp1 = 0 ;
30352 27 : int res1 = 0 ;
30353 27 : int val2 ;
30354 27 : int ecode2 = 0 ;
30355 27 : int val3 ;
30356 27 : int ecode3 = 0 ;
30357 27 : bool val4 ;
30358 27 : int ecode4 = 0 ;
30359 27 : PyObject *swig_obj[4] ;
30360 :
30361 27 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_SetValueAsBoolean", 4, 4, swig_obj)) SWIG_fail;
30362 27 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30363 27 : if (!SWIG_IsOK(res1)) {
30364 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_SetValueAsBoolean" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30365 : }
30366 27 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30367 27 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30368 27 : if (!SWIG_IsOK(ecode2)) {
30369 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_SetValueAsBoolean" "', argument " "2"" of type '" "int""'");
30370 : }
30371 27 : arg2 = static_cast< int >(val2);
30372 27 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
30373 27 : if (!SWIG_IsOK(ecode3)) {
30374 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_SetValueAsBoolean" "', argument " "3"" of type '" "int""'");
30375 : }
30376 27 : arg3 = static_cast< int >(val3);
30377 27 : ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
30378 27 : if (!SWIG_IsOK(ecode4)) {
30379 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RasterAttributeTable_SetValueAsBoolean" "', argument " "4"" of type '" "bool""'");
30380 : }
30381 27 : arg4 = static_cast< bool >(val4);
30382 27 : {
30383 27 : const int bLocalUseExceptions = GetUseExceptions();
30384 27 : if ( bLocalUseExceptions ) {
30385 25 : pushErrorHandler();
30386 : }
30387 27 : {
30388 27 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30389 27 : GDALRasterAttributeTableShadow_SetValueAsBoolean(arg1,arg2,arg3,arg4);
30390 27 : SWIG_PYTHON_THREAD_END_ALLOW;
30391 : }
30392 27 : if ( bLocalUseExceptions ) {
30393 25 : popErrorHandler();
30394 : }
30395 : #ifndef SED_HACKS
30396 : if ( bLocalUseExceptions ) {
30397 : CPLErr eclass = CPLGetLastErrorType();
30398 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30399 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30400 : }
30401 : }
30402 : #endif
30403 : }
30404 27 : resultobj = SWIG_Py_Void();
30405 32 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30406 : return resultobj;
30407 : fail:
30408 : return NULL;
30409 : }
30410 :
30411 :
30412 16 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_SetValueAsDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30413 16 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30414 16 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30415 16 : int arg2 ;
30416 16 : int arg3 ;
30417 16 : GDALRATDateTime arg4 ;
30418 16 : void *argp1 = 0 ;
30419 16 : int res1 = 0 ;
30420 16 : int val2 ;
30421 16 : int ecode2 = 0 ;
30422 16 : int val3 ;
30423 16 : int ecode3 = 0 ;
30424 16 : void *argp4 ;
30425 16 : int res4 = 0 ;
30426 16 : PyObject *swig_obj[4] ;
30427 :
30428 16 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_SetValueAsDateTime", 4, 4, swig_obj)) SWIG_fail;
30429 16 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30430 16 : if (!SWIG_IsOK(res1)) {
30431 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_SetValueAsDateTime" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30432 : }
30433 16 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30434 16 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30435 16 : if (!SWIG_IsOK(ecode2)) {
30436 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_SetValueAsDateTime" "', argument " "2"" of type '" "int""'");
30437 : }
30438 16 : arg2 = static_cast< int >(val2);
30439 16 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
30440 16 : if (!SWIG_IsOK(ecode3)) {
30441 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_SetValueAsDateTime" "', argument " "3"" of type '" "int""'");
30442 : }
30443 16 : arg3 = static_cast< int >(val3);
30444 16 : {
30445 16 : res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_GDALRATDateTime, 0 | 0);
30446 16 : if (!SWIG_IsOK(res4)) {
30447 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RasterAttributeTable_SetValueAsDateTime" "', argument " "4"" of type '" "GDALRATDateTime""'");
30448 : }
30449 16 : if (!argp4) {
30450 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RasterAttributeTable_SetValueAsDateTime" "', argument " "4"" of type '" "GDALRATDateTime""'");
30451 : } else {
30452 16 : GDALRATDateTime * temp = reinterpret_cast< GDALRATDateTime * >(argp4);
30453 16 : arg4 = *temp;
30454 16 : if (SWIG_IsNewObj(res4)) delete temp;
30455 : }
30456 : }
30457 16 : {
30458 16 : const int bLocalUseExceptions = GetUseExceptions();
30459 16 : if ( bLocalUseExceptions ) {
30460 16 : pushErrorHandler();
30461 : }
30462 16 : {
30463 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30464 16 : GDALRasterAttributeTableShadow_SetValueAsDateTime(arg1,arg2,arg3,arg4);
30465 16 : SWIG_PYTHON_THREAD_END_ALLOW;
30466 : }
30467 16 : if ( bLocalUseExceptions ) {
30468 16 : popErrorHandler();
30469 : }
30470 : #ifndef SED_HACKS
30471 : if ( bLocalUseExceptions ) {
30472 : CPLErr eclass = CPLGetLastErrorType();
30473 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30474 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30475 : }
30476 : }
30477 : #endif
30478 : }
30479 16 : resultobj = SWIG_Py_Void();
30480 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30481 : return resultobj;
30482 : fail:
30483 : return NULL;
30484 : }
30485 :
30486 :
30487 15 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_SetRowCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30488 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30489 15 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30490 15 : int arg2 ;
30491 15 : void *argp1 = 0 ;
30492 15 : int res1 = 0 ;
30493 15 : int val2 ;
30494 15 : int ecode2 = 0 ;
30495 15 : PyObject *swig_obj[2] ;
30496 :
30497 15 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_SetRowCount", 2, 2, swig_obj)) SWIG_fail;
30498 15 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30499 15 : if (!SWIG_IsOK(res1)) {
30500 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_SetRowCount" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30501 : }
30502 15 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30503 15 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30504 15 : if (!SWIG_IsOK(ecode2)) {
30505 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_SetRowCount" "', argument " "2"" of type '" "int""'");
30506 : }
30507 15 : arg2 = static_cast< int >(val2);
30508 15 : {
30509 15 : const int bLocalUseExceptions = GetUseExceptions();
30510 15 : if ( bLocalUseExceptions ) {
30511 15 : pushErrorHandler();
30512 : }
30513 15 : {
30514 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30515 15 : GDALRasterAttributeTableShadow_SetRowCount(arg1,arg2);
30516 15 : SWIG_PYTHON_THREAD_END_ALLOW;
30517 : }
30518 15 : if ( bLocalUseExceptions ) {
30519 15 : popErrorHandler();
30520 : }
30521 : #ifndef SED_HACKS
30522 : if ( bLocalUseExceptions ) {
30523 : CPLErr eclass = CPLGetLastErrorType();
30524 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30525 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30526 : }
30527 : }
30528 : #endif
30529 : }
30530 15 : resultobj = SWIG_Py_Void();
30531 15 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30532 : return resultobj;
30533 : fail:
30534 : return NULL;
30535 : }
30536 :
30537 :
30538 74 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_CreateColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30539 74 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30540 74 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30541 74 : char *arg2 = (char *) 0 ;
30542 74 : GDALRATFieldType arg3 ;
30543 74 : GDALRATFieldUsage arg4 ;
30544 74 : void *argp1 = 0 ;
30545 74 : int res1 = 0 ;
30546 74 : int res2 ;
30547 74 : char *buf2 = 0 ;
30548 74 : int alloc2 = 0 ;
30549 74 : int val3 ;
30550 74 : int ecode3 = 0 ;
30551 74 : int val4 ;
30552 74 : int ecode4 = 0 ;
30553 74 : PyObject *swig_obj[4] ;
30554 74 : int result;
30555 :
30556 74 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_CreateColumn", 4, 4, swig_obj)) SWIG_fail;
30557 74 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30558 74 : if (!SWIG_IsOK(res1)) {
30559 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_CreateColumn" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30560 : }
30561 74 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30562 74 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
30563 74 : if (!SWIG_IsOK(res2)) {
30564 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RasterAttributeTable_CreateColumn" "', argument " "2"" of type '" "char const *""'");
30565 : }
30566 74 : arg2 = reinterpret_cast< char * >(buf2);
30567 74 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
30568 74 : if (!SWIG_IsOK(ecode3)) {
30569 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_CreateColumn" "', argument " "3"" of type '" "GDALRATFieldType""'");
30570 : }
30571 74 : arg3 = static_cast< GDALRATFieldType >(val3);
30572 74 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
30573 74 : if (!SWIG_IsOK(ecode4)) {
30574 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RasterAttributeTable_CreateColumn" "', argument " "4"" of type '" "GDALRATFieldUsage""'");
30575 : }
30576 74 : arg4 = static_cast< GDALRATFieldUsage >(val4);
30577 74 : {
30578 74 : const int bLocalUseExceptions = GetUseExceptions();
30579 74 : if ( bLocalUseExceptions ) {
30580 62 : pushErrorHandler();
30581 : }
30582 74 : {
30583 74 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30584 74 : result = (int)GDALRasterAttributeTableShadow_CreateColumn(arg1,(char const *)arg2,arg3,arg4);
30585 74 : SWIG_PYTHON_THREAD_END_ALLOW;
30586 : }
30587 74 : if ( bLocalUseExceptions ) {
30588 62 : popErrorHandler();
30589 : }
30590 : #ifndef SED_HACKS
30591 : if ( bLocalUseExceptions ) {
30592 : CPLErr eclass = CPLGetLastErrorType();
30593 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30594 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30595 : }
30596 : }
30597 : #endif
30598 : }
30599 74 : resultobj = SWIG_From_int(static_cast< int >(result));
30600 74 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
30601 74 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30602 : return resultobj;
30603 0 : fail:
30604 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
30605 : return NULL;
30606 : }
30607 :
30608 :
30609 1 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetLinearBinning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30610 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30611 1 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30612 1 : double *arg2 = (double *) 0 ;
30613 1 : double *arg3 = (double *) 0 ;
30614 1 : void *argp1 = 0 ;
30615 1 : int res1 = 0 ;
30616 1 : double temp2 ;
30617 1 : int res2 = SWIG_TMPOBJ ;
30618 1 : double temp3 ;
30619 1 : int res3 = SWIG_TMPOBJ ;
30620 1 : PyObject *swig_obj[1] ;
30621 1 : bool result;
30622 :
30623 1 : arg2 = &temp2;
30624 1 : arg3 = &temp3;
30625 1 : if (!args) SWIG_fail;
30626 1 : swig_obj[0] = args;
30627 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30628 1 : if (!SWIG_IsOK(res1)) {
30629 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetLinearBinning" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30630 : }
30631 1 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30632 1 : {
30633 1 : const int bLocalUseExceptions = GetUseExceptions();
30634 1 : if ( bLocalUseExceptions ) {
30635 1 : pushErrorHandler();
30636 : }
30637 1 : {
30638 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30639 1 : result = (bool)GDALRasterAttributeTableShadow_GetLinearBinning(arg1,arg2,arg3);
30640 1 : SWIG_PYTHON_THREAD_END_ALLOW;
30641 : }
30642 1 : if ( bLocalUseExceptions ) {
30643 1 : popErrorHandler();
30644 : }
30645 : #ifndef SED_HACKS
30646 : if ( bLocalUseExceptions ) {
30647 : CPLErr eclass = CPLGetLastErrorType();
30648 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30649 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30650 : }
30651 : }
30652 : #endif
30653 : }
30654 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
30655 1 : if (ReturnSame(SWIG_IsTmpObj(res2))) {
30656 1 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
30657 : } else {
30658 0 : int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30659 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
30660 : }
30661 1 : if (ReturnSame(SWIG_IsTmpObj(res3))) {
30662 1 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
30663 : } else {
30664 0 : int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30665 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
30666 : }
30667 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30668 : return resultobj;
30669 : fail:
30670 : return NULL;
30671 : }
30672 :
30673 :
30674 1 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_SetLinearBinning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30675 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30676 1 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30677 1 : double arg2 ;
30678 1 : double arg3 ;
30679 1 : void *argp1 = 0 ;
30680 1 : int res1 = 0 ;
30681 1 : double val2 ;
30682 1 : int ecode2 = 0 ;
30683 1 : double val3 ;
30684 1 : int ecode3 = 0 ;
30685 1 : PyObject *swig_obj[3] ;
30686 1 : int result;
30687 :
30688 1 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_SetLinearBinning", 3, 3, swig_obj)) SWIG_fail;
30689 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30690 1 : if (!SWIG_IsOK(res1)) {
30691 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_SetLinearBinning" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30692 : }
30693 1 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30694 1 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
30695 1 : if (!SWIG_IsOK(ecode2)) {
30696 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_SetLinearBinning" "', argument " "2"" of type '" "double""'");
30697 : }
30698 1 : arg2 = static_cast< double >(val2);
30699 1 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
30700 1 : if (!SWIG_IsOK(ecode3)) {
30701 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RasterAttributeTable_SetLinearBinning" "', argument " "3"" of type '" "double""'");
30702 : }
30703 1 : arg3 = static_cast< double >(val3);
30704 1 : {
30705 1 : const int bLocalUseExceptions = GetUseExceptions();
30706 1 : if ( bLocalUseExceptions ) {
30707 1 : pushErrorHandler();
30708 : }
30709 1 : {
30710 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30711 1 : result = (int)GDALRasterAttributeTableShadow_SetLinearBinning(arg1,arg2,arg3);
30712 1 : SWIG_PYTHON_THREAD_END_ALLOW;
30713 : }
30714 1 : if ( bLocalUseExceptions ) {
30715 1 : popErrorHandler();
30716 : }
30717 : #ifndef SED_HACKS
30718 : if ( bLocalUseExceptions ) {
30719 : CPLErr eclass = CPLGetLastErrorType();
30720 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30721 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30722 : }
30723 : }
30724 : #endif
30725 : }
30726 1 : resultobj = SWIG_From_int(static_cast< int >(result));
30727 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30728 : return resultobj;
30729 : fail:
30730 : return NULL;
30731 : }
30732 :
30733 :
30734 3 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetRowOfValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30735 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30736 3 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30737 3 : double arg2 ;
30738 3 : void *argp1 = 0 ;
30739 3 : int res1 = 0 ;
30740 3 : double val2 ;
30741 3 : int ecode2 = 0 ;
30742 3 : PyObject *swig_obj[2] ;
30743 3 : int result;
30744 :
30745 3 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_GetRowOfValue", 2, 2, swig_obj)) SWIG_fail;
30746 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30747 3 : if (!SWIG_IsOK(res1)) {
30748 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetRowOfValue" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30749 : }
30750 3 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30751 3 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
30752 3 : if (!SWIG_IsOK(ecode2)) {
30753 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_GetRowOfValue" "', argument " "2"" of type '" "double""'");
30754 : }
30755 3 : arg2 = static_cast< double >(val2);
30756 3 : {
30757 3 : const int bLocalUseExceptions = GetUseExceptions();
30758 3 : if ( bLocalUseExceptions ) {
30759 3 : pushErrorHandler();
30760 : }
30761 3 : {
30762 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30763 3 : result = (int)GDALRasterAttributeTableShadow_GetRowOfValue(arg1,arg2);
30764 3 : SWIG_PYTHON_THREAD_END_ALLOW;
30765 : }
30766 3 : if ( bLocalUseExceptions ) {
30767 3 : popErrorHandler();
30768 : }
30769 : #ifndef SED_HACKS
30770 : if ( bLocalUseExceptions ) {
30771 : CPLErr eclass = CPLGetLastErrorType();
30772 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30773 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30774 : }
30775 : }
30776 : #endif
30777 : }
30778 3 : resultobj = SWIG_From_int(static_cast< int >(result));
30779 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30780 : return resultobj;
30781 : fail:
30782 : return NULL;
30783 : }
30784 :
30785 :
30786 2 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_ChangesAreWrittenToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30787 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30788 2 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30789 2 : void *argp1 = 0 ;
30790 2 : int res1 = 0 ;
30791 2 : PyObject *swig_obj[1] ;
30792 2 : int result;
30793 :
30794 2 : if (!args) SWIG_fail;
30795 2 : swig_obj[0] = args;
30796 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30797 2 : if (!SWIG_IsOK(res1)) {
30798 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_ChangesAreWrittenToFile" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30799 : }
30800 2 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30801 2 : {
30802 2 : const int bLocalUseExceptions = GetUseExceptions();
30803 2 : if ( bLocalUseExceptions ) {
30804 2 : pushErrorHandler();
30805 : }
30806 2 : {
30807 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30808 2 : result = (int)GDALRasterAttributeTableShadow_ChangesAreWrittenToFile(arg1);
30809 2 : SWIG_PYTHON_THREAD_END_ALLOW;
30810 : }
30811 2 : if ( bLocalUseExceptions ) {
30812 2 : popErrorHandler();
30813 : }
30814 : #ifndef SED_HACKS
30815 : if ( bLocalUseExceptions ) {
30816 : CPLErr eclass = CPLGetLastErrorType();
30817 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30818 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30819 : }
30820 : }
30821 : #endif
30822 : }
30823 2 : resultobj = SWIG_From_int(static_cast< int >(result));
30824 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30825 : return resultobj;
30826 : fail:
30827 : return NULL;
30828 : }
30829 :
30830 :
30831 0 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_DumpReadable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30832 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30833 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30834 0 : void *argp1 = 0 ;
30835 0 : int res1 = 0 ;
30836 0 : PyObject *swig_obj[1] ;
30837 :
30838 0 : if (!args) SWIG_fail;
30839 0 : swig_obj[0] = args;
30840 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30841 0 : if (!SWIG_IsOK(res1)) {
30842 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_DumpReadable" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30843 : }
30844 0 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30845 0 : {
30846 0 : const int bLocalUseExceptions = GetUseExceptions();
30847 0 : if ( bLocalUseExceptions ) {
30848 0 : pushErrorHandler();
30849 : }
30850 0 : {
30851 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30852 0 : GDALRasterAttributeTableShadow_DumpReadable(arg1);
30853 0 : SWIG_PYTHON_THREAD_END_ALLOW;
30854 : }
30855 0 : if ( bLocalUseExceptions ) {
30856 0 : popErrorHandler();
30857 : }
30858 : #ifndef SED_HACKS
30859 : if ( bLocalUseExceptions ) {
30860 : CPLErr eclass = CPLGetLastErrorType();
30861 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30862 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30863 : }
30864 : }
30865 : #endif
30866 : }
30867 0 : resultobj = SWIG_Py_Void();
30868 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30869 : return resultobj;
30870 : fail:
30871 : return NULL;
30872 : }
30873 :
30874 :
30875 3 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_SetTableType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30876 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30877 3 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30878 3 : GDALRATTableType arg2 ;
30879 3 : void *argp1 = 0 ;
30880 3 : int res1 = 0 ;
30881 3 : int val2 ;
30882 3 : int ecode2 = 0 ;
30883 3 : PyObject *swig_obj[2] ;
30884 :
30885 3 : if (!SWIG_Python_UnpackTuple(args, "RasterAttributeTable_SetTableType", 2, 2, swig_obj)) SWIG_fail;
30886 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30887 3 : if (!SWIG_IsOK(res1)) {
30888 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_SetTableType" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30889 : }
30890 3 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30891 3 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30892 3 : if (!SWIG_IsOK(ecode2)) {
30893 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterAttributeTable_SetTableType" "', argument " "2"" of type '" "GDALRATTableType""'");
30894 : }
30895 3 : arg2 = static_cast< GDALRATTableType >(val2);
30896 3 : {
30897 3 : const int bLocalUseExceptions = GetUseExceptions();
30898 3 : if ( bLocalUseExceptions ) {
30899 3 : pushErrorHandler();
30900 : }
30901 3 : {
30902 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30903 3 : GDALRasterAttributeTableShadow_SetTableType(arg1,arg2);
30904 3 : SWIG_PYTHON_THREAD_END_ALLOW;
30905 : }
30906 3 : if ( bLocalUseExceptions ) {
30907 3 : popErrorHandler();
30908 : }
30909 : #ifndef SED_HACKS
30910 : if ( bLocalUseExceptions ) {
30911 : CPLErr eclass = CPLGetLastErrorType();
30912 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30913 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30914 : }
30915 : }
30916 : #endif
30917 : }
30918 3 : resultobj = SWIG_Py_Void();
30919 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30920 : return resultobj;
30921 : fail:
30922 : return NULL;
30923 : }
30924 :
30925 :
30926 10 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_GetTableType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30927 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30928 10 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30929 10 : void *argp1 = 0 ;
30930 10 : int res1 = 0 ;
30931 10 : PyObject *swig_obj[1] ;
30932 10 : GDALRATTableType result;
30933 :
30934 10 : if (!args) SWIG_fail;
30935 10 : swig_obj[0] = args;
30936 10 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30937 10 : if (!SWIG_IsOK(res1)) {
30938 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_GetTableType" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30939 : }
30940 10 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30941 10 : {
30942 10 : const int bLocalUseExceptions = GetUseExceptions();
30943 10 : if ( bLocalUseExceptions ) {
30944 10 : pushErrorHandler();
30945 : }
30946 10 : {
30947 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30948 10 : result = (GDALRATTableType)GDALRasterAttributeTableShadow_GetTableType(arg1);
30949 10 : SWIG_PYTHON_THREAD_END_ALLOW;
30950 : }
30951 10 : if ( bLocalUseExceptions ) {
30952 10 : popErrorHandler();
30953 : }
30954 : #ifndef SED_HACKS
30955 : if ( bLocalUseExceptions ) {
30956 : CPLErr eclass = CPLGetLastErrorType();
30957 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
30958 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
30959 : }
30960 : }
30961 : #endif
30962 : }
30963 10 : resultobj = SWIG_From_int(static_cast< int >(result));
30964 10 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
30965 : return resultobj;
30966 : fail:
30967 : return NULL;
30968 : }
30969 :
30970 :
30971 1 : SWIGINTERN PyObject *_wrap_RasterAttributeTable_RemoveStatistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30972 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
30973 1 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
30974 1 : void *argp1 = 0 ;
30975 1 : int res1 = 0 ;
30976 1 : PyObject *swig_obj[1] ;
30977 :
30978 1 : if (!args) SWIG_fail;
30979 1 : swig_obj[0] = args;
30980 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
30981 1 : if (!SWIG_IsOK(res1)) {
30982 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterAttributeTable_RemoveStatistics" "', argument " "1"" of type '" "GDALRasterAttributeTableShadow *""'");
30983 : }
30984 1 : arg1 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp1);
30985 1 : {
30986 1 : const int bLocalUseExceptions = GetUseExceptions();
30987 1 : if ( bLocalUseExceptions ) {
30988 1 : pushErrorHandler();
30989 : }
30990 1 : {
30991 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30992 1 : GDALRasterAttributeTableShadow_RemoveStatistics(arg1);
30993 1 : SWIG_PYTHON_THREAD_END_ALLOW;
30994 : }
30995 1 : if ( bLocalUseExceptions ) {
30996 1 : popErrorHandler();
30997 : }
30998 : #ifndef SED_HACKS
30999 : if ( bLocalUseExceptions ) {
31000 : CPLErr eclass = CPLGetLastErrorType();
31001 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31002 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31003 : }
31004 : }
31005 : #endif
31006 : }
31007 1 : resultobj = SWIG_Py_Void();
31008 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31009 : return resultobj;
31010 : fail:
31011 : return NULL;
31012 : }
31013 :
31014 :
31015 277 : SWIGINTERN PyObject *RasterAttributeTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31016 277 : PyObject *obj;
31017 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
31018 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALRasterAttributeTableShadow, SWIG_NewClientData(obj));
31019 277 : return SWIG_Py_Void();
31020 : }
31021 :
31022 24 : SWIGINTERN PyObject *RasterAttributeTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31023 24 : return SWIG_Python_InitShadowInstance(args);
31024 : }
31025 :
31026 1535 : SWIGINTERN PyObject *_wrap_delete_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31027 1535 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31028 1535 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
31029 1535 : void *argp1 = 0 ;
31030 1535 : int res1 = 0 ;
31031 1535 : PyObject *swig_obj[1] ;
31032 :
31033 1535 : if (!args) SWIG_fail;
31034 1535 : swig_obj[0] = args;
31035 1535 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, SWIG_POINTER_DISOWN | 0 );
31036 1535 : if (!SWIG_IsOK(res1)) {
31037 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Group" "', argument " "1"" of type '" "GDALGroupHS *""'");
31038 : }
31039 1535 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
31040 1535 : {
31041 1535 : const int bLocalUseExceptions = GetUseExceptions();
31042 1535 : if ( bLocalUseExceptions ) {
31043 603 : pushErrorHandler();
31044 : }
31045 1535 : {
31046 1535 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31047 1535 : delete_GDALGroupHS(arg1);
31048 1535 : SWIG_PYTHON_THREAD_END_ALLOW;
31049 : }
31050 1535 : if ( bLocalUseExceptions ) {
31051 603 : popErrorHandler();
31052 : }
31053 : #ifndef SED_HACKS
31054 : if ( bLocalUseExceptions ) {
31055 : CPLErr eclass = CPLGetLastErrorType();
31056 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31057 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31058 : }
31059 : }
31060 : #endif
31061 : }
31062 1535 : resultobj = SWIG_Py_Void();
31063 1535 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31064 : return resultobj;
31065 : fail:
31066 : return NULL;
31067 : }
31068 :
31069 :
31070 95 : SWIGINTERN PyObject *_wrap_Group_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31071 95 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31072 95 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
31073 95 : void *argp1 = 0 ;
31074 95 : int res1 = 0 ;
31075 95 : PyObject *swig_obj[1] ;
31076 95 : char *result = 0 ;
31077 :
31078 95 : if (!args) SWIG_fail;
31079 95 : swig_obj[0] = args;
31080 95 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
31081 95 : if (!SWIG_IsOK(res1)) {
31082 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_GetName" "', argument " "1"" of type '" "GDALGroupHS *""'");
31083 : }
31084 95 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
31085 95 : {
31086 95 : const int bLocalUseExceptions = GetUseExceptions();
31087 95 : if ( bLocalUseExceptions ) {
31088 17 : pushErrorHandler();
31089 : }
31090 95 : {
31091 95 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31092 95 : result = (char *)GDALGroupHS_GetName(arg1);
31093 95 : SWIG_PYTHON_THREAD_END_ALLOW;
31094 : }
31095 95 : if ( bLocalUseExceptions ) {
31096 17 : popErrorHandler();
31097 : }
31098 : #ifndef SED_HACKS
31099 : if ( bLocalUseExceptions ) {
31100 : CPLErr eclass = CPLGetLastErrorType();
31101 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31102 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31103 : }
31104 : }
31105 : #endif
31106 : }
31107 95 : resultobj = SWIG_FromCharPtr((const char *)result);
31108 95 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31109 : return resultobj;
31110 : fail:
31111 : return NULL;
31112 : }
31113 :
31114 :
31115 47 : SWIGINTERN PyObject *_wrap_Group_GetFullName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31116 47 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31117 47 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
31118 47 : void *argp1 = 0 ;
31119 47 : int res1 = 0 ;
31120 47 : PyObject *swig_obj[1] ;
31121 47 : char *result = 0 ;
31122 :
31123 47 : if (!args) SWIG_fail;
31124 47 : swig_obj[0] = args;
31125 47 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
31126 47 : if (!SWIG_IsOK(res1)) {
31127 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_GetFullName" "', argument " "1"" of type '" "GDALGroupHS *""'");
31128 : }
31129 47 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
31130 47 : {
31131 47 : const int bLocalUseExceptions = GetUseExceptions();
31132 47 : if ( bLocalUseExceptions ) {
31133 17 : pushErrorHandler();
31134 : }
31135 47 : {
31136 47 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31137 47 : result = (char *)GDALGroupHS_GetFullName(arg1);
31138 47 : SWIG_PYTHON_THREAD_END_ALLOW;
31139 : }
31140 47 : if ( bLocalUseExceptions ) {
31141 17 : popErrorHandler();
31142 : }
31143 : #ifndef SED_HACKS
31144 : if ( bLocalUseExceptions ) {
31145 : CPLErr eclass = CPLGetLastErrorType();
31146 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31147 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31148 : }
31149 : }
31150 : #endif
31151 : }
31152 47 : resultobj = SWIG_FromCharPtr((const char *)result);
31153 47 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31154 : return resultobj;
31155 : fail:
31156 : return NULL;
31157 : }
31158 :
31159 :
31160 337 : SWIGINTERN PyObject *_wrap_Group_GetMDArrayNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31161 337 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31162 337 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
31163 337 : char **arg2 = (char **) 0 ;
31164 337 : void *argp1 = 0 ;
31165 337 : int res1 = 0 ;
31166 337 : PyObject *swig_obj[2] ;
31167 337 : char **result = 0 ;
31168 :
31169 337 : if (!SWIG_Python_UnpackTuple(args, "Group_GetMDArrayNames", 1, 2, swig_obj)) SWIG_fail;
31170 337 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
31171 337 : if (!SWIG_IsOK(res1)) {
31172 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_GetMDArrayNames" "', argument " "1"" of type '" "GDALGroupHS *""'");
31173 : }
31174 337 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
31175 337 : if (swig_obj[1]) {
31176 337 : {
31177 : /* %typemap(in) char **dict */
31178 337 : arg2 = NULL;
31179 337 : if ( PySequence_Check( swig_obj[1] ) ) {
31180 337 : int bErr = FALSE;
31181 337 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
31182 337 : if ( bErr )
31183 : {
31184 0 : SWIG_fail;
31185 : }
31186 : }
31187 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
31188 0 : int bErr = FALSE;
31189 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
31190 0 : if ( bErr )
31191 : {
31192 0 : SWIG_fail;
31193 : }
31194 : }
31195 : else {
31196 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
31197 0 : SWIG_fail;
31198 : }
31199 : }
31200 : }
31201 337 : {
31202 337 : const int bLocalUseExceptions = GetUseExceptions();
31203 337 : if ( bLocalUseExceptions ) {
31204 82 : pushErrorHandler();
31205 : }
31206 337 : {
31207 337 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31208 337 : result = (char **)GDALGroupHS_GetMDArrayNames(arg1,arg2);
31209 337 : SWIG_PYTHON_THREAD_END_ALLOW;
31210 : }
31211 337 : if ( bLocalUseExceptions ) {
31212 82 : popErrorHandler();
31213 : }
31214 : #ifndef SED_HACKS
31215 : if ( bLocalUseExceptions ) {
31216 : CPLErr eclass = CPLGetLastErrorType();
31217 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31218 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31219 : }
31220 : }
31221 : #endif
31222 : }
31223 337 : {
31224 : /* %typemap(out) char **CSL -> ( string ) */
31225 337 : bool bErr = false;
31226 337 : resultobj = CSLToList(result, &bErr);
31227 337 : CSLDestroy(result);
31228 337 : if( bErr ) {
31229 0 : SWIG_fail;
31230 : }
31231 : }
31232 337 : {
31233 : /* %typemap(freearg) char **dict */
31234 337 : CSLDestroy( arg2 );
31235 : }
31236 341 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31237 : return resultobj;
31238 0 : fail:
31239 0 : {
31240 : /* %typemap(freearg) char **dict */
31241 0 : CSLDestroy( arg2 );
31242 : }
31243 : return NULL;
31244 : }
31245 :
31246 :
31247 1 : SWIGINTERN PyObject *_wrap_Group_GetMDArrayFullNamesRecursive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31248 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31249 1 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
31250 1 : char **arg2 = (char **) 0 ;
31251 1 : char **arg3 = (char **) 0 ;
31252 1 : void *argp1 = 0 ;
31253 1 : int res1 = 0 ;
31254 1 : void *argp2 = 0 ;
31255 1 : int res2 = 0 ;
31256 1 : void *argp3 = 0 ;
31257 1 : int res3 = 0 ;
31258 1 : PyObject *swig_obj[3] ;
31259 1 : char **result = 0 ;
31260 :
31261 1 : if (!SWIG_Python_UnpackTuple(args, "Group_GetMDArrayFullNamesRecursive", 1, 3, swig_obj)) SWIG_fail;
31262 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
31263 1 : if (!SWIG_IsOK(res1)) {
31264 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_GetMDArrayFullNamesRecursive" "', argument " "1"" of type '" "GDALGroupHS *""'");
31265 : }
31266 1 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
31267 1 : if (swig_obj[1]) {
31268 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 | 0 );
31269 0 : if (!SWIG_IsOK(res2)) {
31270 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_GetMDArrayFullNamesRecursive" "', argument " "2"" of type '" "char **""'");
31271 : }
31272 0 : arg2 = reinterpret_cast< char ** >(argp2);
31273 : }
31274 1 : if (swig_obj[2]) {
31275 0 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_char, 0 | 0 );
31276 0 : if (!SWIG_IsOK(res3)) {
31277 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Group_GetMDArrayFullNamesRecursive" "', argument " "3"" of type '" "char **""'");
31278 : }
31279 0 : arg3 = reinterpret_cast< char ** >(argp3);
31280 : }
31281 1 : {
31282 1 : const int bLocalUseExceptions = GetUseExceptions();
31283 1 : if ( bLocalUseExceptions ) {
31284 1 : pushErrorHandler();
31285 : }
31286 1 : {
31287 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31288 1 : result = (char **)GDALGroupHS_GetMDArrayFullNamesRecursive(arg1,arg2,arg3);
31289 1 : SWIG_PYTHON_THREAD_END_ALLOW;
31290 : }
31291 1 : if ( bLocalUseExceptions ) {
31292 1 : popErrorHandler();
31293 : }
31294 : #ifndef SED_HACKS
31295 : if ( bLocalUseExceptions ) {
31296 : CPLErr eclass = CPLGetLastErrorType();
31297 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31298 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31299 : }
31300 : }
31301 : #endif
31302 : }
31303 1 : {
31304 : /* %typemap(out) char **CSL -> ( string ) */
31305 1 : bool bErr = false;
31306 1 : resultobj = CSLToList(result, &bErr);
31307 1 : CSLDestroy(result);
31308 1 : if( bErr ) {
31309 0 : SWIG_fail;
31310 : }
31311 : }
31312 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31313 : return resultobj;
31314 : fail:
31315 : return NULL;
31316 : }
31317 :
31318 :
31319 835 : SWIGINTERN PyObject *_wrap_Group_OpenMDArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31320 835 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31321 835 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
31322 835 : char *arg2 = (char *) 0 ;
31323 835 : char **arg3 = (char **) 0 ;
31324 835 : void *argp1 = 0 ;
31325 835 : int res1 = 0 ;
31326 835 : int res2 ;
31327 835 : char *buf2 = 0 ;
31328 835 : int alloc2 = 0 ;
31329 835 : PyObject *swig_obj[3] ;
31330 835 : GDALMDArrayHS *result = 0 ;
31331 :
31332 835 : if (!SWIG_Python_UnpackTuple(args, "Group_OpenMDArray", 2, 3, swig_obj)) SWIG_fail;
31333 835 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
31334 835 : if (!SWIG_IsOK(res1)) {
31335 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_OpenMDArray" "', argument " "1"" of type '" "GDALGroupHS *""'");
31336 : }
31337 835 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
31338 835 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
31339 835 : if (!SWIG_IsOK(res2)) {
31340 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_OpenMDArray" "', argument " "2"" of type '" "char const *""'");
31341 : }
31342 835 : arg2 = reinterpret_cast< char * >(buf2);
31343 835 : if (swig_obj[2]) {
31344 10 : {
31345 : /* %typemap(in) char **dict */
31346 10 : arg3 = NULL;
31347 10 : if ( PySequence_Check( swig_obj[2] ) ) {
31348 10 : int bErr = FALSE;
31349 10 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
31350 10 : if ( bErr )
31351 : {
31352 0 : SWIG_fail;
31353 : }
31354 : }
31355 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
31356 0 : int bErr = FALSE;
31357 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
31358 0 : if ( bErr )
31359 : {
31360 0 : SWIG_fail;
31361 : }
31362 : }
31363 : else {
31364 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
31365 0 : SWIG_fail;
31366 : }
31367 : }
31368 : }
31369 835 : {
31370 835 : if (!arg2) {
31371 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
31372 : }
31373 : }
31374 835 : {
31375 835 : const int bLocalUseExceptions = GetUseExceptions();
31376 835 : if ( bLocalUseExceptions ) {
31377 255 : pushErrorHandler();
31378 : }
31379 835 : {
31380 835 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31381 835 : result = (GDALMDArrayHS *)GDALGroupHS_OpenMDArray(arg1,(char const *)arg2,arg3);
31382 835 : SWIG_PYTHON_THREAD_END_ALLOW;
31383 : }
31384 835 : if ( bLocalUseExceptions ) {
31385 255 : popErrorHandler();
31386 : }
31387 : #ifndef SED_HACKS
31388 : if ( bLocalUseExceptions ) {
31389 : CPLErr eclass = CPLGetLastErrorType();
31390 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31391 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31392 : }
31393 : }
31394 : #endif
31395 : }
31396 835 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_OWN | 0 );
31397 835 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31398 835 : {
31399 : /* %typemap(freearg) char **dict */
31400 835 : CSLDestroy( arg3 );
31401 : }
31402 869 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31403 : return resultobj;
31404 0 : fail:
31405 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31406 0 : {
31407 : /* %typemap(freearg) char **dict */
31408 0 : CSLDestroy( arg3 );
31409 : }
31410 : return NULL;
31411 : }
31412 :
31413 :
31414 18 : SWIGINTERN PyObject *_wrap_Group_OpenMDArrayFromFullname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31415 18 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31416 18 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
31417 18 : char *arg2 = (char *) 0 ;
31418 18 : char **arg3 = (char **) 0 ;
31419 18 : void *argp1 = 0 ;
31420 18 : int res1 = 0 ;
31421 18 : int res2 ;
31422 18 : char *buf2 = 0 ;
31423 18 : int alloc2 = 0 ;
31424 18 : PyObject *swig_obj[3] ;
31425 18 : GDALMDArrayHS *result = 0 ;
31426 :
31427 18 : if (!SWIG_Python_UnpackTuple(args, "Group_OpenMDArrayFromFullname", 2, 3, swig_obj)) SWIG_fail;
31428 18 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
31429 18 : if (!SWIG_IsOK(res1)) {
31430 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_OpenMDArrayFromFullname" "', argument " "1"" of type '" "GDALGroupHS *""'");
31431 : }
31432 18 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
31433 18 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
31434 18 : if (!SWIG_IsOK(res2)) {
31435 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_OpenMDArrayFromFullname" "', argument " "2"" of type '" "char const *""'");
31436 : }
31437 18 : arg2 = reinterpret_cast< char * >(buf2);
31438 18 : if (swig_obj[2]) {
31439 0 : {
31440 : /* %typemap(in) char **dict */
31441 0 : arg3 = NULL;
31442 0 : if ( PySequence_Check( swig_obj[2] ) ) {
31443 0 : int bErr = FALSE;
31444 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
31445 0 : if ( bErr )
31446 : {
31447 0 : SWIG_fail;
31448 : }
31449 : }
31450 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
31451 0 : int bErr = FALSE;
31452 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
31453 0 : if ( bErr )
31454 : {
31455 0 : SWIG_fail;
31456 : }
31457 : }
31458 : else {
31459 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
31460 0 : SWIG_fail;
31461 : }
31462 : }
31463 : }
31464 18 : {
31465 18 : if (!arg2) {
31466 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
31467 : }
31468 : }
31469 18 : {
31470 18 : const int bLocalUseExceptions = GetUseExceptions();
31471 18 : if ( bLocalUseExceptions ) {
31472 10 : pushErrorHandler();
31473 : }
31474 18 : {
31475 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31476 18 : result = (GDALMDArrayHS *)GDALGroupHS_OpenMDArrayFromFullname(arg1,(char const *)arg2,arg3);
31477 18 : SWIG_PYTHON_THREAD_END_ALLOW;
31478 : }
31479 18 : if ( bLocalUseExceptions ) {
31480 10 : popErrorHandler();
31481 : }
31482 : #ifndef SED_HACKS
31483 : if ( bLocalUseExceptions ) {
31484 : CPLErr eclass = CPLGetLastErrorType();
31485 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31486 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31487 : }
31488 : }
31489 : #endif
31490 : }
31491 18 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_OWN | 0 );
31492 18 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31493 18 : {
31494 : /* %typemap(freearg) char **dict */
31495 18 : CSLDestroy( arg3 );
31496 : }
31497 20 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31498 : return resultobj;
31499 0 : fail:
31500 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31501 0 : {
31502 : /* %typemap(freearg) char **dict */
31503 0 : CSLDestroy( arg3 );
31504 : }
31505 : return NULL;
31506 : }
31507 :
31508 :
31509 19 : SWIGINTERN PyObject *_wrap_Group_ResolveMDArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31510 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31511 19 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
31512 19 : char *arg2 = (char *) 0 ;
31513 19 : char *arg3 = (char *) 0 ;
31514 19 : char **arg4 = (char **) 0 ;
31515 19 : void *argp1 = 0 ;
31516 19 : int res1 = 0 ;
31517 19 : int res2 ;
31518 19 : char *buf2 = 0 ;
31519 19 : int alloc2 = 0 ;
31520 19 : int res3 ;
31521 19 : char *buf3 = 0 ;
31522 19 : int alloc3 = 0 ;
31523 19 : PyObject *swig_obj[4] ;
31524 19 : GDALMDArrayHS *result = 0 ;
31525 :
31526 19 : if (!SWIG_Python_UnpackTuple(args, "Group_ResolveMDArray", 3, 4, swig_obj)) SWIG_fail;
31527 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
31528 19 : if (!SWIG_IsOK(res1)) {
31529 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_ResolveMDArray" "', argument " "1"" of type '" "GDALGroupHS *""'");
31530 : }
31531 19 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
31532 19 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
31533 19 : if (!SWIG_IsOK(res2)) {
31534 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_ResolveMDArray" "', argument " "2"" of type '" "char const *""'");
31535 : }
31536 19 : arg2 = reinterpret_cast< char * >(buf2);
31537 19 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
31538 19 : if (!SWIG_IsOK(res3)) {
31539 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Group_ResolveMDArray" "', argument " "3"" of type '" "char const *""'");
31540 : }
31541 19 : arg3 = reinterpret_cast< char * >(buf3);
31542 19 : if (swig_obj[3]) {
31543 0 : {
31544 : /* %typemap(in) char **dict */
31545 0 : arg4 = NULL;
31546 0 : if ( PySequence_Check( swig_obj[3] ) ) {
31547 0 : int bErr = FALSE;
31548 0 : arg4 = CSLFromPySequence(swig_obj[3], &bErr);
31549 0 : if ( bErr )
31550 : {
31551 0 : SWIG_fail;
31552 : }
31553 : }
31554 0 : else if ( PyMapping_Check( swig_obj[3] ) ) {
31555 0 : int bErr = FALSE;
31556 0 : arg4 = CSLFromPyMapping(swig_obj[3], &bErr);
31557 0 : if ( bErr )
31558 : {
31559 0 : SWIG_fail;
31560 : }
31561 : }
31562 : else {
31563 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
31564 0 : SWIG_fail;
31565 : }
31566 : }
31567 : }
31568 19 : {
31569 19 : if (!arg2) {
31570 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
31571 : }
31572 : }
31573 19 : {
31574 19 : const int bLocalUseExceptions = GetUseExceptions();
31575 19 : if ( bLocalUseExceptions ) {
31576 1 : pushErrorHandler();
31577 : }
31578 19 : {
31579 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31580 19 : result = (GDALMDArrayHS *)GDALGroupHS_ResolveMDArray(arg1,(char const *)arg2,(char const *)arg3,arg4);
31581 19 : SWIG_PYTHON_THREAD_END_ALLOW;
31582 : }
31583 19 : if ( bLocalUseExceptions ) {
31584 1 : popErrorHandler();
31585 : }
31586 : #ifndef SED_HACKS
31587 : if ( bLocalUseExceptions ) {
31588 : CPLErr eclass = CPLGetLastErrorType();
31589 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31590 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31591 : }
31592 : }
31593 : #endif
31594 : }
31595 19 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_OWN | 0 );
31596 19 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31597 19 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
31598 19 : {
31599 : /* %typemap(freearg) char **dict */
31600 19 : CSLDestroy( arg4 );
31601 : }
31602 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31603 : return resultobj;
31604 0 : fail:
31605 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31606 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
31607 0 : {
31608 : /* %typemap(freearg) char **dict */
31609 0 : CSLDestroy( arg4 );
31610 : }
31611 : return NULL;
31612 : }
31613 :
31614 :
31615 98 : SWIGINTERN PyObject *_wrap_Group_GetGroupNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31616 98 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31617 98 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
31618 98 : char **arg2 = (char **) 0 ;
31619 98 : void *argp1 = 0 ;
31620 98 : int res1 = 0 ;
31621 98 : PyObject *swig_obj[2] ;
31622 98 : char **result = 0 ;
31623 :
31624 98 : if (!SWIG_Python_UnpackTuple(args, "Group_GetGroupNames", 1, 2, swig_obj)) SWIG_fail;
31625 98 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
31626 98 : if (!SWIG_IsOK(res1)) {
31627 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_GetGroupNames" "', argument " "1"" of type '" "GDALGroupHS *""'");
31628 : }
31629 98 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
31630 98 : if (swig_obj[1]) {
31631 98 : {
31632 : /* %typemap(in) char **dict */
31633 98 : arg2 = NULL;
31634 98 : if ( PySequence_Check( swig_obj[1] ) ) {
31635 98 : int bErr = FALSE;
31636 98 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
31637 98 : if ( bErr )
31638 : {
31639 0 : SWIG_fail;
31640 : }
31641 : }
31642 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
31643 0 : int bErr = FALSE;
31644 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
31645 0 : if ( bErr )
31646 : {
31647 0 : SWIG_fail;
31648 : }
31649 : }
31650 : else {
31651 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
31652 0 : SWIG_fail;
31653 : }
31654 : }
31655 : }
31656 98 : {
31657 98 : const int bLocalUseExceptions = GetUseExceptions();
31658 98 : if ( bLocalUseExceptions ) {
31659 52 : pushErrorHandler();
31660 : }
31661 98 : {
31662 98 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31663 98 : result = (char **)GDALGroupHS_GetGroupNames(arg1,arg2);
31664 98 : SWIG_PYTHON_THREAD_END_ALLOW;
31665 : }
31666 98 : if ( bLocalUseExceptions ) {
31667 52 : popErrorHandler();
31668 : }
31669 : #ifndef SED_HACKS
31670 : if ( bLocalUseExceptions ) {
31671 : CPLErr eclass = CPLGetLastErrorType();
31672 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31673 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31674 : }
31675 : }
31676 : #endif
31677 : }
31678 98 : {
31679 : /* %typemap(out) char **CSL -> ( string ) */
31680 98 : bool bErr = false;
31681 98 : resultobj = CSLToList(result, &bErr);
31682 98 : CSLDestroy(result);
31683 98 : if( bErr ) {
31684 0 : SWIG_fail;
31685 : }
31686 : }
31687 98 : {
31688 : /* %typemap(freearg) char **dict */
31689 98 : CSLDestroy( arg2 );
31690 : }
31691 98 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31692 : return resultobj;
31693 0 : fail:
31694 0 : {
31695 : /* %typemap(freearg) char **dict */
31696 0 : CSLDestroy( arg2 );
31697 : }
31698 : return NULL;
31699 : }
31700 :
31701 :
31702 163 : SWIGINTERN PyObject *_wrap_Group_OpenGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31703 163 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31704 163 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
31705 163 : char *arg2 = (char *) 0 ;
31706 163 : char **arg3 = (char **) 0 ;
31707 163 : void *argp1 = 0 ;
31708 163 : int res1 = 0 ;
31709 163 : int res2 ;
31710 163 : char *buf2 = 0 ;
31711 163 : int alloc2 = 0 ;
31712 163 : PyObject *swig_obj[3] ;
31713 163 : GDALGroupHS *result = 0 ;
31714 :
31715 163 : if (!SWIG_Python_UnpackTuple(args, "Group_OpenGroup", 2, 3, swig_obj)) SWIG_fail;
31716 163 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
31717 163 : if (!SWIG_IsOK(res1)) {
31718 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_OpenGroup" "', argument " "1"" of type '" "GDALGroupHS *""'");
31719 : }
31720 163 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
31721 163 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
31722 163 : if (!SWIG_IsOK(res2)) {
31723 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_OpenGroup" "', argument " "2"" of type '" "char const *""'");
31724 : }
31725 163 : arg2 = reinterpret_cast< char * >(buf2);
31726 163 : if (swig_obj[2]) {
31727 1 : {
31728 : /* %typemap(in) char **dict */
31729 1 : arg3 = NULL;
31730 1 : if ( PySequence_Check( swig_obj[2] ) ) {
31731 1 : int bErr = FALSE;
31732 1 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
31733 1 : if ( bErr )
31734 : {
31735 0 : SWIG_fail;
31736 : }
31737 : }
31738 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
31739 0 : int bErr = FALSE;
31740 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
31741 0 : if ( bErr )
31742 : {
31743 0 : SWIG_fail;
31744 : }
31745 : }
31746 : else {
31747 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
31748 0 : SWIG_fail;
31749 : }
31750 : }
31751 : }
31752 163 : {
31753 163 : if (!arg2) {
31754 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
31755 : }
31756 : }
31757 163 : {
31758 163 : const int bLocalUseExceptions = GetUseExceptions();
31759 163 : if ( bLocalUseExceptions ) {
31760 97 : pushErrorHandler();
31761 : }
31762 163 : {
31763 163 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31764 163 : result = (GDALGroupHS *)GDALGroupHS_OpenGroup(arg1,(char const *)arg2,arg3);
31765 163 : SWIG_PYTHON_THREAD_END_ALLOW;
31766 : }
31767 163 : if ( bLocalUseExceptions ) {
31768 97 : popErrorHandler();
31769 : }
31770 : #ifndef SED_HACKS
31771 : if ( bLocalUseExceptions ) {
31772 : CPLErr eclass = CPLGetLastErrorType();
31773 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31774 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31775 : }
31776 : }
31777 : #endif
31778 : }
31779 163 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALGroupHS, SWIG_POINTER_OWN | 0 );
31780 163 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31781 163 : {
31782 : /* %typemap(freearg) char **dict */
31783 163 : CSLDestroy( arg3 );
31784 : }
31785 187 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31786 : return resultobj;
31787 0 : fail:
31788 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31789 0 : {
31790 : /* %typemap(freearg) char **dict */
31791 0 : CSLDestroy( arg3 );
31792 : }
31793 : return NULL;
31794 : }
31795 :
31796 :
31797 3 : SWIGINTERN PyObject *_wrap_Group_OpenGroupFromFullname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31798 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31799 3 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
31800 3 : char *arg2 = (char *) 0 ;
31801 3 : char **arg3 = (char **) 0 ;
31802 3 : void *argp1 = 0 ;
31803 3 : int res1 = 0 ;
31804 3 : int res2 ;
31805 3 : char *buf2 = 0 ;
31806 3 : int alloc2 = 0 ;
31807 3 : PyObject *swig_obj[3] ;
31808 3 : GDALGroupHS *result = 0 ;
31809 :
31810 3 : if (!SWIG_Python_UnpackTuple(args, "Group_OpenGroupFromFullname", 2, 3, swig_obj)) SWIG_fail;
31811 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
31812 3 : if (!SWIG_IsOK(res1)) {
31813 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_OpenGroupFromFullname" "', argument " "1"" of type '" "GDALGroupHS *""'");
31814 : }
31815 3 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
31816 3 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
31817 3 : if (!SWIG_IsOK(res2)) {
31818 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_OpenGroupFromFullname" "', argument " "2"" of type '" "char const *""'");
31819 : }
31820 3 : arg2 = reinterpret_cast< char * >(buf2);
31821 3 : if (swig_obj[2]) {
31822 0 : {
31823 : /* %typemap(in) char **dict */
31824 0 : arg3 = NULL;
31825 0 : if ( PySequence_Check( swig_obj[2] ) ) {
31826 0 : int bErr = FALSE;
31827 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
31828 0 : if ( bErr )
31829 : {
31830 0 : SWIG_fail;
31831 : }
31832 : }
31833 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
31834 0 : int bErr = FALSE;
31835 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
31836 0 : if ( bErr )
31837 : {
31838 0 : SWIG_fail;
31839 : }
31840 : }
31841 : else {
31842 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
31843 0 : SWIG_fail;
31844 : }
31845 : }
31846 : }
31847 3 : {
31848 3 : if (!arg2) {
31849 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
31850 : }
31851 : }
31852 3 : {
31853 3 : const int bLocalUseExceptions = GetUseExceptions();
31854 3 : if ( bLocalUseExceptions ) {
31855 1 : pushErrorHandler();
31856 : }
31857 3 : {
31858 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31859 3 : result = (GDALGroupHS *)GDALGroupHS_OpenGroupFromFullname(arg1,(char const *)arg2,arg3);
31860 3 : SWIG_PYTHON_THREAD_END_ALLOW;
31861 : }
31862 3 : if ( bLocalUseExceptions ) {
31863 1 : popErrorHandler();
31864 : }
31865 : #ifndef SED_HACKS
31866 : if ( bLocalUseExceptions ) {
31867 : CPLErr eclass = CPLGetLastErrorType();
31868 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31869 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31870 : }
31871 : }
31872 : #endif
31873 : }
31874 3 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALGroupHS, SWIG_POINTER_OWN | 0 );
31875 3 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31876 3 : {
31877 : /* %typemap(freearg) char **dict */
31878 3 : CSLDestroy( arg3 );
31879 : }
31880 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31881 : return resultobj;
31882 0 : fail:
31883 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31884 0 : {
31885 : /* %typemap(freearg) char **dict */
31886 0 : CSLDestroy( arg3 );
31887 : }
31888 : return NULL;
31889 : }
31890 :
31891 :
31892 8 : SWIGINTERN PyObject *_wrap_Group_GetVectorLayerNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31893 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31894 8 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
31895 8 : char **arg2 = (char **) 0 ;
31896 8 : void *argp1 = 0 ;
31897 8 : int res1 = 0 ;
31898 8 : PyObject *swig_obj[2] ;
31899 8 : char **result = 0 ;
31900 :
31901 8 : if (!SWIG_Python_UnpackTuple(args, "Group_GetVectorLayerNames", 1, 2, swig_obj)) SWIG_fail;
31902 8 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
31903 8 : if (!SWIG_IsOK(res1)) {
31904 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_GetVectorLayerNames" "', argument " "1"" of type '" "GDALGroupHS *""'");
31905 : }
31906 8 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
31907 8 : if (swig_obj[1]) {
31908 0 : {
31909 : /* %typemap(in) char **dict */
31910 0 : arg2 = NULL;
31911 0 : if ( PySequence_Check( swig_obj[1] ) ) {
31912 0 : int bErr = FALSE;
31913 0 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
31914 0 : if ( bErr )
31915 : {
31916 0 : SWIG_fail;
31917 : }
31918 : }
31919 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
31920 0 : int bErr = FALSE;
31921 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
31922 0 : if ( bErr )
31923 : {
31924 0 : SWIG_fail;
31925 : }
31926 : }
31927 : else {
31928 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
31929 0 : SWIG_fail;
31930 : }
31931 : }
31932 : }
31933 8 : {
31934 8 : const int bLocalUseExceptions = GetUseExceptions();
31935 8 : if ( bLocalUseExceptions ) {
31936 0 : pushErrorHandler();
31937 : }
31938 8 : {
31939 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31940 8 : result = (char **)GDALGroupHS_GetVectorLayerNames(arg1,arg2);
31941 8 : SWIG_PYTHON_THREAD_END_ALLOW;
31942 : }
31943 8 : if ( bLocalUseExceptions ) {
31944 0 : popErrorHandler();
31945 : }
31946 : #ifndef SED_HACKS
31947 : if ( bLocalUseExceptions ) {
31948 : CPLErr eclass = CPLGetLastErrorType();
31949 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
31950 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
31951 : }
31952 : }
31953 : #endif
31954 : }
31955 8 : {
31956 : /* %typemap(out) char **CSL -> ( string ) */
31957 8 : bool bErr = false;
31958 8 : resultobj = CSLToList(result, &bErr);
31959 8 : CSLDestroy(result);
31960 8 : if( bErr ) {
31961 0 : SWIG_fail;
31962 : }
31963 : }
31964 8 : {
31965 : /* %typemap(freearg) char **dict */
31966 8 : CSLDestroy( arg2 );
31967 : }
31968 8 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
31969 : return resultobj;
31970 0 : fail:
31971 0 : {
31972 : /* %typemap(freearg) char **dict */
31973 0 : CSLDestroy( arg2 );
31974 : }
31975 : return NULL;
31976 : }
31977 :
31978 :
31979 12 : SWIGINTERN PyObject *_wrap_Group_OpenVectorLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31980 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
31981 12 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
31982 12 : char *arg2 = (char *) 0 ;
31983 12 : char **arg3 = (char **) 0 ;
31984 12 : void *argp1 = 0 ;
31985 12 : int res1 = 0 ;
31986 12 : int res2 ;
31987 12 : char *buf2 = 0 ;
31988 12 : int alloc2 = 0 ;
31989 12 : PyObject *swig_obj[3] ;
31990 12 : OGRLayerShadow *result = 0 ;
31991 :
31992 12 : if (!SWIG_Python_UnpackTuple(args, "Group_OpenVectorLayer", 2, 3, swig_obj)) SWIG_fail;
31993 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
31994 12 : if (!SWIG_IsOK(res1)) {
31995 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_OpenVectorLayer" "', argument " "1"" of type '" "GDALGroupHS *""'");
31996 : }
31997 12 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
31998 12 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
31999 12 : if (!SWIG_IsOK(res2)) {
32000 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_OpenVectorLayer" "', argument " "2"" of type '" "char const *""'");
32001 : }
32002 12 : arg2 = reinterpret_cast< char * >(buf2);
32003 12 : if (swig_obj[2]) {
32004 0 : {
32005 : /* %typemap(in) char **dict */
32006 0 : arg3 = NULL;
32007 0 : if ( PySequence_Check( swig_obj[2] ) ) {
32008 0 : int bErr = FALSE;
32009 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
32010 0 : if ( bErr )
32011 : {
32012 0 : SWIG_fail;
32013 : }
32014 : }
32015 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
32016 0 : int bErr = FALSE;
32017 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
32018 0 : if ( bErr )
32019 : {
32020 0 : SWIG_fail;
32021 : }
32022 : }
32023 : else {
32024 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
32025 0 : SWIG_fail;
32026 : }
32027 : }
32028 : }
32029 12 : {
32030 12 : if (!arg2) {
32031 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
32032 : }
32033 : }
32034 12 : {
32035 12 : const int bLocalUseExceptions = GetUseExceptions();
32036 12 : if ( bLocalUseExceptions ) {
32037 1 : pushErrorHandler();
32038 : }
32039 12 : {
32040 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32041 12 : result = (OGRLayerShadow *)GDALGroupHS_OpenVectorLayer(arg1,(char const *)arg2,arg3);
32042 12 : SWIG_PYTHON_THREAD_END_ALLOW;
32043 : }
32044 12 : if ( bLocalUseExceptions ) {
32045 1 : popErrorHandler();
32046 : }
32047 : #ifndef SED_HACKS
32048 : if ( bLocalUseExceptions ) {
32049 : CPLErr eclass = CPLGetLastErrorType();
32050 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32051 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32052 : }
32053 : }
32054 : #endif
32055 : }
32056 12 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
32057 12 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32058 12 : {
32059 : /* %typemap(freearg) char **dict */
32060 12 : CSLDestroy( arg3 );
32061 : }
32062 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32063 : return resultobj;
32064 0 : fail:
32065 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32066 0 : {
32067 : /* %typemap(freearg) char **dict */
32068 0 : CSLDestroy( arg3 );
32069 : }
32070 : return NULL;
32071 : }
32072 :
32073 :
32074 73 : SWIGINTERN PyObject *_wrap_Group_GetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32075 73 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32076 73 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
32077 73 : GDALDimensionHS ***arg2 = (GDALDimensionHS ***) 0 ;
32078 73 : size_t *arg3 = (size_t *) 0 ;
32079 73 : char **arg4 = (char **) 0 ;
32080 73 : void *argp1 = 0 ;
32081 73 : int res1 = 0 ;
32082 73 : GDALDimensionHS **dims2 = 0 ;
32083 73 : size_t nCount2 = 0 ;
32084 73 : PyObject *swig_obj[2] ;
32085 :
32086 73 : {
32087 : /* %typemap(in,numinputs=0) (GDALDimensionHS*** pdims, size_t* pnCount) */
32088 73 : arg2 = &dims2;
32089 73 : arg3 = &nCount2;
32090 : }
32091 73 : if (!SWIG_Python_UnpackTuple(args, "Group_GetDimensions", 1, 2, swig_obj)) SWIG_fail;
32092 73 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
32093 73 : if (!SWIG_IsOK(res1)) {
32094 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_GetDimensions" "', argument " "1"" of type '" "GDALGroupHS *""'");
32095 : }
32096 73 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
32097 73 : if (swig_obj[1]) {
32098 0 : {
32099 : /* %typemap(in) char **dict */
32100 0 : arg4 = NULL;
32101 0 : if ( PySequence_Check( swig_obj[1] ) ) {
32102 0 : int bErr = FALSE;
32103 0 : arg4 = CSLFromPySequence(swig_obj[1], &bErr);
32104 0 : if ( bErr )
32105 : {
32106 0 : SWIG_fail;
32107 : }
32108 : }
32109 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
32110 0 : int bErr = FALSE;
32111 0 : arg4 = CSLFromPyMapping(swig_obj[1], &bErr);
32112 0 : if ( bErr )
32113 : {
32114 0 : SWIG_fail;
32115 : }
32116 : }
32117 : else {
32118 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
32119 0 : SWIG_fail;
32120 : }
32121 : }
32122 : }
32123 73 : {
32124 73 : const int bLocalUseExceptions = GetUseExceptions();
32125 73 : if ( bLocalUseExceptions ) {
32126 40 : pushErrorHandler();
32127 : }
32128 73 : {
32129 73 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32130 73 : GDALGroupHS_GetDimensions(arg1,arg2,arg3,arg4);
32131 73 : SWIG_PYTHON_THREAD_END_ALLOW;
32132 : }
32133 73 : if ( bLocalUseExceptions ) {
32134 40 : popErrorHandler();
32135 : }
32136 : #ifndef SED_HACKS
32137 : if ( bLocalUseExceptions ) {
32138 : CPLErr eclass = CPLGetLastErrorType();
32139 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32140 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32141 : }
32142 : }
32143 : #endif
32144 : }
32145 73 : resultobj = SWIG_Py_Void();
32146 73 : {
32147 : /* %typemap(argout) (GDALDimensionHS*** pdims, size_t* pnCount) */
32148 73 : Py_DECREF(resultobj);
32149 73 : resultobj = PyList_New( *arg3 );
32150 73 : if( !resultobj ) {
32151 0 : SWIG_fail;
32152 : }
32153 230 : for( size_t i = 0; i < *arg3; i++ ) {
32154 157 : PyList_SetItem(resultobj, i,
32155 157 : SWIG_NewPointerObj((void*)(*arg2)[i],SWIGTYPE_p_GDALDimensionHS,SWIG_POINTER_OWN) );
32156 : /* We have borrowed the GDALDimensionHS */
32157 157 : (*arg2)[i] = NULL;
32158 : }
32159 : }
32160 73 : {
32161 : /* %typemap(freearg) (GDALDimensionHS*** pdims, size_t* pnCount) */
32162 73 : GDALReleaseDimensions(*arg2, *arg3);
32163 : }
32164 73 : {
32165 : /* %typemap(freearg) char **dict */
32166 73 : CSLDestroy( arg4 );
32167 : }
32168 73 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32169 : return resultobj;
32170 0 : fail:
32171 0 : {
32172 : /* %typemap(freearg) (GDALDimensionHS*** pdims, size_t* pnCount) */
32173 0 : GDALReleaseDimensions(*arg2, *arg3);
32174 : }
32175 0 : {
32176 : /* %typemap(freearg) char **dict */
32177 0 : CSLDestroy( arg4 );
32178 : }
32179 : return NULL;
32180 : }
32181 :
32182 :
32183 80 : SWIGINTERN PyObject *_wrap_Group_GetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32184 80 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32185 80 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
32186 80 : char *arg2 = (char *) 0 ;
32187 80 : void *argp1 = 0 ;
32188 80 : int res1 = 0 ;
32189 80 : int res2 ;
32190 80 : char *buf2 = 0 ;
32191 80 : int alloc2 = 0 ;
32192 80 : PyObject *swig_obj[2] ;
32193 80 : GDALAttributeHS *result = 0 ;
32194 :
32195 80 : if (!SWIG_Python_UnpackTuple(args, "Group_GetAttribute", 2, 2, swig_obj)) SWIG_fail;
32196 80 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
32197 80 : if (!SWIG_IsOK(res1)) {
32198 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_GetAttribute" "', argument " "1"" of type '" "GDALGroupHS *""'");
32199 : }
32200 80 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
32201 80 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
32202 80 : if (!SWIG_IsOK(res2)) {
32203 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_GetAttribute" "', argument " "2"" of type '" "char const *""'");
32204 : }
32205 80 : arg2 = reinterpret_cast< char * >(buf2);
32206 80 : {
32207 80 : if (!arg2) {
32208 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
32209 : }
32210 : }
32211 80 : {
32212 80 : const int bLocalUseExceptions = GetUseExceptions();
32213 80 : if ( bLocalUseExceptions ) {
32214 22 : pushErrorHandler();
32215 : }
32216 80 : {
32217 80 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32218 80 : result = (GDALAttributeHS *)GDALGroupHS_GetAttribute(arg1,(char const *)arg2);
32219 80 : SWIG_PYTHON_THREAD_END_ALLOW;
32220 : }
32221 80 : if ( bLocalUseExceptions ) {
32222 22 : popErrorHandler();
32223 : }
32224 : #ifndef SED_HACKS
32225 : if ( bLocalUseExceptions ) {
32226 : CPLErr eclass = CPLGetLastErrorType();
32227 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32228 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32229 : }
32230 : }
32231 : #endif
32232 : }
32233 80 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALAttributeHS, SWIG_POINTER_OWN | 0 );
32234 80 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32235 84 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32236 : return resultobj;
32237 0 : fail:
32238 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32239 : return NULL;
32240 : }
32241 :
32242 :
32243 71 : SWIGINTERN PyObject *_wrap_Group_GetAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32244 71 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32245 71 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
32246 71 : GDALAttributeHS ***arg2 = (GDALAttributeHS ***) 0 ;
32247 71 : size_t *arg3 = (size_t *) 0 ;
32248 71 : char **arg4 = (char **) 0 ;
32249 71 : void *argp1 = 0 ;
32250 71 : int res1 = 0 ;
32251 71 : GDALAttributeHS **attrs2 = 0 ;
32252 71 : size_t nCount2 = 0 ;
32253 71 : PyObject *swig_obj[2] ;
32254 :
32255 71 : {
32256 : /* %typemap(in,numinputs=0) (GDALAttributeHS*** pattrs, size_t* pnCount) */
32257 71 : arg2 = &attrs2;
32258 71 : arg3 = &nCount2;
32259 : }
32260 71 : if (!SWIG_Python_UnpackTuple(args, "Group_GetAttributes", 1, 2, swig_obj)) SWIG_fail;
32261 71 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
32262 71 : if (!SWIG_IsOK(res1)) {
32263 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_GetAttributes" "', argument " "1"" of type '" "GDALGroupHS *""'");
32264 : }
32265 71 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
32266 71 : if (swig_obj[1]) {
32267 0 : {
32268 : /* %typemap(in) char **dict */
32269 0 : arg4 = NULL;
32270 0 : if ( PySequence_Check( swig_obj[1] ) ) {
32271 0 : int bErr = FALSE;
32272 0 : arg4 = CSLFromPySequence(swig_obj[1], &bErr);
32273 0 : if ( bErr )
32274 : {
32275 0 : SWIG_fail;
32276 : }
32277 : }
32278 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
32279 0 : int bErr = FALSE;
32280 0 : arg4 = CSLFromPyMapping(swig_obj[1], &bErr);
32281 0 : if ( bErr )
32282 : {
32283 0 : SWIG_fail;
32284 : }
32285 : }
32286 : else {
32287 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
32288 0 : SWIG_fail;
32289 : }
32290 : }
32291 : }
32292 71 : {
32293 71 : const int bLocalUseExceptions = GetUseExceptions();
32294 71 : if ( bLocalUseExceptions ) {
32295 35 : pushErrorHandler();
32296 : }
32297 71 : {
32298 71 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32299 71 : GDALGroupHS_GetAttributes(arg1,arg2,arg3,arg4);
32300 71 : SWIG_PYTHON_THREAD_END_ALLOW;
32301 : }
32302 71 : if ( bLocalUseExceptions ) {
32303 35 : popErrorHandler();
32304 : }
32305 : #ifndef SED_HACKS
32306 : if ( bLocalUseExceptions ) {
32307 : CPLErr eclass = CPLGetLastErrorType();
32308 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32309 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32310 : }
32311 : }
32312 : #endif
32313 : }
32314 71 : resultobj = SWIG_Py_Void();
32315 71 : {
32316 : /* %typemap(argout) (GDALAttributeHS*** pattrs, size_t* pnCount) */
32317 71 : Py_DECREF(resultobj);
32318 71 : resultobj = PyList_New( *arg3 );
32319 71 : if( !resultobj ) {
32320 0 : SWIG_fail;
32321 : }
32322 229 : for( size_t i = 0; i < *arg3; i++ ) {
32323 158 : PyList_SetItem(resultobj, i,
32324 158 : SWIG_NewPointerObj((void*)(*arg2)[i],SWIGTYPE_p_GDALAttributeHS,SWIG_POINTER_OWN) );
32325 : /* We have borrowed the GDALAttributeHS */
32326 158 : (*arg2)[i] = NULL;
32327 : }
32328 : }
32329 71 : {
32330 : /* %typemap(freearg) (GDALAttributeHS*** pattrs, size_t* pnCount) */
32331 71 : GDALReleaseAttributes(*arg2, *arg3);
32332 : }
32333 71 : {
32334 : /* %typemap(freearg) char **dict */
32335 71 : CSLDestroy( arg4 );
32336 : }
32337 71 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32338 : return resultobj;
32339 0 : fail:
32340 0 : {
32341 : /* %typemap(freearg) (GDALAttributeHS*** pattrs, size_t* pnCount) */
32342 0 : GDALReleaseAttributes(*arg2, *arg3);
32343 : }
32344 0 : {
32345 : /* %typemap(freearg) char **dict */
32346 0 : CSLDestroy( arg4 );
32347 : }
32348 : return NULL;
32349 : }
32350 :
32351 :
32352 4 : SWIGINTERN PyObject *_wrap_Group_GetStructuralInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32353 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32354 4 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
32355 4 : void *argp1 = 0 ;
32356 4 : int res1 = 0 ;
32357 4 : PyObject *swig_obj[1] ;
32358 4 : char **result = 0 ;
32359 :
32360 4 : if (!args) SWIG_fail;
32361 4 : swig_obj[0] = args;
32362 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
32363 4 : if (!SWIG_IsOK(res1)) {
32364 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_GetStructuralInfo" "', argument " "1"" of type '" "GDALGroupHS *""'");
32365 : }
32366 4 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
32367 4 : {
32368 4 : const int bLocalUseExceptions = GetUseExceptions();
32369 4 : if ( bLocalUseExceptions ) {
32370 0 : pushErrorHandler();
32371 : }
32372 4 : {
32373 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32374 4 : result = (char **)GDALGroupHS_GetStructuralInfo(arg1);
32375 4 : SWIG_PYTHON_THREAD_END_ALLOW;
32376 : }
32377 4 : if ( bLocalUseExceptions ) {
32378 0 : popErrorHandler();
32379 : }
32380 : #ifndef SED_HACKS
32381 : if ( bLocalUseExceptions ) {
32382 : CPLErr eclass = CPLGetLastErrorType();
32383 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32384 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32385 : }
32386 : }
32387 : #endif
32388 : }
32389 4 : {
32390 : /* %typemap(out) char **dict */
32391 4 : resultobj = GetCSLStringAsPyDict(result, false);
32392 : }
32393 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32394 : return resultobj;
32395 : fail:
32396 : return NULL;
32397 : }
32398 :
32399 :
32400 180 : SWIGINTERN PyObject *_wrap_Group_CreateGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32401 180 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32402 180 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
32403 180 : char *arg2 = (char *) 0 ;
32404 180 : char **arg3 = (char **) 0 ;
32405 180 : void *argp1 = 0 ;
32406 180 : int res1 = 0 ;
32407 180 : int res2 ;
32408 180 : char *buf2 = 0 ;
32409 180 : int alloc2 = 0 ;
32410 180 : PyObject * obj0 = 0 ;
32411 180 : PyObject * obj1 = 0 ;
32412 180 : PyObject * obj2 = 0 ;
32413 180 : char * kwnames[] = {
32414 : (char *)"self", (char *)"name", (char *)"options", NULL
32415 : };
32416 180 : GDALGroupHS *result = 0 ;
32417 :
32418 180 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Group_CreateGroup", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
32419 180 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
32420 180 : if (!SWIG_IsOK(res1)) {
32421 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_CreateGroup" "', argument " "1"" of type '" "GDALGroupHS *""'");
32422 : }
32423 180 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
32424 180 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32425 180 : if (!SWIG_IsOK(res2)) {
32426 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_CreateGroup" "', argument " "2"" of type '" "char const *""'");
32427 : }
32428 180 : arg2 = reinterpret_cast< char * >(buf2);
32429 180 : if (obj2) {
32430 0 : {
32431 : /* %typemap(in) char **dict */
32432 0 : arg3 = NULL;
32433 0 : if ( PySequence_Check( obj2 ) ) {
32434 0 : int bErr = FALSE;
32435 0 : arg3 = CSLFromPySequence(obj2, &bErr);
32436 0 : if ( bErr )
32437 : {
32438 0 : SWIG_fail;
32439 : }
32440 : }
32441 0 : else if ( PyMapping_Check( obj2 ) ) {
32442 0 : int bErr = FALSE;
32443 0 : arg3 = CSLFromPyMapping(obj2, &bErr);
32444 0 : if ( bErr )
32445 : {
32446 0 : SWIG_fail;
32447 : }
32448 : }
32449 : else {
32450 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
32451 0 : SWIG_fail;
32452 : }
32453 : }
32454 : }
32455 180 : {
32456 180 : if (!arg2) {
32457 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
32458 : }
32459 : }
32460 179 : {
32461 179 : const int bLocalUseExceptions = GetUseExceptions();
32462 179 : if ( bLocalUseExceptions ) {
32463 92 : pushErrorHandler();
32464 : }
32465 179 : {
32466 179 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32467 179 : result = (GDALGroupHS *)GDALGroupHS_CreateGroup(arg1,(char const *)arg2,arg3);
32468 179 : SWIG_PYTHON_THREAD_END_ALLOW;
32469 : }
32470 179 : if ( bLocalUseExceptions ) {
32471 92 : popErrorHandler();
32472 : }
32473 : #ifndef SED_HACKS
32474 : if ( bLocalUseExceptions ) {
32475 : CPLErr eclass = CPLGetLastErrorType();
32476 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32477 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32478 : }
32479 : }
32480 : #endif
32481 : }
32482 179 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALGroupHS, SWIG_POINTER_OWN | 0 );
32483 179 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32484 179 : {
32485 : /* %typemap(freearg) char **dict */
32486 179 : CSLDestroy( arg3 );
32487 : }
32488 186 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32489 : return resultobj;
32490 1 : fail:
32491 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32492 1 : {
32493 : /* %typemap(freearg) char **dict */
32494 1 : CSLDestroy( arg3 );
32495 : }
32496 : return NULL;
32497 : }
32498 :
32499 :
32500 20 : SWIGINTERN PyObject *_wrap_Group_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32501 20 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32502 20 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
32503 20 : char *arg2 = (char *) 0 ;
32504 20 : char **arg3 = (char **) 0 ;
32505 20 : void *argp1 = 0 ;
32506 20 : int res1 = 0 ;
32507 20 : int res2 ;
32508 20 : char *buf2 = 0 ;
32509 20 : int alloc2 = 0 ;
32510 20 : PyObject *swig_obj[3] ;
32511 20 : CPLErr result;
32512 :
32513 20 : if (!SWIG_Python_UnpackTuple(args, "Group_DeleteGroup", 2, 3, swig_obj)) SWIG_fail;
32514 20 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
32515 20 : if (!SWIG_IsOK(res1)) {
32516 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_DeleteGroup" "', argument " "1"" of type '" "GDALGroupHS *""'");
32517 : }
32518 20 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
32519 20 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
32520 20 : if (!SWIG_IsOK(res2)) {
32521 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_DeleteGroup" "', argument " "2"" of type '" "char const *""'");
32522 : }
32523 20 : arg2 = reinterpret_cast< char * >(buf2);
32524 20 : if (swig_obj[2]) {
32525 0 : {
32526 : /* %typemap(in) char **dict */
32527 0 : arg3 = NULL;
32528 0 : if ( PySequence_Check( swig_obj[2] ) ) {
32529 0 : int bErr = FALSE;
32530 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
32531 0 : if ( bErr )
32532 : {
32533 0 : SWIG_fail;
32534 : }
32535 : }
32536 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
32537 0 : int bErr = FALSE;
32538 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
32539 0 : if ( bErr )
32540 : {
32541 0 : SWIG_fail;
32542 : }
32543 : }
32544 : else {
32545 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
32546 0 : SWIG_fail;
32547 : }
32548 : }
32549 : }
32550 20 : {
32551 20 : if (!arg2) {
32552 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
32553 : }
32554 : }
32555 20 : {
32556 20 : const int bLocalUseExceptions = GetUseExceptions();
32557 20 : if ( bLocalUseExceptions ) {
32558 20 : pushErrorHandler();
32559 : }
32560 20 : {
32561 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32562 20 : result = (CPLErr)GDALGroupHS_DeleteGroup(arg1,(char const *)arg2,arg3);
32563 20 : SWIG_PYTHON_THREAD_END_ALLOW;
32564 : }
32565 20 : if ( bLocalUseExceptions ) {
32566 20 : popErrorHandler();
32567 : }
32568 : #ifndef SED_HACKS
32569 : if ( bLocalUseExceptions ) {
32570 : CPLErr eclass = CPLGetLastErrorType();
32571 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32572 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32573 : }
32574 : }
32575 : #endif
32576 : }
32577 20 : resultobj = SWIG_From_int(static_cast< int >(result));
32578 20 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32579 20 : {
32580 : /* %typemap(freearg) char **dict */
32581 20 : CSLDestroy( arg3 );
32582 : }
32583 46 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32584 : return resultobj;
32585 0 : fail:
32586 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32587 0 : {
32588 : /* %typemap(freearg) char **dict */
32589 0 : CSLDestroy( arg3 );
32590 : }
32591 : return NULL;
32592 : }
32593 :
32594 :
32595 759 : SWIGINTERN PyObject *_wrap_Group_CreateDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32596 759 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32597 759 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
32598 759 : char *arg2 = (char *) 0 ;
32599 759 : char *arg3 = (char *) 0 ;
32600 759 : char *arg4 = (char *) 0 ;
32601 759 : GUIntBig arg5 ;
32602 759 : char **arg6 = (char **) 0 ;
32603 759 : void *argp1 = 0 ;
32604 759 : int res1 = 0 ;
32605 759 : int res2 ;
32606 759 : char *buf2 = 0 ;
32607 759 : int alloc2 = 0 ;
32608 759 : int res3 ;
32609 759 : char *buf3 = 0 ;
32610 759 : int alloc3 = 0 ;
32611 759 : int res4 ;
32612 759 : char *buf4 = 0 ;
32613 759 : int alloc4 = 0 ;
32614 759 : PyObject * obj0 = 0 ;
32615 759 : PyObject * obj1 = 0 ;
32616 759 : PyObject * obj2 = 0 ;
32617 759 : PyObject * obj3 = 0 ;
32618 759 : PyObject * obj4 = 0 ;
32619 759 : PyObject * obj5 = 0 ;
32620 759 : char * kwnames[] = {
32621 : (char *)"self", (char *)"name", (char *)"dim_type", (char *)"direction", (char *)"size", (char *)"options", NULL
32622 : };
32623 759 : GDALDimensionHS *result = 0 ;
32624 :
32625 759 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|O:Group_CreateDimension", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
32626 759 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
32627 759 : if (!SWIG_IsOK(res1)) {
32628 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_CreateDimension" "', argument " "1"" of type '" "GDALGroupHS *""'");
32629 : }
32630 759 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
32631 759 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32632 759 : if (!SWIG_IsOK(res2)) {
32633 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_CreateDimension" "', argument " "2"" of type '" "char const *""'");
32634 : }
32635 759 : arg2 = reinterpret_cast< char * >(buf2);
32636 759 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
32637 759 : if (!SWIG_IsOK(res3)) {
32638 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Group_CreateDimension" "', argument " "3"" of type '" "char const *""'");
32639 : }
32640 759 : arg3 = reinterpret_cast< char * >(buf3);
32641 759 : res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
32642 759 : if (!SWIG_IsOK(res4)) {
32643 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Group_CreateDimension" "', argument " "4"" of type '" "char const *""'");
32644 : }
32645 759 : arg4 = reinterpret_cast< char * >(buf4);
32646 759 : {
32647 759 : arg5 = (GIntBig)PyLong_AsUnsignedLongLong(obj4);
32648 : }
32649 759 : if (obj5) {
32650 7 : {
32651 : /* %typemap(in) char **dict */
32652 7 : arg6 = NULL;
32653 7 : if ( PySequence_Check( obj5 ) ) {
32654 7 : int bErr = FALSE;
32655 7 : arg6 = CSLFromPySequence(obj5, &bErr);
32656 7 : if ( bErr )
32657 : {
32658 0 : SWIG_fail;
32659 : }
32660 : }
32661 0 : else if ( PyMapping_Check( obj5 ) ) {
32662 0 : int bErr = FALSE;
32663 0 : arg6 = CSLFromPyMapping(obj5, &bErr);
32664 0 : if ( bErr )
32665 : {
32666 0 : SWIG_fail;
32667 : }
32668 : }
32669 : else {
32670 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
32671 0 : SWIG_fail;
32672 : }
32673 : }
32674 : }
32675 759 : {
32676 759 : if (!arg2) {
32677 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
32678 : }
32679 : }
32680 759 : {
32681 759 : const int bLocalUseExceptions = GetUseExceptions();
32682 759 : if ( bLocalUseExceptions ) {
32683 171 : pushErrorHandler();
32684 : }
32685 759 : {
32686 759 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32687 759 : result = (GDALDimensionHS *)GDALGroupHS_CreateDimension(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5,arg6);
32688 759 : SWIG_PYTHON_THREAD_END_ALLOW;
32689 : }
32690 759 : if ( bLocalUseExceptions ) {
32691 171 : popErrorHandler();
32692 : }
32693 : #ifndef SED_HACKS
32694 : if ( bLocalUseExceptions ) {
32695 : CPLErr eclass = CPLGetLastErrorType();
32696 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32697 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32698 : }
32699 : }
32700 : #endif
32701 : }
32702 759 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDimensionHS, SWIG_POINTER_OWN | 0 );
32703 759 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32704 759 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
32705 759 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
32706 759 : {
32707 : /* %typemap(freearg) char **dict */
32708 759 : CSLDestroy( arg6 );
32709 : }
32710 759 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32711 : return resultobj;
32712 0 : fail:
32713 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32714 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
32715 0 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
32716 0 : {
32717 : /* %typemap(freearg) char **dict */
32718 0 : CSLDestroy( arg6 );
32719 : }
32720 : return NULL;
32721 : }
32722 :
32723 :
32724 712 : SWIGINTERN PyObject *_wrap_Group_CreateMDArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32725 712 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32726 712 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
32727 712 : char *arg2 = (char *) 0 ;
32728 712 : int arg3 ;
32729 712 : GDALDimensionHS **arg4 = (GDALDimensionHS **) 0 ;
32730 712 : GDALExtendedDataTypeHS *arg5 = (GDALExtendedDataTypeHS *) 0 ;
32731 712 : char **arg6 = (char **) 0 ;
32732 712 : void *argp1 = 0 ;
32733 712 : int res1 = 0 ;
32734 712 : int res2 ;
32735 712 : char *buf2 = 0 ;
32736 712 : int alloc2 = 0 ;
32737 712 : void *argp5 = 0 ;
32738 712 : int res5 = 0 ;
32739 712 : PyObject *swig_obj[5] ;
32740 712 : GDALMDArrayHS *result = 0 ;
32741 :
32742 712 : if (!SWIG_Python_UnpackTuple(args, "Group_CreateMDArray", 4, 5, swig_obj)) SWIG_fail;
32743 712 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
32744 712 : if (!SWIG_IsOK(res1)) {
32745 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_CreateMDArray" "', argument " "1"" of type '" "GDALGroupHS *""'");
32746 : }
32747 712 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
32748 712 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
32749 712 : if (!SWIG_IsOK(res2)) {
32750 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_CreateMDArray" "', argument " "2"" of type '" "char const *""'");
32751 : }
32752 712 : arg2 = reinterpret_cast< char * >(buf2);
32753 712 : {
32754 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALDimensionHS *optional_##GDALDimensionHS)*/
32755 712 : if ( !PySequence_Check(swig_obj[2]) ) {
32756 1 : PyErr_SetString(PyExc_TypeError, "not a sequence");
32757 1 : SWIG_fail;
32758 : }
32759 711 : Py_ssize_t size = PySequence_Size(swig_obj[2]);
32760 711 : if( size > (Py_ssize_t)INT_MAX ) {
32761 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
32762 0 : SWIG_fail;
32763 : }
32764 711 : if( (size_t)size > SIZE_MAX / sizeof(GDALDimensionHS*) ) {
32765 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
32766 0 : SWIG_fail;
32767 : }
32768 711 : arg3 = (int)size;
32769 711 : arg4 = (GDALDimensionHS**) VSIMalloc(arg3*sizeof(GDALDimensionHS*));
32770 711 : if( !arg4) {
32771 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
32772 0 : SWIG_fail;
32773 : }
32774 :
32775 1688 : for( int i = 0; i<arg3; i++ ) {
32776 979 : PyObject *o = PySequence_GetItem(swig_obj[2],i);
32777 979 : GDALDimensionHS* rawobjectpointer = NULL;
32778 979 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALDimensionHS, SWIG_POINTER_EXCEPTION | 0 ));
32779 979 : if (!rawobjectpointer) {
32780 2 : Py_DECREF(o);
32781 2 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALDimensionHS");
32782 2 : SWIG_fail;
32783 : }
32784 977 : arg4[i] = rawobjectpointer;
32785 977 : Py_DECREF(o);
32786 :
32787 : }
32788 : }
32789 709 : res5 = SWIG_ConvertPtr(swig_obj[3], &argp5,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
32790 709 : if (!SWIG_IsOK(res5)) {
32791 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Group_CreateMDArray" "', argument " "5"" of type '" "GDALExtendedDataTypeHS *""'");
32792 : }
32793 709 : arg5 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp5);
32794 709 : if (swig_obj[4]) {
32795 136 : {
32796 : /* %typemap(in) char **dict */
32797 136 : arg6 = NULL;
32798 136 : if ( PySequence_Check( swig_obj[4] ) ) {
32799 136 : int bErr = FALSE;
32800 136 : arg6 = CSLFromPySequence(swig_obj[4], &bErr);
32801 136 : if ( bErr )
32802 : {
32803 0 : SWIG_fail;
32804 : }
32805 : }
32806 0 : else if ( PyMapping_Check( swig_obj[4] ) ) {
32807 0 : int bErr = FALSE;
32808 0 : arg6 = CSLFromPyMapping(swig_obj[4], &bErr);
32809 0 : if ( bErr )
32810 : {
32811 0 : SWIG_fail;
32812 : }
32813 : }
32814 : else {
32815 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
32816 0 : SWIG_fail;
32817 : }
32818 : }
32819 : }
32820 709 : {
32821 709 : if (!arg2) {
32822 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
32823 : }
32824 : }
32825 708 : {
32826 708 : if (!arg5) {
32827 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
32828 : }
32829 : }
32830 707 : {
32831 707 : const int bLocalUseExceptions = GetUseExceptions();
32832 707 : if ( bLocalUseExceptions ) {
32833 262 : pushErrorHandler();
32834 : }
32835 707 : {
32836 707 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32837 707 : result = (GDALMDArrayHS *)GDALGroupHS_CreateMDArray(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
32838 707 : SWIG_PYTHON_THREAD_END_ALLOW;
32839 : }
32840 707 : if ( bLocalUseExceptions ) {
32841 262 : popErrorHandler();
32842 : }
32843 : #ifndef SED_HACKS
32844 : if ( bLocalUseExceptions ) {
32845 : CPLErr eclass = CPLGetLastErrorType();
32846 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32847 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32848 : }
32849 : }
32850 : #endif
32851 : }
32852 707 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_OWN | 0 );
32853 707 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32854 707 : {
32855 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALDimensionHS **poObjects)*/
32856 707 : CPLFree( arg4 );
32857 : }
32858 707 : {
32859 : /* %typemap(freearg) char **dict */
32860 707 : CSLDestroy( arg6 );
32861 : }
32862 724 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32863 : return resultobj;
32864 5 : fail:
32865 5 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32866 5 : {
32867 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALDimensionHS **poObjects)*/
32868 5 : CPLFree( arg4 );
32869 : }
32870 5 : {
32871 : /* %typemap(freearg) char **dict */
32872 5 : CSLDestroy( arg6 );
32873 : }
32874 : return NULL;
32875 : }
32876 :
32877 :
32878 20 : SWIGINTERN PyObject *_wrap_Group_DeleteMDArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32879 20 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32880 20 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
32881 20 : char *arg2 = (char *) 0 ;
32882 20 : char **arg3 = (char **) 0 ;
32883 20 : void *argp1 = 0 ;
32884 20 : int res1 = 0 ;
32885 20 : int res2 ;
32886 20 : char *buf2 = 0 ;
32887 20 : int alloc2 = 0 ;
32888 20 : PyObject *swig_obj[3] ;
32889 20 : CPLErr result;
32890 :
32891 20 : if (!SWIG_Python_UnpackTuple(args, "Group_DeleteMDArray", 2, 3, swig_obj)) SWIG_fail;
32892 20 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
32893 20 : if (!SWIG_IsOK(res1)) {
32894 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_DeleteMDArray" "', argument " "1"" of type '" "GDALGroupHS *""'");
32895 : }
32896 20 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
32897 20 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
32898 20 : if (!SWIG_IsOK(res2)) {
32899 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_DeleteMDArray" "', argument " "2"" of type '" "char const *""'");
32900 : }
32901 20 : arg2 = reinterpret_cast< char * >(buf2);
32902 20 : if (swig_obj[2]) {
32903 0 : {
32904 : /* %typemap(in) char **dict */
32905 0 : arg3 = NULL;
32906 0 : if ( PySequence_Check( swig_obj[2] ) ) {
32907 0 : int bErr = FALSE;
32908 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
32909 0 : if ( bErr )
32910 : {
32911 0 : SWIG_fail;
32912 : }
32913 : }
32914 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
32915 0 : int bErr = FALSE;
32916 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
32917 0 : if ( bErr )
32918 : {
32919 0 : SWIG_fail;
32920 : }
32921 : }
32922 : else {
32923 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
32924 0 : SWIG_fail;
32925 : }
32926 : }
32927 : }
32928 20 : {
32929 20 : if (!arg2) {
32930 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
32931 : }
32932 : }
32933 20 : {
32934 20 : const int bLocalUseExceptions = GetUseExceptions();
32935 20 : if ( bLocalUseExceptions ) {
32936 20 : pushErrorHandler();
32937 : }
32938 20 : {
32939 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32940 20 : result = (CPLErr)GDALGroupHS_DeleteMDArray(arg1,(char const *)arg2,arg3);
32941 20 : SWIG_PYTHON_THREAD_END_ALLOW;
32942 : }
32943 20 : if ( bLocalUseExceptions ) {
32944 20 : popErrorHandler();
32945 : }
32946 : #ifndef SED_HACKS
32947 : if ( bLocalUseExceptions ) {
32948 : CPLErr eclass = CPLGetLastErrorType();
32949 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
32950 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
32951 : }
32952 : }
32953 : #endif
32954 : }
32955 20 : resultobj = SWIG_From_int(static_cast< int >(result));
32956 20 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32957 20 : {
32958 : /* %typemap(freearg) char **dict */
32959 20 : CSLDestroy( arg3 );
32960 : }
32961 46 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
32962 : return resultobj;
32963 0 : fail:
32964 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32965 0 : {
32966 : /* %typemap(freearg) char **dict */
32967 0 : CSLDestroy( arg3 );
32968 : }
32969 : return NULL;
32970 : }
32971 :
32972 :
32973 126 : SWIGINTERN PyObject *_wrap_Group_CreateAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32974 126 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
32975 126 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
32976 126 : char *arg2 = (char *) 0 ;
32977 126 : int arg3 ;
32978 126 : GUIntBig *arg4 = (GUIntBig *) 0 ;
32979 126 : GDALExtendedDataTypeHS *arg5 = (GDALExtendedDataTypeHS *) 0 ;
32980 126 : char **arg6 = (char **) 0 ;
32981 126 : void *argp1 = 0 ;
32982 126 : int res1 = 0 ;
32983 126 : int res2 ;
32984 126 : char *buf2 = 0 ;
32985 126 : int alloc2 = 0 ;
32986 126 : void *argp5 = 0 ;
32987 126 : int res5 = 0 ;
32988 126 : PyObject *swig_obj[5] ;
32989 126 : GDALAttributeHS *result = 0 ;
32990 :
32991 126 : if (!SWIG_Python_UnpackTuple(args, "Group_CreateAttribute", 4, 5, swig_obj)) SWIG_fail;
32992 126 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
32993 126 : if (!SWIG_IsOK(res1)) {
32994 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_CreateAttribute" "', argument " "1"" of type '" "GDALGroupHS *""'");
32995 : }
32996 126 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
32997 126 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
32998 126 : if (!SWIG_IsOK(res2)) {
32999 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_CreateAttribute" "', argument " "2"" of type '" "char const *""'");
33000 : }
33001 126 : arg2 = reinterpret_cast< char * >(buf2);
33002 126 : {
33003 : /* %typemap(in,numinputs=1) (int nList, GUIntBig* pList)*/
33004 126 : arg4 = CreateCGUIntBigListFromSequence(swig_obj[2], &arg3);
33005 126 : if( arg3 < 0 ) {
33006 0 : SWIG_fail;
33007 : }
33008 : }
33009 126 : res5 = SWIG_ConvertPtr(swig_obj[3], &argp5,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
33010 126 : if (!SWIG_IsOK(res5)) {
33011 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Group_CreateAttribute" "', argument " "5"" of type '" "GDALExtendedDataTypeHS *""'");
33012 : }
33013 126 : arg5 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp5);
33014 126 : if (swig_obj[4]) {
33015 6 : {
33016 : /* %typemap(in) char **dict */
33017 6 : arg6 = NULL;
33018 6 : if ( PySequence_Check( swig_obj[4] ) ) {
33019 6 : int bErr = FALSE;
33020 6 : arg6 = CSLFromPySequence(swig_obj[4], &bErr);
33021 6 : if ( bErr )
33022 : {
33023 0 : SWIG_fail;
33024 : }
33025 : }
33026 0 : else if ( PyMapping_Check( swig_obj[4] ) ) {
33027 0 : int bErr = FALSE;
33028 0 : arg6 = CSLFromPyMapping(swig_obj[4], &bErr);
33029 0 : if ( bErr )
33030 : {
33031 0 : SWIG_fail;
33032 : }
33033 : }
33034 : else {
33035 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
33036 0 : SWIG_fail;
33037 : }
33038 : }
33039 : }
33040 126 : {
33041 126 : if (!arg2) {
33042 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33043 : }
33044 : }
33045 125 : {
33046 125 : if (!arg5) {
33047 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33048 : }
33049 : }
33050 125 : {
33051 125 : const int bLocalUseExceptions = GetUseExceptions();
33052 125 : if ( bLocalUseExceptions ) {
33053 53 : pushErrorHandler();
33054 : }
33055 125 : {
33056 125 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33057 125 : result = (GDALAttributeHS *)GDALGroupHS_CreateAttribute(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
33058 125 : SWIG_PYTHON_THREAD_END_ALLOW;
33059 : }
33060 125 : if ( bLocalUseExceptions ) {
33061 53 : popErrorHandler();
33062 : }
33063 : #ifndef SED_HACKS
33064 : if ( bLocalUseExceptions ) {
33065 : CPLErr eclass = CPLGetLastErrorType();
33066 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33067 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33068 : }
33069 : }
33070 : #endif
33071 : }
33072 125 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALAttributeHS, SWIG_POINTER_OWN | 0 );
33073 125 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33074 125 : {
33075 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
33076 125 : free(arg4);
33077 : }
33078 125 : {
33079 : /* %typemap(freearg) char **dict */
33080 125 : CSLDestroy( arg6 );
33081 : }
33082 128 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33083 : return resultobj;
33084 1 : fail:
33085 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33086 1 : {
33087 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
33088 1 : free(arg4);
33089 : }
33090 1 : {
33091 : /* %typemap(freearg) char **dict */
33092 1 : CSLDestroy( arg6 );
33093 : }
33094 : return NULL;
33095 : }
33096 :
33097 :
33098 25 : SWIGINTERN PyObject *_wrap_Group_DeleteAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33099 25 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33100 25 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
33101 25 : char *arg2 = (char *) 0 ;
33102 25 : char **arg3 = (char **) 0 ;
33103 25 : void *argp1 = 0 ;
33104 25 : int res1 = 0 ;
33105 25 : int res2 ;
33106 25 : char *buf2 = 0 ;
33107 25 : int alloc2 = 0 ;
33108 25 : PyObject *swig_obj[3] ;
33109 25 : CPLErr result;
33110 :
33111 25 : if (!SWIG_Python_UnpackTuple(args, "Group_DeleteAttribute", 2, 3, swig_obj)) SWIG_fail;
33112 25 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
33113 25 : if (!SWIG_IsOK(res1)) {
33114 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_DeleteAttribute" "', argument " "1"" of type '" "GDALGroupHS *""'");
33115 : }
33116 25 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
33117 25 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
33118 25 : if (!SWIG_IsOK(res2)) {
33119 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_DeleteAttribute" "', argument " "2"" of type '" "char const *""'");
33120 : }
33121 25 : arg2 = reinterpret_cast< char * >(buf2);
33122 25 : if (swig_obj[2]) {
33123 0 : {
33124 : /* %typemap(in) char **dict */
33125 0 : arg3 = NULL;
33126 0 : if ( PySequence_Check( swig_obj[2] ) ) {
33127 0 : int bErr = FALSE;
33128 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
33129 0 : if ( bErr )
33130 : {
33131 0 : SWIG_fail;
33132 : }
33133 : }
33134 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
33135 0 : int bErr = FALSE;
33136 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
33137 0 : if ( bErr )
33138 : {
33139 0 : SWIG_fail;
33140 : }
33141 : }
33142 : else {
33143 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
33144 0 : SWIG_fail;
33145 : }
33146 : }
33147 : }
33148 25 : {
33149 25 : if (!arg2) {
33150 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
33151 : }
33152 : }
33153 25 : {
33154 25 : const int bLocalUseExceptions = GetUseExceptions();
33155 25 : if ( bLocalUseExceptions ) {
33156 25 : pushErrorHandler();
33157 : }
33158 25 : {
33159 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33160 25 : result = (CPLErr)GDALGroupHS_DeleteAttribute(arg1,(char const *)arg2,arg3);
33161 25 : SWIG_PYTHON_THREAD_END_ALLOW;
33162 : }
33163 25 : if ( bLocalUseExceptions ) {
33164 25 : popErrorHandler();
33165 : }
33166 : #ifndef SED_HACKS
33167 : if ( bLocalUseExceptions ) {
33168 : CPLErr eclass = CPLGetLastErrorType();
33169 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33170 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33171 : }
33172 : }
33173 : #endif
33174 : }
33175 25 : resultobj = SWIG_From_int(static_cast< int >(result));
33176 25 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33177 25 : {
33178 : /* %typemap(freearg) char **dict */
33179 25 : CSLDestroy( arg3 );
33180 : }
33181 55 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33182 : return resultobj;
33183 0 : fail:
33184 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33185 0 : {
33186 : /* %typemap(freearg) char **dict */
33187 0 : CSLDestroy( arg3 );
33188 : }
33189 : return NULL;
33190 : }
33191 :
33192 :
33193 45 : SWIGINTERN PyObject *_wrap_Group_Rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33194 45 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33195 45 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
33196 45 : char *arg2 = (char *) 0 ;
33197 45 : void *argp1 = 0 ;
33198 45 : int res1 = 0 ;
33199 45 : int res2 ;
33200 45 : char *buf2 = 0 ;
33201 45 : int alloc2 = 0 ;
33202 45 : PyObject *swig_obj[2] ;
33203 45 : CPLErr result;
33204 :
33205 45 : if (!SWIG_Python_UnpackTuple(args, "Group_Rename", 2, 2, swig_obj)) SWIG_fail;
33206 45 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
33207 45 : if (!SWIG_IsOK(res1)) {
33208 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_Rename" "', argument " "1"" of type '" "GDALGroupHS *""'");
33209 : }
33210 45 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
33211 45 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
33212 45 : if (!SWIG_IsOK(res2)) {
33213 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_Rename" "', argument " "2"" of type '" "char const *""'");
33214 : }
33215 45 : arg2 = reinterpret_cast< char * >(buf2);
33216 45 : {
33217 45 : const int bLocalUseExceptions = GetUseExceptions();
33218 45 : if ( bLocalUseExceptions ) {
33219 45 : pushErrorHandler();
33220 : }
33221 45 : {
33222 45 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33223 45 : result = (CPLErr)GDALGroupHS_Rename(arg1,(char const *)arg2);
33224 45 : SWIG_PYTHON_THREAD_END_ALLOW;
33225 : }
33226 45 : if ( bLocalUseExceptions ) {
33227 45 : popErrorHandler();
33228 : }
33229 : #ifndef SED_HACKS
33230 : if ( bLocalUseExceptions ) {
33231 : CPLErr eclass = CPLGetLastErrorType();
33232 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33233 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33234 : }
33235 : }
33236 : #endif
33237 : }
33238 45 : resultobj = SWIG_From_int(static_cast< int >(result));
33239 45 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33240 119 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33241 : return resultobj;
33242 0 : fail:
33243 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33244 : return NULL;
33245 : }
33246 :
33247 :
33248 14 : SWIGINTERN PyObject *_wrap_Group_SubsetDimensionFromSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33249 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33250 14 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
33251 14 : char *arg2 = (char *) 0 ;
33252 14 : char **arg3 = (char **) 0 ;
33253 14 : void *argp1 = 0 ;
33254 14 : int res1 = 0 ;
33255 14 : int res2 ;
33256 14 : char *buf2 = 0 ;
33257 14 : int alloc2 = 0 ;
33258 14 : PyObject *swig_obj[3] ;
33259 14 : GDALGroupHS *result = 0 ;
33260 :
33261 14 : if (!SWIG_Python_UnpackTuple(args, "Group_SubsetDimensionFromSelection", 2, 3, swig_obj)) SWIG_fail;
33262 14 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
33263 14 : if (!SWIG_IsOK(res1)) {
33264 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_SubsetDimensionFromSelection" "', argument " "1"" of type '" "GDALGroupHS *""'");
33265 : }
33266 14 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
33267 14 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
33268 14 : if (!SWIG_IsOK(res2)) {
33269 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_SubsetDimensionFromSelection" "', argument " "2"" of type '" "char const *""'");
33270 : }
33271 14 : arg2 = reinterpret_cast< char * >(buf2);
33272 14 : if (swig_obj[2]) {
33273 0 : {
33274 : /* %typemap(in) char **dict */
33275 0 : arg3 = NULL;
33276 0 : if ( PySequence_Check( swig_obj[2] ) ) {
33277 0 : int bErr = FALSE;
33278 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
33279 0 : if ( bErr )
33280 : {
33281 0 : SWIG_fail;
33282 : }
33283 : }
33284 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
33285 0 : int bErr = FALSE;
33286 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
33287 0 : if ( bErr )
33288 : {
33289 0 : SWIG_fail;
33290 : }
33291 : }
33292 : else {
33293 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
33294 0 : SWIG_fail;
33295 : }
33296 : }
33297 : }
33298 14 : {
33299 14 : const int bLocalUseExceptions = GetUseExceptions();
33300 14 : if ( bLocalUseExceptions ) {
33301 13 : pushErrorHandler();
33302 : }
33303 14 : {
33304 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33305 14 : result = (GDALGroupHS *)GDALGroupHS_SubsetDimensionFromSelection(arg1,(char const *)arg2,arg3);
33306 14 : SWIG_PYTHON_THREAD_END_ALLOW;
33307 : }
33308 14 : if ( bLocalUseExceptions ) {
33309 13 : popErrorHandler();
33310 : }
33311 : #ifndef SED_HACKS
33312 : if ( bLocalUseExceptions ) {
33313 : CPLErr eclass = CPLGetLastErrorType();
33314 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33315 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33316 : }
33317 : }
33318 : #endif
33319 : }
33320 14 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALGroupHS, SWIG_POINTER_OWN | 0 );
33321 14 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33322 14 : {
33323 : /* %typemap(freearg) char **dict */
33324 14 : CSLDestroy( arg3 );
33325 : }
33326 30 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33327 : return resultobj;
33328 0 : fail:
33329 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33330 0 : {
33331 : /* %typemap(freearg) char **dict */
33332 0 : CSLDestroy( arg3 );
33333 : }
33334 : return NULL;
33335 : }
33336 :
33337 :
33338 2 : SWIGINTERN PyObject *_wrap_Group_GetDataTypeCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33339 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33340 2 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
33341 2 : void *argp1 = 0 ;
33342 2 : int res1 = 0 ;
33343 2 : PyObject *swig_obj[1] ;
33344 2 : size_t result;
33345 :
33346 2 : if (!args) SWIG_fail;
33347 2 : swig_obj[0] = args;
33348 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
33349 2 : if (!SWIG_IsOK(res1)) {
33350 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_GetDataTypeCount" "', argument " "1"" of type '" "GDALGroupHS *""'");
33351 : }
33352 2 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
33353 2 : {
33354 2 : const int bLocalUseExceptions = GetUseExceptions();
33355 2 : if ( bLocalUseExceptions ) {
33356 2 : pushErrorHandler();
33357 : }
33358 2 : {
33359 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33360 2 : result = GDALGroupHS_GetDataTypeCount(arg1);
33361 2 : SWIG_PYTHON_THREAD_END_ALLOW;
33362 : }
33363 2 : if ( bLocalUseExceptions ) {
33364 2 : popErrorHandler();
33365 : }
33366 : #ifndef SED_HACKS
33367 : if ( bLocalUseExceptions ) {
33368 : CPLErr eclass = CPLGetLastErrorType();
33369 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33370 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33371 : }
33372 : }
33373 : #endif
33374 : }
33375 2 : resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33376 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33377 : return resultobj;
33378 : fail:
33379 : return NULL;
33380 : }
33381 :
33382 :
33383 2 : SWIGINTERN PyObject *_wrap_Group_GetDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33384 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33385 2 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
33386 2 : size_t arg2 ;
33387 2 : void *argp1 = 0 ;
33388 2 : int res1 = 0 ;
33389 2 : size_t val2 ;
33390 2 : int ecode2 = 0 ;
33391 2 : PyObject *swig_obj[2] ;
33392 2 : GDALExtendedDataTypeHS *result = 0 ;
33393 :
33394 2 : if (!SWIG_Python_UnpackTuple(args, "Group_GetDataType", 2, 2, swig_obj)) SWIG_fail;
33395 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
33396 2 : if (!SWIG_IsOK(res1)) {
33397 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_GetDataType" "', argument " "1"" of type '" "GDALGroupHS *""'");
33398 : }
33399 2 : arg1 = reinterpret_cast< GDALGroupHS * >(argp1);
33400 2 : ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
33401 2 : if (!SWIG_IsOK(ecode2)) {
33402 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_GetDataType" "', argument " "2"" of type '" "size_t""'");
33403 : }
33404 2 : arg2 = static_cast< size_t >(val2);
33405 2 : {
33406 2 : const int bLocalUseExceptions = GetUseExceptions();
33407 2 : if ( bLocalUseExceptions ) {
33408 2 : pushErrorHandler();
33409 : }
33410 2 : {
33411 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33412 2 : result = (GDALExtendedDataTypeHS *)GDALGroupHS_GetDataType(arg1,arg2);
33413 2 : SWIG_PYTHON_THREAD_END_ALLOW;
33414 : }
33415 2 : if ( bLocalUseExceptions ) {
33416 2 : popErrorHandler();
33417 : }
33418 : #ifndef SED_HACKS
33419 : if ( bLocalUseExceptions ) {
33420 : CPLErr eclass = CPLGetLastErrorType();
33421 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33422 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33423 : }
33424 : }
33425 : #endif
33426 : }
33427 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALExtendedDataTypeHS, SWIG_POINTER_OWN | 0 );
33428 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33429 : return resultobj;
33430 : fail:
33431 : return NULL;
33432 : }
33433 :
33434 :
33435 277 : SWIGINTERN PyObject *Group_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33436 277 : PyObject *obj;
33437 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
33438 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALGroupHS, SWIG_NewClientData(obj));
33439 277 : return SWIG_Py_Void();
33440 : }
33441 :
33442 12 : SWIGINTERN PyObject *_wrap_Statistics_min_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33443 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33444 12 : Statistics *arg1 = (Statistics *) 0 ;
33445 12 : void *argp1 = 0 ;
33446 12 : int res1 = 0 ;
33447 12 : PyObject *swig_obj[1] ;
33448 12 : double result;
33449 :
33450 12 : if (!args) SWIG_fail;
33451 12 : swig_obj[0] = args;
33452 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 | 0 );
33453 12 : if (!SWIG_IsOK(res1)) {
33454 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_min_get" "', argument " "1"" of type '" "Statistics *""'");
33455 : }
33456 12 : arg1 = reinterpret_cast< Statistics * >(argp1);
33457 12 : {
33458 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33459 12 : result = (double) ((arg1)->min);
33460 12 : SWIG_PYTHON_THREAD_END_ALLOW;
33461 : }
33462 12 : resultobj = SWIG_From_double(static_cast< double >(result));
33463 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33464 : return resultobj;
33465 : fail:
33466 : return NULL;
33467 : }
33468 :
33469 :
33470 12 : SWIGINTERN PyObject *_wrap_Statistics_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33471 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33472 12 : Statistics *arg1 = (Statistics *) 0 ;
33473 12 : void *argp1 = 0 ;
33474 12 : int res1 = 0 ;
33475 12 : PyObject *swig_obj[1] ;
33476 12 : double result;
33477 :
33478 12 : if (!args) SWIG_fail;
33479 12 : swig_obj[0] = args;
33480 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 | 0 );
33481 12 : if (!SWIG_IsOK(res1)) {
33482 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_max_get" "', argument " "1"" of type '" "Statistics *""'");
33483 : }
33484 12 : arg1 = reinterpret_cast< Statistics * >(argp1);
33485 12 : {
33486 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33487 12 : result = (double) ((arg1)->max);
33488 12 : SWIG_PYTHON_THREAD_END_ALLOW;
33489 : }
33490 12 : resultobj = SWIG_From_double(static_cast< double >(result));
33491 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33492 : return resultobj;
33493 : fail:
33494 : return NULL;
33495 : }
33496 :
33497 :
33498 5 : SWIGINTERN PyObject *_wrap_Statistics_mean_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33499 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33500 5 : Statistics *arg1 = (Statistics *) 0 ;
33501 5 : void *argp1 = 0 ;
33502 5 : int res1 = 0 ;
33503 5 : PyObject *swig_obj[1] ;
33504 5 : double result;
33505 :
33506 5 : if (!args) SWIG_fail;
33507 5 : swig_obj[0] = args;
33508 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 | 0 );
33509 5 : if (!SWIG_IsOK(res1)) {
33510 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_mean_get" "', argument " "1"" of type '" "Statistics *""'");
33511 : }
33512 5 : arg1 = reinterpret_cast< Statistics * >(argp1);
33513 5 : {
33514 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33515 5 : result = (double) ((arg1)->mean);
33516 5 : SWIG_PYTHON_THREAD_END_ALLOW;
33517 : }
33518 5 : resultobj = SWIG_From_double(static_cast< double >(result));
33519 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33520 : return resultobj;
33521 : fail:
33522 : return NULL;
33523 : }
33524 :
33525 :
33526 5 : SWIGINTERN PyObject *_wrap_Statistics_std_dev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33527 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33528 5 : Statistics *arg1 = (Statistics *) 0 ;
33529 5 : void *argp1 = 0 ;
33530 5 : int res1 = 0 ;
33531 5 : PyObject *swig_obj[1] ;
33532 5 : double result;
33533 :
33534 5 : if (!args) SWIG_fail;
33535 5 : swig_obj[0] = args;
33536 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 | 0 );
33537 5 : if (!SWIG_IsOK(res1)) {
33538 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_std_dev_get" "', argument " "1"" of type '" "Statistics *""'");
33539 : }
33540 5 : arg1 = reinterpret_cast< Statistics * >(argp1);
33541 5 : {
33542 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33543 5 : result = (double) ((arg1)->std_dev);
33544 5 : SWIG_PYTHON_THREAD_END_ALLOW;
33545 : }
33546 5 : resultobj = SWIG_From_double(static_cast< double >(result));
33547 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33548 : return resultobj;
33549 : fail:
33550 : return NULL;
33551 : }
33552 :
33553 :
33554 5 : SWIGINTERN PyObject *_wrap_Statistics_valid_count_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33555 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33556 5 : Statistics *arg1 = (Statistics *) 0 ;
33557 5 : void *argp1 = 0 ;
33558 5 : int res1 = 0 ;
33559 5 : PyObject *swig_obj[1] ;
33560 5 : GIntBig result;
33561 :
33562 5 : if (!args) SWIG_fail;
33563 5 : swig_obj[0] = args;
33564 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 | 0 );
33565 5 : if (!SWIG_IsOK(res1)) {
33566 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_valid_count_get" "', argument " "1"" of type '" "Statistics *""'");
33567 : }
33568 5 : arg1 = reinterpret_cast< Statistics * >(argp1);
33569 5 : {
33570 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33571 5 : result = ((arg1)->valid_count);
33572 5 : SWIG_PYTHON_THREAD_END_ALLOW;
33573 : }
33574 5 : {
33575 5 : resultobj = PyLong_FromLongLong(result);
33576 : }
33577 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33578 : return resultobj;
33579 : fail:
33580 : return NULL;
33581 : }
33582 :
33583 :
33584 0 : SWIGINTERN PyObject *_wrap_delete_Statistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33585 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33586 0 : Statistics *arg1 = (Statistics *) 0 ;
33587 0 : void *argp1 = 0 ;
33588 0 : int res1 = 0 ;
33589 0 : PyObject *swig_obj[1] ;
33590 :
33591 0 : if (!args) SWIG_fail;
33592 0 : swig_obj[0] = args;
33593 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, SWIG_POINTER_DISOWN | 0 );
33594 0 : if (!SWIG_IsOK(res1)) {
33595 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Statistics" "', argument " "1"" of type '" "Statistics *""'");
33596 : }
33597 0 : arg1 = reinterpret_cast< Statistics * >(argp1);
33598 0 : {
33599 0 : const int bLocalUseExceptions = GetUseExceptions();
33600 0 : if ( bLocalUseExceptions ) {
33601 0 : pushErrorHandler();
33602 : }
33603 0 : {
33604 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33605 0 : delete_Statistics(arg1);
33606 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33607 : }
33608 0 : if ( bLocalUseExceptions ) {
33609 0 : popErrorHandler();
33610 : }
33611 : #ifndef SED_HACKS
33612 : if ( bLocalUseExceptions ) {
33613 : CPLErr eclass = CPLGetLastErrorType();
33614 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33615 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33616 : }
33617 : }
33618 : #endif
33619 : }
33620 0 : resultobj = SWIG_Py_Void();
33621 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33622 : return resultobj;
33623 : fail:
33624 : return NULL;
33625 : }
33626 :
33627 :
33628 0 : SWIGINTERN PyObject *_wrap_new_Statistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33629 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33630 0 : Statistics *result = 0 ;
33631 :
33632 0 : if (!SWIG_Python_UnpackTuple(args, "new_Statistics", 0, 0, 0)) SWIG_fail;
33633 0 : {
33634 0 : const int bLocalUseExceptions = GetUseExceptions();
33635 0 : if ( bLocalUseExceptions ) {
33636 0 : pushErrorHandler();
33637 : }
33638 0 : {
33639 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33640 0 : result = (Statistics *)new Statistics();
33641 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33642 : }
33643 0 : if ( bLocalUseExceptions ) {
33644 0 : popErrorHandler();
33645 : }
33646 : #ifndef SED_HACKS
33647 : if ( bLocalUseExceptions ) {
33648 : CPLErr eclass = CPLGetLastErrorType();
33649 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33650 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33651 : }
33652 : }
33653 : #endif
33654 : }
33655 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Statistics, SWIG_POINTER_NEW | 0 );
33656 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33657 : return resultobj;
33658 0 : fail:
33659 0 : return NULL;
33660 : }
33661 :
33662 :
33663 277 : SWIGINTERN PyObject *Statistics_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33664 277 : PyObject *obj;
33665 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
33666 277 : SWIG_TypeNewClientData(SWIGTYPE_p_Statistics, SWIG_NewClientData(obj));
33667 277 : return SWIG_Py_Void();
33668 : }
33669 :
33670 0 : SWIGINTERN PyObject *Statistics_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33671 0 : return SWIG_Python_InitShadowInstance(args);
33672 : }
33673 :
33674 14 : SWIGINTERN PyObject *_wrap_delete_RawBlockInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33675 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33676 14 : GDALMDArrayRawBlockInfo *arg1 = (GDALMDArrayRawBlockInfo *) 0 ;
33677 14 : void *argp1 = 0 ;
33678 14 : int res1 = 0 ;
33679 14 : PyObject *swig_obj[1] ;
33680 :
33681 14 : if (!args) SWIG_fail;
33682 14 : swig_obj[0] = args;
33683 14 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayRawBlockInfo, SWIG_POINTER_DISOWN | 0 );
33684 14 : if (!SWIG_IsOK(res1)) {
33685 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RawBlockInfo" "', argument " "1"" of type '" "GDALMDArrayRawBlockInfo *""'");
33686 : }
33687 14 : arg1 = reinterpret_cast< GDALMDArrayRawBlockInfo * >(argp1);
33688 14 : {
33689 14 : const int bLocalUseExceptions = GetUseExceptions();
33690 14 : if ( bLocalUseExceptions ) {
33691 14 : pushErrorHandler();
33692 : }
33693 14 : {
33694 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33695 14 : delete_GDALMDArrayRawBlockInfo(arg1);
33696 14 : SWIG_PYTHON_THREAD_END_ALLOW;
33697 : }
33698 14 : if ( bLocalUseExceptions ) {
33699 14 : popErrorHandler();
33700 : }
33701 : #ifndef SED_HACKS
33702 : if ( bLocalUseExceptions ) {
33703 : CPLErr eclass = CPLGetLastErrorType();
33704 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33705 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33706 : }
33707 : }
33708 : #endif
33709 : }
33710 14 : resultobj = SWIG_Py_Void();
33711 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33712 : return resultobj;
33713 : fail:
33714 : return NULL;
33715 : }
33716 :
33717 :
33718 6 : SWIGINTERN PyObject *_wrap_RawBlockInfo_GetOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33719 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33720 6 : GDALMDArrayRawBlockInfo *arg1 = (GDALMDArrayRawBlockInfo *) 0 ;
33721 6 : void *argp1 = 0 ;
33722 6 : int res1 = 0 ;
33723 6 : PyObject *swig_obj[1] ;
33724 6 : GUIntBig result;
33725 :
33726 6 : if (!args) SWIG_fail;
33727 6 : swig_obj[0] = args;
33728 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayRawBlockInfo, 0 | 0 );
33729 6 : if (!SWIG_IsOK(res1)) {
33730 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawBlockInfo_GetOffset" "', argument " "1"" of type '" "GDALMDArrayRawBlockInfo *""'");
33731 : }
33732 6 : arg1 = reinterpret_cast< GDALMDArrayRawBlockInfo * >(argp1);
33733 6 : {
33734 6 : const int bLocalUseExceptions = GetUseExceptions();
33735 6 : if ( bLocalUseExceptions ) {
33736 6 : pushErrorHandler();
33737 : }
33738 6 : {
33739 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33740 6 : result = GDALMDArrayRawBlockInfo_GetOffset(arg1);
33741 6 : SWIG_PYTHON_THREAD_END_ALLOW;
33742 : }
33743 6 : if ( bLocalUseExceptions ) {
33744 6 : popErrorHandler();
33745 : }
33746 : #ifndef SED_HACKS
33747 : if ( bLocalUseExceptions ) {
33748 : CPLErr eclass = CPLGetLastErrorType();
33749 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33750 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33751 : }
33752 : }
33753 : #endif
33754 : }
33755 6 : {
33756 6 : resultobj = PyLong_FromUnsignedLongLong(result);
33757 : }
33758 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33759 : return resultobj;
33760 : fail:
33761 : return NULL;
33762 : }
33763 :
33764 :
33765 6 : SWIGINTERN PyObject *_wrap_RawBlockInfo_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33766 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33767 6 : GDALMDArrayRawBlockInfo *arg1 = (GDALMDArrayRawBlockInfo *) 0 ;
33768 6 : void *argp1 = 0 ;
33769 6 : int res1 = 0 ;
33770 6 : PyObject *swig_obj[1] ;
33771 6 : GUIntBig result;
33772 :
33773 6 : if (!args) SWIG_fail;
33774 6 : swig_obj[0] = args;
33775 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayRawBlockInfo, 0 | 0 );
33776 6 : if (!SWIG_IsOK(res1)) {
33777 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawBlockInfo_GetSize" "', argument " "1"" of type '" "GDALMDArrayRawBlockInfo *""'");
33778 : }
33779 6 : arg1 = reinterpret_cast< GDALMDArrayRawBlockInfo * >(argp1);
33780 6 : {
33781 6 : const int bLocalUseExceptions = GetUseExceptions();
33782 6 : if ( bLocalUseExceptions ) {
33783 6 : pushErrorHandler();
33784 : }
33785 6 : {
33786 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33787 6 : result = GDALMDArrayRawBlockInfo_GetSize(arg1);
33788 6 : SWIG_PYTHON_THREAD_END_ALLOW;
33789 : }
33790 6 : if ( bLocalUseExceptions ) {
33791 6 : popErrorHandler();
33792 : }
33793 : #ifndef SED_HACKS
33794 : if ( bLocalUseExceptions ) {
33795 : CPLErr eclass = CPLGetLastErrorType();
33796 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33797 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33798 : }
33799 : }
33800 : #endif
33801 : }
33802 6 : {
33803 6 : resultobj = PyLong_FromUnsignedLongLong(result);
33804 : }
33805 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33806 : return resultobj;
33807 : fail:
33808 : return NULL;
33809 : }
33810 :
33811 :
33812 6 : SWIGINTERN PyObject *_wrap_RawBlockInfo_GetFilename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33813 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33814 6 : GDALMDArrayRawBlockInfo *arg1 = (GDALMDArrayRawBlockInfo *) 0 ;
33815 6 : void *argp1 = 0 ;
33816 6 : int res1 = 0 ;
33817 6 : PyObject *swig_obj[1] ;
33818 6 : char *result = 0 ;
33819 :
33820 6 : if (!args) SWIG_fail;
33821 6 : swig_obj[0] = args;
33822 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayRawBlockInfo, 0 | 0 );
33823 6 : if (!SWIG_IsOK(res1)) {
33824 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawBlockInfo_GetFilename" "', argument " "1"" of type '" "GDALMDArrayRawBlockInfo *""'");
33825 : }
33826 6 : arg1 = reinterpret_cast< GDALMDArrayRawBlockInfo * >(argp1);
33827 6 : {
33828 6 : const int bLocalUseExceptions = GetUseExceptions();
33829 6 : if ( bLocalUseExceptions ) {
33830 6 : pushErrorHandler();
33831 : }
33832 6 : {
33833 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33834 6 : result = (char *)GDALMDArrayRawBlockInfo_GetFilename(arg1);
33835 6 : SWIG_PYTHON_THREAD_END_ALLOW;
33836 : }
33837 6 : if ( bLocalUseExceptions ) {
33838 6 : popErrorHandler();
33839 : }
33840 : #ifndef SED_HACKS
33841 : if ( bLocalUseExceptions ) {
33842 : CPLErr eclass = CPLGetLastErrorType();
33843 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33844 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33845 : }
33846 : }
33847 : #endif
33848 : }
33849 6 : resultobj = SWIG_FromCharPtr((const char *)result);
33850 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33851 : return resultobj;
33852 : fail:
33853 : return NULL;
33854 : }
33855 :
33856 :
33857 14 : SWIGINTERN PyObject *_wrap_RawBlockInfo_GetInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33858 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33859 14 : GDALMDArrayRawBlockInfo *arg1 = (GDALMDArrayRawBlockInfo *) 0 ;
33860 14 : void *argp1 = 0 ;
33861 14 : int res1 = 0 ;
33862 14 : PyObject *swig_obj[1] ;
33863 14 : char **result = 0 ;
33864 :
33865 14 : if (!args) SWIG_fail;
33866 14 : swig_obj[0] = args;
33867 14 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayRawBlockInfo, 0 | 0 );
33868 14 : if (!SWIG_IsOK(res1)) {
33869 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawBlockInfo_GetInfo" "', argument " "1"" of type '" "GDALMDArrayRawBlockInfo *""'");
33870 : }
33871 14 : arg1 = reinterpret_cast< GDALMDArrayRawBlockInfo * >(argp1);
33872 14 : {
33873 14 : const int bLocalUseExceptions = GetUseExceptions();
33874 14 : if ( bLocalUseExceptions ) {
33875 14 : pushErrorHandler();
33876 : }
33877 14 : {
33878 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33879 14 : result = (char **)GDALMDArrayRawBlockInfo_GetInfo(arg1);
33880 14 : SWIG_PYTHON_THREAD_END_ALLOW;
33881 : }
33882 14 : if ( bLocalUseExceptions ) {
33883 14 : popErrorHandler();
33884 : }
33885 : #ifndef SED_HACKS
33886 : if ( bLocalUseExceptions ) {
33887 : CPLErr eclass = CPLGetLastErrorType();
33888 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33889 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33890 : }
33891 : }
33892 : #endif
33893 : }
33894 14 : {
33895 : /* %typemap(out) char **options -> ( string ) */
33896 14 : bool bErr = false;
33897 14 : resultobj = CSLToList(result, &bErr);
33898 14 : if( bErr ) {
33899 0 : SWIG_fail;
33900 : }
33901 : }
33902 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33903 : return resultobj;
33904 : fail:
33905 : return NULL;
33906 : }
33907 :
33908 :
33909 4 : SWIGINTERN PyObject *_wrap_RawBlockInfo_GetInlineData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33910 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33911 4 : GDALMDArrayRawBlockInfo *arg1 = (GDALMDArrayRawBlockInfo *) 0 ;
33912 4 : size_t *arg2 = (size_t *) 0 ;
33913 4 : char **arg3 = (char **) 0 ;
33914 4 : void *argp1 = 0 ;
33915 4 : int res1 = 0 ;
33916 4 : size_t nLen2 = 0 ;
33917 4 : char *pBuf2 = 0 ;
33918 4 : PyObject *swig_obj[1] ;
33919 :
33920 4 : {
33921 : /* %typemap(in,numinputs=0) (size_t *nLen2, char **pBuf2 ) */
33922 4 : arg2 = &nLen2;
33923 4 : arg3 = &pBuf2;
33924 : }
33925 4 : if (!args) SWIG_fail;
33926 4 : swig_obj[0] = args;
33927 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayRawBlockInfo, 0 | 0 );
33928 4 : if (!SWIG_IsOK(res1)) {
33929 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawBlockInfo_GetInlineData" "', argument " "1"" of type '" "GDALMDArrayRawBlockInfo *""'");
33930 : }
33931 4 : arg1 = reinterpret_cast< GDALMDArrayRawBlockInfo * >(argp1);
33932 4 : {
33933 4 : const int bLocalUseExceptions = GetUseExceptions();
33934 4 : if ( bLocalUseExceptions ) {
33935 4 : pushErrorHandler();
33936 : }
33937 4 : {
33938 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33939 4 : GDALMDArrayRawBlockInfo_GetInlineData(arg1,arg2,arg3);
33940 4 : SWIG_PYTHON_THREAD_END_ALLOW;
33941 : }
33942 4 : if ( bLocalUseExceptions ) {
33943 4 : popErrorHandler();
33944 : }
33945 : #ifndef SED_HACKS
33946 : if ( bLocalUseExceptions ) {
33947 : CPLErr eclass = CPLGetLastErrorType();
33948 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
33949 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
33950 : }
33951 : }
33952 : #endif
33953 : }
33954 4 : resultobj = SWIG_Py_Void();
33955 4 : {
33956 : /* %typemap(argout) (size_t *nLen, char **pBuf ) */
33957 4 : Py_XDECREF(resultobj);
33958 4 : if( *arg3 ) {
33959 1 : resultobj = PyByteArray_FromStringAndSize( *arg3, *arg2 );
33960 : }
33961 : else {
33962 3 : resultobj = Py_None;
33963 3 : Py_INCREF(Py_None);
33964 : }
33965 : }
33966 4 : {
33967 : /* %typemap(freearg) (size_t *nLen, char **pBuf ) */
33968 4 : VSIFree( *arg3 );
33969 : }
33970 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
33971 : return resultobj;
33972 0 : fail:
33973 0 : {
33974 : /* %typemap(freearg) (size_t *nLen, char **pBuf ) */
33975 0 : VSIFree( *arg3 );
33976 : }
33977 : return NULL;
33978 : }
33979 :
33980 :
33981 0 : SWIGINTERN PyObject *_wrap_new_RawBlockInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33982 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
33983 0 : GDALMDArrayRawBlockInfo *result = 0 ;
33984 :
33985 0 : if (!SWIG_Python_UnpackTuple(args, "new_RawBlockInfo", 0, 0, 0)) SWIG_fail;
33986 0 : {
33987 0 : const int bLocalUseExceptions = GetUseExceptions();
33988 0 : if ( bLocalUseExceptions ) {
33989 0 : pushErrorHandler();
33990 : }
33991 0 : {
33992 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33993 0 : result = (GDALMDArrayRawBlockInfo *)new GDALMDArrayRawBlockInfo();
33994 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33995 : }
33996 0 : if ( bLocalUseExceptions ) {
33997 0 : popErrorHandler();
33998 : }
33999 : #ifndef SED_HACKS
34000 : if ( bLocalUseExceptions ) {
34001 : CPLErr eclass = CPLGetLastErrorType();
34002 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34003 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34004 : }
34005 : }
34006 : #endif
34007 : }
34008 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayRawBlockInfo, SWIG_POINTER_NEW | 0 );
34009 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34010 : return resultobj;
34011 0 : fail:
34012 0 : return NULL;
34013 : }
34014 :
34015 :
34016 277 : SWIGINTERN PyObject *RawBlockInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34017 277 : PyObject *obj;
34018 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
34019 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALMDArrayRawBlockInfo, SWIG_NewClientData(obj));
34020 277 : return SWIG_Py_Void();
34021 : }
34022 :
34023 0 : SWIGINTERN PyObject *RawBlockInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34024 0 : return SWIG_Python_InitShadowInstance(args);
34025 : }
34026 :
34027 2193 : SWIGINTERN PyObject *_wrap_delete_MDArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34028 2193 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34029 2193 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
34030 2193 : void *argp1 = 0 ;
34031 2193 : int res1 = 0 ;
34032 2193 : PyObject *swig_obj[1] ;
34033 :
34034 2193 : if (!args) SWIG_fail;
34035 2193 : swig_obj[0] = args;
34036 2193 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_DISOWN | 0 );
34037 2193 : if (!SWIG_IsOK(res1)) {
34038 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDArray" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
34039 : }
34040 2193 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
34041 2193 : {
34042 2193 : const int bLocalUseExceptions = GetUseExceptions();
34043 2193 : if ( bLocalUseExceptions ) {
34044 587 : pushErrorHandler();
34045 : }
34046 2193 : {
34047 2193 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34048 2193 : delete_GDALMDArrayHS(arg1);
34049 2193 : SWIG_PYTHON_THREAD_END_ALLOW;
34050 : }
34051 2193 : if ( bLocalUseExceptions ) {
34052 587 : popErrorHandler();
34053 : }
34054 : #ifndef SED_HACKS
34055 : if ( bLocalUseExceptions ) {
34056 : CPLErr eclass = CPLGetLastErrorType();
34057 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34058 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34059 : }
34060 : }
34061 : #endif
34062 : }
34063 2193 : resultobj = SWIG_Py_Void();
34064 2193 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34065 : return resultobj;
34066 : fail:
34067 : return NULL;
34068 : }
34069 :
34070 :
34071 83 : SWIGINTERN PyObject *_wrap_MDArray_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34072 83 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34073 83 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
34074 83 : void *argp1 = 0 ;
34075 83 : int res1 = 0 ;
34076 83 : PyObject *swig_obj[1] ;
34077 83 : char *result = 0 ;
34078 :
34079 83 : if (!args) SWIG_fail;
34080 83 : swig_obj[0] = args;
34081 83 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
34082 83 : if (!SWIG_IsOK(res1)) {
34083 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetName" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
34084 : }
34085 83 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
34086 83 : {
34087 83 : const int bLocalUseExceptions = GetUseExceptions();
34088 83 : if ( bLocalUseExceptions ) {
34089 27 : pushErrorHandler();
34090 : }
34091 83 : {
34092 83 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34093 83 : result = (char *)GDALMDArrayHS_GetName(arg1);
34094 83 : SWIG_PYTHON_THREAD_END_ALLOW;
34095 : }
34096 83 : if ( bLocalUseExceptions ) {
34097 27 : popErrorHandler();
34098 : }
34099 : #ifndef SED_HACKS
34100 : if ( bLocalUseExceptions ) {
34101 : CPLErr eclass = CPLGetLastErrorType();
34102 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34103 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34104 : }
34105 : }
34106 : #endif
34107 : }
34108 83 : resultobj = SWIG_FromCharPtr((const char *)result);
34109 83 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34110 : return resultobj;
34111 : fail:
34112 : return NULL;
34113 : }
34114 :
34115 :
34116 50 : SWIGINTERN PyObject *_wrap_MDArray_GetFullName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34117 50 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34118 50 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
34119 50 : void *argp1 = 0 ;
34120 50 : int res1 = 0 ;
34121 50 : PyObject *swig_obj[1] ;
34122 50 : char *result = 0 ;
34123 :
34124 50 : if (!args) SWIG_fail;
34125 50 : swig_obj[0] = args;
34126 50 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
34127 50 : if (!SWIG_IsOK(res1)) {
34128 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetFullName" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
34129 : }
34130 50 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
34131 50 : {
34132 50 : const int bLocalUseExceptions = GetUseExceptions();
34133 50 : if ( bLocalUseExceptions ) {
34134 27 : pushErrorHandler();
34135 : }
34136 50 : {
34137 50 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34138 50 : result = (char *)GDALMDArrayHS_GetFullName(arg1);
34139 50 : SWIG_PYTHON_THREAD_END_ALLOW;
34140 : }
34141 50 : if ( bLocalUseExceptions ) {
34142 27 : popErrorHandler();
34143 : }
34144 : #ifndef SED_HACKS
34145 : if ( bLocalUseExceptions ) {
34146 : CPLErr eclass = CPLGetLastErrorType();
34147 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34148 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34149 : }
34150 : }
34151 : #endif
34152 : }
34153 50 : resultobj = SWIG_FromCharPtr((const char *)result);
34154 50 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34155 : return resultobj;
34156 : fail:
34157 : return NULL;
34158 : }
34159 :
34160 :
34161 6 : SWIGINTERN PyObject *_wrap_MDArray_GetTotalElementsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34162 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34163 6 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
34164 6 : void *argp1 = 0 ;
34165 6 : int res1 = 0 ;
34166 6 : PyObject *swig_obj[1] ;
34167 6 : GUIntBig result;
34168 :
34169 6 : if (!args) SWIG_fail;
34170 6 : swig_obj[0] = args;
34171 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
34172 6 : if (!SWIG_IsOK(res1)) {
34173 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetTotalElementsCount" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
34174 : }
34175 6 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
34176 6 : {
34177 6 : const int bLocalUseExceptions = GetUseExceptions();
34178 6 : if ( bLocalUseExceptions ) {
34179 0 : pushErrorHandler();
34180 : }
34181 6 : {
34182 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34183 6 : result = GDALMDArrayHS_GetTotalElementsCount(arg1);
34184 6 : SWIG_PYTHON_THREAD_END_ALLOW;
34185 : }
34186 6 : if ( bLocalUseExceptions ) {
34187 0 : popErrorHandler();
34188 : }
34189 : #ifndef SED_HACKS
34190 : if ( bLocalUseExceptions ) {
34191 : CPLErr eclass = CPLGetLastErrorType();
34192 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34193 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34194 : }
34195 : }
34196 : #endif
34197 : }
34198 6 : {
34199 6 : resultobj = PyLong_FromUnsignedLongLong(result);
34200 : }
34201 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34202 : return resultobj;
34203 : fail:
34204 : return NULL;
34205 : }
34206 :
34207 :
34208 3684 : SWIGINTERN PyObject *_wrap_MDArray_GetDimensionCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34209 3684 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34210 3684 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
34211 3684 : void *argp1 = 0 ;
34212 3684 : int res1 = 0 ;
34213 3684 : PyObject *swig_obj[1] ;
34214 3684 : size_t result;
34215 :
34216 3684 : if (!args) SWIG_fail;
34217 3684 : swig_obj[0] = args;
34218 3684 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
34219 3684 : if (!SWIG_IsOK(res1)) {
34220 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetDimensionCount" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
34221 : }
34222 3684 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
34223 3684 : {
34224 3684 : const int bLocalUseExceptions = GetUseExceptions();
34225 3684 : if ( bLocalUseExceptions ) {
34226 618 : pushErrorHandler();
34227 : }
34228 3684 : {
34229 3684 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34230 3684 : result = GDALMDArrayHS_GetDimensionCount(arg1);
34231 3684 : SWIG_PYTHON_THREAD_END_ALLOW;
34232 : }
34233 3684 : if ( bLocalUseExceptions ) {
34234 618 : popErrorHandler();
34235 : }
34236 : #ifndef SED_HACKS
34237 : if ( bLocalUseExceptions ) {
34238 : CPLErr eclass = CPLGetLastErrorType();
34239 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34240 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34241 : }
34242 : }
34243 : #endif
34244 : }
34245 3684 : resultobj = SWIG_From_size_t(static_cast< size_t >(result));
34246 3684 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34247 : return resultobj;
34248 : fail:
34249 : return NULL;
34250 : }
34251 :
34252 :
34253 2438 : SWIGINTERN PyObject *_wrap_MDArray_GetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34254 2438 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34255 2438 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
34256 2438 : GDALDimensionHS ***arg2 = (GDALDimensionHS ***) 0 ;
34257 2438 : size_t *arg3 = (size_t *) 0 ;
34258 2438 : void *argp1 = 0 ;
34259 2438 : int res1 = 0 ;
34260 2438 : GDALDimensionHS **dims2 = 0 ;
34261 2438 : size_t nCount2 = 0 ;
34262 2438 : PyObject *swig_obj[1] ;
34263 :
34264 2438 : {
34265 : /* %typemap(in,numinputs=0) (GDALDimensionHS*** pdims, size_t* pnCount) */
34266 2438 : arg2 = &dims2;
34267 2438 : arg3 = &nCount2;
34268 : }
34269 2438 : if (!args) SWIG_fail;
34270 2438 : swig_obj[0] = args;
34271 2438 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
34272 2438 : if (!SWIG_IsOK(res1)) {
34273 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetDimensions" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
34274 : }
34275 2438 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
34276 2438 : {
34277 2438 : const int bLocalUseExceptions = GetUseExceptions();
34278 2438 : if ( bLocalUseExceptions ) {
34279 443 : pushErrorHandler();
34280 : }
34281 2438 : {
34282 2438 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34283 2438 : GDALMDArrayHS_GetDimensions(arg1,arg2,arg3);
34284 2438 : SWIG_PYTHON_THREAD_END_ALLOW;
34285 : }
34286 2438 : if ( bLocalUseExceptions ) {
34287 443 : popErrorHandler();
34288 : }
34289 : #ifndef SED_HACKS
34290 : if ( bLocalUseExceptions ) {
34291 : CPLErr eclass = CPLGetLastErrorType();
34292 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34293 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34294 : }
34295 : }
34296 : #endif
34297 : }
34298 2438 : resultobj = SWIG_Py_Void();
34299 2438 : {
34300 : /* %typemap(argout) (GDALDimensionHS*** pdims, size_t* pnCount) */
34301 2438 : Py_DECREF(resultobj);
34302 2438 : resultobj = PyList_New( *arg3 );
34303 2438 : if( !resultobj ) {
34304 0 : SWIG_fail;
34305 : }
34306 6855 : for( size_t i = 0; i < *arg3; i++ ) {
34307 4417 : PyList_SetItem(resultobj, i,
34308 4417 : SWIG_NewPointerObj((void*)(*arg2)[i],SWIGTYPE_p_GDALDimensionHS,SWIG_POINTER_OWN) );
34309 : /* We have borrowed the GDALDimensionHS */
34310 4417 : (*arg2)[i] = NULL;
34311 : }
34312 : }
34313 2438 : {
34314 : /* %typemap(freearg) (GDALDimensionHS*** pdims, size_t* pnCount) */
34315 2438 : GDALReleaseDimensions(*arg2, *arg3);
34316 : }
34317 2438 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34318 : return resultobj;
34319 0 : fail:
34320 0 : {
34321 : /* %typemap(freearg) (GDALDimensionHS*** pdims, size_t* pnCount) */
34322 0 : GDALReleaseDimensions(*arg2, *arg3);
34323 : }
34324 : return NULL;
34325 : }
34326 :
34327 :
34328 13 : SWIGINTERN PyObject *_wrap_MDArray_GetCoordinateVariables(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34329 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34330 13 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
34331 13 : GDALMDArrayHS ***arg2 = (GDALMDArrayHS ***) 0 ;
34332 13 : size_t *arg3 = (size_t *) 0 ;
34333 13 : void *argp1 = 0 ;
34334 13 : int res1 = 0 ;
34335 13 : GDALMDArrayHS **arrays2 = 0 ;
34336 13 : size_t nCount2 = 0 ;
34337 13 : PyObject *swig_obj[1] ;
34338 :
34339 13 : {
34340 : /* %typemap(in,numinputs=0) (GDALMDArrayHS*** parrays, size_t* pnCount) */
34341 13 : arg2 = &arrays2;
34342 13 : arg3 = &nCount2;
34343 : }
34344 13 : if (!args) SWIG_fail;
34345 13 : swig_obj[0] = args;
34346 13 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
34347 13 : if (!SWIG_IsOK(res1)) {
34348 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetCoordinateVariables" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
34349 : }
34350 13 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
34351 13 : {
34352 13 : const int bLocalUseExceptions = GetUseExceptions();
34353 13 : if ( bLocalUseExceptions ) {
34354 3 : pushErrorHandler();
34355 : }
34356 13 : {
34357 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34358 13 : GDALMDArrayHS_GetCoordinateVariables(arg1,arg2,arg3);
34359 13 : SWIG_PYTHON_THREAD_END_ALLOW;
34360 : }
34361 13 : if ( bLocalUseExceptions ) {
34362 3 : popErrorHandler();
34363 : }
34364 : #ifndef SED_HACKS
34365 : if ( bLocalUseExceptions ) {
34366 : CPLErr eclass = CPLGetLastErrorType();
34367 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34368 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34369 : }
34370 : }
34371 : #endif
34372 : }
34373 13 : resultobj = SWIG_Py_Void();
34374 13 : {
34375 : /* %typemap(argout) (GDALMDArrayHS*** parrays, size_t* pnCount) */
34376 13 : Py_DECREF(resultobj);
34377 13 : resultobj = PyList_New( *arg3 );
34378 13 : if( !resultobj ) {
34379 0 : SWIG_fail;
34380 : }
34381 29 : for( size_t i = 0; i < *arg3; i++ ) {
34382 16 : PyList_SetItem(resultobj, i,
34383 16 : SWIG_NewPointerObj((void*)(*arg2)[i],SWIGTYPE_p_GDALMDArrayHS,SWIG_POINTER_OWN) );
34384 : /* We have borrowed the GDALMDArrayHS */
34385 16 : (*arg2)[i] = NULL;
34386 : }
34387 : }
34388 13 : {
34389 : /* %typemap(freearg) (GDALMDArrayHS*** parrays, size_t* pnCount) */
34390 13 : GDALReleaseArrays(*arg2, *arg3);
34391 : }
34392 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34393 : return resultobj;
34394 0 : fail:
34395 0 : {
34396 : /* %typemap(freearg) (GDALMDArrayHS*** parrays, size_t* pnCount) */
34397 0 : GDALReleaseArrays(*arg2, *arg3);
34398 : }
34399 : return NULL;
34400 : }
34401 :
34402 :
34403 98 : SWIGINTERN PyObject *_wrap_MDArray_GetBlockSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34404 98 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34405 98 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
34406 98 : GUIntBig **arg2 = (GUIntBig **) 0 ;
34407 98 : size_t *arg3 = (size_t *) 0 ;
34408 98 : void *argp1 = 0 ;
34409 98 : int res1 = 0 ;
34410 98 : GUIntBig *vals2 = 0 ;
34411 98 : size_t nCount2 = 0 ;
34412 98 : PyObject *swig_obj[1] ;
34413 :
34414 98 : {
34415 : /* %typemap(in,numinputs=0) (GUIntBig** pvals, size_t* pnCount) */
34416 98 : arg2 = &vals2;
34417 98 : arg3 = &nCount2;
34418 : }
34419 98 : if (!args) SWIG_fail;
34420 98 : swig_obj[0] = args;
34421 98 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
34422 98 : if (!SWIG_IsOK(res1)) {
34423 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetBlockSize" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
34424 : }
34425 98 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
34426 98 : {
34427 98 : const int bLocalUseExceptions = GetUseExceptions();
34428 98 : if ( bLocalUseExceptions ) {
34429 5 : pushErrorHandler();
34430 : }
34431 98 : {
34432 98 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34433 98 : GDALMDArrayHS_GetBlockSize(arg1,arg2,arg3);
34434 98 : SWIG_PYTHON_THREAD_END_ALLOW;
34435 : }
34436 98 : if ( bLocalUseExceptions ) {
34437 5 : popErrorHandler();
34438 : }
34439 : #ifndef SED_HACKS
34440 : if ( bLocalUseExceptions ) {
34441 : CPLErr eclass = CPLGetLastErrorType();
34442 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34443 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34444 : }
34445 : }
34446 : #endif
34447 : }
34448 98 : resultobj = SWIG_Py_Void();
34449 98 : {
34450 : /* %typemap(argout) (GUIntBig** pvals, size_t* pnCount) */
34451 98 : Py_DECREF(resultobj);
34452 98 : resultobj = PyList_New( *arg3 );
34453 98 : if( !resultobj ) {
34454 0 : SWIG_fail;
34455 : }
34456 301 : for( size_t i = 0; i < *arg3; i++ ) {
34457 203 : char szTmp[32];
34458 203 : snprintf(szTmp, sizeof(szTmp), CPL_FRMT_GUIB, (*arg2)[i]);
34459 203 : PyObject *o = PyLong_FromString(szTmp, NULL, 10);
34460 203 : PyList_SetItem(resultobj, i, o );
34461 : }
34462 : }
34463 98 : {
34464 : /* %typemap(freearg) (GUIntBig** pvals, size_t* pnCount) */
34465 98 : CPLFree(*arg2);
34466 : }
34467 98 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34468 : return resultobj;
34469 0 : fail:
34470 0 : {
34471 : /* %typemap(freearg) (GUIntBig** pvals, size_t* pnCount) */
34472 0 : CPLFree(*arg2);
34473 : }
34474 : return NULL;
34475 : }
34476 :
34477 :
34478 1 : SWIGINTERN PyObject *_wrap_MDArray_GetProcessingChunkSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34479 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34480 1 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
34481 1 : size_t arg2 ;
34482 1 : GUIntBig **arg3 = (GUIntBig **) 0 ;
34483 1 : size_t *arg4 = (size_t *) 0 ;
34484 1 : void *argp1 = 0 ;
34485 1 : int res1 = 0 ;
34486 1 : size_t val2 ;
34487 1 : int ecode2 = 0 ;
34488 1 : GUIntBig *vals3 = 0 ;
34489 1 : size_t nCount3 = 0 ;
34490 1 : PyObject *swig_obj[2] ;
34491 :
34492 1 : {
34493 : /* %typemap(in,numinputs=0) (GUIntBig** pvals, size_t* pnCount) */
34494 1 : arg3 = &vals3;
34495 1 : arg4 = &nCount3;
34496 : }
34497 1 : if (!SWIG_Python_UnpackTuple(args, "MDArray_GetProcessingChunkSize", 2, 2, swig_obj)) SWIG_fail;
34498 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
34499 1 : if (!SWIG_IsOK(res1)) {
34500 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetProcessingChunkSize" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
34501 : }
34502 1 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
34503 1 : ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
34504 1 : if (!SWIG_IsOK(ecode2)) {
34505 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MDArray_GetProcessingChunkSize" "', argument " "2"" of type '" "size_t""'");
34506 : }
34507 1 : arg2 = static_cast< size_t >(val2);
34508 1 : {
34509 1 : const int bLocalUseExceptions = GetUseExceptions();
34510 1 : if ( bLocalUseExceptions ) {
34511 0 : pushErrorHandler();
34512 : }
34513 1 : {
34514 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34515 1 : GDALMDArrayHS_GetProcessingChunkSize(arg1,arg2,arg3,arg4);
34516 1 : SWIG_PYTHON_THREAD_END_ALLOW;
34517 : }
34518 1 : if ( bLocalUseExceptions ) {
34519 0 : popErrorHandler();
34520 : }
34521 : #ifndef SED_HACKS
34522 : if ( bLocalUseExceptions ) {
34523 : CPLErr eclass = CPLGetLastErrorType();
34524 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34525 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34526 : }
34527 : }
34528 : #endif
34529 : }
34530 1 : resultobj = SWIG_Py_Void();
34531 1 : {
34532 : /* %typemap(argout) (GUIntBig** pvals, size_t* pnCount) */
34533 1 : Py_DECREF(resultobj);
34534 1 : resultobj = PyList_New( *arg4 );
34535 1 : if( !resultobj ) {
34536 0 : SWIG_fail;
34537 : }
34538 3 : for( size_t i = 0; i < *arg4; i++ ) {
34539 2 : char szTmp[32];
34540 2 : snprintf(szTmp, sizeof(szTmp), CPL_FRMT_GUIB, (*arg3)[i]);
34541 2 : PyObject *o = PyLong_FromString(szTmp, NULL, 10);
34542 2 : PyList_SetItem(resultobj, i, o );
34543 : }
34544 : }
34545 1 : {
34546 : /* %typemap(freearg) (GUIntBig** pvals, size_t* pnCount) */
34547 1 : CPLFree(*arg3);
34548 : }
34549 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34550 : return resultobj;
34551 0 : fail:
34552 0 : {
34553 : /* %typemap(freearg) (GUIntBig** pvals, size_t* pnCount) */
34554 0 : CPLFree(*arg3);
34555 : }
34556 : return NULL;
34557 : }
34558 :
34559 :
34560 2218 : SWIGINTERN PyObject *_wrap_MDArray_GetDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34561 2218 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34562 2218 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
34563 2218 : void *argp1 = 0 ;
34564 2218 : int res1 = 0 ;
34565 2218 : PyObject *swig_obj[1] ;
34566 2218 : GDALExtendedDataTypeHS *result = 0 ;
34567 :
34568 2218 : if (!args) SWIG_fail;
34569 2218 : swig_obj[0] = args;
34570 2218 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
34571 2218 : if (!SWIG_IsOK(res1)) {
34572 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetDataType" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
34573 : }
34574 2218 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
34575 2218 : {
34576 2218 : const int bLocalUseExceptions = GetUseExceptions();
34577 2218 : if ( bLocalUseExceptions ) {
34578 574 : pushErrorHandler();
34579 : }
34580 2218 : {
34581 2218 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34582 2218 : result = (GDALExtendedDataTypeHS *)GDALMDArrayHS_GetDataType(arg1);
34583 2218 : SWIG_PYTHON_THREAD_END_ALLOW;
34584 : }
34585 2218 : if ( bLocalUseExceptions ) {
34586 574 : popErrorHandler();
34587 : }
34588 : #ifndef SED_HACKS
34589 : if ( bLocalUseExceptions ) {
34590 : CPLErr eclass = CPLGetLastErrorType();
34591 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34592 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34593 : }
34594 : }
34595 : #endif
34596 : }
34597 2218 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALExtendedDataTypeHS, SWIG_POINTER_OWN | 0 );
34598 2218 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34599 : return resultobj;
34600 : fail:
34601 : return NULL;
34602 : }
34603 :
34604 :
34605 15 : SWIGINTERN PyObject *_wrap_MDArray_GetStructuralInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34606 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34607 15 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
34608 15 : void *argp1 = 0 ;
34609 15 : int res1 = 0 ;
34610 15 : PyObject *swig_obj[1] ;
34611 15 : char **result = 0 ;
34612 :
34613 15 : if (!args) SWIG_fail;
34614 15 : swig_obj[0] = args;
34615 15 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
34616 15 : if (!SWIG_IsOK(res1)) {
34617 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetStructuralInfo" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
34618 : }
34619 15 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
34620 15 : {
34621 15 : const int bLocalUseExceptions = GetUseExceptions();
34622 15 : if ( bLocalUseExceptions ) {
34623 2 : pushErrorHandler();
34624 : }
34625 15 : {
34626 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34627 15 : result = (char **)GDALMDArrayHS_GetStructuralInfo(arg1);
34628 15 : SWIG_PYTHON_THREAD_END_ALLOW;
34629 : }
34630 15 : if ( bLocalUseExceptions ) {
34631 2 : popErrorHandler();
34632 : }
34633 : #ifndef SED_HACKS
34634 : if ( bLocalUseExceptions ) {
34635 : CPLErr eclass = CPLGetLastErrorType();
34636 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34637 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34638 : }
34639 : }
34640 : #endif
34641 : }
34642 15 : {
34643 : /* %typemap(out) char **dict */
34644 15 : resultobj = GetCSLStringAsPyDict(result, false);
34645 : }
34646 15 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34647 : return resultobj;
34648 : fail:
34649 : return NULL;
34650 : }
34651 :
34652 :
34653 44 : SWIGINTERN PyObject *_wrap_MDArray_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34654 44 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34655 44 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
34656 44 : int arg2 ;
34657 44 : GUIntBig *arg3 = (GUIntBig *) 0 ;
34658 44 : char **arg4 = (char **) NULL ;
34659 44 : void *argp1 = 0 ;
34660 44 : int res1 = 0 ;
34661 44 : PyObject *swig_obj[3] ;
34662 44 : CPLErr result;
34663 :
34664 44 : if (!SWIG_Python_UnpackTuple(args, "MDArray_Resize", 2, 3, swig_obj)) SWIG_fail;
34665 44 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
34666 44 : if (!SWIG_IsOK(res1)) {
34667 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_Resize" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
34668 : }
34669 44 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
34670 44 : {
34671 : /* %typemap(in,numinputs=1) (int nList, GUIntBig* pList)*/
34672 44 : arg3 = CreateCGUIntBigListFromSequence(swig_obj[1], &arg2);
34673 44 : if( arg2 < 0 ) {
34674 0 : SWIG_fail;
34675 : }
34676 : }
34677 44 : if (swig_obj[2]) {
34678 0 : {
34679 : /* %typemap(in) char **dict */
34680 0 : arg4 = NULL;
34681 0 : if ( PySequence_Check( swig_obj[2] ) ) {
34682 0 : int bErr = FALSE;
34683 0 : arg4 = CSLFromPySequence(swig_obj[2], &bErr);
34684 0 : if ( bErr )
34685 : {
34686 0 : SWIG_fail;
34687 : }
34688 : }
34689 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
34690 0 : int bErr = FALSE;
34691 0 : arg4 = CSLFromPyMapping(swig_obj[2], &bErr);
34692 0 : if ( bErr )
34693 : {
34694 0 : SWIG_fail;
34695 : }
34696 : }
34697 : else {
34698 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
34699 0 : SWIG_fail;
34700 : }
34701 : }
34702 : }
34703 44 : {
34704 44 : const int bLocalUseExceptions = GetUseExceptions();
34705 44 : if ( bLocalUseExceptions ) {
34706 0 : pushErrorHandler();
34707 : }
34708 44 : {
34709 44 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34710 44 : result = (CPLErr)GDALMDArrayHS_Resize(arg1,arg2,arg3,arg4);
34711 44 : SWIG_PYTHON_THREAD_END_ALLOW;
34712 : }
34713 44 : if ( bLocalUseExceptions ) {
34714 0 : popErrorHandler();
34715 : }
34716 : #ifndef SED_HACKS
34717 : if ( bLocalUseExceptions ) {
34718 : CPLErr eclass = CPLGetLastErrorType();
34719 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34720 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34721 : }
34722 : }
34723 : #endif
34724 : }
34725 44 : resultobj = SWIG_From_int(static_cast< int >(result));
34726 44 : {
34727 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
34728 44 : free(arg3);
34729 : }
34730 44 : {
34731 : /* %typemap(freearg) char **dict */
34732 44 : CSLDestroy( arg4 );
34733 : }
34734 44 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34735 : return resultobj;
34736 0 : fail:
34737 0 : {
34738 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
34739 0 : free(arg3);
34740 : }
34741 0 : {
34742 : /* %typemap(freearg) char **dict */
34743 0 : CSLDestroy( arg4 );
34744 : }
34745 : return NULL;
34746 : }
34747 :
34748 :
34749 1926 : SWIGINTERN PyObject *_wrap_MDArray_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34750 1926 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34751 1926 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
34752 1926 : int arg2 ;
34753 1926 : GUIntBig *arg3 = (GUIntBig *) 0 ;
34754 1926 : int arg4 ;
34755 1926 : GUIntBig *arg5 = (GUIntBig *) 0 ;
34756 1926 : int arg6 ;
34757 1926 : GIntBig *arg7 = (GIntBig *) 0 ;
34758 1926 : int arg8 ;
34759 1926 : GIntBig *arg9 = (GIntBig *) 0 ;
34760 1926 : GDALExtendedDataTypeHS *arg10 = (GDALExtendedDataTypeHS *) 0 ;
34761 1926 : void **arg11 = (void **) 0 ;
34762 1926 : void *argp1 = 0 ;
34763 1926 : int res1 = 0 ;
34764 1926 : void *argp10 = 0 ;
34765 1926 : int res10 = 0 ;
34766 1926 : void *pyObject11 = NULL ;
34767 1926 : PyObject *swig_obj[6] ;
34768 1926 : CPLErr result;
34769 :
34770 1926 : {
34771 : /* %typemap(in,numinputs=0) ( void **outPythonObject ) ( void *pyObject11 = NULL ) */
34772 1926 : arg11 = &pyObject11;
34773 : }
34774 1926 : if (!SWIG_Python_UnpackTuple(args, "MDArray_Read", 6, 6, swig_obj)) SWIG_fail;
34775 1926 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
34776 1926 : if (!SWIG_IsOK(res1)) {
34777 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_Read" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
34778 : }
34779 1926 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
34780 1926 : {
34781 : /* %typemap(in,numinputs=1) (int nList, GUIntBig* pList)*/
34782 1926 : arg3 = CreateCGUIntBigListFromSequence(swig_obj[1], &arg2);
34783 1926 : if( arg2 < 0 ) {
34784 0 : SWIG_fail;
34785 : }
34786 : }
34787 1926 : {
34788 : /* %typemap(in,numinputs=1) (int nList, GUIntBig* pList)*/
34789 1926 : arg5 = CreateCGUIntBigListFromSequence(swig_obj[2], &arg4);
34790 1926 : if( arg4 < 0 ) {
34791 0 : SWIG_fail;
34792 : }
34793 : }
34794 1926 : {
34795 : /* %typemap(in,numinputs=1) (int nList, GIntBig* pList)*/
34796 1926 : arg7 = CreateCGIntBigListFromSequence(swig_obj[3], &arg6);
34797 1926 : if( arg6 < 0 ) {
34798 0 : SWIG_fail;
34799 : }
34800 : }
34801 1926 : {
34802 : /* %typemap(in,numinputs=1) (int nList, GIntBig* pList)*/
34803 1926 : arg9 = CreateCGIntBigListFromSequence(swig_obj[4], &arg8);
34804 1926 : if( arg8 < 0 ) {
34805 0 : SWIG_fail;
34806 : }
34807 : }
34808 1926 : res10 = SWIG_ConvertPtr(swig_obj[5], &argp10,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
34809 1926 : if (!SWIG_IsOK(res10)) {
34810 0 : SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "MDArray_Read" "', argument " "10"" of type '" "GDALExtendedDataTypeHS *""'");
34811 : }
34812 1926 : arg10 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp10);
34813 1926 : {
34814 1926 : if (!arg10) {
34815 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
34816 : }
34817 : }
34818 1926 : {
34819 1926 : const int bLocalUseExceptions = GetUseExceptions();
34820 1926 : if ( bLocalUseExceptions ) {
34821 171 : pushErrorHandler();
34822 : }
34823 1926 : {
34824 1926 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34825 1926 : result = (CPLErr)GDALMDArrayHS_Read(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
34826 1926 : SWIG_PYTHON_THREAD_END_ALLOW;
34827 : }
34828 1926 : if ( bLocalUseExceptions ) {
34829 171 : popErrorHandler();
34830 : }
34831 : #ifndef SED_HACKS
34832 : if ( bLocalUseExceptions ) {
34833 : CPLErr eclass = CPLGetLastErrorType();
34834 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34835 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34836 : }
34837 : }
34838 : #endif
34839 : }
34840 1926 : resultobj = SWIG_From_int(static_cast< int >(result));
34841 1926 : {
34842 : /* %typemap(argout) ( void **outPythonObject ) */
34843 1926 : Py_XDECREF(resultobj);
34844 1926 : if (*arg11)
34845 : {
34846 : resultobj = (PyObject*)*arg11;
34847 : }
34848 : else
34849 : {
34850 41 : resultobj = Py_None;
34851 41 : Py_INCREF(resultobj);
34852 : }
34853 : }
34854 1926 : {
34855 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
34856 1926 : free(arg3);
34857 : }
34858 1926 : {
34859 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
34860 1926 : free(arg5);
34861 : }
34862 1926 : {
34863 : /* %typemap(freearg) (int nList, GIntBig* pList) */
34864 1926 : free(arg7);
34865 : }
34866 1926 : {
34867 : /* %typemap(freearg) (int nList, GIntBig* pList) */
34868 1926 : free(arg9);
34869 : }
34870 1934 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
34871 : return resultobj;
34872 0 : fail:
34873 0 : {
34874 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
34875 0 : free(arg3);
34876 : }
34877 0 : {
34878 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
34879 0 : free(arg5);
34880 : }
34881 0 : {
34882 : /* %typemap(freearg) (int nList, GIntBig* pList) */
34883 0 : free(arg7);
34884 : }
34885 0 : {
34886 : /* %typemap(freearg) (int nList, GIntBig* pList) */
34887 0 : free(arg9);
34888 : }
34889 0 : return NULL;
34890 : }
34891 :
34892 :
34893 14 : SWIGINTERN PyObject *_wrap_MDArray_WriteStringArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34894 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
34895 14 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
34896 14 : int arg2 ;
34897 14 : GUIntBig *arg3 = (GUIntBig *) 0 ;
34898 14 : int arg4 ;
34899 14 : GUIntBig *arg5 = (GUIntBig *) 0 ;
34900 14 : int arg6 ;
34901 14 : GIntBig *arg7 = (GIntBig *) 0 ;
34902 14 : GDALExtendedDataTypeHS *arg8 = (GDALExtendedDataTypeHS *) 0 ;
34903 14 : char **arg9 = (char **) 0 ;
34904 14 : void *argp1 = 0 ;
34905 14 : int res1 = 0 ;
34906 14 : void *argp8 = 0 ;
34907 14 : int res8 = 0 ;
34908 14 : PyObject *swig_obj[6] ;
34909 14 : CPLErr result;
34910 :
34911 14 : if (!SWIG_Python_UnpackTuple(args, "MDArray_WriteStringArray", 6, 6, swig_obj)) SWIG_fail;
34912 14 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
34913 14 : if (!SWIG_IsOK(res1)) {
34914 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_WriteStringArray" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
34915 : }
34916 14 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
34917 14 : {
34918 : /* %typemap(in,numinputs=1) (int nList, GUIntBig* pList)*/
34919 14 : arg3 = CreateCGUIntBigListFromSequence(swig_obj[1], &arg2);
34920 14 : if( arg2 < 0 ) {
34921 0 : SWIG_fail;
34922 : }
34923 : }
34924 14 : {
34925 : /* %typemap(in,numinputs=1) (int nList, GUIntBig* pList)*/
34926 14 : arg5 = CreateCGUIntBigListFromSequence(swig_obj[2], &arg4);
34927 14 : if( arg4 < 0 ) {
34928 0 : SWIG_fail;
34929 : }
34930 : }
34931 14 : {
34932 : /* %typemap(in,numinputs=1) (int nList, GIntBig* pList)*/
34933 14 : arg7 = CreateCGIntBigListFromSequence(swig_obj[3], &arg6);
34934 14 : if( arg6 < 0 ) {
34935 0 : SWIG_fail;
34936 : }
34937 : }
34938 14 : res8 = SWIG_ConvertPtr(swig_obj[4], &argp8,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
34939 14 : if (!SWIG_IsOK(res8)) {
34940 0 : SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "MDArray_WriteStringArray" "', argument " "8"" of type '" "GDALExtendedDataTypeHS *""'");
34941 : }
34942 14 : arg8 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp8);
34943 14 : {
34944 : /* %typemap(in) char **dict */
34945 14 : arg9 = NULL;
34946 14 : if ( PySequence_Check( swig_obj[5] ) ) {
34947 14 : int bErr = FALSE;
34948 14 : arg9 = CSLFromPySequence(swig_obj[5], &bErr);
34949 14 : if ( bErr )
34950 : {
34951 0 : SWIG_fail;
34952 : }
34953 : }
34954 0 : else if ( PyMapping_Check( swig_obj[5] ) ) {
34955 0 : int bErr = FALSE;
34956 0 : arg9 = CSLFromPyMapping(swig_obj[5], &bErr);
34957 0 : if ( bErr )
34958 : {
34959 0 : SWIG_fail;
34960 : }
34961 : }
34962 : else {
34963 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
34964 0 : SWIG_fail;
34965 : }
34966 : }
34967 14 : {
34968 14 : if (!arg8) {
34969 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
34970 : }
34971 : }
34972 14 : {
34973 14 : const int bLocalUseExceptions = GetUseExceptions();
34974 14 : if ( bLocalUseExceptions ) {
34975 4 : pushErrorHandler();
34976 : }
34977 14 : {
34978 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34979 14 : result = (CPLErr)GDALMDArrayHS_WriteStringArray(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
34980 14 : SWIG_PYTHON_THREAD_END_ALLOW;
34981 : }
34982 14 : if ( bLocalUseExceptions ) {
34983 4 : popErrorHandler();
34984 : }
34985 : #ifndef SED_HACKS
34986 : if ( bLocalUseExceptions ) {
34987 : CPLErr eclass = CPLGetLastErrorType();
34988 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
34989 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
34990 : }
34991 : }
34992 : #endif
34993 : }
34994 14 : resultobj = SWIG_From_int(static_cast< int >(result));
34995 14 : {
34996 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
34997 14 : free(arg3);
34998 : }
34999 14 : {
35000 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
35001 14 : free(arg5);
35002 : }
35003 14 : {
35004 : /* %typemap(freearg) (int nList, GIntBig* pList) */
35005 14 : free(arg7);
35006 : }
35007 14 : {
35008 : /* %typemap(freearg) char **dict */
35009 14 : CSLDestroy( arg9 );
35010 : }
35011 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35012 : return resultobj;
35013 0 : fail:
35014 0 : {
35015 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
35016 0 : free(arg3);
35017 : }
35018 0 : {
35019 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
35020 0 : free(arg5);
35021 : }
35022 0 : {
35023 : /* %typemap(freearg) (int nList, GIntBig* pList) */
35024 0 : free(arg7);
35025 : }
35026 0 : {
35027 : /* %typemap(freearg) char **dict */
35028 0 : CSLDestroy( arg9 );
35029 : }
35030 : return NULL;
35031 : }
35032 :
35033 :
35034 613 : SWIGINTERN PyObject *_wrap_MDArray_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35035 613 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35036 613 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
35037 613 : int arg2 ;
35038 613 : GUIntBig *arg3 = (GUIntBig *) 0 ;
35039 613 : int arg4 ;
35040 613 : GUIntBig *arg5 = (GUIntBig *) 0 ;
35041 613 : int arg6 ;
35042 613 : GIntBig *arg7 = (GIntBig *) 0 ;
35043 613 : int arg8 ;
35044 613 : GIntBig *arg9 = (GIntBig *) 0 ;
35045 613 : GDALExtendedDataTypeHS *arg10 = (GDALExtendedDataTypeHS *) 0 ;
35046 613 : GIntBig arg11 ;
35047 613 : char *arg12 = (char *) 0 ;
35048 613 : void *argp1 = 0 ;
35049 613 : int res1 = 0 ;
35050 613 : void *argp10 = 0 ;
35051 613 : int res10 = 0 ;
35052 613 : int alloc11 = 0 ;
35053 613 : bool viewIsValid11 = false ;
35054 613 : Py_buffer view11 ;
35055 613 : PyObject *swig_obj[7] ;
35056 613 : CPLErr result;
35057 :
35058 613 : if (!SWIG_Python_UnpackTuple(args, "MDArray_Write", 7, 7, swig_obj)) SWIG_fail;
35059 613 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
35060 613 : if (!SWIG_IsOK(res1)) {
35061 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_Write" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
35062 : }
35063 613 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
35064 613 : {
35065 : /* %typemap(in,numinputs=1) (int nList, GUIntBig* pList)*/
35066 613 : arg3 = CreateCGUIntBigListFromSequence(swig_obj[1], &arg2);
35067 613 : if( arg2 < 0 ) {
35068 0 : SWIG_fail;
35069 : }
35070 : }
35071 613 : {
35072 : /* %typemap(in,numinputs=1) (int nList, GUIntBig* pList)*/
35073 613 : arg5 = CreateCGUIntBigListFromSequence(swig_obj[2], &arg4);
35074 613 : if( arg4 < 0 ) {
35075 0 : SWIG_fail;
35076 : }
35077 : }
35078 613 : {
35079 : /* %typemap(in,numinputs=1) (int nList, GIntBig* pList)*/
35080 613 : arg7 = CreateCGIntBigListFromSequence(swig_obj[3], &arg6);
35081 613 : if( arg6 < 0 ) {
35082 0 : SWIG_fail;
35083 : }
35084 : }
35085 613 : {
35086 : /* %typemap(in,numinputs=1) (int nList, GIntBig* pList)*/
35087 613 : arg9 = CreateCGIntBigListFromSequence(swig_obj[4], &arg8);
35088 613 : if( arg8 < 0 ) {
35089 0 : SWIG_fail;
35090 : }
35091 : }
35092 613 : res10 = SWIG_ConvertPtr(swig_obj[5], &argp10,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
35093 613 : if (!SWIG_IsOK(res10)) {
35094 0 : SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "MDArray_Write" "', argument " "10"" of type '" "GDALExtendedDataTypeHS *""'");
35095 : }
35096 613 : arg10 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp10);
35097 613 : {
35098 : /* %typemap(in,numinputs=1) (GIntBig nLen, char *pBuf ) */
35099 613 : char* ptr = NULL;
35100 613 : if( !GetBufferAsCharPtrGIntBigSize(swig_obj[6], &arg11, &ptr, &alloc11, &viewIsValid11, &view11) ) {
35101 0 : SWIG_fail;
35102 : }
35103 613 : arg12 = (char *)ptr;
35104 : }
35105 613 : {
35106 613 : if (!arg10) {
35107 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
35108 : }
35109 : }
35110 613 : {
35111 613 : const int bLocalUseExceptions = GetUseExceptions();
35112 613 : if ( bLocalUseExceptions ) {
35113 140 : pushErrorHandler();
35114 : }
35115 613 : {
35116 613 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35117 613 : result = (CPLErr)GDALMDArrayHS_Write(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
35118 613 : SWIG_PYTHON_THREAD_END_ALLOW;
35119 : }
35120 613 : if ( bLocalUseExceptions ) {
35121 140 : popErrorHandler();
35122 : }
35123 : #ifndef SED_HACKS
35124 : if ( bLocalUseExceptions ) {
35125 : CPLErr eclass = CPLGetLastErrorType();
35126 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35127 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35128 : }
35129 : }
35130 : #endif
35131 : }
35132 613 : resultobj = SWIG_From_int(static_cast< int >(result));
35133 613 : {
35134 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
35135 613 : free(arg3);
35136 : }
35137 613 : {
35138 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
35139 613 : free(arg5);
35140 : }
35141 613 : {
35142 : /* %typemap(freearg) (int nList, GIntBig* pList) */
35143 613 : free(arg7);
35144 : }
35145 613 : {
35146 : /* %typemap(freearg) (int nList, GIntBig* pList) */
35147 613 : free(arg9);
35148 : }
35149 613 : {
35150 : /* %typemap(freearg) (GIntBig *nLen, char *pBuf ) */
35151 613 : if( viewIsValid11 ) {
35152 612 : PyBuffer_Release(&view11);
35153 : }
35154 1 : else if( alloc11 == SWIG_NEWOBJ ) {
35155 1 : delete[] arg12;
35156 : }
35157 : }
35158 615 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35159 : return resultobj;
35160 0 : fail:
35161 0 : {
35162 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
35163 0 : free(arg3);
35164 : }
35165 0 : {
35166 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
35167 0 : free(arg5);
35168 : }
35169 0 : {
35170 : /* %typemap(freearg) (int nList, GIntBig* pList) */
35171 0 : free(arg7);
35172 : }
35173 0 : {
35174 : /* %typemap(freearg) (int nList, GIntBig* pList) */
35175 0 : free(arg9);
35176 : }
35177 0 : {
35178 : /* %typemap(freearg) (GIntBig *nLen, char *pBuf ) */
35179 0 : if( viewIsValid11 ) {
35180 0 : PyBuffer_Release(&view11);
35181 : }
35182 0 : else if( alloc11 == SWIG_NEWOBJ ) {
35183 0 : delete[] arg12;
35184 : }
35185 : }
35186 : return NULL;
35187 : }
35188 :
35189 :
35190 22 : SWIGINTERN PyObject *_wrap_MDArray_AdviseRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35191 22 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35192 22 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
35193 22 : int arg2 ;
35194 22 : GUIntBig *arg3 = (GUIntBig *) 0 ;
35195 22 : int arg4 ;
35196 22 : GUIntBig *arg5 = (GUIntBig *) 0 ;
35197 22 : char **arg6 = (char **) 0 ;
35198 22 : void *argp1 = 0 ;
35199 22 : int res1 = 0 ;
35200 22 : PyObject *swig_obj[4] ;
35201 22 : CPLErr result;
35202 :
35203 22 : if (!SWIG_Python_UnpackTuple(args, "MDArray_AdviseRead", 3, 4, swig_obj)) SWIG_fail;
35204 22 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
35205 22 : if (!SWIG_IsOK(res1)) {
35206 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_AdviseRead" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
35207 : }
35208 22 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
35209 22 : {
35210 : /* %typemap(in,numinputs=1) (int nList, GUIntBig* pList)*/
35211 22 : arg3 = CreateCGUIntBigListFromSequence(swig_obj[1], &arg2);
35212 22 : if( arg2 < 0 ) {
35213 0 : SWIG_fail;
35214 : }
35215 : }
35216 22 : {
35217 : /* %typemap(in,numinputs=1) (int nList, GUIntBig* pList)*/
35218 22 : arg5 = CreateCGUIntBigListFromSequence(swig_obj[2], &arg4);
35219 22 : if( arg4 < 0 ) {
35220 0 : SWIG_fail;
35221 : }
35222 : }
35223 22 : if (swig_obj[3]) {
35224 22 : {
35225 : /* %typemap(in) char **dict */
35226 22 : arg6 = NULL;
35227 22 : if ( PySequence_Check( swig_obj[3] ) ) {
35228 22 : int bErr = FALSE;
35229 22 : arg6 = CSLFromPySequence(swig_obj[3], &bErr);
35230 22 : if ( bErr )
35231 : {
35232 0 : SWIG_fail;
35233 : }
35234 : }
35235 0 : else if ( PyMapping_Check( swig_obj[3] ) ) {
35236 0 : int bErr = FALSE;
35237 0 : arg6 = CSLFromPyMapping(swig_obj[3], &bErr);
35238 0 : if ( bErr )
35239 : {
35240 0 : SWIG_fail;
35241 : }
35242 : }
35243 : else {
35244 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
35245 0 : SWIG_fail;
35246 : }
35247 : }
35248 : }
35249 22 : {
35250 22 : const int bLocalUseExceptions = GetUseExceptions();
35251 22 : if ( bLocalUseExceptions ) {
35252 0 : pushErrorHandler();
35253 : }
35254 22 : {
35255 22 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35256 22 : result = (CPLErr)GDALMDArrayHS_AdviseRead(arg1,arg2,arg3,arg4,arg5,arg6);
35257 22 : SWIG_PYTHON_THREAD_END_ALLOW;
35258 : }
35259 22 : if ( bLocalUseExceptions ) {
35260 0 : popErrorHandler();
35261 : }
35262 : #ifndef SED_HACKS
35263 : if ( bLocalUseExceptions ) {
35264 : CPLErr eclass = CPLGetLastErrorType();
35265 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35266 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35267 : }
35268 : }
35269 : #endif
35270 : }
35271 22 : resultobj = SWIG_From_int(static_cast< int >(result));
35272 22 : {
35273 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
35274 22 : free(arg3);
35275 : }
35276 22 : {
35277 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
35278 22 : free(arg5);
35279 : }
35280 22 : {
35281 : /* %typemap(freearg) char **dict */
35282 22 : CSLDestroy( arg6 );
35283 : }
35284 22 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35285 : return resultobj;
35286 0 : fail:
35287 0 : {
35288 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
35289 0 : free(arg3);
35290 : }
35291 0 : {
35292 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
35293 0 : free(arg5);
35294 : }
35295 0 : {
35296 : /* %typemap(freearg) char **dict */
35297 0 : CSLDestroy( arg6 );
35298 : }
35299 : return NULL;
35300 : }
35301 :
35302 :
35303 120 : SWIGINTERN PyObject *_wrap_MDArray_GetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35304 120 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35305 120 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
35306 120 : char *arg2 = (char *) 0 ;
35307 120 : void *argp1 = 0 ;
35308 120 : int res1 = 0 ;
35309 120 : int res2 ;
35310 120 : char *buf2 = 0 ;
35311 120 : int alloc2 = 0 ;
35312 120 : PyObject *swig_obj[2] ;
35313 120 : GDALAttributeHS *result = 0 ;
35314 :
35315 120 : if (!SWIG_Python_UnpackTuple(args, "MDArray_GetAttribute", 2, 2, swig_obj)) SWIG_fail;
35316 120 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
35317 120 : if (!SWIG_IsOK(res1)) {
35318 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetAttribute" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
35319 : }
35320 120 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
35321 120 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
35322 120 : if (!SWIG_IsOK(res2)) {
35323 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MDArray_GetAttribute" "', argument " "2"" of type '" "char const *""'");
35324 : }
35325 120 : arg2 = reinterpret_cast< char * >(buf2);
35326 120 : {
35327 120 : if (!arg2) {
35328 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
35329 : }
35330 : }
35331 120 : {
35332 120 : const int bLocalUseExceptions = GetUseExceptions();
35333 120 : if ( bLocalUseExceptions ) {
35334 59 : pushErrorHandler();
35335 : }
35336 120 : {
35337 120 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35338 120 : result = (GDALAttributeHS *)GDALMDArrayHS_GetAttribute(arg1,(char const *)arg2);
35339 120 : SWIG_PYTHON_THREAD_END_ALLOW;
35340 : }
35341 120 : if ( bLocalUseExceptions ) {
35342 59 : popErrorHandler();
35343 : }
35344 : #ifndef SED_HACKS
35345 : if ( bLocalUseExceptions ) {
35346 : CPLErr eclass = CPLGetLastErrorType();
35347 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35348 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35349 : }
35350 : }
35351 : #endif
35352 : }
35353 120 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALAttributeHS, SWIG_POINTER_OWN | 0 );
35354 120 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
35355 130 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35356 : return resultobj;
35357 0 : fail:
35358 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
35359 : return NULL;
35360 : }
35361 :
35362 :
35363 59 : SWIGINTERN PyObject *_wrap_MDArray_GetAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35364 59 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35365 59 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
35366 59 : GDALAttributeHS ***arg2 = (GDALAttributeHS ***) 0 ;
35367 59 : size_t *arg3 = (size_t *) 0 ;
35368 59 : char **arg4 = (char **) 0 ;
35369 59 : void *argp1 = 0 ;
35370 59 : int res1 = 0 ;
35371 59 : GDALAttributeHS **attrs2 = 0 ;
35372 59 : size_t nCount2 = 0 ;
35373 59 : PyObject *swig_obj[2] ;
35374 :
35375 59 : {
35376 : /* %typemap(in,numinputs=0) (GDALAttributeHS*** pattrs, size_t* pnCount) */
35377 59 : arg2 = &attrs2;
35378 59 : arg3 = &nCount2;
35379 : }
35380 59 : if (!SWIG_Python_UnpackTuple(args, "MDArray_GetAttributes", 1, 2, swig_obj)) SWIG_fail;
35381 59 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
35382 59 : if (!SWIG_IsOK(res1)) {
35383 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetAttributes" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
35384 : }
35385 59 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
35386 59 : if (swig_obj[1]) {
35387 0 : {
35388 : /* %typemap(in) char **dict */
35389 0 : arg4 = NULL;
35390 0 : if ( PySequence_Check( swig_obj[1] ) ) {
35391 0 : int bErr = FALSE;
35392 0 : arg4 = CSLFromPySequence(swig_obj[1], &bErr);
35393 0 : if ( bErr )
35394 : {
35395 0 : SWIG_fail;
35396 : }
35397 : }
35398 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
35399 0 : int bErr = FALSE;
35400 0 : arg4 = CSLFromPyMapping(swig_obj[1], &bErr);
35401 0 : if ( bErr )
35402 : {
35403 0 : SWIG_fail;
35404 : }
35405 : }
35406 : else {
35407 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
35408 0 : SWIG_fail;
35409 : }
35410 : }
35411 : }
35412 59 : {
35413 59 : const int bLocalUseExceptions = GetUseExceptions();
35414 59 : if ( bLocalUseExceptions ) {
35415 42 : pushErrorHandler();
35416 : }
35417 59 : {
35418 59 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35419 59 : GDALMDArrayHS_GetAttributes(arg1,arg2,arg3,arg4);
35420 59 : SWIG_PYTHON_THREAD_END_ALLOW;
35421 : }
35422 59 : if ( bLocalUseExceptions ) {
35423 42 : popErrorHandler();
35424 : }
35425 : #ifndef SED_HACKS
35426 : if ( bLocalUseExceptions ) {
35427 : CPLErr eclass = CPLGetLastErrorType();
35428 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35429 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35430 : }
35431 : }
35432 : #endif
35433 : }
35434 59 : resultobj = SWIG_Py_Void();
35435 59 : {
35436 : /* %typemap(argout) (GDALAttributeHS*** pattrs, size_t* pnCount) */
35437 59 : Py_DECREF(resultobj);
35438 59 : resultobj = PyList_New( *arg3 );
35439 59 : if( !resultobj ) {
35440 0 : SWIG_fail;
35441 : }
35442 189 : for( size_t i = 0; i < *arg3; i++ ) {
35443 130 : PyList_SetItem(resultobj, i,
35444 130 : SWIG_NewPointerObj((void*)(*arg2)[i],SWIGTYPE_p_GDALAttributeHS,SWIG_POINTER_OWN) );
35445 : /* We have borrowed the GDALAttributeHS */
35446 130 : (*arg2)[i] = NULL;
35447 : }
35448 : }
35449 59 : {
35450 : /* %typemap(freearg) (GDALAttributeHS*** pattrs, size_t* pnCount) */
35451 59 : GDALReleaseAttributes(*arg2, *arg3);
35452 : }
35453 59 : {
35454 : /* %typemap(freearg) char **dict */
35455 59 : CSLDestroy( arg4 );
35456 : }
35457 75 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35458 : return resultobj;
35459 0 : fail:
35460 0 : {
35461 : /* %typemap(freearg) (GDALAttributeHS*** pattrs, size_t* pnCount) */
35462 0 : GDALReleaseAttributes(*arg2, *arg3);
35463 : }
35464 0 : {
35465 : /* %typemap(freearg) char **dict */
35466 0 : CSLDestroy( arg4 );
35467 : }
35468 : return NULL;
35469 : }
35470 :
35471 :
35472 189 : SWIGINTERN PyObject *_wrap_MDArray_CreateAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35473 189 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35474 189 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
35475 189 : char *arg2 = (char *) 0 ;
35476 189 : int arg3 ;
35477 189 : GUIntBig *arg4 = (GUIntBig *) 0 ;
35478 189 : GDALExtendedDataTypeHS *arg5 = (GDALExtendedDataTypeHS *) 0 ;
35479 189 : char **arg6 = (char **) 0 ;
35480 189 : void *argp1 = 0 ;
35481 189 : int res1 = 0 ;
35482 189 : int res2 ;
35483 189 : char *buf2 = 0 ;
35484 189 : int alloc2 = 0 ;
35485 189 : void *argp5 = 0 ;
35486 189 : int res5 = 0 ;
35487 189 : PyObject *swig_obj[5] ;
35488 189 : GDALAttributeHS *result = 0 ;
35489 :
35490 189 : if (!SWIG_Python_UnpackTuple(args, "MDArray_CreateAttribute", 4, 5, swig_obj)) SWIG_fail;
35491 189 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
35492 189 : if (!SWIG_IsOK(res1)) {
35493 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_CreateAttribute" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
35494 : }
35495 189 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
35496 189 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
35497 189 : if (!SWIG_IsOK(res2)) {
35498 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MDArray_CreateAttribute" "', argument " "2"" of type '" "char const *""'");
35499 : }
35500 189 : arg2 = reinterpret_cast< char * >(buf2);
35501 189 : {
35502 : /* %typemap(in,numinputs=1) (int nList, GUIntBig* pList)*/
35503 189 : arg4 = CreateCGUIntBigListFromSequence(swig_obj[2], &arg3);
35504 189 : if( arg3 < 0 ) {
35505 0 : SWIG_fail;
35506 : }
35507 : }
35508 189 : res5 = SWIG_ConvertPtr(swig_obj[3], &argp5,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
35509 189 : if (!SWIG_IsOK(res5)) {
35510 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MDArray_CreateAttribute" "', argument " "5"" of type '" "GDALExtendedDataTypeHS *""'");
35511 : }
35512 189 : arg5 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp5);
35513 189 : if (swig_obj[4]) {
35514 0 : {
35515 : /* %typemap(in) char **dict */
35516 0 : arg6 = NULL;
35517 0 : if ( PySequence_Check( swig_obj[4] ) ) {
35518 0 : int bErr = FALSE;
35519 0 : arg6 = CSLFromPySequence(swig_obj[4], &bErr);
35520 0 : if ( bErr )
35521 : {
35522 0 : SWIG_fail;
35523 : }
35524 : }
35525 0 : else if ( PyMapping_Check( swig_obj[4] ) ) {
35526 0 : int bErr = FALSE;
35527 0 : arg6 = CSLFromPyMapping(swig_obj[4], &bErr);
35528 0 : if ( bErr )
35529 : {
35530 0 : SWIG_fail;
35531 : }
35532 : }
35533 : else {
35534 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
35535 0 : SWIG_fail;
35536 : }
35537 : }
35538 : }
35539 189 : {
35540 189 : if (!arg2) {
35541 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
35542 : }
35543 : }
35544 188 : {
35545 188 : if (!arg5) {
35546 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
35547 : }
35548 : }
35549 188 : {
35550 188 : const int bLocalUseExceptions = GetUseExceptions();
35551 188 : if ( bLocalUseExceptions ) {
35552 144 : pushErrorHandler();
35553 : }
35554 188 : {
35555 188 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35556 188 : result = (GDALAttributeHS *)GDALMDArrayHS_CreateAttribute(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
35557 188 : SWIG_PYTHON_THREAD_END_ALLOW;
35558 : }
35559 188 : if ( bLocalUseExceptions ) {
35560 144 : popErrorHandler();
35561 : }
35562 : #ifndef SED_HACKS
35563 : if ( bLocalUseExceptions ) {
35564 : CPLErr eclass = CPLGetLastErrorType();
35565 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35566 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35567 : }
35568 : }
35569 : #endif
35570 : }
35571 188 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALAttributeHS, SWIG_POINTER_OWN | 0 );
35572 188 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
35573 188 : {
35574 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
35575 188 : free(arg4);
35576 : }
35577 188 : {
35578 : /* %typemap(freearg) char **dict */
35579 188 : CSLDestroy( arg6 );
35580 : }
35581 191 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35582 : return resultobj;
35583 1 : fail:
35584 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
35585 1 : {
35586 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
35587 1 : free(arg4);
35588 : }
35589 1 : {
35590 : /* %typemap(freearg) char **dict */
35591 1 : CSLDestroy( arg6 );
35592 : }
35593 : return NULL;
35594 : }
35595 :
35596 :
35597 24 : SWIGINTERN PyObject *_wrap_MDArray_DeleteAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35598 24 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35599 24 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
35600 24 : char *arg2 = (char *) 0 ;
35601 24 : char **arg3 = (char **) 0 ;
35602 24 : void *argp1 = 0 ;
35603 24 : int res1 = 0 ;
35604 24 : int res2 ;
35605 24 : char *buf2 = 0 ;
35606 24 : int alloc2 = 0 ;
35607 24 : PyObject *swig_obj[3] ;
35608 24 : CPLErr result;
35609 :
35610 24 : if (!SWIG_Python_UnpackTuple(args, "MDArray_DeleteAttribute", 2, 3, swig_obj)) SWIG_fail;
35611 24 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
35612 24 : if (!SWIG_IsOK(res1)) {
35613 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_DeleteAttribute" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
35614 : }
35615 24 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
35616 24 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
35617 24 : if (!SWIG_IsOK(res2)) {
35618 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MDArray_DeleteAttribute" "', argument " "2"" of type '" "char const *""'");
35619 : }
35620 24 : arg2 = reinterpret_cast< char * >(buf2);
35621 24 : if (swig_obj[2]) {
35622 0 : {
35623 : /* %typemap(in) char **dict */
35624 0 : arg3 = NULL;
35625 0 : if ( PySequence_Check( swig_obj[2] ) ) {
35626 0 : int bErr = FALSE;
35627 0 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
35628 0 : if ( bErr )
35629 : {
35630 0 : SWIG_fail;
35631 : }
35632 : }
35633 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
35634 0 : int bErr = FALSE;
35635 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
35636 0 : if ( bErr )
35637 : {
35638 0 : SWIG_fail;
35639 : }
35640 : }
35641 : else {
35642 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
35643 0 : SWIG_fail;
35644 : }
35645 : }
35646 : }
35647 24 : {
35648 24 : if (!arg2) {
35649 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
35650 : }
35651 : }
35652 24 : {
35653 24 : const int bLocalUseExceptions = GetUseExceptions();
35654 24 : if ( bLocalUseExceptions ) {
35655 24 : pushErrorHandler();
35656 : }
35657 24 : {
35658 24 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35659 24 : result = (CPLErr)GDALMDArrayHS_DeleteAttribute(arg1,(char const *)arg2,arg3);
35660 24 : SWIG_PYTHON_THREAD_END_ALLOW;
35661 : }
35662 24 : if ( bLocalUseExceptions ) {
35663 24 : popErrorHandler();
35664 : }
35665 : #ifndef SED_HACKS
35666 : if ( bLocalUseExceptions ) {
35667 : CPLErr eclass = CPLGetLastErrorType();
35668 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35669 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35670 : }
35671 : }
35672 : #endif
35673 : }
35674 24 : resultobj = SWIG_From_int(static_cast< int >(result));
35675 24 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
35676 24 : {
35677 : /* %typemap(freearg) char **dict */
35678 24 : CSLDestroy( arg3 );
35679 : }
35680 52 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35681 : return resultobj;
35682 0 : fail:
35683 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
35684 0 : {
35685 : /* %typemap(freearg) char **dict */
35686 0 : CSLDestroy( arg3 );
35687 : }
35688 : return NULL;
35689 : }
35690 :
35691 :
35692 73 : SWIGINTERN PyObject *_wrap_MDArray_GetNoDataValueAsRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35693 73 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35694 73 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
35695 73 : void **arg2 = (void **) 0 ;
35696 73 : void *argp1 = 0 ;
35697 73 : int res1 = 0 ;
35698 73 : void *pyObject2 = NULL ;
35699 73 : PyObject *swig_obj[1] ;
35700 73 : CPLErr result;
35701 :
35702 73 : {
35703 : /* %typemap(in,numinputs=0) ( void **outPythonObject ) ( void *pyObject2 = NULL ) */
35704 73 : arg2 = &pyObject2;
35705 : }
35706 73 : if (!args) SWIG_fail;
35707 73 : swig_obj[0] = args;
35708 73 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
35709 73 : if (!SWIG_IsOK(res1)) {
35710 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetNoDataValueAsRaw" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
35711 : }
35712 73 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
35713 73 : {
35714 73 : const int bLocalUseExceptions = GetUseExceptions();
35715 73 : if ( bLocalUseExceptions ) {
35716 20 : pushErrorHandler();
35717 : }
35718 73 : {
35719 73 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35720 73 : result = (CPLErr)GDALMDArrayHS_GetNoDataValueAsRaw(arg1,arg2);
35721 73 : SWIG_PYTHON_THREAD_END_ALLOW;
35722 : }
35723 73 : if ( bLocalUseExceptions ) {
35724 20 : popErrorHandler();
35725 : }
35726 : #ifndef SED_HACKS
35727 : if ( bLocalUseExceptions ) {
35728 : CPLErr eclass = CPLGetLastErrorType();
35729 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35730 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35731 : }
35732 : }
35733 : #endif
35734 : }
35735 73 : resultobj = SWIG_From_int(static_cast< int >(result));
35736 73 : {
35737 : /* %typemap(argout) ( void **outPythonObject ) */
35738 73 : Py_XDECREF(resultobj);
35739 73 : if (*arg2)
35740 : {
35741 : resultobj = (PyObject*)*arg2;
35742 : }
35743 : else
35744 : {
35745 37 : resultobj = Py_None;
35746 37 : Py_INCREF(resultobj);
35747 : }
35748 : }
35749 73 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35750 : return resultobj;
35751 : fail:
35752 : return NULL;
35753 : }
35754 :
35755 :
35756 121 : SWIGINTERN PyObject *_wrap_MDArray_GetNoDataValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35757 121 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35758 121 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
35759 121 : double *arg2 = (double *) 0 ;
35760 121 : int *arg3 = (int *) 0 ;
35761 121 : void *argp1 = 0 ;
35762 121 : int res1 = 0 ;
35763 121 : double tmpval2 ;
35764 121 : int tmphasval2 ;
35765 121 : PyObject *swig_obj[1] ;
35766 :
35767 121 : {
35768 : /* %typemap(python,in,numinputs=0) (double *val, int *hasval) */
35769 121 : arg2 = &tmpval2;
35770 121 : arg3 = &tmphasval2;
35771 : }
35772 121 : if (!args) SWIG_fail;
35773 121 : swig_obj[0] = args;
35774 121 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
35775 121 : if (!SWIG_IsOK(res1)) {
35776 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetNoDataValueAsDouble" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
35777 : }
35778 121 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
35779 121 : {
35780 121 : const int bLocalUseExceptions = GetUseExceptions();
35781 121 : if ( bLocalUseExceptions ) {
35782 8 : pushErrorHandler();
35783 : }
35784 121 : {
35785 121 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35786 121 : GDALMDArrayHS_GetNoDataValueAsDouble(arg1,arg2,arg3);
35787 121 : SWIG_PYTHON_THREAD_END_ALLOW;
35788 : }
35789 121 : if ( bLocalUseExceptions ) {
35790 8 : popErrorHandler();
35791 : }
35792 : #ifndef SED_HACKS
35793 : if ( bLocalUseExceptions ) {
35794 : CPLErr eclass = CPLGetLastErrorType();
35795 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35796 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35797 : }
35798 : }
35799 : #endif
35800 : }
35801 121 : resultobj = SWIG_Py_Void();
35802 121 : {
35803 : /* %typemap(python,argout) (double *val, int *hasval) */
35804 121 : PyObject *r;
35805 121 : if ( !*arg3 ) {
35806 48 : Py_INCREF(Py_None);
35807 48 : r = Py_None;
35808 : }
35809 : else {
35810 73 : r = PyFloat_FromDouble( *arg2 );
35811 : }
35812 : #if SWIG_VERSION >= 0x040300
35813 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
35814 : #else
35815 121 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
35816 : #endif
35817 : }
35818 121 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35819 : return resultobj;
35820 : fail:
35821 : return NULL;
35822 : }
35823 :
35824 :
35825 11 : SWIGINTERN PyObject *_wrap_MDArray_GetNoDataValueAsInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35826 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35827 11 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
35828 11 : GIntBig *arg2 = (GIntBig *) 0 ;
35829 11 : int *arg3 = (int *) 0 ;
35830 11 : void *argp1 = 0 ;
35831 11 : int res1 = 0 ;
35832 11 : GIntBig tmpval2 ;
35833 11 : int tmphasval2 ;
35834 11 : PyObject *swig_obj[1] ;
35835 :
35836 11 : {
35837 : /* %typemap(python,in,numinputs=0) (GIntBig *val, int *hasval) */
35838 11 : arg2 = &tmpval2;
35839 11 : arg3 = &tmphasval2;
35840 : }
35841 11 : if (!args) SWIG_fail;
35842 11 : swig_obj[0] = args;
35843 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
35844 11 : if (!SWIG_IsOK(res1)) {
35845 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetNoDataValueAsInt64" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
35846 : }
35847 11 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
35848 11 : {
35849 11 : const int bLocalUseExceptions = GetUseExceptions();
35850 11 : if ( bLocalUseExceptions ) {
35851 0 : pushErrorHandler();
35852 : }
35853 11 : {
35854 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35855 11 : GDALMDArrayHS_GetNoDataValueAsInt64(arg1,arg2,arg3);
35856 11 : SWIG_PYTHON_THREAD_END_ALLOW;
35857 : }
35858 11 : if ( bLocalUseExceptions ) {
35859 0 : popErrorHandler();
35860 : }
35861 : #ifndef SED_HACKS
35862 : if ( bLocalUseExceptions ) {
35863 : CPLErr eclass = CPLGetLastErrorType();
35864 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35865 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35866 : }
35867 : }
35868 : #endif
35869 : }
35870 11 : resultobj = SWIG_Py_Void();
35871 11 : {
35872 : /* %typemap(python,argout) (GIntBig *val, int *hasval) */
35873 11 : PyObject *r;
35874 11 : if ( !*arg3 ) {
35875 4 : Py_INCREF(Py_None);
35876 4 : r = Py_None;
35877 : }
35878 : else {
35879 7 : r = PyLong_FromLongLong( *arg2 );
35880 : }
35881 : #if SWIG_VERSION >= 0x040300
35882 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
35883 : #else
35884 11 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
35885 : #endif
35886 : }
35887 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35888 : return resultobj;
35889 : fail:
35890 : return NULL;
35891 : }
35892 :
35893 :
35894 7 : SWIGINTERN PyObject *_wrap_MDArray_GetNoDataValueAsUInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35895 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35896 7 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
35897 7 : GUIntBig *arg2 = (GUIntBig *) 0 ;
35898 7 : int *arg3 = (int *) 0 ;
35899 7 : void *argp1 = 0 ;
35900 7 : int res1 = 0 ;
35901 7 : GUIntBig tmpval2 ;
35902 7 : int tmphasval2 ;
35903 7 : PyObject *swig_obj[1] ;
35904 :
35905 7 : {
35906 : /* %typemap(python,in,numinputs=0) (GUIntBig *val, int *hasval) */
35907 7 : arg2 = &tmpval2;
35908 7 : arg3 = &tmphasval2;
35909 : }
35910 7 : if (!args) SWIG_fail;
35911 7 : swig_obj[0] = args;
35912 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
35913 7 : if (!SWIG_IsOK(res1)) {
35914 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetNoDataValueAsUInt64" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
35915 : }
35916 7 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
35917 7 : {
35918 7 : const int bLocalUseExceptions = GetUseExceptions();
35919 7 : if ( bLocalUseExceptions ) {
35920 0 : pushErrorHandler();
35921 : }
35922 7 : {
35923 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35924 7 : GDALMDArrayHS_GetNoDataValueAsUInt64(arg1,arg2,arg3);
35925 7 : SWIG_PYTHON_THREAD_END_ALLOW;
35926 : }
35927 7 : if ( bLocalUseExceptions ) {
35928 0 : popErrorHandler();
35929 : }
35930 : #ifndef SED_HACKS
35931 : if ( bLocalUseExceptions ) {
35932 : CPLErr eclass = CPLGetLastErrorType();
35933 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35934 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35935 : }
35936 : }
35937 : #endif
35938 : }
35939 7 : resultobj = SWIG_Py_Void();
35940 7 : {
35941 : /* %typemap(python,argout) (GUIntBig *val, int *hasval) */
35942 7 : PyObject *r;
35943 7 : if ( !*arg3 ) {
35944 2 : Py_INCREF(Py_None);
35945 2 : r = Py_None;
35946 : }
35947 : else {
35948 5 : r = PyLong_FromUnsignedLongLong( *arg2 );
35949 : }
35950 : #if SWIG_VERSION >= 0x040300
35951 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
35952 : #else
35953 7 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
35954 : #endif
35955 : }
35956 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
35957 : return resultobj;
35958 : fail:
35959 : return NULL;
35960 : }
35961 :
35962 :
35963 5 : SWIGINTERN PyObject *_wrap_MDArray_GetNoDataValueAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35964 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
35965 5 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
35966 5 : void *argp1 = 0 ;
35967 5 : int res1 = 0 ;
35968 5 : PyObject *swig_obj[1] ;
35969 5 : retStringAndCPLFree *result = 0 ;
35970 :
35971 5 : if (!args) SWIG_fail;
35972 5 : swig_obj[0] = args;
35973 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
35974 5 : if (!SWIG_IsOK(res1)) {
35975 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetNoDataValueAsString" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
35976 : }
35977 5 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
35978 5 : {
35979 5 : const int bLocalUseExceptions = GetUseExceptions();
35980 5 : if ( bLocalUseExceptions ) {
35981 0 : pushErrorHandler();
35982 : }
35983 5 : {
35984 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35985 5 : result = (retStringAndCPLFree *)GDALMDArrayHS_GetNoDataValueAsString(arg1);
35986 5 : SWIG_PYTHON_THREAD_END_ALLOW;
35987 : }
35988 5 : if ( bLocalUseExceptions ) {
35989 0 : popErrorHandler();
35990 : }
35991 : #ifndef SED_HACKS
35992 : if ( bLocalUseExceptions ) {
35993 : CPLErr eclass = CPLGetLastErrorType();
35994 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
35995 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
35996 : }
35997 : }
35998 : #endif
35999 : }
36000 5 : {
36001 : /* %typemap(out) (retStringAndCPLFree*) */
36002 5 : Py_XDECREF(resultobj);
36003 5 : if(result)
36004 : {
36005 2 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
36006 2 : CPLFree(result);
36007 : }
36008 : else
36009 : {
36010 3 : resultobj = Py_None;
36011 3 : Py_INCREF(resultobj);
36012 : }
36013 : }
36014 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36015 : return resultobj;
36016 : fail:
36017 : return NULL;
36018 : }
36019 :
36020 :
36021 55 : SWIGINTERN PyObject *_wrap_MDArray_SetNoDataValueDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36022 55 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36023 55 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36024 55 : double arg2 ;
36025 55 : void *argp1 = 0 ;
36026 55 : int res1 = 0 ;
36027 55 : double val2 ;
36028 55 : int ecode2 = 0 ;
36029 55 : PyObject *swig_obj[2] ;
36030 55 : CPLErr result;
36031 :
36032 55 : if (!SWIG_Python_UnpackTuple(args, "MDArray_SetNoDataValueDouble", 2, 2, swig_obj)) SWIG_fail;
36033 55 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36034 55 : if (!SWIG_IsOK(res1)) {
36035 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_SetNoDataValueDouble" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36036 : }
36037 55 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36038 55 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
36039 55 : if (!SWIG_IsOK(ecode2)) {
36040 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MDArray_SetNoDataValueDouble" "', argument " "2"" of type '" "double""'");
36041 : }
36042 55 : arg2 = static_cast< double >(val2);
36043 55 : {
36044 55 : const int bLocalUseExceptions = GetUseExceptions();
36045 55 : if ( bLocalUseExceptions ) {
36046 8 : pushErrorHandler();
36047 : }
36048 55 : {
36049 55 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36050 55 : result = (CPLErr)GDALMDArrayHS_SetNoDataValueDouble(arg1,arg2);
36051 55 : SWIG_PYTHON_THREAD_END_ALLOW;
36052 : }
36053 55 : if ( bLocalUseExceptions ) {
36054 8 : popErrorHandler();
36055 : }
36056 : #ifndef SED_HACKS
36057 : if ( bLocalUseExceptions ) {
36058 : CPLErr eclass = CPLGetLastErrorType();
36059 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36060 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36061 : }
36062 : }
36063 : #endif
36064 : }
36065 55 : resultobj = SWIG_From_int(static_cast< int >(result));
36066 57 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36067 : return resultobj;
36068 : fail:
36069 : return NULL;
36070 : }
36071 :
36072 :
36073 1 : SWIGINTERN PyObject *_wrap_MDArray_SetNoDataValueInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36074 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36075 1 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36076 1 : GIntBig arg2 ;
36077 1 : void *argp1 = 0 ;
36078 1 : int res1 = 0 ;
36079 1 : PyObject *swig_obj[2] ;
36080 1 : CPLErr result;
36081 :
36082 1 : if (!SWIG_Python_UnpackTuple(args, "MDArray_SetNoDataValueInt64", 2, 2, swig_obj)) SWIG_fail;
36083 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36084 1 : if (!SWIG_IsOK(res1)) {
36085 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_SetNoDataValueInt64" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36086 : }
36087 1 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36088 1 : {
36089 1 : arg2 = (GIntBig)PyLong_AsLongLong(swig_obj[1]);
36090 : }
36091 1 : {
36092 1 : const int bLocalUseExceptions = GetUseExceptions();
36093 1 : if ( bLocalUseExceptions ) {
36094 0 : pushErrorHandler();
36095 : }
36096 1 : {
36097 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36098 1 : result = (CPLErr)GDALMDArrayHS_SetNoDataValueInt64(arg1,arg2);
36099 1 : SWIG_PYTHON_THREAD_END_ALLOW;
36100 : }
36101 1 : if ( bLocalUseExceptions ) {
36102 0 : popErrorHandler();
36103 : }
36104 : #ifndef SED_HACKS
36105 : if ( bLocalUseExceptions ) {
36106 : CPLErr eclass = CPLGetLastErrorType();
36107 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36108 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36109 : }
36110 : }
36111 : #endif
36112 : }
36113 1 : resultobj = SWIG_From_int(static_cast< int >(result));
36114 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36115 : return resultobj;
36116 : fail:
36117 : return NULL;
36118 : }
36119 :
36120 :
36121 1 : SWIGINTERN PyObject *_wrap_MDArray_SetNoDataValueUInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36122 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36123 1 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36124 1 : GUIntBig arg2 ;
36125 1 : void *argp1 = 0 ;
36126 1 : int res1 = 0 ;
36127 1 : PyObject *swig_obj[2] ;
36128 1 : CPLErr result;
36129 :
36130 1 : if (!SWIG_Python_UnpackTuple(args, "MDArray_SetNoDataValueUInt64", 2, 2, swig_obj)) SWIG_fail;
36131 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36132 1 : if (!SWIG_IsOK(res1)) {
36133 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_SetNoDataValueUInt64" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36134 : }
36135 1 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36136 1 : {
36137 1 : arg2 = (GIntBig)PyLong_AsUnsignedLongLong(swig_obj[1]);
36138 : }
36139 1 : {
36140 1 : const int bLocalUseExceptions = GetUseExceptions();
36141 1 : if ( bLocalUseExceptions ) {
36142 0 : pushErrorHandler();
36143 : }
36144 1 : {
36145 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36146 1 : result = (CPLErr)GDALMDArrayHS_SetNoDataValueUInt64(arg1,arg2);
36147 1 : SWIG_PYTHON_THREAD_END_ALLOW;
36148 : }
36149 1 : if ( bLocalUseExceptions ) {
36150 0 : popErrorHandler();
36151 : }
36152 : #ifndef SED_HACKS
36153 : if ( bLocalUseExceptions ) {
36154 : CPLErr eclass = CPLGetLastErrorType();
36155 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36156 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36157 : }
36158 : }
36159 : #endif
36160 : }
36161 1 : resultobj = SWIG_From_int(static_cast< int >(result));
36162 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36163 : return resultobj;
36164 : fail:
36165 : return NULL;
36166 : }
36167 :
36168 :
36169 3 : SWIGINTERN PyObject *_wrap_MDArray_SetNoDataValueString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36170 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36171 3 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36172 3 : char *arg2 = (char *) 0 ;
36173 3 : void *argp1 = 0 ;
36174 3 : int res1 = 0 ;
36175 3 : int res2 ;
36176 3 : char *buf2 = 0 ;
36177 3 : int alloc2 = 0 ;
36178 3 : PyObject *swig_obj[2] ;
36179 3 : CPLErr result;
36180 :
36181 3 : if (!SWIG_Python_UnpackTuple(args, "MDArray_SetNoDataValueString", 2, 2, swig_obj)) SWIG_fail;
36182 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36183 3 : if (!SWIG_IsOK(res1)) {
36184 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_SetNoDataValueString" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36185 : }
36186 3 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36187 3 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
36188 3 : if (!SWIG_IsOK(res2)) {
36189 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MDArray_SetNoDataValueString" "', argument " "2"" of type '" "char const *""'");
36190 : }
36191 3 : arg2 = reinterpret_cast< char * >(buf2);
36192 3 : {
36193 3 : const int bLocalUseExceptions = GetUseExceptions();
36194 3 : if ( bLocalUseExceptions ) {
36195 0 : pushErrorHandler();
36196 : }
36197 3 : {
36198 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36199 3 : result = (CPLErr)GDALMDArrayHS_SetNoDataValueString(arg1,(char const *)arg2);
36200 3 : SWIG_PYTHON_THREAD_END_ALLOW;
36201 : }
36202 3 : if ( bLocalUseExceptions ) {
36203 0 : popErrorHandler();
36204 : }
36205 : #ifndef SED_HACKS
36206 : if ( bLocalUseExceptions ) {
36207 : CPLErr eclass = CPLGetLastErrorType();
36208 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36209 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36210 : }
36211 : }
36212 : #endif
36213 : }
36214 3 : resultobj = SWIG_From_int(static_cast< int >(result));
36215 3 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
36216 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36217 : return resultobj;
36218 0 : fail:
36219 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
36220 : return NULL;
36221 : }
36222 :
36223 :
36224 8 : SWIGINTERN PyObject *_wrap_MDArray_SetNoDataValueRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36225 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36226 8 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36227 8 : GIntBig arg2 ;
36228 8 : char *arg3 = (char *) 0 ;
36229 8 : void *argp1 = 0 ;
36230 8 : int res1 = 0 ;
36231 8 : int alloc2 = 0 ;
36232 8 : bool viewIsValid2 = false ;
36233 8 : Py_buffer view2 ;
36234 8 : PyObject *swig_obj[2] ;
36235 8 : CPLErr result;
36236 :
36237 8 : if (!SWIG_Python_UnpackTuple(args, "MDArray_SetNoDataValueRaw", 2, 2, swig_obj)) SWIG_fail;
36238 8 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36239 8 : if (!SWIG_IsOK(res1)) {
36240 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_SetNoDataValueRaw" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36241 : }
36242 8 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36243 8 : {
36244 : /* %typemap(in,numinputs=1) (GIntBig nLen, char *pBuf ) */
36245 8 : char* ptr = NULL;
36246 8 : if( !GetBufferAsCharPtrGIntBigSize(swig_obj[1], &arg2, &ptr, &alloc2, &viewIsValid2, &view2) ) {
36247 0 : SWIG_fail;
36248 : }
36249 8 : arg3 = (char *)ptr;
36250 : }
36251 8 : {
36252 8 : const int bLocalUseExceptions = GetUseExceptions();
36253 8 : if ( bLocalUseExceptions ) {
36254 1 : pushErrorHandler();
36255 : }
36256 8 : {
36257 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36258 8 : result = (CPLErr)GDALMDArrayHS_SetNoDataValueRaw(arg1,arg2,arg3);
36259 8 : SWIG_PYTHON_THREAD_END_ALLOW;
36260 : }
36261 8 : if ( bLocalUseExceptions ) {
36262 1 : popErrorHandler();
36263 : }
36264 : #ifndef SED_HACKS
36265 : if ( bLocalUseExceptions ) {
36266 : CPLErr eclass = CPLGetLastErrorType();
36267 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36268 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36269 : }
36270 : }
36271 : #endif
36272 : }
36273 8 : resultobj = SWIG_From_int(static_cast< int >(result));
36274 8 : {
36275 : /* %typemap(freearg) (GIntBig *nLen, char *pBuf ) */
36276 8 : if( viewIsValid2 ) {
36277 8 : PyBuffer_Release(&view2);
36278 : }
36279 0 : else if (ReturnSame(alloc2) == SWIG_NEWOBJ ) {
36280 0 : delete[] arg3;
36281 : }
36282 : }
36283 8 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36284 : return resultobj;
36285 0 : fail:
36286 0 : {
36287 : /* %typemap(freearg) (GIntBig *nLen, char *pBuf ) */
36288 0 : if( viewIsValid2 ) {
36289 0 : PyBuffer_Release(&view2);
36290 : }
36291 8 : else if (ReturnSame(alloc2) == SWIG_NEWOBJ ) {
36292 : delete[] arg3;
36293 : }
36294 : }
36295 : return NULL;
36296 : }
36297 :
36298 :
36299 4 : SWIGINTERN PyObject *_wrap_MDArray_DeleteNoDataValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36300 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36301 4 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36302 4 : void *argp1 = 0 ;
36303 4 : int res1 = 0 ;
36304 4 : PyObject *swig_obj[1] ;
36305 4 : CPLErr result;
36306 :
36307 4 : if (!args) SWIG_fail;
36308 4 : swig_obj[0] = args;
36309 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36310 4 : if (!SWIG_IsOK(res1)) {
36311 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_DeleteNoDataValue" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36312 : }
36313 4 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36314 4 : {
36315 4 : const int bLocalUseExceptions = GetUseExceptions();
36316 4 : if ( bLocalUseExceptions ) {
36317 0 : pushErrorHandler();
36318 : }
36319 4 : {
36320 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36321 4 : result = (CPLErr)GDALMDArrayHS_DeleteNoDataValue(arg1);
36322 4 : SWIG_PYTHON_THREAD_END_ALLOW;
36323 : }
36324 4 : if ( bLocalUseExceptions ) {
36325 0 : popErrorHandler();
36326 : }
36327 : #ifndef SED_HACKS
36328 : if ( bLocalUseExceptions ) {
36329 : CPLErr eclass = CPLGetLastErrorType();
36330 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36331 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36332 : }
36333 : }
36334 : #endif
36335 : }
36336 4 : resultobj = SWIG_From_int(static_cast< int >(result));
36337 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36338 : return resultobj;
36339 : fail:
36340 : return NULL;
36341 : }
36342 :
36343 :
36344 102 : SWIGINTERN PyObject *_wrap_MDArray_GetOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36345 102 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36346 102 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36347 102 : double *arg2 = (double *) 0 ;
36348 102 : int *arg3 = (int *) 0 ;
36349 102 : void *argp1 = 0 ;
36350 102 : int res1 = 0 ;
36351 102 : double tmpval2 ;
36352 102 : int tmphasval2 ;
36353 102 : PyObject *swig_obj[1] ;
36354 :
36355 102 : {
36356 : /* %typemap(python,in,numinputs=0) (double *val, int *hasval) */
36357 102 : arg2 = &tmpval2;
36358 102 : arg3 = &tmphasval2;
36359 : }
36360 102 : if (!args) SWIG_fail;
36361 102 : swig_obj[0] = args;
36362 102 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36363 102 : if (!SWIG_IsOK(res1)) {
36364 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetOffset" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36365 : }
36366 102 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36367 102 : {
36368 102 : const int bLocalUseExceptions = GetUseExceptions();
36369 102 : if ( bLocalUseExceptions ) {
36370 1 : pushErrorHandler();
36371 : }
36372 102 : {
36373 102 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36374 102 : GDALMDArrayHS_GetOffset(arg1,arg2,arg3);
36375 102 : SWIG_PYTHON_THREAD_END_ALLOW;
36376 : }
36377 102 : if ( bLocalUseExceptions ) {
36378 1 : popErrorHandler();
36379 : }
36380 : #ifndef SED_HACKS
36381 : if ( bLocalUseExceptions ) {
36382 : CPLErr eclass = CPLGetLastErrorType();
36383 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36384 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36385 : }
36386 : }
36387 : #endif
36388 : }
36389 102 : resultobj = SWIG_Py_Void();
36390 102 : {
36391 : /* %typemap(python,argout) (double *val, int *hasval) */
36392 102 : PyObject *r;
36393 102 : if ( !*arg3 ) {
36394 83 : Py_INCREF(Py_None);
36395 83 : r = Py_None;
36396 : }
36397 : else {
36398 19 : r = PyFloat_FromDouble( *arg2 );
36399 : }
36400 : #if SWIG_VERSION >= 0x040300
36401 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
36402 : #else
36403 102 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
36404 : #endif
36405 : }
36406 102 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36407 : return resultobj;
36408 : fail:
36409 : return NULL;
36410 : }
36411 :
36412 :
36413 5 : SWIGINTERN PyObject *_wrap_MDArray_GetOffsetStorageType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36414 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36415 5 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36416 5 : void *argp1 = 0 ;
36417 5 : int res1 = 0 ;
36418 5 : PyObject *swig_obj[1] ;
36419 5 : GDALDataType result;
36420 :
36421 5 : if (!args) SWIG_fail;
36422 5 : swig_obj[0] = args;
36423 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36424 5 : if (!SWIG_IsOK(res1)) {
36425 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetOffsetStorageType" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36426 : }
36427 5 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36428 5 : {
36429 5 : const int bLocalUseExceptions = GetUseExceptions();
36430 5 : if ( bLocalUseExceptions ) {
36431 0 : pushErrorHandler();
36432 : }
36433 5 : {
36434 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36435 5 : result = (GDALDataType)GDALMDArrayHS_GetOffsetStorageType(arg1);
36436 5 : SWIG_PYTHON_THREAD_END_ALLOW;
36437 : }
36438 5 : if ( bLocalUseExceptions ) {
36439 0 : popErrorHandler();
36440 : }
36441 : #ifndef SED_HACKS
36442 : if ( bLocalUseExceptions ) {
36443 : CPLErr eclass = CPLGetLastErrorType();
36444 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36445 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36446 : }
36447 : }
36448 : #endif
36449 : }
36450 5 : resultobj = SWIG_From_int(static_cast< int >(result));
36451 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36452 : return resultobj;
36453 : fail:
36454 : return NULL;
36455 : }
36456 :
36457 :
36458 105 : SWIGINTERN PyObject *_wrap_MDArray_GetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36459 105 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36460 105 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36461 105 : double *arg2 = (double *) 0 ;
36462 105 : int *arg3 = (int *) 0 ;
36463 105 : void *argp1 = 0 ;
36464 105 : int res1 = 0 ;
36465 105 : double tmpval2 ;
36466 105 : int tmphasval2 ;
36467 105 : PyObject *swig_obj[1] ;
36468 :
36469 105 : {
36470 : /* %typemap(python,in,numinputs=0) (double *val, int *hasval) */
36471 105 : arg2 = &tmpval2;
36472 105 : arg3 = &tmphasval2;
36473 : }
36474 105 : if (!args) SWIG_fail;
36475 105 : swig_obj[0] = args;
36476 105 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36477 105 : if (!SWIG_IsOK(res1)) {
36478 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetScale" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36479 : }
36480 105 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36481 105 : {
36482 105 : const int bLocalUseExceptions = GetUseExceptions();
36483 105 : if ( bLocalUseExceptions ) {
36484 1 : pushErrorHandler();
36485 : }
36486 105 : {
36487 105 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36488 105 : GDALMDArrayHS_GetScale(arg1,arg2,arg3);
36489 105 : SWIG_PYTHON_THREAD_END_ALLOW;
36490 : }
36491 105 : if ( bLocalUseExceptions ) {
36492 1 : popErrorHandler();
36493 : }
36494 : #ifndef SED_HACKS
36495 : if ( bLocalUseExceptions ) {
36496 : CPLErr eclass = CPLGetLastErrorType();
36497 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36498 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36499 : }
36500 : }
36501 : #endif
36502 : }
36503 105 : resultobj = SWIG_Py_Void();
36504 105 : {
36505 : /* %typemap(python,argout) (double *val, int *hasval) */
36506 105 : PyObject *r;
36507 105 : if ( !*arg3 ) {
36508 83 : Py_INCREF(Py_None);
36509 83 : r = Py_None;
36510 : }
36511 : else {
36512 22 : r = PyFloat_FromDouble( *arg2 );
36513 : }
36514 : #if SWIG_VERSION >= 0x040300
36515 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
36516 : #else
36517 105 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
36518 : #endif
36519 : }
36520 105 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36521 : return resultobj;
36522 : fail:
36523 : return NULL;
36524 : }
36525 :
36526 :
36527 5 : SWIGINTERN PyObject *_wrap_MDArray_GetScaleStorageType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36528 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36529 5 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36530 5 : void *argp1 = 0 ;
36531 5 : int res1 = 0 ;
36532 5 : PyObject *swig_obj[1] ;
36533 5 : GDALDataType result;
36534 :
36535 5 : if (!args) SWIG_fail;
36536 5 : swig_obj[0] = args;
36537 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36538 5 : if (!SWIG_IsOK(res1)) {
36539 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetScaleStorageType" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36540 : }
36541 5 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36542 5 : {
36543 5 : const int bLocalUseExceptions = GetUseExceptions();
36544 5 : if ( bLocalUseExceptions ) {
36545 0 : pushErrorHandler();
36546 : }
36547 5 : {
36548 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36549 5 : result = (GDALDataType)GDALMDArrayHS_GetScaleStorageType(arg1);
36550 5 : SWIG_PYTHON_THREAD_END_ALLOW;
36551 : }
36552 5 : if ( bLocalUseExceptions ) {
36553 0 : popErrorHandler();
36554 : }
36555 : #ifndef SED_HACKS
36556 : if ( bLocalUseExceptions ) {
36557 : CPLErr eclass = CPLGetLastErrorType();
36558 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36559 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36560 : }
36561 : }
36562 : #endif
36563 : }
36564 5 : resultobj = SWIG_From_int(static_cast< int >(result));
36565 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36566 : return resultobj;
36567 : fail:
36568 : return NULL;
36569 : }
36570 :
36571 :
36572 21 : SWIGINTERN PyObject *_wrap_MDArray_SetOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36573 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36574 21 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36575 21 : double arg2 ;
36576 21 : GDALDataType arg3 = (GDALDataType) GDT_Unknown ;
36577 21 : void *argp1 = 0 ;
36578 21 : int res1 = 0 ;
36579 21 : double val2 ;
36580 21 : int ecode2 = 0 ;
36581 21 : PyObject * obj0 = 0 ;
36582 21 : PyObject * obj1 = 0 ;
36583 21 : PyObject * obj2 = 0 ;
36584 21 : char * kwnames[] = {
36585 : (char *)"self", (char *)"val", (char *)"storageType", NULL
36586 : };
36587 21 : CPLErr result;
36588 :
36589 21 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:MDArray_SetOffset", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
36590 21 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36591 21 : if (!SWIG_IsOK(res1)) {
36592 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_SetOffset" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36593 : }
36594 21 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36595 21 : ecode2 = SWIG_AsVal_double(obj1, &val2);
36596 21 : if (!SWIG_IsOK(ecode2)) {
36597 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MDArray_SetOffset" "', argument " "2"" of type '" "double""'");
36598 : }
36599 21 : arg2 = static_cast< double >(val2);
36600 21 : if (obj2) {
36601 2 : {
36602 : // %typemap(in) GDALDataType
36603 2 : int val = 0;
36604 2 : int ecode = SWIG_AsVal_int(obj2, &val);
36605 2 : if (!SWIG_IsOK(ecode)) {
36606 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
36607 : }
36608 2 : if( val < GDT_Unknown || val >= GDT_TypeCount )
36609 : {
36610 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
36611 : }
36612 : arg3 = static_cast<GDALDataType>(val);
36613 : }
36614 : }
36615 21 : {
36616 21 : const int bLocalUseExceptions = GetUseExceptions();
36617 21 : if ( bLocalUseExceptions ) {
36618 2 : pushErrorHandler();
36619 : }
36620 21 : {
36621 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36622 21 : result = (CPLErr)GDALMDArrayHS_SetOffset(arg1,arg2,arg3);
36623 21 : SWIG_PYTHON_THREAD_END_ALLOW;
36624 : }
36625 21 : if ( bLocalUseExceptions ) {
36626 2 : popErrorHandler();
36627 : }
36628 : #ifndef SED_HACKS
36629 : if ( bLocalUseExceptions ) {
36630 : CPLErr eclass = CPLGetLastErrorType();
36631 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36632 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36633 : }
36634 : }
36635 : #endif
36636 : }
36637 21 : resultobj = SWIG_From_int(static_cast< int >(result));
36638 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36639 : return resultobj;
36640 : fail:
36641 : return NULL;
36642 : }
36643 :
36644 :
36645 21 : SWIGINTERN PyObject *_wrap_MDArray_SetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36646 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36647 21 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36648 21 : double arg2 ;
36649 21 : GDALDataType arg3 = (GDALDataType) GDT_Unknown ;
36650 21 : void *argp1 = 0 ;
36651 21 : int res1 = 0 ;
36652 21 : double val2 ;
36653 21 : int ecode2 = 0 ;
36654 21 : PyObject * obj0 = 0 ;
36655 21 : PyObject * obj1 = 0 ;
36656 21 : PyObject * obj2 = 0 ;
36657 21 : char * kwnames[] = {
36658 : (char *)"self", (char *)"val", (char *)"storageType", NULL
36659 : };
36660 21 : CPLErr result;
36661 :
36662 21 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:MDArray_SetScale", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
36663 21 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36664 21 : if (!SWIG_IsOK(res1)) {
36665 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_SetScale" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36666 : }
36667 21 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36668 21 : ecode2 = SWIG_AsVal_double(obj1, &val2);
36669 21 : if (!SWIG_IsOK(ecode2)) {
36670 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MDArray_SetScale" "', argument " "2"" of type '" "double""'");
36671 : }
36672 21 : arg2 = static_cast< double >(val2);
36673 21 : if (obj2) {
36674 2 : {
36675 : // %typemap(in) GDALDataType
36676 2 : int val = 0;
36677 2 : int ecode = SWIG_AsVal_int(obj2, &val);
36678 2 : if (!SWIG_IsOK(ecode)) {
36679 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
36680 : }
36681 2 : if( val < GDT_Unknown || val >= GDT_TypeCount )
36682 : {
36683 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
36684 : }
36685 : arg3 = static_cast<GDALDataType>(val);
36686 : }
36687 : }
36688 21 : {
36689 21 : const int bLocalUseExceptions = GetUseExceptions();
36690 21 : if ( bLocalUseExceptions ) {
36691 2 : pushErrorHandler();
36692 : }
36693 21 : {
36694 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36695 21 : result = (CPLErr)GDALMDArrayHS_SetScale(arg1,arg2,arg3);
36696 21 : SWIG_PYTHON_THREAD_END_ALLOW;
36697 : }
36698 21 : if ( bLocalUseExceptions ) {
36699 2 : popErrorHandler();
36700 : }
36701 : #ifndef SED_HACKS
36702 : if ( bLocalUseExceptions ) {
36703 : CPLErr eclass = CPLGetLastErrorType();
36704 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36705 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36706 : }
36707 : }
36708 : #endif
36709 : }
36710 21 : resultobj = SWIG_From_int(static_cast< int >(result));
36711 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36712 : return resultobj;
36713 : fail:
36714 : return NULL;
36715 : }
36716 :
36717 :
36718 15 : SWIGINTERN PyObject *_wrap_MDArray_SetUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36719 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36720 15 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36721 15 : char *arg2 = (char *) 0 ;
36722 15 : void *argp1 = 0 ;
36723 15 : int res1 = 0 ;
36724 15 : int res2 ;
36725 15 : char *buf2 = 0 ;
36726 15 : int alloc2 = 0 ;
36727 15 : PyObject *swig_obj[2] ;
36728 15 : CPLErr result;
36729 :
36730 15 : if (!SWIG_Python_UnpackTuple(args, "MDArray_SetUnit", 2, 2, swig_obj)) SWIG_fail;
36731 15 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36732 15 : if (!SWIG_IsOK(res1)) {
36733 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_SetUnit" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36734 : }
36735 15 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36736 15 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
36737 15 : if (!SWIG_IsOK(res2)) {
36738 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MDArray_SetUnit" "', argument " "2"" of type '" "char const *""'");
36739 : }
36740 15 : arg2 = reinterpret_cast< char * >(buf2);
36741 15 : {
36742 15 : const int bLocalUseExceptions = GetUseExceptions();
36743 15 : if ( bLocalUseExceptions ) {
36744 4 : pushErrorHandler();
36745 : }
36746 15 : {
36747 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36748 15 : result = (CPLErr)GDALMDArrayHS_SetUnit(arg1,(char const *)arg2);
36749 15 : SWIG_PYTHON_THREAD_END_ALLOW;
36750 : }
36751 15 : if ( bLocalUseExceptions ) {
36752 4 : popErrorHandler();
36753 : }
36754 : #ifndef SED_HACKS
36755 : if ( bLocalUseExceptions ) {
36756 : CPLErr eclass = CPLGetLastErrorType();
36757 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36758 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36759 : }
36760 : }
36761 : #endif
36762 : }
36763 15 : resultobj = SWIG_From_int(static_cast< int >(result));
36764 15 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
36765 15 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36766 : return resultobj;
36767 0 : fail:
36768 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
36769 : return NULL;
36770 : }
36771 :
36772 :
36773 113 : SWIGINTERN PyObject *_wrap_MDArray_GetUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36774 113 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36775 113 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36776 113 : void *argp1 = 0 ;
36777 113 : int res1 = 0 ;
36778 113 : PyObject *swig_obj[1] ;
36779 113 : char *result = 0 ;
36780 :
36781 113 : if (!args) SWIG_fail;
36782 113 : swig_obj[0] = args;
36783 113 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36784 113 : if (!SWIG_IsOK(res1)) {
36785 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetUnit" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36786 : }
36787 113 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36788 113 : {
36789 113 : const int bLocalUseExceptions = GetUseExceptions();
36790 113 : if ( bLocalUseExceptions ) {
36791 7 : pushErrorHandler();
36792 : }
36793 113 : {
36794 113 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36795 113 : result = (char *)GDALMDArrayHS_GetUnit(arg1);
36796 113 : SWIG_PYTHON_THREAD_END_ALLOW;
36797 : }
36798 113 : if ( bLocalUseExceptions ) {
36799 7 : popErrorHandler();
36800 : }
36801 : #ifndef SED_HACKS
36802 : if ( bLocalUseExceptions ) {
36803 : CPLErr eclass = CPLGetLastErrorType();
36804 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36805 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36806 : }
36807 : }
36808 : #endif
36809 : }
36810 113 : resultobj = SWIG_FromCharPtr((const char *)result);
36811 113 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36812 : return resultobj;
36813 : fail:
36814 : return NULL;
36815 : }
36816 :
36817 :
36818 30 : SWIGINTERN PyObject *_wrap_MDArray_SetSpatialRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36819 30 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36820 30 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36821 30 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
36822 30 : void *argp1 = 0 ;
36823 30 : int res1 = 0 ;
36824 30 : void *argp2 = 0 ;
36825 30 : int res2 = 0 ;
36826 30 : PyObject *swig_obj[2] ;
36827 30 : OGRErr result;
36828 :
36829 30 : if (!SWIG_Python_UnpackTuple(args, "MDArray_SetSpatialRef", 2, 2, swig_obj)) SWIG_fail;
36830 30 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36831 30 : if (!SWIG_IsOK(res1)) {
36832 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_SetSpatialRef" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36833 : }
36834 30 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36835 30 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
36836 30 : if (!SWIG_IsOK(res2)) {
36837 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MDArray_SetSpatialRef" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'");
36838 : }
36839 30 : arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
36840 30 : {
36841 30 : const int bLocalUseExceptions = GetUseExceptions();
36842 30 : if ( bLocalUseExceptions ) {
36843 4 : pushErrorHandler();
36844 : }
36845 30 : {
36846 30 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36847 30 : result = (OGRErr)GDALMDArrayHS_SetSpatialRef(arg1,arg2);
36848 30 : SWIG_PYTHON_THREAD_END_ALLOW;
36849 : }
36850 30 : if ( bLocalUseExceptions ) {
36851 4 : popErrorHandler();
36852 : }
36853 : #ifndef SED_HACKS
36854 : if ( bLocalUseExceptions ) {
36855 : CPLErr eclass = CPLGetLastErrorType();
36856 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36857 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36858 : }
36859 : }
36860 : #endif
36861 : }
36862 30 : {
36863 : /* %typemap(out) OGRErr */
36864 30 : if ( result != 0 && GetUseExceptions()) {
36865 0 : const char* pszMessage = CPLGetLastErrorMsg();
36866 0 : if( pszMessage[0] != '\0' )
36867 0 : PyErr_SetString( PyExc_RuntimeError, pszMessage );
36868 : else
36869 0 : PyErr_SetString( PyExc_RuntimeError, OGRErrMessages(result) );
36870 0 : SWIG_fail;
36871 : }
36872 : }
36873 30 : {
36874 : /* %typemap(ret) OGRErr */
36875 30 : if ( ReturnSame(resultobj == Py_None || resultobj == 0) ) {
36876 30 : resultobj = PyInt_FromLong( result );
36877 : }
36878 : }
36879 30 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36880 : return resultobj;
36881 : fail:
36882 : return NULL;
36883 : }
36884 :
36885 :
36886 81 : SWIGINTERN PyObject *_wrap_MDArray_GetSpatialRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36887 81 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36888 81 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36889 81 : void *argp1 = 0 ;
36890 81 : int res1 = 0 ;
36891 81 : PyObject *swig_obj[1] ;
36892 81 : OSRSpatialReferenceShadow *result = 0 ;
36893 :
36894 81 : if (!args) SWIG_fail;
36895 81 : swig_obj[0] = args;
36896 81 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36897 81 : if (!SWIG_IsOK(res1)) {
36898 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetSpatialRef" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36899 : }
36900 81 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36901 81 : {
36902 81 : const int bLocalUseExceptions = GetUseExceptions();
36903 81 : if ( bLocalUseExceptions ) {
36904 13 : pushErrorHandler();
36905 : }
36906 81 : {
36907 81 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36908 81 : result = (OSRSpatialReferenceShadow *)GDALMDArrayHS_GetSpatialRef(arg1);
36909 81 : SWIG_PYTHON_THREAD_END_ALLOW;
36910 : }
36911 81 : if ( bLocalUseExceptions ) {
36912 13 : popErrorHandler();
36913 : }
36914 : #ifndef SED_HACKS
36915 : if ( bLocalUseExceptions ) {
36916 : CPLErr eclass = CPLGetLastErrorType();
36917 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36918 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36919 : }
36920 : }
36921 : #endif
36922 : }
36923 81 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRSpatialReferenceShadow, SWIG_POINTER_OWN | 0 );
36924 81 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36925 : return resultobj;
36926 : fail:
36927 : return NULL;
36928 : }
36929 :
36930 :
36931 439 : SWIGINTERN PyObject *_wrap_MDArray_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36932 439 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36933 439 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36934 439 : char *arg2 = (char *) 0 ;
36935 439 : void *argp1 = 0 ;
36936 439 : int res1 = 0 ;
36937 439 : int res2 ;
36938 439 : char *buf2 = 0 ;
36939 439 : int alloc2 = 0 ;
36940 439 : PyObject *swig_obj[2] ;
36941 439 : GDALMDArrayHS *result = 0 ;
36942 :
36943 439 : if (!SWIG_Python_UnpackTuple(args, "MDArray_GetView", 2, 2, swig_obj)) SWIG_fail;
36944 439 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
36945 439 : if (!SWIG_IsOK(res1)) {
36946 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetView" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
36947 : }
36948 439 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
36949 439 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
36950 439 : if (!SWIG_IsOK(res2)) {
36951 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MDArray_GetView" "', argument " "2"" of type '" "char const *""'");
36952 : }
36953 439 : arg2 = reinterpret_cast< char * >(buf2);
36954 439 : {
36955 439 : if (!arg2) {
36956 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
36957 : }
36958 : }
36959 438 : {
36960 438 : const int bLocalUseExceptions = GetUseExceptions();
36961 438 : if ( bLocalUseExceptions ) {
36962 10 : pushErrorHandler();
36963 : }
36964 438 : {
36965 438 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36966 438 : result = (GDALMDArrayHS *)GDALMDArrayHS_GetView(arg1,(char const *)arg2);
36967 438 : SWIG_PYTHON_THREAD_END_ALLOW;
36968 : }
36969 438 : if ( bLocalUseExceptions ) {
36970 10 : popErrorHandler();
36971 : }
36972 : #ifndef SED_HACKS
36973 : if ( bLocalUseExceptions ) {
36974 : CPLErr eclass = CPLGetLastErrorType();
36975 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
36976 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
36977 : }
36978 : }
36979 : #endif
36980 : }
36981 438 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_OWN | 0 );
36982 438 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
36983 439 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
36984 : return resultobj;
36985 1 : fail:
36986 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
36987 : return NULL;
36988 : }
36989 :
36990 :
36991 44 : SWIGINTERN PyObject *_wrap_MDArray_Transpose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36992 44 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
36993 44 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
36994 44 : int arg2 ;
36995 44 : int *arg3 = (int *) 0 ;
36996 44 : void *argp1 = 0 ;
36997 44 : int res1 = 0 ;
36998 44 : PyObject *swig_obj[2] ;
36999 44 : GDALMDArrayHS *result = 0 ;
37000 :
37001 44 : if (!SWIG_Python_UnpackTuple(args, "MDArray_Transpose", 2, 2, swig_obj)) SWIG_fail;
37002 44 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
37003 44 : if (!SWIG_IsOK(res1)) {
37004 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_Transpose" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
37005 : }
37006 44 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
37007 44 : {
37008 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
37009 44 : arg3 = CreateCIntListFromSequence(swig_obj[1], &arg2);
37010 44 : if( arg2 < 0 ) {
37011 0 : SWIG_fail;
37012 : }
37013 : }
37014 44 : {
37015 44 : const int bLocalUseExceptions = GetUseExceptions();
37016 44 : if ( bLocalUseExceptions ) {
37017 1 : pushErrorHandler();
37018 : }
37019 44 : {
37020 44 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37021 44 : result = (GDALMDArrayHS *)GDALMDArrayHS_Transpose(arg1,arg2,arg3);
37022 44 : SWIG_PYTHON_THREAD_END_ALLOW;
37023 : }
37024 44 : if ( bLocalUseExceptions ) {
37025 1 : popErrorHandler();
37026 : }
37027 : #ifndef SED_HACKS
37028 : if ( bLocalUseExceptions ) {
37029 : CPLErr eclass = CPLGetLastErrorType();
37030 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
37031 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
37032 : }
37033 : }
37034 : #endif
37035 : }
37036 44 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_OWN | 0 );
37037 44 : {
37038 : /* %typemap(freearg) (int nList, int* pList) */
37039 44 : free(arg3);
37040 : }
37041 44 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
37042 : return resultobj;
37043 0 : fail:
37044 0 : {
37045 : /* %typemap(freearg) (int nList, int* pList) */
37046 0 : free(arg3);
37047 : }
37048 0 : return NULL;
37049 : }
37050 :
37051 :
37052 13 : SWIGINTERN PyObject *_wrap_MDArray_GetUnscaled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37053 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
37054 13 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
37055 13 : void *argp1 = 0 ;
37056 13 : int res1 = 0 ;
37057 13 : PyObject *swig_obj[1] ;
37058 13 : GDALMDArrayHS *result = 0 ;
37059 :
37060 13 : if (!args) SWIG_fail;
37061 13 : swig_obj[0] = args;
37062 13 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
37063 13 : if (!SWIG_IsOK(res1)) {
37064 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetUnscaled" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
37065 : }
37066 13 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
37067 13 : {
37068 13 : const int bLocalUseExceptions = GetUseExceptions();
37069 13 : if ( bLocalUseExceptions ) {
37070 0 : pushErrorHandler();
37071 : }
37072 13 : {
37073 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37074 13 : result = (GDALMDArrayHS *)GDALMDArrayHS_GetUnscaled(arg1);
37075 13 : SWIG_PYTHON_THREAD_END_ALLOW;
37076 : }
37077 13 : if ( bLocalUseExceptions ) {
37078 0 : popErrorHandler();
37079 : }
37080 : #ifndef SED_HACKS
37081 : if ( bLocalUseExceptions ) {
37082 : CPLErr eclass = CPLGetLastErrorType();
37083 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
37084 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
37085 : }
37086 : }
37087 : #endif
37088 : }
37089 13 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_OWN | 0 );
37090 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
37091 : return resultobj;
37092 : fail:
37093 : return NULL;
37094 : }
37095 :
37096 :
37097 35 : SWIGINTERN PyObject *_wrap_MDArray_GetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37098 35 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
37099 35 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
37100 35 : char **arg2 = (char **) 0 ;
37101 35 : void *argp1 = 0 ;
37102 35 : int res1 = 0 ;
37103 35 : PyObject *swig_obj[2] ;
37104 35 : GDALMDArrayHS *result = 0 ;
37105 :
37106 35 : if (!SWIG_Python_UnpackTuple(args, "MDArray_GetMask", 1, 2, swig_obj)) SWIG_fail;
37107 35 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
37108 35 : if (!SWIG_IsOK(res1)) {
37109 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetMask" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
37110 : }
37111 35 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
37112 35 : if (swig_obj[1]) {
37113 14 : {
37114 : /* %typemap(in) char **dict */
37115 14 : arg2 = NULL;
37116 14 : if ( PySequence_Check( swig_obj[1] ) ) {
37117 14 : int bErr = FALSE;
37118 14 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
37119 14 : if ( bErr )
37120 : {
37121 0 : SWIG_fail;
37122 : }
37123 : }
37124 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
37125 0 : int bErr = FALSE;
37126 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
37127 0 : if ( bErr )
37128 : {
37129 0 : SWIG_fail;
37130 : }
37131 : }
37132 : else {
37133 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
37134 0 : SWIG_fail;
37135 : }
37136 : }
37137 : }
37138 35 : {
37139 35 : const int bLocalUseExceptions = GetUseExceptions();
37140 35 : if ( bLocalUseExceptions ) {
37141 14 : pushErrorHandler();
37142 : }
37143 35 : {
37144 35 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37145 35 : result = (GDALMDArrayHS *)GDALMDArrayHS_GetMask(arg1,arg2);
37146 35 : SWIG_PYTHON_THREAD_END_ALLOW;
37147 : }
37148 35 : if ( bLocalUseExceptions ) {
37149 14 : popErrorHandler();
37150 : }
37151 : #ifndef SED_HACKS
37152 : if ( bLocalUseExceptions ) {
37153 : CPLErr eclass = CPLGetLastErrorType();
37154 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
37155 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
37156 : }
37157 : }
37158 : #endif
37159 : }
37160 35 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_OWN | 0 );
37161 35 : {
37162 : /* %typemap(freearg) char **dict */
37163 35 : CSLDestroy( arg2 );
37164 : }
37165 47 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
37166 : return resultobj;
37167 0 : fail:
37168 0 : {
37169 : /* %typemap(freearg) char **dict */
37170 0 : CSLDestroy( arg2 );
37171 : }
37172 : return NULL;
37173 : }
37174 :
37175 :
37176 22 : SWIGINTERN PyObject *_wrap_MDArray_GetGridded(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37177 22 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
37178 22 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
37179 22 : char *arg2 = (char *) 0 ;
37180 22 : GDALMDArrayHS *arg3 = (GDALMDArrayHS *) NULL ;
37181 22 : GDALMDArrayHS *arg4 = (GDALMDArrayHS *) NULL ;
37182 22 : char **arg5 = (char **) 0 ;
37183 22 : void *argp1 = 0 ;
37184 22 : int res1 = 0 ;
37185 22 : int res2 ;
37186 22 : char *buf2 = 0 ;
37187 22 : int alloc2 = 0 ;
37188 22 : void *argp3 = 0 ;
37189 22 : int res3 = 0 ;
37190 22 : void *argp4 = 0 ;
37191 22 : int res4 = 0 ;
37192 22 : PyObject * obj0 = 0 ;
37193 22 : PyObject * obj1 = 0 ;
37194 22 : PyObject * obj2 = 0 ;
37195 22 : PyObject * obj3 = 0 ;
37196 22 : PyObject * obj4 = 0 ;
37197 22 : char * kwnames[] = {
37198 : (char *)"self", (char *)"pszGridOptions", (char *)"xArray", (char *)"yArray", (char *)"options", NULL
37199 : };
37200 22 : GDALMDArrayHS *result = 0 ;
37201 :
37202 22 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:MDArray_GetGridded", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
37203 22 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
37204 22 : if (!SWIG_IsOK(res1)) {
37205 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetGridded" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
37206 : }
37207 22 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
37208 22 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
37209 22 : if (!SWIG_IsOK(res2)) {
37210 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MDArray_GetGridded" "', argument " "2"" of type '" "char const *""'");
37211 : }
37212 22 : arg2 = reinterpret_cast< char * >(buf2);
37213 22 : if (obj2) {
37214 14 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
37215 14 : if (!SWIG_IsOK(res3)) {
37216 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MDArray_GetGridded" "', argument " "3"" of type '" "GDALMDArrayHS *""'");
37217 : }
37218 14 : arg3 = reinterpret_cast< GDALMDArrayHS * >(argp3);
37219 : }
37220 22 : if (obj3) {
37221 13 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
37222 13 : if (!SWIG_IsOK(res4)) {
37223 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MDArray_GetGridded" "', argument " "4"" of type '" "GDALMDArrayHS *""'");
37224 : }
37225 13 : arg4 = reinterpret_cast< GDALMDArrayHS * >(argp4);
37226 : }
37227 22 : if (obj4) {
37228 3 : {
37229 : /* %typemap(in) char **dict */
37230 3 : arg5 = NULL;
37231 3 : if ( PySequence_Check( obj4 ) ) {
37232 3 : int bErr = FALSE;
37233 3 : arg5 = CSLFromPySequence(obj4, &bErr);
37234 3 : if ( bErr )
37235 : {
37236 0 : SWIG_fail;
37237 : }
37238 : }
37239 0 : else if ( PyMapping_Check( obj4 ) ) {
37240 0 : int bErr = FALSE;
37241 0 : arg5 = CSLFromPyMapping(obj4, &bErr);
37242 0 : if ( bErr )
37243 : {
37244 0 : SWIG_fail;
37245 : }
37246 : }
37247 : else {
37248 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
37249 0 : SWIG_fail;
37250 : }
37251 : }
37252 : }
37253 22 : {
37254 22 : if (!arg2) {
37255 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
37256 : }
37257 : }
37258 22 : {
37259 22 : const int bLocalUseExceptions = GetUseExceptions();
37260 22 : if ( bLocalUseExceptions ) {
37261 0 : pushErrorHandler();
37262 : }
37263 22 : {
37264 22 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37265 22 : result = (GDALMDArrayHS *)GDALMDArrayHS_GetGridded(arg1,(char const *)arg2,arg3,arg4,arg5);
37266 22 : SWIG_PYTHON_THREAD_END_ALLOW;
37267 : }
37268 22 : if ( bLocalUseExceptions ) {
37269 0 : popErrorHandler();
37270 : }
37271 : #ifndef SED_HACKS
37272 : if ( bLocalUseExceptions ) {
37273 : CPLErr eclass = CPLGetLastErrorType();
37274 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
37275 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
37276 : }
37277 : }
37278 : #endif
37279 : }
37280 22 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_OWN | 0 );
37281 22 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
37282 22 : {
37283 : /* %typemap(freearg) char **dict */
37284 22 : CSLDestroy( arg5 );
37285 : }
37286 22 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
37287 : return resultobj;
37288 0 : fail:
37289 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
37290 0 : {
37291 : /* %typemap(freearg) char **dict */
37292 0 : CSLDestroy( arg5 );
37293 : }
37294 : return NULL;
37295 : }
37296 :
37297 :
37298 102 : SWIGINTERN PyObject *_wrap_MDArray_AsClassicDataset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37299 102 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
37300 102 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
37301 102 : size_t arg2 ;
37302 102 : size_t arg3 ;
37303 102 : GDALGroupHS *arg4 = (GDALGroupHS *) NULL ;
37304 102 : char **arg5 = (char **) 0 ;
37305 102 : void *argp1 = 0 ;
37306 102 : int res1 = 0 ;
37307 102 : size_t val2 ;
37308 102 : int ecode2 = 0 ;
37309 102 : size_t val3 ;
37310 102 : int ecode3 = 0 ;
37311 102 : void *argp4 = 0 ;
37312 102 : int res4 = 0 ;
37313 102 : PyObject *swig_obj[5] ;
37314 102 : GDALDatasetShadow *result = 0 ;
37315 :
37316 102 : if (!SWIG_Python_UnpackTuple(args, "MDArray_AsClassicDataset", 3, 5, swig_obj)) SWIG_fail;
37317 102 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
37318 102 : if (!SWIG_IsOK(res1)) {
37319 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_AsClassicDataset" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
37320 : }
37321 102 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
37322 102 : ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
37323 102 : if (!SWIG_IsOK(ecode2)) {
37324 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MDArray_AsClassicDataset" "', argument " "2"" of type '" "size_t""'");
37325 : }
37326 102 : arg2 = static_cast< size_t >(val2);
37327 102 : ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
37328 102 : if (!SWIG_IsOK(ecode3)) {
37329 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MDArray_AsClassicDataset" "', argument " "3"" of type '" "size_t""'");
37330 : }
37331 102 : arg3 = static_cast< size_t >(val3);
37332 102 : if (swig_obj[3]) {
37333 52 : res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_GDALGroupHS, 0 | 0 );
37334 52 : if (!SWIG_IsOK(res4)) {
37335 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MDArray_AsClassicDataset" "', argument " "4"" of type '" "GDALGroupHS *""'");
37336 : }
37337 52 : arg4 = reinterpret_cast< GDALGroupHS * >(argp4);
37338 : }
37339 102 : if (swig_obj[4]) {
37340 52 : {
37341 : /* %typemap(in) char **dict */
37342 52 : arg5 = NULL;
37343 52 : if ( PySequence_Check( swig_obj[4] ) ) {
37344 52 : int bErr = FALSE;
37345 52 : arg5 = CSLFromPySequence(swig_obj[4], &bErr);
37346 52 : if ( bErr )
37347 : {
37348 0 : SWIG_fail;
37349 : }
37350 : }
37351 0 : else if ( PyMapping_Check( swig_obj[4] ) ) {
37352 0 : int bErr = FALSE;
37353 0 : arg5 = CSLFromPyMapping(swig_obj[4], &bErr);
37354 0 : if ( bErr )
37355 : {
37356 0 : SWIG_fail;
37357 : }
37358 : }
37359 : else {
37360 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
37361 0 : SWIG_fail;
37362 : }
37363 : }
37364 : }
37365 102 : {
37366 102 : const int bLocalUseExceptions = GetUseExceptions();
37367 102 : if ( bLocalUseExceptions ) {
37368 72 : pushErrorHandler();
37369 : }
37370 102 : {
37371 102 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37372 102 : result = (GDALDatasetShadow *)GDALMDArrayHS_AsClassicDataset(arg1,arg2,arg3,arg4,arg5);
37373 102 : SWIG_PYTHON_THREAD_END_ALLOW;
37374 : }
37375 102 : if ( bLocalUseExceptions ) {
37376 72 : popErrorHandler();
37377 : }
37378 : #ifndef SED_HACKS
37379 : if ( bLocalUseExceptions ) {
37380 : CPLErr eclass = CPLGetLastErrorType();
37381 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
37382 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
37383 : }
37384 : }
37385 : #endif
37386 : }
37387 102 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
37388 102 : {
37389 : /* %typemap(freearg) char **dict */
37390 102 : CSLDestroy( arg5 );
37391 : }
37392 188 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
37393 : return resultobj;
37394 0 : fail:
37395 0 : {
37396 : /* %typemap(freearg) char **dict */
37397 0 : CSLDestroy( arg5 );
37398 : }
37399 : return NULL;
37400 : }
37401 :
37402 :
37403 18 : SWIGINTERN PyObject *_wrap_MDArray_GetRawBlockInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37404 18 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
37405 18 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
37406 18 : int arg2 ;
37407 18 : GUIntBig *arg3 = (GUIntBig *) 0 ;
37408 18 : void *argp1 = 0 ;
37409 18 : int res1 = 0 ;
37410 18 : PyObject *swig_obj[2] ;
37411 18 : GDALMDArrayRawBlockInfo *result = 0 ;
37412 :
37413 18 : if (!SWIG_Python_UnpackTuple(args, "MDArray_GetRawBlockInfo", 2, 2, swig_obj)) SWIG_fail;
37414 18 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
37415 18 : if (!SWIG_IsOK(res1)) {
37416 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetRawBlockInfo" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
37417 : }
37418 18 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
37419 18 : {
37420 : /* %typemap(in,numinputs=1) (int nList, GUIntBig* pList)*/
37421 18 : arg3 = CreateCGUIntBigListFromSequence(swig_obj[1], &arg2);
37422 18 : if( arg2 < 0 ) {
37423 0 : SWIG_fail;
37424 : }
37425 : }
37426 18 : {
37427 18 : const int bLocalUseExceptions = GetUseExceptions();
37428 18 : if ( bLocalUseExceptions ) {
37429 18 : pushErrorHandler();
37430 : }
37431 18 : {
37432 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37433 18 : result = (GDALMDArrayRawBlockInfo *)GDALMDArrayHS_GetRawBlockInfo(arg1,arg2,arg3);
37434 18 : SWIG_PYTHON_THREAD_END_ALLOW;
37435 : }
37436 18 : if ( bLocalUseExceptions ) {
37437 18 : popErrorHandler();
37438 : }
37439 : #ifndef SED_HACKS
37440 : if ( bLocalUseExceptions ) {
37441 : CPLErr eclass = CPLGetLastErrorType();
37442 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
37443 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
37444 : }
37445 : }
37446 : #endif
37447 : }
37448 18 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayRawBlockInfo, SWIG_POINTER_OWN | 0 );
37449 18 : {
37450 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
37451 18 : free(arg3);
37452 : }
37453 26 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
37454 : return resultobj;
37455 0 : fail:
37456 0 : {
37457 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
37458 0 : free(arg3);
37459 : }
37460 0 : return NULL;
37461 : }
37462 :
37463 :
37464 15 : SWIGINTERN PyObject *_wrap_MDArray_GetStatistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37465 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
37466 15 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
37467 15 : bool arg2 = (bool) FALSE ;
37468 15 : bool arg3 = (bool) TRUE ;
37469 15 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
37470 15 : void *arg5 = (void *) NULL ;
37471 15 : void *argp1 = 0 ;
37472 15 : int res1 = 0 ;
37473 15 : bool val2 ;
37474 15 : int ecode2 = 0 ;
37475 15 : bool val3 ;
37476 15 : int ecode3 = 0 ;
37477 15 : PyObject * obj0 = 0 ;
37478 15 : PyObject * obj1 = 0 ;
37479 15 : PyObject * obj2 = 0 ;
37480 15 : PyObject * obj3 = 0 ;
37481 15 : PyObject * obj4 = 0 ;
37482 15 : char * kwnames[] = {
37483 : (char *)"self", (char *)"approx_ok", (char *)"force", (char *)"callback", (char *)"callback_data", NULL
37484 : };
37485 15 : Statistics *result = 0 ;
37486 :
37487 : /* %typemap(arginit) ( const char* callback_data=NULL) */
37488 15 : PyProgressData *psProgressInfo;
37489 15 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
37490 15 : psProgressInfo->nLastReported = -1;
37491 15 : psProgressInfo->psPyCallback = NULL;
37492 15 : psProgressInfo->psPyCallbackData = NULL;
37493 15 : arg5 = psProgressInfo;
37494 15 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOO:MDArray_GetStatistics", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
37495 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
37496 15 : if (!SWIG_IsOK(res1)) {
37497 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetStatistics" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
37498 : }
37499 15 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
37500 15 : if (obj1) {
37501 13 : ecode2 = SWIG_AsVal_bool(obj1, &val2);
37502 13 : if (!SWIG_IsOK(ecode2)) {
37503 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MDArray_GetStatistics" "', argument " "2"" of type '" "bool""'");
37504 : }
37505 : arg2 = static_cast< bool >(val2);
37506 : }
37507 15 : if (obj2) {
37508 13 : ecode3 = SWIG_AsVal_bool(obj2, &val3);
37509 13 : if (!SWIG_IsOK(ecode3)) {
37510 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MDArray_GetStatistics" "', argument " "3"" of type '" "bool""'");
37511 : }
37512 : arg3 = static_cast< bool >(val3);
37513 : }
37514 15 : if (obj3) {
37515 0 : {
37516 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
37517 : /* callback_func typemap */
37518 :
37519 : /* In some cases 0 is passed instead of None. */
37520 : /* See https://github.com/OSGeo/gdal/pull/219 */
37521 0 : if ( PyLong_Check(obj3) || PyInt_Check(obj3) )
37522 : {
37523 0 : if( PyLong_AsLong(obj3) == 0 )
37524 : {
37525 0 : obj3 = Py_None;
37526 : }
37527 : }
37528 :
37529 0 : if (obj3 && obj3 != Py_None ) {
37530 0 : void* cbfunction = NULL;
37531 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj3,
37532 : (void**)&cbfunction,
37533 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
37534 : SWIG_POINTER_EXCEPTION | 0 ));
37535 :
37536 0 : if ( cbfunction == GDALTermProgress ) {
37537 : arg4 = GDALTermProgress;
37538 : } else {
37539 0 : if (!PyCallable_Check(obj3)) {
37540 0 : PyErr_SetString( PyExc_RuntimeError,
37541 : "Object given is not a Python function" );
37542 0 : SWIG_fail;
37543 : }
37544 0 : psProgressInfo->psPyCallback = obj3;
37545 0 : arg4 = PyProgressProxy;
37546 : }
37547 :
37548 : }
37549 :
37550 : }
37551 : }
37552 15 : if (obj4) {
37553 0 : {
37554 : /* %typemap(in) ( void* callback_data=NULL) */
37555 0 : psProgressInfo->psPyCallbackData = obj4 ;
37556 : }
37557 : }
37558 15 : {
37559 15 : const int bLocalUseExceptions = GetUseExceptions();
37560 15 : if ( bLocalUseExceptions ) {
37561 5 : pushErrorHandler();
37562 : }
37563 15 : {
37564 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37565 15 : result = (Statistics *)GDALMDArrayHS_GetStatistics(arg1,arg2,arg3,arg4,arg5);
37566 15 : SWIG_PYTHON_THREAD_END_ALLOW;
37567 : }
37568 15 : if ( bLocalUseExceptions ) {
37569 5 : popErrorHandler();
37570 : }
37571 : #ifndef SED_HACKS
37572 : if ( bLocalUseExceptions ) {
37573 : CPLErr eclass = CPLGetLastErrorType();
37574 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
37575 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
37576 : }
37577 : }
37578 : #endif
37579 : }
37580 15 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Statistics, 0 | 0 );
37581 15 : {
37582 : /* %typemap(freearg) ( void* callback_data=NULL) */
37583 :
37584 15 : CPLFree(psProgressInfo);
37585 :
37586 : }
37587 15 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
37588 : return resultobj;
37589 0 : fail:
37590 0 : {
37591 : /* %typemap(freearg) ( void* callback_data=NULL) */
37592 :
37593 0 : CPLFree(psProgressInfo);
37594 :
37595 : }
37596 : return NULL;
37597 : }
37598 :
37599 :
37600 4 : SWIGINTERN PyObject *_wrap_MDArray_ComputeStatistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37601 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
37602 4 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
37603 4 : bool arg2 = (bool) FALSE ;
37604 4 : GDALProgressFunc arg3 = (GDALProgressFunc) NULL ;
37605 4 : void *arg4 = (void *) NULL ;
37606 4 : char **arg5 = (char **) 0 ;
37607 4 : void *argp1 = 0 ;
37608 4 : int res1 = 0 ;
37609 4 : bool val2 ;
37610 4 : int ecode2 = 0 ;
37611 4 : PyObject * obj0 = 0 ;
37612 4 : PyObject * obj1 = 0 ;
37613 4 : PyObject * obj2 = 0 ;
37614 4 : PyObject * obj3 = 0 ;
37615 4 : PyObject * obj4 = 0 ;
37616 4 : char * kwnames[] = {
37617 : (char *)"self", (char *)"approx_ok", (char *)"callback", (char *)"callback_data", (char *)"options", NULL
37618 : };
37619 4 : Statistics *result = 0 ;
37620 :
37621 : /* %typemap(arginit) ( const char* callback_data=NULL) */
37622 4 : PyProgressData *psProgressInfo;
37623 4 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
37624 4 : psProgressInfo->nLastReported = -1;
37625 4 : psProgressInfo->psPyCallback = NULL;
37626 4 : psProgressInfo->psPyCallbackData = NULL;
37627 4 : arg4 = psProgressInfo;
37628 4 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOO:MDArray_ComputeStatistics", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
37629 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
37630 4 : if (!SWIG_IsOK(res1)) {
37631 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_ComputeStatistics" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
37632 : }
37633 4 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
37634 4 : if (obj1) {
37635 2 : ecode2 = SWIG_AsVal_bool(obj1, &val2);
37636 2 : if (!SWIG_IsOK(ecode2)) {
37637 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MDArray_ComputeStatistics" "', argument " "2"" of type '" "bool""'");
37638 : }
37639 : arg2 = static_cast< bool >(val2);
37640 : }
37641 4 : if (obj2) {
37642 0 : {
37643 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
37644 : /* callback_func typemap */
37645 :
37646 : /* In some cases 0 is passed instead of None. */
37647 : /* See https://github.com/OSGeo/gdal/pull/219 */
37648 0 : if ( PyLong_Check(obj2) || PyInt_Check(obj2) )
37649 : {
37650 0 : if( PyLong_AsLong(obj2) == 0 )
37651 : {
37652 0 : obj2 = Py_None;
37653 : }
37654 : }
37655 :
37656 0 : if (obj2 && obj2 != Py_None ) {
37657 0 : void* cbfunction = NULL;
37658 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj2,
37659 : (void**)&cbfunction,
37660 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
37661 : SWIG_POINTER_EXCEPTION | 0 ));
37662 :
37663 0 : if ( cbfunction == GDALTermProgress ) {
37664 : arg3 = GDALTermProgress;
37665 : } else {
37666 0 : if (!PyCallable_Check(obj2)) {
37667 0 : PyErr_SetString( PyExc_RuntimeError,
37668 : "Object given is not a Python function" );
37669 0 : SWIG_fail;
37670 : }
37671 0 : psProgressInfo->psPyCallback = obj2;
37672 0 : arg3 = PyProgressProxy;
37673 : }
37674 :
37675 : }
37676 :
37677 : }
37678 : }
37679 4 : if (obj3) {
37680 0 : {
37681 : /* %typemap(in) ( void* callback_data=NULL) */
37682 0 : psProgressInfo->psPyCallbackData = obj3 ;
37683 : }
37684 : }
37685 4 : if (obj4) {
37686 2 : {
37687 : /* %typemap(in) char **dict */
37688 2 : arg5 = NULL;
37689 2 : if ( PySequence_Check( obj4 ) ) {
37690 2 : int bErr = FALSE;
37691 2 : arg5 = CSLFromPySequence(obj4, &bErr);
37692 2 : if ( bErr )
37693 : {
37694 0 : SWIG_fail;
37695 : }
37696 : }
37697 0 : else if ( PyMapping_Check( obj4 ) ) {
37698 0 : int bErr = FALSE;
37699 0 : arg5 = CSLFromPyMapping(obj4, &bErr);
37700 0 : if ( bErr )
37701 : {
37702 0 : SWIG_fail;
37703 : }
37704 : }
37705 : else {
37706 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
37707 0 : SWIG_fail;
37708 : }
37709 : }
37710 : }
37711 4 : {
37712 4 : const int bLocalUseExceptions = GetUseExceptions();
37713 4 : if ( bLocalUseExceptions ) {
37714 2 : pushErrorHandler();
37715 : }
37716 4 : {
37717 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37718 4 : result = (Statistics *)GDALMDArrayHS_ComputeStatistics(arg1,arg2,arg3,arg4,arg5);
37719 4 : SWIG_PYTHON_THREAD_END_ALLOW;
37720 : }
37721 4 : if ( bLocalUseExceptions ) {
37722 2 : popErrorHandler();
37723 : }
37724 : #ifndef SED_HACKS
37725 : if ( bLocalUseExceptions ) {
37726 : CPLErr eclass = CPLGetLastErrorType();
37727 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
37728 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
37729 : }
37730 : }
37731 : #endif
37732 : }
37733 4 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Statistics, 0 | 0 );
37734 4 : {
37735 : /* %typemap(freearg) ( void* callback_data=NULL) */
37736 :
37737 4 : CPLFree(psProgressInfo);
37738 :
37739 : }
37740 4 : {
37741 : /* %typemap(freearg) char **dict */
37742 4 : CSLDestroy( arg5 );
37743 : }
37744 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
37745 : return resultobj;
37746 0 : fail:
37747 0 : {
37748 : /* %typemap(freearg) ( void* callback_data=NULL) */
37749 :
37750 0 : CPLFree(psProgressInfo);
37751 :
37752 : }
37753 0 : {
37754 : /* %typemap(freearg) char **dict */
37755 0 : CSLDestroy( arg5 );
37756 : }
37757 : return NULL;
37758 : }
37759 :
37760 :
37761 34 : SWIGINTERN PyObject *_wrap_MDArray_GetResampled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37762 34 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
37763 34 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
37764 34 : int arg2 ;
37765 34 : GDALDimensionHS **arg3 = (GDALDimensionHS **) 0 ;
37766 34 : GDALRIOResampleAlg arg4 ;
37767 34 : OSRSpatialReferenceShadow **arg5 = (OSRSpatialReferenceShadow **) 0 ;
37768 34 : char **arg6 = (char **) 0 ;
37769 34 : void *argp1 = 0 ;
37770 34 : int res1 = 0 ;
37771 34 : OSRSpatialReferenceShadow *val5 ;
37772 34 : PyObject *swig_obj[5] ;
37773 34 : GDALMDArrayHS *result = 0 ;
37774 :
37775 34 : if (!SWIG_Python_UnpackTuple(args, "MDArray_GetResampled", 4, 5, swig_obj)) SWIG_fail;
37776 34 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
37777 34 : if (!SWIG_IsOK(res1)) {
37778 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_GetResampled" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
37779 : }
37780 34 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
37781 34 : {
37782 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALDimensionHS *optional_##GDALDimensionHS)*/
37783 34 : if ( !PySequence_Check(swig_obj[1]) ) {
37784 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
37785 0 : SWIG_fail;
37786 : }
37787 34 : Py_ssize_t size = PySequence_Size(swig_obj[1]);
37788 34 : if( size > (Py_ssize_t)INT_MAX ) {
37789 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
37790 0 : SWIG_fail;
37791 : }
37792 34 : if( (size_t)size > SIZE_MAX / sizeof(GDALDimensionHS*) ) {
37793 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
37794 0 : SWIG_fail;
37795 : }
37796 34 : arg2 = (int)size;
37797 34 : arg3 = (GDALDimensionHS**) VSIMalloc(arg2*sizeof(GDALDimensionHS*));
37798 34 : if( !arg3) {
37799 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
37800 0 : SWIG_fail;
37801 : }
37802 :
37803 112 : for( int i = 0; i<arg2; i++ ) {
37804 78 : PyObject *o = PySequence_GetItem(swig_obj[1],i);
37805 78 : GDALDimensionHS* rawobjectpointer = NULL;
37806 78 : if( o != Py_None )
37807 : {
37808 8 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALDimensionHS, SWIG_POINTER_EXCEPTION | 0 ));
37809 8 : if (!rawobjectpointer) {
37810 0 : Py_DECREF(o);
37811 0 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALDimensionHS");
37812 0 : SWIG_fail;
37813 : }
37814 : }
37815 78 : arg3[i] = rawobjectpointer;
37816 78 : Py_DECREF(o);
37817 :
37818 : }
37819 : }
37820 34 : {
37821 : // %typemap(in) GDALRIOResampleAlg
37822 34 : int val = 0;
37823 34 : int ecode = SWIG_AsVal_int(swig_obj[2], &val);
37824 34 : if (!SWIG_IsOK(ecode)) {
37825 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALRIOResampleAlg");
37826 : }
37827 34 : if( val < 0 ||
37828 34 : ( val >= static_cast<int>(GRIORA_RESERVED_START) &&
37829 34 : val <= static_cast<int>(GRIORA_RESERVED_END) ) ||
37830 : val > static_cast<int>(GRIORA_LAST) )
37831 : {
37832 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for resample_alg");
37833 : }
37834 34 : arg4 = static_cast< GDALRIOResampleAlg >(val);
37835 : }
37836 34 : {
37837 : /* %typemap(in) (OSRSpatialReferenceShadow** optional_OSRSpatialReferenceShadow) */
37838 34 : if ( swig_obj[3] == Py_None ) {
37839 : arg5 = NULL;
37840 : }
37841 : else {
37842 1 : void* argp = NULL;
37843 1 : int res = SWIG_ConvertPtr(swig_obj[3], &argp, SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0);
37844 1 : if (!SWIG_IsOK(res)) {
37845 0 : SWIG_exception_fail(SWIG_ArgError(res), "argument of type != OSRSpatialReferenceShadow");
37846 : }
37847 1 : val5 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp);
37848 1 : arg5 = &val5;
37849 : }
37850 : }
37851 34 : if (swig_obj[4]) {
37852 5 : {
37853 : /* %typemap(in) char **dict */
37854 5 : arg6 = NULL;
37855 5 : if ( PySequence_Check( swig_obj[4] ) ) {
37856 5 : int bErr = FALSE;
37857 5 : arg6 = CSLFromPySequence(swig_obj[4], &bErr);
37858 5 : if ( bErr )
37859 : {
37860 0 : SWIG_fail;
37861 : }
37862 : }
37863 0 : else if ( PyMapping_Check( swig_obj[4] ) ) {
37864 0 : int bErr = FALSE;
37865 0 : arg6 = CSLFromPyMapping(swig_obj[4], &bErr);
37866 0 : if ( bErr )
37867 : {
37868 0 : SWIG_fail;
37869 : }
37870 : }
37871 : else {
37872 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
37873 0 : SWIG_fail;
37874 : }
37875 : }
37876 : }
37877 34 : {
37878 34 : const int bLocalUseExceptions = GetUseExceptions();
37879 34 : if ( bLocalUseExceptions ) {
37880 0 : pushErrorHandler();
37881 : }
37882 34 : {
37883 34 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37884 34 : result = (GDALMDArrayHS *)GDALMDArrayHS_GetResampled(arg1,arg2,arg3,arg4,arg5,arg6);
37885 34 : SWIG_PYTHON_THREAD_END_ALLOW;
37886 : }
37887 34 : if ( bLocalUseExceptions ) {
37888 0 : popErrorHandler();
37889 : }
37890 : #ifndef SED_HACKS
37891 : if ( bLocalUseExceptions ) {
37892 : CPLErr eclass = CPLGetLastErrorType();
37893 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
37894 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
37895 : }
37896 : }
37897 : #endif
37898 : }
37899 34 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_OWN | 0 );
37900 34 : {
37901 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALDimensionHS **poObjectsItemMaybeNull)*/
37902 34 : CPLFree( arg3 );
37903 : }
37904 34 : {
37905 : /* %typemap(freearg) char **dict */
37906 34 : CSLDestroy( arg6 );
37907 : }
37908 34 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
37909 : return resultobj;
37910 0 : fail:
37911 0 : {
37912 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALDimensionHS **poObjectsItemMaybeNull)*/
37913 0 : CPLFree( arg3 );
37914 : }
37915 0 : {
37916 : /* %typemap(freearg) char **dict */
37917 0 : CSLDestroy( arg6 );
37918 : }
37919 : return NULL;
37920 : }
37921 :
37922 :
37923 7 : SWIGINTERN PyObject *_wrap_MDArray_GetMeshGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37924 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
37925 7 : int arg1 ;
37926 7 : GDALMDArrayHS **arg2 = (GDALMDArrayHS **) 0 ;
37927 7 : GDALMDArrayHS ***arg3 = (GDALMDArrayHS ***) 0 ;
37928 7 : size_t *arg4 = (size_t *) 0 ;
37929 7 : char **arg5 = (char **) 0 ;
37930 7 : GDALMDArrayHS **arrays3 = 0 ;
37931 7 : size_t nCount3 = 0 ;
37932 7 : PyObject *swig_obj[2] ;
37933 :
37934 7 : {
37935 : /* %typemap(in,numinputs=0) (GDALMDArrayHS*** parrays, size_t* pnCount) */
37936 7 : arg3 = &arrays3;
37937 7 : arg4 = &nCount3;
37938 : }
37939 7 : if (!SWIG_Python_UnpackTuple(args, "MDArray_GetMeshGrid", 1, 2, swig_obj)) SWIG_fail;
37940 7 : {
37941 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALMDArrayHS *optional_##GDALMDArrayHS)*/
37942 7 : if ( !PySequence_Check(swig_obj[0]) ) {
37943 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
37944 0 : SWIG_fail;
37945 : }
37946 7 : Py_ssize_t size = PySequence_Size(swig_obj[0]);
37947 7 : if( size > (Py_ssize_t)INT_MAX ) {
37948 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
37949 0 : SWIG_fail;
37950 : }
37951 7 : if( (size_t)size > SIZE_MAX / sizeof(GDALMDArrayHS*) ) {
37952 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
37953 0 : SWIG_fail;
37954 : }
37955 7 : arg1 = (int)size;
37956 7 : arg2 = (GDALMDArrayHS**) VSIMalloc(arg1*sizeof(GDALMDArrayHS*));
37957 7 : if( !arg2) {
37958 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
37959 0 : SWIG_fail;
37960 : }
37961 :
37962 20 : for( int i = 0; i<arg1; i++ ) {
37963 13 : PyObject *o = PySequence_GetItem(swig_obj[0],i);
37964 13 : GDALMDArrayHS* rawobjectpointer = NULL;
37965 13 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_EXCEPTION | 0 ));
37966 13 : if (!rawobjectpointer) {
37967 0 : Py_DECREF(o);
37968 0 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALMDArrayHS");
37969 0 : SWIG_fail;
37970 : }
37971 13 : arg2[i] = rawobjectpointer;
37972 13 : Py_DECREF(o);
37973 :
37974 : }
37975 : }
37976 7 : if (swig_obj[1]) {
37977 5 : {
37978 : /* %typemap(in) char **dict */
37979 5 : arg5 = NULL;
37980 5 : if ( PySequence_Check( swig_obj[1] ) ) {
37981 5 : int bErr = FALSE;
37982 5 : arg5 = CSLFromPySequence(swig_obj[1], &bErr);
37983 5 : if ( bErr )
37984 : {
37985 0 : SWIG_fail;
37986 : }
37987 : }
37988 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
37989 0 : int bErr = FALSE;
37990 0 : arg5 = CSLFromPyMapping(swig_obj[1], &bErr);
37991 0 : if ( bErr )
37992 : {
37993 0 : SWIG_fail;
37994 : }
37995 : }
37996 : else {
37997 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
37998 0 : SWIG_fail;
37999 : }
38000 : }
38001 : }
38002 7 : {
38003 7 : const int bLocalUseExceptions = GetUseExceptions();
38004 7 : if ( bLocalUseExceptions ) {
38005 7 : pushErrorHandler();
38006 : }
38007 7 : {
38008 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38009 7 : GDALMDArrayHS_GetMeshGrid(arg1,arg2,arg3,arg4,arg5);
38010 7 : SWIG_PYTHON_THREAD_END_ALLOW;
38011 : }
38012 7 : if ( bLocalUseExceptions ) {
38013 7 : popErrorHandler();
38014 : }
38015 : #ifndef SED_HACKS
38016 : if ( bLocalUseExceptions ) {
38017 : CPLErr eclass = CPLGetLastErrorType();
38018 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38019 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38020 : }
38021 : }
38022 : #endif
38023 : }
38024 7 : resultobj = SWIG_Py_Void();
38025 7 : {
38026 : /* %typemap(argout) (GDALMDArrayHS*** parrays, size_t* pnCount) */
38027 7 : Py_DECREF(resultobj);
38028 7 : resultobj = PyList_New( *arg4 );
38029 7 : if( !resultobj ) {
38030 0 : SWIG_fail;
38031 : }
38032 17 : for( size_t i = 0; i < *arg4; i++ ) {
38033 10 : PyList_SetItem(resultobj, i,
38034 10 : SWIG_NewPointerObj((void*)(*arg3)[i],SWIGTYPE_p_GDALMDArrayHS,SWIG_POINTER_OWN) );
38035 : /* We have borrowed the GDALMDArrayHS */
38036 10 : (*arg3)[i] = NULL;
38037 : }
38038 : }
38039 7 : {
38040 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALMDArrayHS **poObjects)*/
38041 7 : CPLFree( arg2 );
38042 : }
38043 7 : {
38044 : /* %typemap(freearg) (GDALMDArrayHS*** parrays, size_t* pnCount) */
38045 7 : GDALReleaseArrays(*arg3, *arg4);
38046 : }
38047 7 : {
38048 : /* %typemap(freearg) char **dict */
38049 7 : CSLDestroy( arg5 );
38050 : }
38051 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38052 : return resultobj;
38053 0 : fail:
38054 0 : {
38055 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALMDArrayHS **poObjects)*/
38056 0 : CPLFree( arg2 );
38057 : }
38058 0 : {
38059 : /* %typemap(freearg) (GDALMDArrayHS*** parrays, size_t* pnCount) */
38060 0 : GDALReleaseArrays(*arg3, *arg4);
38061 : }
38062 0 : {
38063 : /* %typemap(freearg) char **dict */
38064 0 : CSLDestroy( arg5 );
38065 : }
38066 : return NULL;
38067 : }
38068 :
38069 :
38070 7 : SWIGINTERN PyObject *_wrap_MDArray_Cache(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38071 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38072 7 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
38073 7 : char **arg2 = (char **) NULL ;
38074 7 : void *argp1 = 0 ;
38075 7 : int res1 = 0 ;
38076 7 : PyObject *swig_obj[2] ;
38077 7 : bool result;
38078 :
38079 7 : if (!SWIG_Python_UnpackTuple(args, "MDArray_Cache", 1, 2, swig_obj)) SWIG_fail;
38080 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
38081 7 : if (!SWIG_IsOK(res1)) {
38082 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_Cache" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
38083 : }
38084 7 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
38085 7 : if (swig_obj[1]) {
38086 1 : {
38087 : /* %typemap(in) char **dict */
38088 1 : arg2 = NULL;
38089 1 : if ( PySequence_Check( swig_obj[1] ) ) {
38090 1 : int bErr = FALSE;
38091 1 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
38092 1 : if ( bErr )
38093 : {
38094 0 : SWIG_fail;
38095 : }
38096 : }
38097 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
38098 0 : int bErr = FALSE;
38099 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
38100 0 : if ( bErr )
38101 : {
38102 0 : SWIG_fail;
38103 : }
38104 : }
38105 : else {
38106 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
38107 0 : SWIG_fail;
38108 : }
38109 : }
38110 : }
38111 7 : {
38112 7 : const int bLocalUseExceptions = GetUseExceptions();
38113 7 : if ( bLocalUseExceptions ) {
38114 1 : pushErrorHandler();
38115 : }
38116 7 : {
38117 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38118 7 : result = (bool)GDALMDArrayHS_Cache(arg1,arg2);
38119 7 : SWIG_PYTHON_THREAD_END_ALLOW;
38120 : }
38121 7 : if ( bLocalUseExceptions ) {
38122 1 : popErrorHandler();
38123 : }
38124 : #ifndef SED_HACKS
38125 : if ( bLocalUseExceptions ) {
38126 : CPLErr eclass = CPLGetLastErrorType();
38127 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38128 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38129 : }
38130 : }
38131 : #endif
38132 : }
38133 7 : resultobj = SWIG_From_bool(static_cast< bool >(result));
38134 7 : {
38135 : /* %typemap(freearg) char **dict */
38136 7 : CSLDestroy( arg2 );
38137 : }
38138 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38139 : return resultobj;
38140 0 : fail:
38141 0 : {
38142 : /* %typemap(freearg) char **dict */
38143 0 : CSLDestroy( arg2 );
38144 : }
38145 : return NULL;
38146 : }
38147 :
38148 :
38149 28 : SWIGINTERN PyObject *_wrap_MDArray_Rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38150 28 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38151 28 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
38152 28 : char *arg2 = (char *) 0 ;
38153 28 : void *argp1 = 0 ;
38154 28 : int res1 = 0 ;
38155 28 : int res2 ;
38156 28 : char *buf2 = 0 ;
38157 28 : int alloc2 = 0 ;
38158 28 : PyObject *swig_obj[2] ;
38159 28 : CPLErr result;
38160 :
38161 28 : if (!SWIG_Python_UnpackTuple(args, "MDArray_Rename", 2, 2, swig_obj)) SWIG_fail;
38162 28 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
38163 28 : if (!SWIG_IsOK(res1)) {
38164 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MDArray_Rename" "', argument " "1"" of type '" "GDALMDArrayHS *""'");
38165 : }
38166 28 : arg1 = reinterpret_cast< GDALMDArrayHS * >(argp1);
38167 28 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
38168 28 : if (!SWIG_IsOK(res2)) {
38169 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MDArray_Rename" "', argument " "2"" of type '" "char const *""'");
38170 : }
38171 28 : arg2 = reinterpret_cast< char * >(buf2);
38172 28 : {
38173 28 : const int bLocalUseExceptions = GetUseExceptions();
38174 28 : if ( bLocalUseExceptions ) {
38175 28 : pushErrorHandler();
38176 : }
38177 28 : {
38178 28 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38179 28 : result = (CPLErr)GDALMDArrayHS_Rename(arg1,(char const *)arg2);
38180 28 : SWIG_PYTHON_THREAD_END_ALLOW;
38181 : }
38182 28 : if ( bLocalUseExceptions ) {
38183 28 : popErrorHandler();
38184 : }
38185 : #ifndef SED_HACKS
38186 : if ( bLocalUseExceptions ) {
38187 : CPLErr eclass = CPLGetLastErrorType();
38188 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38189 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38190 : }
38191 : }
38192 : #endif
38193 : }
38194 28 : resultobj = SWIG_From_int(static_cast< int >(result));
38195 28 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
38196 68 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38197 : return resultobj;
38198 0 : fail:
38199 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
38200 : return NULL;
38201 : }
38202 :
38203 :
38204 277 : SWIGINTERN PyObject *MDArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38205 277 : PyObject *obj;
38206 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
38207 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALMDArrayHS, SWIG_NewClientData(obj));
38208 277 : return SWIG_Py_Void();
38209 : }
38210 :
38211 765 : SWIGINTERN PyObject *_wrap_delete_Attribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38212 765 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38213 765 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38214 765 : void *argp1 = 0 ;
38215 765 : int res1 = 0 ;
38216 765 : PyObject *swig_obj[1] ;
38217 :
38218 765 : if (!args) SWIG_fail;
38219 765 : swig_obj[0] = args;
38220 765 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, SWIG_POINTER_DISOWN | 0 );
38221 765 : if (!SWIG_IsOK(res1)) {
38222 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Attribute" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38223 : }
38224 765 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38225 765 : {
38226 765 : const int bLocalUseExceptions = GetUseExceptions();
38227 765 : if ( bLocalUseExceptions ) {
38228 398 : pushErrorHandler();
38229 : }
38230 765 : {
38231 765 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38232 765 : delete_GDALAttributeHS(arg1);
38233 765 : SWIG_PYTHON_THREAD_END_ALLOW;
38234 : }
38235 765 : if ( bLocalUseExceptions ) {
38236 398 : popErrorHandler();
38237 : }
38238 : #ifndef SED_HACKS
38239 : if ( bLocalUseExceptions ) {
38240 : CPLErr eclass = CPLGetLastErrorType();
38241 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38242 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38243 : }
38244 : }
38245 : #endif
38246 : }
38247 765 : resultobj = SWIG_Py_Void();
38248 765 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38249 : return resultobj;
38250 : fail:
38251 : return NULL;
38252 : }
38253 :
38254 :
38255 361 : SWIGINTERN PyObject *_wrap_Attribute_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38256 361 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38257 361 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38258 361 : void *argp1 = 0 ;
38259 361 : int res1 = 0 ;
38260 361 : PyObject *swig_obj[1] ;
38261 361 : char *result = 0 ;
38262 :
38263 361 : if (!args) SWIG_fail;
38264 361 : swig_obj[0] = args;
38265 361 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
38266 361 : if (!SWIG_IsOK(res1)) {
38267 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_GetName" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38268 : }
38269 361 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38270 361 : {
38271 361 : const int bLocalUseExceptions = GetUseExceptions();
38272 361 : if ( bLocalUseExceptions ) {
38273 149 : pushErrorHandler();
38274 : }
38275 361 : {
38276 361 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38277 361 : result = (char *)GDALAttributeHS_GetName(arg1);
38278 361 : SWIG_PYTHON_THREAD_END_ALLOW;
38279 : }
38280 361 : if ( bLocalUseExceptions ) {
38281 149 : popErrorHandler();
38282 : }
38283 : #ifndef SED_HACKS
38284 : if ( bLocalUseExceptions ) {
38285 : CPLErr eclass = CPLGetLastErrorType();
38286 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38287 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38288 : }
38289 : }
38290 : #endif
38291 : }
38292 361 : resultobj = SWIG_FromCharPtr((const char *)result);
38293 361 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38294 : return resultobj;
38295 : fail:
38296 : return NULL;
38297 : }
38298 :
38299 :
38300 49 : SWIGINTERN PyObject *_wrap_Attribute_GetFullName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38301 49 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38302 49 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38303 49 : void *argp1 = 0 ;
38304 49 : int res1 = 0 ;
38305 49 : PyObject *swig_obj[1] ;
38306 49 : char *result = 0 ;
38307 :
38308 49 : if (!args) SWIG_fail;
38309 49 : swig_obj[0] = args;
38310 49 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
38311 49 : if (!SWIG_IsOK(res1)) {
38312 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_GetFullName" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38313 : }
38314 49 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38315 49 : {
38316 49 : const int bLocalUseExceptions = GetUseExceptions();
38317 49 : if ( bLocalUseExceptions ) {
38318 41 : pushErrorHandler();
38319 : }
38320 49 : {
38321 49 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38322 49 : result = (char *)GDALAttributeHS_GetFullName(arg1);
38323 49 : SWIG_PYTHON_THREAD_END_ALLOW;
38324 : }
38325 49 : if ( bLocalUseExceptions ) {
38326 41 : popErrorHandler();
38327 : }
38328 : #ifndef SED_HACKS
38329 : if ( bLocalUseExceptions ) {
38330 : CPLErr eclass = CPLGetLastErrorType();
38331 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38332 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38333 : }
38334 : }
38335 : #endif
38336 : }
38337 49 : resultobj = SWIG_FromCharPtr((const char *)result);
38338 49 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38339 : return resultobj;
38340 : fail:
38341 : return NULL;
38342 : }
38343 :
38344 :
38345 177 : SWIGINTERN PyObject *_wrap_Attribute_GetTotalElementsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38346 177 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38347 177 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38348 177 : void *argp1 = 0 ;
38349 177 : int res1 = 0 ;
38350 177 : PyObject *swig_obj[1] ;
38351 177 : GUIntBig result;
38352 :
38353 177 : if (!args) SWIG_fail;
38354 177 : swig_obj[0] = args;
38355 177 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
38356 177 : if (!SWIG_IsOK(res1)) {
38357 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_GetTotalElementsCount" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38358 : }
38359 177 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38360 177 : {
38361 177 : const int bLocalUseExceptions = GetUseExceptions();
38362 177 : if ( bLocalUseExceptions ) {
38363 52 : pushErrorHandler();
38364 : }
38365 177 : {
38366 177 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38367 177 : result = GDALAttributeHS_GetTotalElementsCount(arg1);
38368 177 : SWIG_PYTHON_THREAD_END_ALLOW;
38369 : }
38370 177 : if ( bLocalUseExceptions ) {
38371 52 : popErrorHandler();
38372 : }
38373 : #ifndef SED_HACKS
38374 : if ( bLocalUseExceptions ) {
38375 : CPLErr eclass = CPLGetLastErrorType();
38376 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38377 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38378 : }
38379 : }
38380 : #endif
38381 : }
38382 177 : {
38383 177 : resultobj = PyLong_FromUnsignedLongLong(result);
38384 : }
38385 177 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38386 : return resultobj;
38387 : fail:
38388 : return NULL;
38389 : }
38390 :
38391 :
38392 12 : SWIGINTERN PyObject *_wrap_Attribute_GetDimensionCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38393 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38394 12 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38395 12 : void *argp1 = 0 ;
38396 12 : int res1 = 0 ;
38397 12 : PyObject *swig_obj[1] ;
38398 12 : size_t result;
38399 :
38400 12 : if (!args) SWIG_fail;
38401 12 : swig_obj[0] = args;
38402 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
38403 12 : if (!SWIG_IsOK(res1)) {
38404 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_GetDimensionCount" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38405 : }
38406 12 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38407 12 : {
38408 12 : const int bLocalUseExceptions = GetUseExceptions();
38409 12 : if ( bLocalUseExceptions ) {
38410 6 : pushErrorHandler();
38411 : }
38412 12 : {
38413 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38414 12 : result = GDALAttributeHS_GetDimensionCount(arg1);
38415 12 : SWIG_PYTHON_THREAD_END_ALLOW;
38416 : }
38417 12 : if ( bLocalUseExceptions ) {
38418 6 : popErrorHandler();
38419 : }
38420 : #ifndef SED_HACKS
38421 : if ( bLocalUseExceptions ) {
38422 : CPLErr eclass = CPLGetLastErrorType();
38423 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38424 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38425 : }
38426 : }
38427 : #endif
38428 : }
38429 12 : resultobj = SWIG_From_size_t(static_cast< size_t >(result));
38430 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38431 : return resultobj;
38432 : fail:
38433 : return NULL;
38434 : }
38435 :
38436 :
38437 11 : SWIGINTERN PyObject *_wrap_Attribute_GetDimensionsSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38438 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38439 11 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38440 11 : GUIntBig **arg2 = (GUIntBig **) 0 ;
38441 11 : size_t *arg3 = (size_t *) 0 ;
38442 11 : void *argp1 = 0 ;
38443 11 : int res1 = 0 ;
38444 11 : GUIntBig *vals2 = 0 ;
38445 11 : size_t nCount2 = 0 ;
38446 11 : PyObject *swig_obj[1] ;
38447 :
38448 11 : {
38449 : /* %typemap(in,numinputs=0) (GUIntBig** pvals, size_t* pnCount) */
38450 11 : arg2 = &vals2;
38451 11 : arg3 = &nCount2;
38452 : }
38453 11 : if (!args) SWIG_fail;
38454 11 : swig_obj[0] = args;
38455 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
38456 11 : if (!SWIG_IsOK(res1)) {
38457 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_GetDimensionsSize" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38458 : }
38459 11 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38460 11 : {
38461 11 : const int bLocalUseExceptions = GetUseExceptions();
38462 11 : if ( bLocalUseExceptions ) {
38463 5 : pushErrorHandler();
38464 : }
38465 11 : {
38466 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38467 11 : GDALAttributeHS_GetDimensionsSize(arg1,arg2,arg3);
38468 11 : SWIG_PYTHON_THREAD_END_ALLOW;
38469 : }
38470 11 : if ( bLocalUseExceptions ) {
38471 5 : popErrorHandler();
38472 : }
38473 : #ifndef SED_HACKS
38474 : if ( bLocalUseExceptions ) {
38475 : CPLErr eclass = CPLGetLastErrorType();
38476 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38477 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38478 : }
38479 : }
38480 : #endif
38481 : }
38482 11 : resultobj = SWIG_Py_Void();
38483 11 : {
38484 : /* %typemap(argout) (GUIntBig** pvals, size_t* pnCount) */
38485 11 : Py_DECREF(resultobj);
38486 11 : resultobj = PyList_New( *arg3 );
38487 11 : if( !resultobj ) {
38488 0 : SWIG_fail;
38489 : }
38490 22 : for( size_t i = 0; i < *arg3; i++ ) {
38491 11 : char szTmp[32];
38492 11 : snprintf(szTmp, sizeof(szTmp), CPL_FRMT_GUIB, (*arg2)[i]);
38493 11 : PyObject *o = PyLong_FromString(szTmp, NULL, 10);
38494 11 : PyList_SetItem(resultobj, i, o );
38495 : }
38496 : }
38497 11 : {
38498 : /* %typemap(freearg) (GUIntBig** pvals, size_t* pnCount) */
38499 11 : CPLFree(*arg2);
38500 : }
38501 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38502 : return resultobj;
38503 0 : fail:
38504 0 : {
38505 : /* %typemap(freearg) (GUIntBig** pvals, size_t* pnCount) */
38506 0 : CPLFree(*arg2);
38507 : }
38508 : return NULL;
38509 : }
38510 :
38511 :
38512 419 : SWIGINTERN PyObject *_wrap_Attribute_GetDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38513 419 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38514 419 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38515 419 : void *argp1 = 0 ;
38516 419 : int res1 = 0 ;
38517 419 : PyObject *swig_obj[1] ;
38518 419 : GDALExtendedDataTypeHS *result = 0 ;
38519 :
38520 419 : if (!args) SWIG_fail;
38521 419 : swig_obj[0] = args;
38522 419 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
38523 419 : if (!SWIG_IsOK(res1)) {
38524 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_GetDataType" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38525 : }
38526 419 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38527 419 : {
38528 419 : const int bLocalUseExceptions = GetUseExceptions();
38529 419 : if ( bLocalUseExceptions ) {
38530 203 : pushErrorHandler();
38531 : }
38532 419 : {
38533 419 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38534 419 : result = (GDALExtendedDataTypeHS *)GDALAttributeHS_GetDataType(arg1);
38535 419 : SWIG_PYTHON_THREAD_END_ALLOW;
38536 : }
38537 419 : if ( bLocalUseExceptions ) {
38538 203 : popErrorHandler();
38539 : }
38540 : #ifndef SED_HACKS
38541 : if ( bLocalUseExceptions ) {
38542 : CPLErr eclass = CPLGetLastErrorType();
38543 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38544 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38545 : }
38546 : }
38547 : #endif
38548 : }
38549 419 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALExtendedDataTypeHS, SWIG_POINTER_OWN | 0 );
38550 419 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38551 : return resultobj;
38552 : fail:
38553 : return NULL;
38554 : }
38555 :
38556 :
38557 10 : SWIGINTERN PyObject *_wrap_Attribute_ReadAsRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38558 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38559 10 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38560 10 : void **arg2 = (void **) 0 ;
38561 10 : void *argp1 = 0 ;
38562 10 : int res1 = 0 ;
38563 10 : void *pyObject2 = NULL ;
38564 10 : PyObject *swig_obj[1] ;
38565 10 : CPLErr result;
38566 :
38567 10 : {
38568 : /* %typemap(in,numinputs=0) ( void **outPythonObject ) ( void *pyObject2 = NULL ) */
38569 10 : arg2 = &pyObject2;
38570 : }
38571 10 : if (!args) SWIG_fail;
38572 10 : swig_obj[0] = args;
38573 10 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
38574 10 : if (!SWIG_IsOK(res1)) {
38575 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_ReadAsRaw" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38576 : }
38577 10 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38578 10 : {
38579 10 : const int bLocalUseExceptions = GetUseExceptions();
38580 10 : if ( bLocalUseExceptions ) {
38581 4 : pushErrorHandler();
38582 : }
38583 10 : {
38584 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38585 10 : result = (CPLErr)GDALAttributeHS_ReadAsRaw(arg1,arg2);
38586 10 : SWIG_PYTHON_THREAD_END_ALLOW;
38587 : }
38588 10 : if ( bLocalUseExceptions ) {
38589 4 : popErrorHandler();
38590 : }
38591 : #ifndef SED_HACKS
38592 : if ( bLocalUseExceptions ) {
38593 : CPLErr eclass = CPLGetLastErrorType();
38594 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38595 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38596 : }
38597 : }
38598 : #endif
38599 : }
38600 10 : resultobj = SWIG_From_int(static_cast< int >(result));
38601 10 : {
38602 : /* %typemap(argout) ( void **outPythonObject ) */
38603 10 : Py_XDECREF(resultobj);
38604 10 : if (*arg2)
38605 : {
38606 : resultobj = (PyObject*)*arg2;
38607 : }
38608 : else
38609 : {
38610 4 : resultobj = Py_None;
38611 4 : Py_INCREF(resultobj);
38612 : }
38613 : }
38614 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38615 : return resultobj;
38616 : fail:
38617 : return NULL;
38618 : }
38619 :
38620 :
38621 108 : SWIGINTERN PyObject *_wrap_Attribute_ReadAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38622 108 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38623 108 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38624 108 : void *argp1 = 0 ;
38625 108 : int res1 = 0 ;
38626 108 : PyObject *swig_obj[1] ;
38627 108 : char *result = 0 ;
38628 :
38629 108 : if (!args) SWIG_fail;
38630 108 : swig_obj[0] = args;
38631 108 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
38632 108 : if (!SWIG_IsOK(res1)) {
38633 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_ReadAsString" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38634 : }
38635 108 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38636 108 : {
38637 108 : const int bLocalUseExceptions = GetUseExceptions();
38638 108 : if ( bLocalUseExceptions ) {
38639 31 : pushErrorHandler();
38640 : }
38641 108 : {
38642 108 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38643 108 : result = (char *)GDALAttributeHS_ReadAsString(arg1);
38644 108 : SWIG_PYTHON_THREAD_END_ALLOW;
38645 : }
38646 108 : if ( bLocalUseExceptions ) {
38647 31 : popErrorHandler();
38648 : }
38649 : #ifndef SED_HACKS
38650 : if ( bLocalUseExceptions ) {
38651 : CPLErr eclass = CPLGetLastErrorType();
38652 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38653 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38654 : }
38655 : }
38656 : #endif
38657 : }
38658 108 : resultobj = SWIG_FromCharPtr((const char *)result);
38659 108 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38660 : return resultobj;
38661 : fail:
38662 : return NULL;
38663 : }
38664 :
38665 :
38666 22 : SWIGINTERN PyObject *_wrap_Attribute_ReadAsInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38667 22 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38668 22 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38669 22 : void *argp1 = 0 ;
38670 22 : int res1 = 0 ;
38671 22 : PyObject *swig_obj[1] ;
38672 22 : int result;
38673 :
38674 22 : if (!args) SWIG_fail;
38675 22 : swig_obj[0] = args;
38676 22 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
38677 22 : if (!SWIG_IsOK(res1)) {
38678 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_ReadAsInt" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38679 : }
38680 22 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38681 22 : {
38682 22 : const int bLocalUseExceptions = GetUseExceptions();
38683 22 : if ( bLocalUseExceptions ) {
38684 9 : pushErrorHandler();
38685 : }
38686 22 : {
38687 22 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38688 22 : result = (int)GDALAttributeHS_ReadAsInt(arg1);
38689 22 : SWIG_PYTHON_THREAD_END_ALLOW;
38690 : }
38691 22 : if ( bLocalUseExceptions ) {
38692 9 : popErrorHandler();
38693 : }
38694 : #ifndef SED_HACKS
38695 : if ( bLocalUseExceptions ) {
38696 : CPLErr eclass = CPLGetLastErrorType();
38697 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38698 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38699 : }
38700 : }
38701 : #endif
38702 : }
38703 22 : resultobj = SWIG_From_int(static_cast< int >(result));
38704 24 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38705 : return resultobj;
38706 : fail:
38707 : return NULL;
38708 : }
38709 :
38710 :
38711 15 : SWIGINTERN PyObject *_wrap_Attribute_ReadAsInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38712 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38713 15 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38714 15 : void *argp1 = 0 ;
38715 15 : int res1 = 0 ;
38716 15 : PyObject *swig_obj[1] ;
38717 15 : long long result;
38718 :
38719 15 : if (!args) SWIG_fail;
38720 15 : swig_obj[0] = args;
38721 15 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
38722 15 : if (!SWIG_IsOK(res1)) {
38723 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_ReadAsInt64" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38724 : }
38725 15 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38726 15 : {
38727 15 : const int bLocalUseExceptions = GetUseExceptions();
38728 15 : if ( bLocalUseExceptions ) {
38729 1 : pushErrorHandler();
38730 : }
38731 15 : {
38732 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38733 15 : result = (long long)GDALAttributeHS_ReadAsInt64(arg1);
38734 15 : SWIG_PYTHON_THREAD_END_ALLOW;
38735 : }
38736 15 : if ( bLocalUseExceptions ) {
38737 1 : popErrorHandler();
38738 : }
38739 : #ifndef SED_HACKS
38740 : if ( bLocalUseExceptions ) {
38741 : CPLErr eclass = CPLGetLastErrorType();
38742 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38743 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38744 : }
38745 : }
38746 : #endif
38747 : }
38748 15 : resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
38749 15 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38750 : return resultobj;
38751 : fail:
38752 : return NULL;
38753 : }
38754 :
38755 :
38756 40 : SWIGINTERN PyObject *_wrap_Attribute_ReadAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38757 40 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38758 40 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38759 40 : void *argp1 = 0 ;
38760 40 : int res1 = 0 ;
38761 40 : PyObject *swig_obj[1] ;
38762 40 : double result;
38763 :
38764 40 : if (!args) SWIG_fail;
38765 40 : swig_obj[0] = args;
38766 40 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
38767 40 : if (!SWIG_IsOK(res1)) {
38768 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_ReadAsDouble" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38769 : }
38770 40 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38771 40 : {
38772 40 : const int bLocalUseExceptions = GetUseExceptions();
38773 40 : if ( bLocalUseExceptions ) {
38774 6 : pushErrorHandler();
38775 : }
38776 40 : {
38777 40 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38778 40 : result = (double)GDALAttributeHS_ReadAsDouble(arg1);
38779 40 : SWIG_PYTHON_THREAD_END_ALLOW;
38780 : }
38781 40 : if ( bLocalUseExceptions ) {
38782 6 : popErrorHandler();
38783 : }
38784 : #ifndef SED_HACKS
38785 : if ( bLocalUseExceptions ) {
38786 : CPLErr eclass = CPLGetLastErrorType();
38787 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38788 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38789 : }
38790 : }
38791 : #endif
38792 : }
38793 40 : resultobj = SWIG_From_double(static_cast< double >(result));
38794 40 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38795 : return resultobj;
38796 : fail:
38797 : return NULL;
38798 : }
38799 :
38800 :
38801 19 : SWIGINTERN PyObject *_wrap_Attribute_ReadAsStringArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38802 19 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38803 19 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38804 19 : void *argp1 = 0 ;
38805 19 : int res1 = 0 ;
38806 19 : PyObject *swig_obj[1] ;
38807 19 : char **result = 0 ;
38808 :
38809 19 : if (!args) SWIG_fail;
38810 19 : swig_obj[0] = args;
38811 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
38812 19 : if (!SWIG_IsOK(res1)) {
38813 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_ReadAsStringArray" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38814 : }
38815 19 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38816 19 : {
38817 19 : const int bLocalUseExceptions = GetUseExceptions();
38818 19 : if ( bLocalUseExceptions ) {
38819 4 : pushErrorHandler();
38820 : }
38821 19 : {
38822 19 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38823 19 : result = (char **)GDALAttributeHS_ReadAsStringArray(arg1);
38824 19 : SWIG_PYTHON_THREAD_END_ALLOW;
38825 : }
38826 19 : if ( bLocalUseExceptions ) {
38827 4 : popErrorHandler();
38828 : }
38829 : #ifndef SED_HACKS
38830 : if ( bLocalUseExceptions ) {
38831 : CPLErr eclass = CPLGetLastErrorType();
38832 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38833 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38834 : }
38835 : }
38836 : #endif
38837 : }
38838 19 : {
38839 : /* %typemap(out) char **CSL -> ( string ) */
38840 19 : bool bErr = false;
38841 19 : resultobj = CSLToList(result, &bErr);
38842 19 : CSLDestroy(result);
38843 19 : if( bErr ) {
38844 0 : SWIG_fail;
38845 : }
38846 : }
38847 19 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38848 : return resultobj;
38849 : fail:
38850 : return NULL;
38851 : }
38852 :
38853 :
38854 15 : SWIGINTERN PyObject *_wrap_Attribute_ReadAsIntArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38855 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38856 15 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38857 15 : int **arg2 = (int **) 0 ;
38858 15 : size_t *arg3 = (size_t *) 0 ;
38859 15 : void *argp1 = 0 ;
38860 15 : int res1 = 0 ;
38861 15 : int *vals2 = 0 ;
38862 15 : size_t nCount2 = 0 ;
38863 15 : PyObject *swig_obj[1] ;
38864 :
38865 15 : {
38866 : /* %typemap(in,numinputs=0) (int** pvals, size_t* pnCount) */
38867 15 : arg2 = &vals2;
38868 15 : arg3 = &nCount2;
38869 : }
38870 15 : if (!args) SWIG_fail;
38871 15 : swig_obj[0] = args;
38872 15 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
38873 15 : if (!SWIG_IsOK(res1)) {
38874 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_ReadAsIntArray" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38875 : }
38876 15 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38877 15 : {
38878 15 : const int bLocalUseExceptions = GetUseExceptions();
38879 15 : if ( bLocalUseExceptions ) {
38880 4 : pushErrorHandler();
38881 : }
38882 15 : {
38883 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38884 15 : GDALAttributeHS_ReadAsIntArray(arg1,arg2,arg3);
38885 15 : SWIG_PYTHON_THREAD_END_ALLOW;
38886 : }
38887 15 : if ( bLocalUseExceptions ) {
38888 4 : popErrorHandler();
38889 : }
38890 : #ifndef SED_HACKS
38891 : if ( bLocalUseExceptions ) {
38892 : CPLErr eclass = CPLGetLastErrorType();
38893 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38894 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38895 : }
38896 : }
38897 : #endif
38898 : }
38899 15 : resultobj = SWIG_Py_Void();
38900 15 : {
38901 : /* %typemap(argout) (int** pvals, size_t* pnCount) */
38902 15 : PyObject *list = CreateTupleFromIntArray(*arg2, *arg3);
38903 15 : Py_DECREF(resultobj);
38904 15 : resultobj = list;
38905 : }
38906 15 : {
38907 : /* %typemap(freearg) (int** pvals, size_t* pnCount) */
38908 15 : CPLFree(*arg2);
38909 : }
38910 15 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38911 : return resultobj;
38912 0 : fail:
38913 0 : {
38914 : /* %typemap(freearg) (int** pvals, size_t* pnCount) */
38915 0 : CPLFree(*arg2);
38916 : }
38917 : return NULL;
38918 : }
38919 :
38920 :
38921 14 : SWIGINTERN PyObject *_wrap_Attribute_ReadAsInt64Array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38922 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38923 14 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38924 14 : long long **arg2 = (long long **) 0 ;
38925 14 : size_t *arg3 = (size_t *) 0 ;
38926 14 : void *argp1 = 0 ;
38927 14 : int res1 = 0 ;
38928 14 : long long *vals2 = 0 ;
38929 14 : size_t nCount2 = 0 ;
38930 14 : PyObject *swig_obj[1] ;
38931 :
38932 14 : {
38933 : /* %typemap(in,numinputs=0) (long long** pvals, size_t* pnCount) */
38934 14 : arg2 = &vals2;
38935 14 : arg3 = &nCount2;
38936 : }
38937 14 : if (!args) SWIG_fail;
38938 14 : swig_obj[0] = args;
38939 14 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
38940 14 : if (!SWIG_IsOK(res1)) {
38941 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_ReadAsInt64Array" "', argument " "1"" of type '" "GDALAttributeHS *""'");
38942 : }
38943 14 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
38944 14 : {
38945 14 : const int bLocalUseExceptions = GetUseExceptions();
38946 14 : if ( bLocalUseExceptions ) {
38947 1 : pushErrorHandler();
38948 : }
38949 14 : {
38950 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38951 14 : GDALAttributeHS_ReadAsInt64Array(arg1,arg2,arg3);
38952 14 : SWIG_PYTHON_THREAD_END_ALLOW;
38953 : }
38954 14 : if ( bLocalUseExceptions ) {
38955 1 : popErrorHandler();
38956 : }
38957 : #ifndef SED_HACKS
38958 : if ( bLocalUseExceptions ) {
38959 : CPLErr eclass = CPLGetLastErrorType();
38960 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
38961 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
38962 : }
38963 : }
38964 : #endif
38965 : }
38966 14 : resultobj = SWIG_Py_Void();
38967 14 : {
38968 : /* %typemap(argout) (int** pvals, size_t* pnCount) */
38969 14 : PyObject *list = CreateTupleFromInt64Array(*arg2, *arg3);
38970 14 : Py_DECREF(resultobj);
38971 14 : resultobj = list;
38972 : }
38973 14 : {
38974 : /* %typemap(freearg) (long long** pvals, size_t* pnCount) */
38975 14 : CPLFree(*arg2);
38976 : }
38977 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
38978 : return resultobj;
38979 0 : fail:
38980 0 : {
38981 : /* %typemap(freearg) (long long** pvals, size_t* pnCount) */
38982 0 : CPLFree(*arg2);
38983 : }
38984 : return NULL;
38985 : }
38986 :
38987 :
38988 29 : SWIGINTERN PyObject *_wrap_Attribute_ReadAsDoubleArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38989 29 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
38990 29 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
38991 29 : double **arg2 = (double **) 0 ;
38992 29 : size_t *arg3 = (size_t *) 0 ;
38993 29 : void *argp1 = 0 ;
38994 29 : int res1 = 0 ;
38995 29 : double *vals2 = 0 ;
38996 29 : size_t nCount2 = 0 ;
38997 29 : PyObject *swig_obj[1] ;
38998 :
38999 29 : {
39000 : /* %typemap(in,numinputs=0) (double** pvals, size_t* pnCount) */
39001 29 : arg2 = &vals2;
39002 29 : arg3 = &nCount2;
39003 : }
39004 29 : if (!args) SWIG_fail;
39005 29 : swig_obj[0] = args;
39006 29 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
39007 29 : if (!SWIG_IsOK(res1)) {
39008 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_ReadAsDoubleArray" "', argument " "1"" of type '" "GDALAttributeHS *""'");
39009 : }
39010 29 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
39011 29 : {
39012 29 : const int bLocalUseExceptions = GetUseExceptions();
39013 29 : if ( bLocalUseExceptions ) {
39014 3 : pushErrorHandler();
39015 : }
39016 29 : {
39017 29 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39018 29 : GDALAttributeHS_ReadAsDoubleArray(arg1,arg2,arg3);
39019 29 : SWIG_PYTHON_THREAD_END_ALLOW;
39020 : }
39021 29 : if ( bLocalUseExceptions ) {
39022 3 : popErrorHandler();
39023 : }
39024 : #ifndef SED_HACKS
39025 : if ( bLocalUseExceptions ) {
39026 : CPLErr eclass = CPLGetLastErrorType();
39027 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39028 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39029 : }
39030 : }
39031 : #endif
39032 : }
39033 29 : resultobj = SWIG_Py_Void();
39034 29 : {
39035 : /* %typemap(argout) (double** pvals, size_t* pnCount) */
39036 29 : PyObject *list = CreateTupleFromDoubleArray(*arg2, *arg3);
39037 29 : Py_DECREF(resultobj);
39038 29 : resultobj = list;
39039 : }
39040 29 : {
39041 : /* %typemap(freearg) (double** pvals, size_t* pnCount) */
39042 29 : CPLFree(*arg2);
39043 : }
39044 29 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39045 : return resultobj;
39046 0 : fail:
39047 0 : {
39048 : /* %typemap(freearg) (double** pvals, size_t* pnCount) */
39049 0 : CPLFree(*arg2);
39050 : }
39051 : return NULL;
39052 : }
39053 :
39054 :
39055 5 : SWIGINTERN PyObject *_wrap_Attribute_WriteRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39056 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39057 5 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
39058 5 : GIntBig arg2 ;
39059 5 : char *arg3 = (char *) 0 ;
39060 5 : void *argp1 = 0 ;
39061 5 : int res1 = 0 ;
39062 5 : int alloc2 = 0 ;
39063 5 : bool viewIsValid2 = false ;
39064 5 : Py_buffer view2 ;
39065 5 : PyObject *swig_obj[2] ;
39066 5 : CPLErr result;
39067 :
39068 5 : if (!SWIG_Python_UnpackTuple(args, "Attribute_WriteRaw", 2, 2, swig_obj)) SWIG_fail;
39069 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
39070 5 : if (!SWIG_IsOK(res1)) {
39071 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_WriteRaw" "', argument " "1"" of type '" "GDALAttributeHS *""'");
39072 : }
39073 5 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
39074 5 : {
39075 : /* %typemap(in,numinputs=1) (GIntBig nLen, char *pBuf ) */
39076 5 : char* ptr = NULL;
39077 5 : if( !GetBufferAsCharPtrGIntBigSize(swig_obj[1], &arg2, &ptr, &alloc2, &viewIsValid2, &view2) ) {
39078 0 : SWIG_fail;
39079 : }
39080 5 : arg3 = (char *)ptr;
39081 : }
39082 5 : {
39083 5 : const int bLocalUseExceptions = GetUseExceptions();
39084 5 : if ( bLocalUseExceptions ) {
39085 4 : pushErrorHandler();
39086 : }
39087 5 : {
39088 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39089 5 : result = (CPLErr)GDALAttributeHS_WriteRaw(arg1,arg2,arg3);
39090 5 : SWIG_PYTHON_THREAD_END_ALLOW;
39091 : }
39092 5 : if ( bLocalUseExceptions ) {
39093 4 : popErrorHandler();
39094 : }
39095 : #ifndef SED_HACKS
39096 : if ( bLocalUseExceptions ) {
39097 : CPLErr eclass = CPLGetLastErrorType();
39098 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39099 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39100 : }
39101 : }
39102 : #endif
39103 : }
39104 5 : resultobj = SWIG_From_int(static_cast< int >(result));
39105 5 : {
39106 : /* %typemap(freearg) (GIntBig *nLen, char *pBuf ) */
39107 5 : if( viewIsValid2 ) {
39108 5 : PyBuffer_Release(&view2);
39109 : }
39110 0 : else if (ReturnSame(alloc2) == SWIG_NEWOBJ ) {
39111 0 : delete[] arg3;
39112 : }
39113 : }
39114 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39115 : return resultobj;
39116 0 : fail:
39117 0 : {
39118 : /* %typemap(freearg) (GIntBig *nLen, char *pBuf ) */
39119 0 : if( viewIsValid2 ) {
39120 0 : PyBuffer_Release(&view2);
39121 : }
39122 5 : else if (ReturnSame(alloc2) == SWIG_NEWOBJ ) {
39123 : delete[] arg3;
39124 : }
39125 : }
39126 : return NULL;
39127 : }
39128 :
39129 :
39130 207 : SWIGINTERN PyObject *_wrap_Attribute_WriteString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39131 207 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39132 207 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
39133 207 : char *arg2 = (char *) 0 ;
39134 207 : void *argp1 = 0 ;
39135 207 : int res1 = 0 ;
39136 207 : int res2 ;
39137 207 : char *buf2 = 0 ;
39138 207 : int alloc2 = 0 ;
39139 207 : PyObject *swig_obj[2] ;
39140 207 : CPLErr result;
39141 :
39142 207 : if (!SWIG_Python_UnpackTuple(args, "Attribute_WriteString", 2, 2, swig_obj)) SWIG_fail;
39143 207 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
39144 207 : if (!SWIG_IsOK(res1)) {
39145 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_WriteString" "', argument " "1"" of type '" "GDALAttributeHS *""'");
39146 : }
39147 207 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
39148 207 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
39149 207 : if (!SWIG_IsOK(res2)) {
39150 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Attribute_WriteString" "', argument " "2"" of type '" "char const *""'");
39151 : }
39152 207 : arg2 = reinterpret_cast< char * >(buf2);
39153 207 : {
39154 207 : const int bLocalUseExceptions = GetUseExceptions();
39155 207 : if ( bLocalUseExceptions ) {
39156 164 : pushErrorHandler();
39157 : }
39158 207 : {
39159 207 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39160 207 : result = (CPLErr)GDALAttributeHS_WriteString(arg1,(char const *)arg2);
39161 207 : SWIG_PYTHON_THREAD_END_ALLOW;
39162 : }
39163 207 : if ( bLocalUseExceptions ) {
39164 164 : popErrorHandler();
39165 : }
39166 : #ifndef SED_HACKS
39167 : if ( bLocalUseExceptions ) {
39168 : CPLErr eclass = CPLGetLastErrorType();
39169 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39170 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39171 : }
39172 : }
39173 : #endif
39174 : }
39175 207 : resultobj = SWIG_From_int(static_cast< int >(result));
39176 207 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
39177 233 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39178 : return resultobj;
39179 0 : fail:
39180 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
39181 : return NULL;
39182 : }
39183 :
39184 :
39185 8 : SWIGINTERN PyObject *_wrap_Attribute_WriteStringArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39186 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39187 8 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
39188 8 : char **arg2 = (char **) 0 ;
39189 8 : void *argp1 = 0 ;
39190 8 : int res1 = 0 ;
39191 8 : PyObject *swig_obj[2] ;
39192 8 : CPLErr result;
39193 :
39194 8 : if (!SWIG_Python_UnpackTuple(args, "Attribute_WriteStringArray", 2, 2, swig_obj)) SWIG_fail;
39195 8 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
39196 8 : if (!SWIG_IsOK(res1)) {
39197 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_WriteStringArray" "', argument " "1"" of type '" "GDALAttributeHS *""'");
39198 : }
39199 8 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
39200 8 : {
39201 : /* %typemap(in) char **dict */
39202 8 : arg2 = NULL;
39203 8 : if ( PySequence_Check( swig_obj[1] ) ) {
39204 8 : int bErr = FALSE;
39205 8 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
39206 8 : if ( bErr )
39207 : {
39208 0 : SWIG_fail;
39209 : }
39210 : }
39211 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
39212 0 : int bErr = FALSE;
39213 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
39214 0 : if ( bErr )
39215 : {
39216 0 : SWIG_fail;
39217 : }
39218 : }
39219 : else {
39220 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
39221 0 : SWIG_fail;
39222 : }
39223 : }
39224 8 : {
39225 8 : const int bLocalUseExceptions = GetUseExceptions();
39226 8 : if ( bLocalUseExceptions ) {
39227 0 : pushErrorHandler();
39228 : }
39229 8 : {
39230 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39231 8 : result = (CPLErr)GDALAttributeHS_WriteStringArray(arg1,arg2);
39232 8 : SWIG_PYTHON_THREAD_END_ALLOW;
39233 : }
39234 8 : if ( bLocalUseExceptions ) {
39235 0 : popErrorHandler();
39236 : }
39237 : #ifndef SED_HACKS
39238 : if ( bLocalUseExceptions ) {
39239 : CPLErr eclass = CPLGetLastErrorType();
39240 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39241 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39242 : }
39243 : }
39244 : #endif
39245 : }
39246 8 : resultobj = SWIG_From_int(static_cast< int >(result));
39247 8 : {
39248 : /* %typemap(freearg) char **dict */
39249 8 : CSLDestroy( arg2 );
39250 : }
39251 8 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39252 : return resultobj;
39253 0 : fail:
39254 0 : {
39255 : /* %typemap(freearg) char **dict */
39256 0 : CSLDestroy( arg2 );
39257 : }
39258 : return NULL;
39259 : }
39260 :
39261 :
39262 22 : SWIGINTERN PyObject *_wrap_Attribute_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39263 22 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39264 22 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
39265 22 : int arg2 ;
39266 22 : void *argp1 = 0 ;
39267 22 : int res1 = 0 ;
39268 22 : int val2 ;
39269 22 : int ecode2 = 0 ;
39270 22 : PyObject *swig_obj[2] ;
39271 22 : CPLErr result;
39272 :
39273 22 : if (!SWIG_Python_UnpackTuple(args, "Attribute_WriteInt", 2, 2, swig_obj)) SWIG_fail;
39274 22 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
39275 22 : if (!SWIG_IsOK(res1)) {
39276 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_WriteInt" "', argument " "1"" of type '" "GDALAttributeHS *""'");
39277 : }
39278 22 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
39279 22 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
39280 22 : if (!SWIG_IsOK(ecode2)) {
39281 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Attribute_WriteInt" "', argument " "2"" of type '" "int""'");
39282 : }
39283 22 : arg2 = static_cast< int >(val2);
39284 22 : {
39285 22 : const int bLocalUseExceptions = GetUseExceptions();
39286 22 : if ( bLocalUseExceptions ) {
39287 4 : pushErrorHandler();
39288 : }
39289 22 : {
39290 22 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39291 22 : result = (CPLErr)GDALAttributeHS_WriteInt(arg1,arg2);
39292 22 : SWIG_PYTHON_THREAD_END_ALLOW;
39293 : }
39294 22 : if ( bLocalUseExceptions ) {
39295 4 : popErrorHandler();
39296 : }
39297 : #ifndef SED_HACKS
39298 : if ( bLocalUseExceptions ) {
39299 : CPLErr eclass = CPLGetLastErrorType();
39300 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39301 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39302 : }
39303 : }
39304 : #endif
39305 : }
39306 22 : resultobj = SWIG_From_int(static_cast< int >(result));
39307 24 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39308 : return resultobj;
39309 : fail:
39310 : return NULL;
39311 : }
39312 :
39313 :
39314 11 : SWIGINTERN PyObject *_wrap_Attribute_WriteInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39315 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39316 11 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
39317 11 : long long arg2 ;
39318 11 : void *argp1 = 0 ;
39319 11 : int res1 = 0 ;
39320 11 : long long val2 ;
39321 11 : int ecode2 = 0 ;
39322 11 : PyObject *swig_obj[2] ;
39323 11 : CPLErr result;
39324 :
39325 11 : if (!SWIG_Python_UnpackTuple(args, "Attribute_WriteInt64", 2, 2, swig_obj)) SWIG_fail;
39326 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
39327 11 : if (!SWIG_IsOK(res1)) {
39328 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_WriteInt64" "', argument " "1"" of type '" "GDALAttributeHS *""'");
39329 : }
39330 11 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
39331 11 : ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
39332 11 : if (!SWIG_IsOK(ecode2)) {
39333 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Attribute_WriteInt64" "', argument " "2"" of type '" "long long""'");
39334 : }
39335 11 : arg2 = static_cast< long long >(val2);
39336 11 : {
39337 11 : const int bLocalUseExceptions = GetUseExceptions();
39338 11 : if ( bLocalUseExceptions ) {
39339 0 : pushErrorHandler();
39340 : }
39341 11 : {
39342 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39343 11 : result = (CPLErr)GDALAttributeHS_WriteInt64(arg1,arg2);
39344 11 : SWIG_PYTHON_THREAD_END_ALLOW;
39345 : }
39346 11 : if ( bLocalUseExceptions ) {
39347 0 : popErrorHandler();
39348 : }
39349 : #ifndef SED_HACKS
39350 : if ( bLocalUseExceptions ) {
39351 : CPLErr eclass = CPLGetLastErrorType();
39352 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39353 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39354 : }
39355 : }
39356 : #endif
39357 : }
39358 11 : resultobj = SWIG_From_int(static_cast< int >(result));
39359 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39360 : return resultobj;
39361 : fail:
39362 : return NULL;
39363 : }
39364 :
39365 :
39366 11 : SWIGINTERN PyObject *_wrap_Attribute_WriteDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39367 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39368 11 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
39369 11 : double arg2 ;
39370 11 : void *argp1 = 0 ;
39371 11 : int res1 = 0 ;
39372 11 : double val2 ;
39373 11 : int ecode2 = 0 ;
39374 11 : PyObject *swig_obj[2] ;
39375 11 : CPLErr result;
39376 :
39377 11 : if (!SWIG_Python_UnpackTuple(args, "Attribute_WriteDouble", 2, 2, swig_obj)) SWIG_fail;
39378 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
39379 11 : if (!SWIG_IsOK(res1)) {
39380 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_WriteDouble" "', argument " "1"" of type '" "GDALAttributeHS *""'");
39381 : }
39382 11 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
39383 11 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
39384 11 : if (!SWIG_IsOK(ecode2)) {
39385 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Attribute_WriteDouble" "', argument " "2"" of type '" "double""'");
39386 : }
39387 11 : arg2 = static_cast< double >(val2);
39388 11 : {
39389 11 : const int bLocalUseExceptions = GetUseExceptions();
39390 11 : if ( bLocalUseExceptions ) {
39391 1 : pushErrorHandler();
39392 : }
39393 11 : {
39394 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39395 11 : result = (CPLErr)GDALAttributeHS_WriteDouble(arg1,arg2);
39396 11 : SWIG_PYTHON_THREAD_END_ALLOW;
39397 : }
39398 11 : if ( bLocalUseExceptions ) {
39399 1 : popErrorHandler();
39400 : }
39401 : #ifndef SED_HACKS
39402 : if ( bLocalUseExceptions ) {
39403 : CPLErr eclass = CPLGetLastErrorType();
39404 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39405 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39406 : }
39407 : }
39408 : #endif
39409 : }
39410 11 : resultobj = SWIG_From_int(static_cast< int >(result));
39411 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39412 : return resultobj;
39413 : fail:
39414 : return NULL;
39415 : }
39416 :
39417 :
39418 11 : SWIGINTERN PyObject *_wrap_Attribute_WriteIntArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39419 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39420 11 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
39421 11 : int arg2 ;
39422 11 : int *arg3 = (int *) 0 ;
39423 11 : void *argp1 = 0 ;
39424 11 : int res1 = 0 ;
39425 11 : PyObject *swig_obj[2] ;
39426 11 : CPLErr result;
39427 :
39428 11 : if (!SWIG_Python_UnpackTuple(args, "Attribute_WriteIntArray", 2, 2, swig_obj)) SWIG_fail;
39429 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
39430 11 : if (!SWIG_IsOK(res1)) {
39431 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_WriteIntArray" "', argument " "1"" of type '" "GDALAttributeHS *""'");
39432 : }
39433 11 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
39434 11 : {
39435 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
39436 11 : arg3 = CreateCIntListFromSequence(swig_obj[1], &arg2);
39437 11 : if( arg2 < 0 ) {
39438 0 : SWIG_fail;
39439 : }
39440 : }
39441 11 : {
39442 11 : const int bLocalUseExceptions = GetUseExceptions();
39443 11 : if ( bLocalUseExceptions ) {
39444 3 : pushErrorHandler();
39445 : }
39446 11 : {
39447 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39448 11 : result = (CPLErr)GDALAttributeHS_WriteIntArray(arg1,arg2,arg3);
39449 11 : SWIG_PYTHON_THREAD_END_ALLOW;
39450 : }
39451 11 : if ( bLocalUseExceptions ) {
39452 3 : popErrorHandler();
39453 : }
39454 : #ifndef SED_HACKS
39455 : if ( bLocalUseExceptions ) {
39456 : CPLErr eclass = CPLGetLastErrorType();
39457 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39458 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39459 : }
39460 : }
39461 : #endif
39462 : }
39463 11 : resultobj = SWIG_From_int(static_cast< int >(result));
39464 11 : {
39465 : /* %typemap(freearg) (int nList, int* pList) */
39466 11 : free(arg3);
39467 : }
39468 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39469 : return resultobj;
39470 0 : fail:
39471 0 : {
39472 : /* %typemap(freearg) (int nList, int* pList) */
39473 0 : free(arg3);
39474 : }
39475 0 : return NULL;
39476 : }
39477 :
39478 :
39479 10 : SWIGINTERN PyObject *_wrap_Attribute_WriteInt64Array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39480 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39481 10 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
39482 10 : int arg2 ;
39483 10 : long long *arg3 = (long long *) 0 ;
39484 10 : void *argp1 = 0 ;
39485 10 : int res1 = 0 ;
39486 10 : PyObject *swig_obj[2] ;
39487 10 : CPLErr result;
39488 :
39489 10 : if (!SWIG_Python_UnpackTuple(args, "Attribute_WriteInt64Array", 2, 2, swig_obj)) SWIG_fail;
39490 10 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
39491 10 : if (!SWIG_IsOK(res1)) {
39492 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_WriteInt64Array" "', argument " "1"" of type '" "GDALAttributeHS *""'");
39493 : }
39494 10 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
39495 10 : {
39496 : /* %typemap(in,numinputs=1) (int nList, long long* pList)*/
39497 10 : arg3 = CreateCInt64ListFromSequence(swig_obj[1], &arg2);
39498 10 : if( arg2 < 0 ) {
39499 0 : SWIG_fail;
39500 : }
39501 : }
39502 10 : {
39503 10 : const int bLocalUseExceptions = GetUseExceptions();
39504 10 : if ( bLocalUseExceptions ) {
39505 0 : pushErrorHandler();
39506 : }
39507 10 : {
39508 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39509 10 : result = (CPLErr)GDALAttributeHS_WriteInt64Array(arg1,arg2,arg3);
39510 10 : SWIG_PYTHON_THREAD_END_ALLOW;
39511 : }
39512 10 : if ( bLocalUseExceptions ) {
39513 0 : popErrorHandler();
39514 : }
39515 : #ifndef SED_HACKS
39516 : if ( bLocalUseExceptions ) {
39517 : CPLErr eclass = CPLGetLastErrorType();
39518 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39519 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39520 : }
39521 : }
39522 : #endif
39523 : }
39524 10 : resultobj = SWIG_From_int(static_cast< int >(result));
39525 10 : {
39526 : /* %typemap(freearg) (int nList, long long* pList) */
39527 10 : free(arg3);
39528 : }
39529 10 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39530 : return resultobj;
39531 0 : fail:
39532 0 : {
39533 : /* %typemap(freearg) (int nList, long long* pList) */
39534 0 : free(arg3);
39535 : }
39536 0 : return NULL;
39537 : }
39538 :
39539 :
39540 7 : SWIGINTERN PyObject *_wrap_Attribute_WriteDoubleArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39541 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39542 7 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
39543 7 : int arg2 ;
39544 7 : double *arg3 = (double *) 0 ;
39545 7 : void *argp1 = 0 ;
39546 7 : int res1 = 0 ;
39547 7 : PyObject *swig_obj[2] ;
39548 7 : CPLErr result;
39549 :
39550 7 : if (!SWIG_Python_UnpackTuple(args, "Attribute_WriteDoubleArray", 2, 2, swig_obj)) SWIG_fail;
39551 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
39552 7 : if (!SWIG_IsOK(res1)) {
39553 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_WriteDoubleArray" "', argument " "1"" of type '" "GDALAttributeHS *""'");
39554 : }
39555 7 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
39556 7 : {
39557 : /* %typemap(in,numinputs=1) (int nList, double* pList)*/
39558 7 : arg3 = CreateCDoubleListFromSequence(swig_obj[1], &arg2);
39559 7 : if( arg2 < 0 ) {
39560 0 : SWIG_fail;
39561 : }
39562 : }
39563 7 : {
39564 7 : const int bLocalUseExceptions = GetUseExceptions();
39565 7 : if ( bLocalUseExceptions ) {
39566 0 : pushErrorHandler();
39567 : }
39568 7 : {
39569 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39570 7 : result = (CPLErr)GDALAttributeHS_WriteDoubleArray(arg1,arg2,arg3);
39571 7 : SWIG_PYTHON_THREAD_END_ALLOW;
39572 : }
39573 7 : if ( bLocalUseExceptions ) {
39574 0 : popErrorHandler();
39575 : }
39576 : #ifndef SED_HACKS
39577 : if ( bLocalUseExceptions ) {
39578 : CPLErr eclass = CPLGetLastErrorType();
39579 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39580 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39581 : }
39582 : }
39583 : #endif
39584 : }
39585 7 : resultobj = SWIG_From_int(static_cast< int >(result));
39586 7 : {
39587 : /* %typemap(freearg) (int nList, double* pList) */
39588 7 : free(arg3);
39589 : }
39590 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39591 : return resultobj;
39592 0 : fail:
39593 0 : {
39594 : /* %typemap(freearg) (int nList, double* pList) */
39595 0 : free(arg3);
39596 : }
39597 0 : return NULL;
39598 : }
39599 :
39600 :
39601 27 : SWIGINTERN PyObject *_wrap_Attribute_Rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39602 27 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39603 27 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
39604 27 : char *arg2 = (char *) 0 ;
39605 27 : void *argp1 = 0 ;
39606 27 : int res1 = 0 ;
39607 27 : int res2 ;
39608 27 : char *buf2 = 0 ;
39609 27 : int alloc2 = 0 ;
39610 27 : PyObject *swig_obj[2] ;
39611 27 : CPLErr result;
39612 :
39613 27 : if (!SWIG_Python_UnpackTuple(args, "Attribute_Rename", 2, 2, swig_obj)) SWIG_fail;
39614 27 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAttributeHS, 0 | 0 );
39615 27 : if (!SWIG_IsOK(res1)) {
39616 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_Rename" "', argument " "1"" of type '" "GDALAttributeHS *""'");
39617 : }
39618 27 : arg1 = reinterpret_cast< GDALAttributeHS * >(argp1);
39619 27 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
39620 27 : if (!SWIG_IsOK(res2)) {
39621 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Attribute_Rename" "', argument " "2"" of type '" "char const *""'");
39622 : }
39623 27 : arg2 = reinterpret_cast< char * >(buf2);
39624 27 : {
39625 27 : const int bLocalUseExceptions = GetUseExceptions();
39626 27 : if ( bLocalUseExceptions ) {
39627 27 : pushErrorHandler();
39628 : }
39629 27 : {
39630 27 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39631 27 : result = (CPLErr)GDALAttributeHS_Rename(arg1,(char const *)arg2);
39632 27 : SWIG_PYTHON_THREAD_END_ALLOW;
39633 : }
39634 27 : if ( bLocalUseExceptions ) {
39635 27 : popErrorHandler();
39636 : }
39637 : #ifndef SED_HACKS
39638 : if ( bLocalUseExceptions ) {
39639 : CPLErr eclass = CPLGetLastErrorType();
39640 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39641 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39642 : }
39643 : }
39644 : #endif
39645 : }
39646 27 : resultobj = SWIG_From_int(static_cast< int >(result));
39647 27 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
39648 61 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39649 : return resultobj;
39650 0 : fail:
39651 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
39652 : return NULL;
39653 : }
39654 :
39655 :
39656 277 : SWIGINTERN PyObject *Attribute_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39657 277 : PyObject *obj;
39658 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
39659 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALAttributeHS, SWIG_NewClientData(obj));
39660 277 : return SWIG_Py_Void();
39661 : }
39662 :
39663 5324 : SWIGINTERN PyObject *_wrap_delete_Dimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39664 5324 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39665 5324 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
39666 5324 : void *argp1 = 0 ;
39667 5324 : int res1 = 0 ;
39668 5324 : PyObject *swig_obj[1] ;
39669 :
39670 5324 : if (!args) SWIG_fail;
39671 5324 : swig_obj[0] = args;
39672 5324 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDimensionHS, SWIG_POINTER_DISOWN | 0 );
39673 5324 : if (!SWIG_IsOK(res1)) {
39674 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dimension" "', argument " "1"" of type '" "GDALDimensionHS *""'");
39675 : }
39676 5324 : arg1 = reinterpret_cast< GDALDimensionHS * >(argp1);
39677 5324 : {
39678 5324 : const int bLocalUseExceptions = GetUseExceptions();
39679 5324 : if ( bLocalUseExceptions ) {
39680 928 : pushErrorHandler();
39681 : }
39682 5324 : {
39683 5324 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39684 5324 : delete_GDALDimensionHS(arg1);
39685 5324 : SWIG_PYTHON_THREAD_END_ALLOW;
39686 : }
39687 5324 : if ( bLocalUseExceptions ) {
39688 928 : popErrorHandler();
39689 : }
39690 : #ifndef SED_HACKS
39691 : if ( bLocalUseExceptions ) {
39692 : CPLErr eclass = CPLGetLastErrorType();
39693 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39694 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39695 : }
39696 : }
39697 : #endif
39698 : }
39699 5324 : resultobj = SWIG_Py_Void();
39700 5324 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39701 : return resultobj;
39702 : fail:
39703 : return NULL;
39704 : }
39705 :
39706 :
39707 286 : SWIGINTERN PyObject *_wrap_Dimension_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39708 286 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39709 286 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
39710 286 : void *argp1 = 0 ;
39711 286 : int res1 = 0 ;
39712 286 : PyObject *swig_obj[1] ;
39713 286 : char *result = 0 ;
39714 :
39715 286 : if (!args) SWIG_fail;
39716 286 : swig_obj[0] = args;
39717 286 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDimensionHS, 0 | 0 );
39718 286 : if (!SWIG_IsOK(res1)) {
39719 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dimension_GetName" "', argument " "1"" of type '" "GDALDimensionHS *""'");
39720 : }
39721 286 : arg1 = reinterpret_cast< GDALDimensionHS * >(argp1);
39722 286 : {
39723 286 : const int bLocalUseExceptions = GetUseExceptions();
39724 286 : if ( bLocalUseExceptions ) {
39725 141 : pushErrorHandler();
39726 : }
39727 286 : {
39728 286 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39729 286 : result = (char *)GDALDimensionHS_GetName(arg1);
39730 286 : SWIG_PYTHON_THREAD_END_ALLOW;
39731 : }
39732 286 : if ( bLocalUseExceptions ) {
39733 141 : popErrorHandler();
39734 : }
39735 : #ifndef SED_HACKS
39736 : if ( bLocalUseExceptions ) {
39737 : CPLErr eclass = CPLGetLastErrorType();
39738 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39739 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39740 : }
39741 : }
39742 : #endif
39743 : }
39744 286 : resultobj = SWIG_FromCharPtr((const char *)result);
39745 286 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39746 : return resultobj;
39747 : fail:
39748 : return NULL;
39749 : }
39750 :
39751 :
39752 82 : SWIGINTERN PyObject *_wrap_Dimension_GetFullName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39753 82 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39754 82 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
39755 82 : void *argp1 = 0 ;
39756 82 : int res1 = 0 ;
39757 82 : PyObject *swig_obj[1] ;
39758 82 : char *result = 0 ;
39759 :
39760 82 : if (!args) SWIG_fail;
39761 82 : swig_obj[0] = args;
39762 82 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDimensionHS, 0 | 0 );
39763 82 : if (!SWIG_IsOK(res1)) {
39764 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dimension_GetFullName" "', argument " "1"" of type '" "GDALDimensionHS *""'");
39765 : }
39766 82 : arg1 = reinterpret_cast< GDALDimensionHS * >(argp1);
39767 82 : {
39768 82 : const int bLocalUseExceptions = GetUseExceptions();
39769 82 : if ( bLocalUseExceptions ) {
39770 51 : pushErrorHandler();
39771 : }
39772 82 : {
39773 82 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39774 82 : result = (char *)GDALDimensionHS_GetFullName(arg1);
39775 82 : SWIG_PYTHON_THREAD_END_ALLOW;
39776 : }
39777 82 : if ( bLocalUseExceptions ) {
39778 51 : popErrorHandler();
39779 : }
39780 : #ifndef SED_HACKS
39781 : if ( bLocalUseExceptions ) {
39782 : CPLErr eclass = CPLGetLastErrorType();
39783 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39784 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39785 : }
39786 : }
39787 : #endif
39788 : }
39789 82 : resultobj = SWIG_FromCharPtr((const char *)result);
39790 82 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39791 : return resultobj;
39792 : fail:
39793 : return NULL;
39794 : }
39795 :
39796 :
39797 60 : SWIGINTERN PyObject *_wrap_Dimension_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39798 60 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39799 60 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
39800 60 : void *argp1 = 0 ;
39801 60 : int res1 = 0 ;
39802 60 : PyObject *swig_obj[1] ;
39803 60 : char *result = 0 ;
39804 :
39805 60 : if (!args) SWIG_fail;
39806 60 : swig_obj[0] = args;
39807 60 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDimensionHS, 0 | 0 );
39808 60 : if (!SWIG_IsOK(res1)) {
39809 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dimension_GetType" "', argument " "1"" of type '" "GDALDimensionHS *""'");
39810 : }
39811 60 : arg1 = reinterpret_cast< GDALDimensionHS * >(argp1);
39812 60 : {
39813 60 : const int bLocalUseExceptions = GetUseExceptions();
39814 60 : if ( bLocalUseExceptions ) {
39815 14 : pushErrorHandler();
39816 : }
39817 60 : {
39818 60 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39819 60 : result = (char *)GDALDimensionHS_GetType(arg1);
39820 60 : SWIG_PYTHON_THREAD_END_ALLOW;
39821 : }
39822 60 : if ( bLocalUseExceptions ) {
39823 14 : popErrorHandler();
39824 : }
39825 : #ifndef SED_HACKS
39826 : if ( bLocalUseExceptions ) {
39827 : CPLErr eclass = CPLGetLastErrorType();
39828 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39829 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39830 : }
39831 : }
39832 : #endif
39833 : }
39834 60 : resultobj = SWIG_FromCharPtr((const char *)result);
39835 60 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39836 : return resultobj;
39837 : fail:
39838 : return NULL;
39839 : }
39840 :
39841 :
39842 28 : SWIGINTERN PyObject *_wrap_Dimension_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39843 28 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39844 28 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
39845 28 : void *argp1 = 0 ;
39846 28 : int res1 = 0 ;
39847 28 : PyObject *swig_obj[1] ;
39848 28 : char *result = 0 ;
39849 :
39850 28 : if (!args) SWIG_fail;
39851 28 : swig_obj[0] = args;
39852 28 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDimensionHS, 0 | 0 );
39853 28 : if (!SWIG_IsOK(res1)) {
39854 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dimension_GetDirection" "', argument " "1"" of type '" "GDALDimensionHS *""'");
39855 : }
39856 28 : arg1 = reinterpret_cast< GDALDimensionHS * >(argp1);
39857 28 : {
39858 28 : const int bLocalUseExceptions = GetUseExceptions();
39859 28 : if ( bLocalUseExceptions ) {
39860 8 : pushErrorHandler();
39861 : }
39862 28 : {
39863 28 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39864 28 : result = (char *)GDALDimensionHS_GetDirection(arg1);
39865 28 : SWIG_PYTHON_THREAD_END_ALLOW;
39866 : }
39867 28 : if ( bLocalUseExceptions ) {
39868 8 : popErrorHandler();
39869 : }
39870 : #ifndef SED_HACKS
39871 : if ( bLocalUseExceptions ) {
39872 : CPLErr eclass = CPLGetLastErrorType();
39873 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39874 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39875 : }
39876 : }
39877 : #endif
39878 : }
39879 28 : resultobj = SWIG_FromCharPtr((const char *)result);
39880 28 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39881 : return resultobj;
39882 : fail:
39883 : return NULL;
39884 : }
39885 :
39886 :
39887 3952 : SWIGINTERN PyObject *_wrap_Dimension_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39888 3952 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39889 3952 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
39890 3952 : void *argp1 = 0 ;
39891 3952 : int res1 = 0 ;
39892 3952 : PyObject *swig_obj[1] ;
39893 3952 : GUIntBig result;
39894 :
39895 3952 : if (!args) SWIG_fail;
39896 3952 : swig_obj[0] = args;
39897 3952 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDimensionHS, 0 | 0 );
39898 3952 : if (!SWIG_IsOK(res1)) {
39899 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dimension_GetSize" "', argument " "1"" of type '" "GDALDimensionHS *""'");
39900 : }
39901 3952 : arg1 = reinterpret_cast< GDALDimensionHS * >(argp1);
39902 3952 : {
39903 3952 : const int bLocalUseExceptions = GetUseExceptions();
39904 3952 : if ( bLocalUseExceptions ) {
39905 623 : pushErrorHandler();
39906 : }
39907 3952 : {
39908 3952 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39909 3952 : result = GDALDimensionHS_GetSize(arg1);
39910 3952 : SWIG_PYTHON_THREAD_END_ALLOW;
39911 : }
39912 3952 : if ( bLocalUseExceptions ) {
39913 623 : popErrorHandler();
39914 : }
39915 : #ifndef SED_HACKS
39916 : if ( bLocalUseExceptions ) {
39917 : CPLErr eclass = CPLGetLastErrorType();
39918 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39919 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39920 : }
39921 : }
39922 : #endif
39923 : }
39924 3952 : {
39925 3952 : resultobj = PyLong_FromUnsignedLongLong(result);
39926 : }
39927 3952 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39928 : return resultobj;
39929 : fail:
39930 : return NULL;
39931 : }
39932 :
39933 :
39934 140 : SWIGINTERN PyObject *_wrap_Dimension_GetIndexingVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39935 140 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39936 140 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
39937 140 : void *argp1 = 0 ;
39938 140 : int res1 = 0 ;
39939 140 : PyObject *swig_obj[1] ;
39940 140 : GDALMDArrayHS *result = 0 ;
39941 :
39942 140 : if (!args) SWIG_fail;
39943 140 : swig_obj[0] = args;
39944 140 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDimensionHS, 0 | 0 );
39945 140 : if (!SWIG_IsOK(res1)) {
39946 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dimension_GetIndexingVariable" "', argument " "1"" of type '" "GDALDimensionHS *""'");
39947 : }
39948 140 : arg1 = reinterpret_cast< GDALDimensionHS * >(argp1);
39949 140 : {
39950 140 : const int bLocalUseExceptions = GetUseExceptions();
39951 140 : if ( bLocalUseExceptions ) {
39952 56 : pushErrorHandler();
39953 : }
39954 140 : {
39955 140 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
39956 140 : result = (GDALMDArrayHS *)GDALDimensionHS_GetIndexingVariable(arg1);
39957 140 : SWIG_PYTHON_THREAD_END_ALLOW;
39958 : }
39959 140 : if ( bLocalUseExceptions ) {
39960 56 : popErrorHandler();
39961 : }
39962 : #ifndef SED_HACKS
39963 : if ( bLocalUseExceptions ) {
39964 : CPLErr eclass = CPLGetLastErrorType();
39965 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
39966 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
39967 : }
39968 : }
39969 : #endif
39970 : }
39971 140 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_OWN | 0 );
39972 140 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
39973 : return resultobj;
39974 : fail:
39975 : return NULL;
39976 : }
39977 :
39978 :
39979 23 : SWIGINTERN PyObject *_wrap_Dimension_SetIndexingVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39980 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
39981 23 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
39982 23 : GDALMDArrayHS *arg2 = (GDALMDArrayHS *) 0 ;
39983 23 : void *argp1 = 0 ;
39984 23 : int res1 = 0 ;
39985 23 : void *argp2 = 0 ;
39986 23 : int res2 = 0 ;
39987 23 : PyObject *swig_obj[2] ;
39988 23 : bool result;
39989 :
39990 23 : if (!SWIG_Python_UnpackTuple(args, "Dimension_SetIndexingVariable", 2, 2, swig_obj)) SWIG_fail;
39991 23 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDimensionHS, 0 | 0 );
39992 23 : if (!SWIG_IsOK(res1)) {
39993 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dimension_SetIndexingVariable" "', argument " "1"" of type '" "GDALDimensionHS *""'");
39994 : }
39995 23 : arg1 = reinterpret_cast< GDALDimensionHS * >(argp1);
39996 23 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALMDArrayHS, 0 | 0 );
39997 23 : if (!SWIG_IsOK(res2)) {
39998 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dimension_SetIndexingVariable" "', argument " "2"" of type '" "GDALMDArrayHS *""'");
39999 : }
40000 23 : arg2 = reinterpret_cast< GDALMDArrayHS * >(argp2);
40001 23 : {
40002 23 : const int bLocalUseExceptions = GetUseExceptions();
40003 23 : if ( bLocalUseExceptions ) {
40004 9 : pushErrorHandler();
40005 : }
40006 23 : {
40007 23 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40008 23 : result = (bool)GDALDimensionHS_SetIndexingVariable(arg1,arg2);
40009 23 : SWIG_PYTHON_THREAD_END_ALLOW;
40010 : }
40011 23 : if ( bLocalUseExceptions ) {
40012 9 : popErrorHandler();
40013 : }
40014 : #ifndef SED_HACKS
40015 : if ( bLocalUseExceptions ) {
40016 : CPLErr eclass = CPLGetLastErrorType();
40017 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40018 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40019 : }
40020 : }
40021 : #endif
40022 : }
40023 23 : resultobj = SWIG_From_bool(static_cast< bool >(result));
40024 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40025 : return resultobj;
40026 : fail:
40027 : return NULL;
40028 : }
40029 :
40030 :
40031 31 : SWIGINTERN PyObject *_wrap_Dimension_Rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40032 31 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40033 31 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
40034 31 : char *arg2 = (char *) 0 ;
40035 31 : void *argp1 = 0 ;
40036 31 : int res1 = 0 ;
40037 31 : int res2 ;
40038 31 : char *buf2 = 0 ;
40039 31 : int alloc2 = 0 ;
40040 31 : PyObject *swig_obj[2] ;
40041 31 : CPLErr result;
40042 :
40043 31 : if (!SWIG_Python_UnpackTuple(args, "Dimension_Rename", 2, 2, swig_obj)) SWIG_fail;
40044 31 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDimensionHS, 0 | 0 );
40045 31 : if (!SWIG_IsOK(res1)) {
40046 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dimension_Rename" "', argument " "1"" of type '" "GDALDimensionHS *""'");
40047 : }
40048 31 : arg1 = reinterpret_cast< GDALDimensionHS * >(argp1);
40049 31 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
40050 31 : if (!SWIG_IsOK(res2)) {
40051 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dimension_Rename" "', argument " "2"" of type '" "char const *""'");
40052 : }
40053 31 : arg2 = reinterpret_cast< char * >(buf2);
40054 31 : {
40055 31 : const int bLocalUseExceptions = GetUseExceptions();
40056 31 : if ( bLocalUseExceptions ) {
40057 31 : pushErrorHandler();
40058 : }
40059 31 : {
40060 31 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40061 31 : result = (CPLErr)GDALDimensionHS_Rename(arg1,(char const *)arg2);
40062 31 : SWIG_PYTHON_THREAD_END_ALLOW;
40063 : }
40064 31 : if ( bLocalUseExceptions ) {
40065 31 : popErrorHandler();
40066 : }
40067 : #ifndef SED_HACKS
40068 : if ( bLocalUseExceptions ) {
40069 : CPLErr eclass = CPLGetLastErrorType();
40070 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40071 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40072 : }
40073 : }
40074 : #endif
40075 : }
40076 31 : resultobj = SWIG_From_int(static_cast< int >(result));
40077 31 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
40078 77 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40079 : return resultobj;
40080 0 : fail:
40081 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
40082 : return NULL;
40083 : }
40084 :
40085 :
40086 277 : SWIGINTERN PyObject *Dimension_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40087 277 : PyObject *obj;
40088 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
40089 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALDimensionHS, SWIG_NewClientData(obj));
40090 277 : return SWIG_Py_Void();
40091 : }
40092 :
40093 5012 : SWIGINTERN PyObject *_wrap_delete_ExtendedDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40094 5012 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40095 5012 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
40096 5012 : void *argp1 = 0 ;
40097 5012 : int res1 = 0 ;
40098 5012 : PyObject *swig_obj[1] ;
40099 :
40100 5012 : if (!args) SWIG_fail;
40101 5012 : swig_obj[0] = args;
40102 5012 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALExtendedDataTypeHS, SWIG_POINTER_DISOWN | 0 );
40103 5012 : if (!SWIG_IsOK(res1)) {
40104 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExtendedDataType" "', argument " "1"" of type '" "GDALExtendedDataTypeHS *""'");
40105 : }
40106 5012 : arg1 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp1);
40107 5012 : {
40108 5012 : const int bLocalUseExceptions = GetUseExceptions();
40109 5012 : if ( bLocalUseExceptions ) {
40110 1510 : pushErrorHandler();
40111 : }
40112 5012 : {
40113 5012 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40114 5012 : delete_GDALExtendedDataTypeHS(arg1);
40115 5012 : SWIG_PYTHON_THREAD_END_ALLOW;
40116 : }
40117 5012 : if ( bLocalUseExceptions ) {
40118 1510 : popErrorHandler();
40119 : }
40120 : #ifndef SED_HACKS
40121 : if ( bLocalUseExceptions ) {
40122 : CPLErr eclass = CPLGetLastErrorType();
40123 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40124 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40125 : }
40126 : }
40127 : #endif
40128 : }
40129 5012 : resultobj = SWIG_Py_Void();
40130 5012 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40131 : return resultobj;
40132 : fail:
40133 : return NULL;
40134 : }
40135 :
40136 :
40137 2108 : SWIGINTERN PyObject *_wrap_ExtendedDataType_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40138 2108 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40139 2108 : GDALDataType arg1 ;
40140 2108 : PyObject *swig_obj[1] ;
40141 2108 : GDALExtendedDataTypeHS *result = 0 ;
40142 :
40143 2108 : if (!args) SWIG_fail;
40144 2108 : swig_obj[0] = args;
40145 2108 : {
40146 : // %typemap(in) GDALDataType
40147 2108 : int val = 0;
40148 2108 : int ecode = SWIG_AsVal_int(swig_obj[0], &val);
40149 2108 : if (!SWIG_IsOK(ecode)) {
40150 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
40151 : }
40152 2108 : if( val < GDT_Unknown || val >= GDT_TypeCount )
40153 : {
40154 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
40155 : }
40156 2108 : arg1 = static_cast<GDALDataType>(val);
40157 : }
40158 2108 : {
40159 2108 : const int bLocalUseExceptions = GetUseExceptions();
40160 2108 : if ( bLocalUseExceptions ) {
40161 579 : pushErrorHandler();
40162 : }
40163 2108 : {
40164 2108 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40165 2108 : result = (GDALExtendedDataTypeHS *)GDALExtendedDataTypeHS_Create(arg1);
40166 2108 : SWIG_PYTHON_THREAD_END_ALLOW;
40167 : }
40168 2108 : if ( bLocalUseExceptions ) {
40169 579 : popErrorHandler();
40170 : }
40171 : #ifndef SED_HACKS
40172 : if ( bLocalUseExceptions ) {
40173 : CPLErr eclass = CPLGetLastErrorType();
40174 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40175 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40176 : }
40177 : }
40178 : #endif
40179 : }
40180 2108 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALExtendedDataTypeHS, SWIG_POINTER_OWN | 0 );
40181 2108 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40182 : return resultobj;
40183 : fail:
40184 : return NULL;
40185 : }
40186 :
40187 :
40188 222 : SWIGINTERN PyObject *_wrap_ExtendedDataType_CreateString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40189 222 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40190 222 : size_t arg1 = (size_t) 0 ;
40191 222 : GDALExtendedDataTypeSubType arg2 = (GDALExtendedDataTypeSubType) GEDTST_NONE ;
40192 222 : size_t val1 ;
40193 222 : int ecode1 = 0 ;
40194 222 : int val2 ;
40195 222 : int ecode2 = 0 ;
40196 222 : PyObject *swig_obj[2] ;
40197 222 : GDALExtendedDataTypeHS *result = 0 ;
40198 :
40199 222 : if (!SWIG_Python_UnpackTuple(args, "ExtendedDataType_CreateString", 0, 2, swig_obj)) SWIG_fail;
40200 222 : if (swig_obj[0]) {
40201 11 : ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
40202 11 : if (!SWIG_IsOK(ecode1)) {
40203 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ExtendedDataType_CreateString" "', argument " "1"" of type '" "size_t""'");
40204 : }
40205 : arg1 = static_cast< size_t >(val1);
40206 : }
40207 222 : if (swig_obj[1]) {
40208 4 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
40209 4 : if (!SWIG_IsOK(ecode2)) {
40210 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExtendedDataType_CreateString" "', argument " "2"" of type '" "GDALExtendedDataTypeSubType""'");
40211 : }
40212 4 : arg2 = static_cast< GDALExtendedDataTypeSubType >(val2);
40213 : }
40214 222 : {
40215 222 : const int bLocalUseExceptions = GetUseExceptions();
40216 222 : if ( bLocalUseExceptions ) {
40217 147 : pushErrorHandler();
40218 : }
40219 222 : {
40220 222 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40221 222 : result = (GDALExtendedDataTypeHS *)GDALExtendedDataTypeHS_CreateString(arg1,arg2);
40222 222 : SWIG_PYTHON_THREAD_END_ALLOW;
40223 : }
40224 222 : if ( bLocalUseExceptions ) {
40225 147 : popErrorHandler();
40226 : }
40227 : #ifndef SED_HACKS
40228 : if ( bLocalUseExceptions ) {
40229 : CPLErr eclass = CPLGetLastErrorType();
40230 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40231 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40232 : }
40233 : }
40234 : #endif
40235 : }
40236 222 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALExtendedDataTypeHS, SWIG_POINTER_OWN | 0 );
40237 222 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40238 : return resultobj;
40239 : fail:
40240 : return NULL;
40241 : }
40242 :
40243 :
40244 22 : SWIGINTERN PyObject *_wrap_ExtendedDataType_CreateCompound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40245 22 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40246 22 : char *arg1 = (char *) 0 ;
40247 22 : size_t arg2 ;
40248 22 : int arg3 ;
40249 22 : GDALEDTComponentHS **arg4 = (GDALEDTComponentHS **) 0 ;
40250 22 : int res1 ;
40251 22 : char *buf1 = 0 ;
40252 22 : int alloc1 = 0 ;
40253 22 : size_t val2 ;
40254 22 : int ecode2 = 0 ;
40255 22 : PyObject *swig_obj[3] ;
40256 22 : GDALExtendedDataTypeHS *result = 0 ;
40257 :
40258 22 : if (!SWIG_Python_UnpackTuple(args, "ExtendedDataType_CreateCompound", 3, 3, swig_obj)) SWIG_fail;
40259 22 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
40260 22 : if (!SWIG_IsOK(res1)) {
40261 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtendedDataType_CreateCompound" "', argument " "1"" of type '" "char const *""'");
40262 : }
40263 22 : arg1 = reinterpret_cast< char * >(buf1);
40264 22 : ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
40265 22 : if (!SWIG_IsOK(ecode2)) {
40266 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExtendedDataType_CreateCompound" "', argument " "2"" of type '" "size_t""'");
40267 : }
40268 22 : arg2 = static_cast< size_t >(val2);
40269 22 : {
40270 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALEDTComponentHS *optional_##GDALEDTComponentHS)*/
40271 22 : if ( !PySequence_Check(swig_obj[2]) ) {
40272 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
40273 0 : SWIG_fail;
40274 : }
40275 22 : Py_ssize_t size = PySequence_Size(swig_obj[2]);
40276 22 : if( size > (Py_ssize_t)INT_MAX ) {
40277 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
40278 0 : SWIG_fail;
40279 : }
40280 22 : if( (size_t)size > SIZE_MAX / sizeof(GDALEDTComponentHS*) ) {
40281 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
40282 0 : SWIG_fail;
40283 : }
40284 22 : arg3 = (int)size;
40285 22 : arg4 = (GDALEDTComponentHS**) VSIMalloc(arg3*sizeof(GDALEDTComponentHS*));
40286 22 : if( !arg4) {
40287 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
40288 0 : SWIG_fail;
40289 : }
40290 :
40291 54 : for( int i = 0; i<arg3; i++ ) {
40292 32 : PyObject *o = PySequence_GetItem(swig_obj[2],i);
40293 32 : GDALEDTComponentHS* rawobjectpointer = NULL;
40294 32 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALEDTComponentHS, SWIG_POINTER_EXCEPTION | 0 ));
40295 32 : if (!rawobjectpointer) {
40296 0 : Py_DECREF(o);
40297 0 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALEDTComponentHS");
40298 0 : SWIG_fail;
40299 : }
40300 32 : arg4[i] = rawobjectpointer;
40301 32 : Py_DECREF(o);
40302 :
40303 : }
40304 : }
40305 22 : {
40306 22 : if (!arg1) {
40307 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
40308 : }
40309 : }
40310 22 : {
40311 22 : const int bLocalUseExceptions = GetUseExceptions();
40312 22 : if ( bLocalUseExceptions ) {
40313 6 : pushErrorHandler();
40314 : }
40315 22 : {
40316 22 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40317 22 : result = (GDALExtendedDataTypeHS *)GDALExtendedDataTypeHS_CreateCompound((char const *)arg1,arg2,arg3,arg4);
40318 22 : SWIG_PYTHON_THREAD_END_ALLOW;
40319 : }
40320 22 : if ( bLocalUseExceptions ) {
40321 6 : popErrorHandler();
40322 : }
40323 : #ifndef SED_HACKS
40324 : if ( bLocalUseExceptions ) {
40325 : CPLErr eclass = CPLGetLastErrorType();
40326 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40327 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40328 : }
40329 : }
40330 : #endif
40331 : }
40332 22 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALExtendedDataTypeHS, SWIG_POINTER_OWN | 0 );
40333 22 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
40334 22 : {
40335 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALEDTComponentHS **poObjects)*/
40336 22 : CPLFree( arg4 );
40337 : }
40338 22 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40339 : return resultobj;
40340 0 : fail:
40341 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
40342 0 : {
40343 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALEDTComponentHS **poObjects)*/
40344 0 : CPLFree( arg4 );
40345 : }
40346 : return NULL;
40347 : }
40348 :
40349 :
40350 8 : SWIGINTERN PyObject *_wrap_ExtendedDataType_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40351 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40352 8 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
40353 8 : void *argp1 = 0 ;
40354 8 : int res1 = 0 ;
40355 8 : PyObject *swig_obj[1] ;
40356 8 : char *result = 0 ;
40357 :
40358 8 : if (!args) SWIG_fail;
40359 8 : swig_obj[0] = args;
40360 8 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
40361 8 : if (!SWIG_IsOK(res1)) {
40362 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtendedDataType_GetName" "', argument " "1"" of type '" "GDALExtendedDataTypeHS *""'");
40363 : }
40364 8 : arg1 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp1);
40365 8 : {
40366 8 : const int bLocalUseExceptions = GetUseExceptions();
40367 8 : if ( bLocalUseExceptions ) {
40368 2 : pushErrorHandler();
40369 : }
40370 8 : {
40371 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40372 8 : result = (char *)GDALExtendedDataTypeHS_GetName(arg1);
40373 8 : SWIG_PYTHON_THREAD_END_ALLOW;
40374 : }
40375 8 : if ( bLocalUseExceptions ) {
40376 2 : popErrorHandler();
40377 : }
40378 : #ifndef SED_HACKS
40379 : if ( bLocalUseExceptions ) {
40380 : CPLErr eclass = CPLGetLastErrorType();
40381 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40382 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40383 : }
40384 : }
40385 : #endif
40386 : }
40387 8 : resultobj = SWIG_FromCharPtr((const char *)result);
40388 8 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40389 : return resultobj;
40390 : fail:
40391 : return NULL;
40392 : }
40393 :
40394 :
40395 3119 : SWIGINTERN PyObject *_wrap_ExtendedDataType_GetClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40396 3119 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40397 3119 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
40398 3119 : void *argp1 = 0 ;
40399 3119 : int res1 = 0 ;
40400 3119 : PyObject *swig_obj[1] ;
40401 3119 : GDALExtendedDataTypeClass result;
40402 :
40403 3119 : if (!args) SWIG_fail;
40404 3119 : swig_obj[0] = args;
40405 3119 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
40406 3119 : if (!SWIG_IsOK(res1)) {
40407 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtendedDataType_GetClass" "', argument " "1"" of type '" "GDALExtendedDataTypeHS *""'");
40408 : }
40409 3119 : arg1 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp1);
40410 3119 : {
40411 3119 : const int bLocalUseExceptions = GetUseExceptions();
40412 3119 : if ( bLocalUseExceptions ) {
40413 813 : pushErrorHandler();
40414 : }
40415 3119 : {
40416 3119 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40417 3119 : result = (GDALExtendedDataTypeClass)GDALExtendedDataTypeHS_GetClass(arg1);
40418 3119 : SWIG_PYTHON_THREAD_END_ALLOW;
40419 : }
40420 3119 : if ( bLocalUseExceptions ) {
40421 813 : popErrorHandler();
40422 : }
40423 : #ifndef SED_HACKS
40424 : if ( bLocalUseExceptions ) {
40425 : CPLErr eclass = CPLGetLastErrorType();
40426 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40427 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40428 : }
40429 : }
40430 : #endif
40431 : }
40432 3119 : resultobj = SWIG_From_int(static_cast< int >(result));
40433 3119 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40434 : return resultobj;
40435 : fail:
40436 : return NULL;
40437 : }
40438 :
40439 :
40440 2142 : SWIGINTERN PyObject *_wrap_ExtendedDataType_GetNumericDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40441 2142 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40442 2142 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
40443 2142 : void *argp1 = 0 ;
40444 2142 : int res1 = 0 ;
40445 2142 : PyObject *swig_obj[1] ;
40446 2142 : GDALDataType result;
40447 :
40448 2142 : if (!args) SWIG_fail;
40449 2142 : swig_obj[0] = args;
40450 2142 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
40451 2142 : if (!SWIG_IsOK(res1)) {
40452 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtendedDataType_GetNumericDataType" "', argument " "1"" of type '" "GDALExtendedDataTypeHS *""'");
40453 : }
40454 2142 : arg1 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp1);
40455 2142 : {
40456 2142 : const int bLocalUseExceptions = GetUseExceptions();
40457 2142 : if ( bLocalUseExceptions ) {
40458 463 : pushErrorHandler();
40459 : }
40460 2142 : {
40461 2142 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40462 2142 : result = (GDALDataType)GDALExtendedDataTypeHS_GetNumericDataType(arg1);
40463 2142 : SWIG_PYTHON_THREAD_END_ALLOW;
40464 : }
40465 2142 : if ( bLocalUseExceptions ) {
40466 463 : popErrorHandler();
40467 : }
40468 : #ifndef SED_HACKS
40469 : if ( bLocalUseExceptions ) {
40470 : CPLErr eclass = CPLGetLastErrorType();
40471 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40472 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40473 : }
40474 : }
40475 : #endif
40476 : }
40477 2142 : resultobj = SWIG_From_int(static_cast< int >(result));
40478 2142 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40479 : return resultobj;
40480 : fail:
40481 : return NULL;
40482 : }
40483 :
40484 :
40485 51 : SWIGINTERN PyObject *_wrap_ExtendedDataType_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40486 51 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40487 51 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
40488 51 : void *argp1 = 0 ;
40489 51 : int res1 = 0 ;
40490 51 : PyObject *swig_obj[1] ;
40491 51 : size_t result;
40492 :
40493 51 : if (!args) SWIG_fail;
40494 51 : swig_obj[0] = args;
40495 51 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
40496 51 : if (!SWIG_IsOK(res1)) {
40497 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtendedDataType_GetSize" "', argument " "1"" of type '" "GDALExtendedDataTypeHS *""'");
40498 : }
40499 51 : arg1 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp1);
40500 51 : {
40501 51 : const int bLocalUseExceptions = GetUseExceptions();
40502 51 : if ( bLocalUseExceptions ) {
40503 34 : pushErrorHandler();
40504 : }
40505 51 : {
40506 51 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40507 51 : result = GDALExtendedDataTypeHS_GetSize(arg1);
40508 51 : SWIG_PYTHON_THREAD_END_ALLOW;
40509 : }
40510 51 : if ( bLocalUseExceptions ) {
40511 34 : popErrorHandler();
40512 : }
40513 : #ifndef SED_HACKS
40514 : if ( bLocalUseExceptions ) {
40515 : CPLErr eclass = CPLGetLastErrorType();
40516 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40517 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40518 : }
40519 : }
40520 : #endif
40521 : }
40522 51 : resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40523 51 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40524 : return resultobj;
40525 : fail:
40526 : return NULL;
40527 : }
40528 :
40529 :
40530 3 : SWIGINTERN PyObject *_wrap_ExtendedDataType_GetMaxStringLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40531 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40532 3 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
40533 3 : void *argp1 = 0 ;
40534 3 : int res1 = 0 ;
40535 3 : PyObject *swig_obj[1] ;
40536 3 : size_t result;
40537 :
40538 3 : if (!args) SWIG_fail;
40539 3 : swig_obj[0] = args;
40540 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
40541 3 : if (!SWIG_IsOK(res1)) {
40542 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtendedDataType_GetMaxStringLength" "', argument " "1"" of type '" "GDALExtendedDataTypeHS *""'");
40543 : }
40544 3 : arg1 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp1);
40545 3 : {
40546 3 : const int bLocalUseExceptions = GetUseExceptions();
40547 3 : if ( bLocalUseExceptions ) {
40548 0 : pushErrorHandler();
40549 : }
40550 3 : {
40551 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40552 3 : result = GDALExtendedDataTypeHS_GetMaxStringLength(arg1);
40553 3 : SWIG_PYTHON_THREAD_END_ALLOW;
40554 : }
40555 3 : if ( bLocalUseExceptions ) {
40556 0 : popErrorHandler();
40557 : }
40558 : #ifndef SED_HACKS
40559 : if ( bLocalUseExceptions ) {
40560 : CPLErr eclass = CPLGetLastErrorType();
40561 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40562 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40563 : }
40564 : }
40565 : #endif
40566 : }
40567 3 : resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40568 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40569 : return resultobj;
40570 : fail:
40571 : return NULL;
40572 : }
40573 :
40574 :
40575 105 : SWIGINTERN PyObject *_wrap_ExtendedDataType_GetSubType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40576 105 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40577 105 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
40578 105 : void *argp1 = 0 ;
40579 105 : int res1 = 0 ;
40580 105 : PyObject *swig_obj[1] ;
40581 105 : GDALExtendedDataTypeSubType result;
40582 :
40583 105 : if (!args) SWIG_fail;
40584 105 : swig_obj[0] = args;
40585 105 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
40586 105 : if (!SWIG_IsOK(res1)) {
40587 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtendedDataType_GetSubType" "', argument " "1"" of type '" "GDALExtendedDataTypeHS *""'");
40588 : }
40589 105 : arg1 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp1);
40590 105 : {
40591 105 : const int bLocalUseExceptions = GetUseExceptions();
40592 105 : if ( bLocalUseExceptions ) {
40593 29 : pushErrorHandler();
40594 : }
40595 105 : {
40596 105 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40597 105 : result = (GDALExtendedDataTypeSubType)GDALExtendedDataTypeHS_GetSubType(arg1);
40598 105 : SWIG_PYTHON_THREAD_END_ALLOW;
40599 : }
40600 105 : if ( bLocalUseExceptions ) {
40601 29 : popErrorHandler();
40602 : }
40603 : #ifndef SED_HACKS
40604 : if ( bLocalUseExceptions ) {
40605 : CPLErr eclass = CPLGetLastErrorType();
40606 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40607 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40608 : }
40609 : }
40610 : #endif
40611 : }
40612 105 : resultobj = SWIG_From_int(static_cast< int >(result));
40613 105 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40614 : return resultobj;
40615 : fail:
40616 : return NULL;
40617 : }
40618 :
40619 :
40620 1 : SWIGINTERN PyObject *_wrap_ExtendedDataType_GetRAT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40621 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40622 1 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
40623 1 : void *argp1 = 0 ;
40624 1 : int res1 = 0 ;
40625 1 : PyObject *swig_obj[1] ;
40626 1 : GDALRasterAttributeTableShadow *result = 0 ;
40627 :
40628 1 : if (!args) SWIG_fail;
40629 1 : swig_obj[0] = args;
40630 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
40631 1 : if (!SWIG_IsOK(res1)) {
40632 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtendedDataType_GetRAT" "', argument " "1"" of type '" "GDALExtendedDataTypeHS *""'");
40633 : }
40634 1 : arg1 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp1);
40635 1 : {
40636 1 : const int bLocalUseExceptions = GetUseExceptions();
40637 1 : if ( bLocalUseExceptions ) {
40638 1 : pushErrorHandler();
40639 : }
40640 1 : {
40641 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40642 1 : result = (GDALRasterAttributeTableShadow *)GDALExtendedDataTypeHS_GetRAT(arg1);
40643 1 : SWIG_PYTHON_THREAD_END_ALLOW;
40644 : }
40645 1 : if ( bLocalUseExceptions ) {
40646 1 : popErrorHandler();
40647 : }
40648 : #ifndef SED_HACKS
40649 : if ( bLocalUseExceptions ) {
40650 : CPLErr eclass = CPLGetLastErrorType();
40651 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40652 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40653 : }
40654 : }
40655 : #endif
40656 : }
40657 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
40658 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40659 : return resultobj;
40660 : fail:
40661 : return NULL;
40662 : }
40663 :
40664 :
40665 21 : SWIGINTERN PyObject *_wrap_ExtendedDataType_GetComponents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40666 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40667 21 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
40668 21 : GDALEDTComponentHS ***arg2 = (GDALEDTComponentHS ***) 0 ;
40669 21 : size_t *arg3 = (size_t *) 0 ;
40670 21 : void *argp1 = 0 ;
40671 21 : int res1 = 0 ;
40672 21 : GDALEDTComponentHS **comps2 = 0 ;
40673 21 : size_t nCount2 = 0 ;
40674 21 : PyObject *swig_obj[1] ;
40675 :
40676 21 : {
40677 : /* %typemap(in,numinputs=0) (GDALEDTComponentHS*** pcomps, size_t* pnCount) */
40678 21 : arg2 = &comps2;
40679 21 : arg3 = &nCount2;
40680 : }
40681 21 : if (!args) SWIG_fail;
40682 21 : swig_obj[0] = args;
40683 21 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
40684 21 : if (!SWIG_IsOK(res1)) {
40685 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtendedDataType_GetComponents" "', argument " "1"" of type '" "GDALExtendedDataTypeHS *""'");
40686 : }
40687 21 : arg1 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp1);
40688 21 : {
40689 21 : const int bLocalUseExceptions = GetUseExceptions();
40690 21 : if ( bLocalUseExceptions ) {
40691 6 : pushErrorHandler();
40692 : }
40693 21 : {
40694 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40695 21 : GDALExtendedDataTypeHS_GetComponents(arg1,arg2,arg3);
40696 21 : SWIG_PYTHON_THREAD_END_ALLOW;
40697 : }
40698 21 : if ( bLocalUseExceptions ) {
40699 6 : popErrorHandler();
40700 : }
40701 : #ifndef SED_HACKS
40702 : if ( bLocalUseExceptions ) {
40703 : CPLErr eclass = CPLGetLastErrorType();
40704 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40705 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40706 : }
40707 : }
40708 : #endif
40709 : }
40710 21 : resultobj = SWIG_Py_Void();
40711 21 : {
40712 : /* %typemap(argout) (GDALEDTComponentHS*** pcomps, size_t* pnCount) */
40713 21 : Py_DECREF(resultobj);
40714 21 : resultobj = PyList_New( *arg3 );
40715 21 : if( !resultobj ) {
40716 0 : SWIG_fail;
40717 : }
40718 62 : for( size_t i = 0; i < *arg3; i++ ) {
40719 41 : PyList_SetItem(resultobj, i,
40720 41 : SWIG_NewPointerObj((void*)(*arg2)[i],SWIGTYPE_p_GDALEDTComponentHS,SWIG_POINTER_OWN) );
40721 : /* We have borrowed the GDALEDTComponentHS */
40722 41 : (*arg2)[i] = NULL;
40723 : }
40724 : }
40725 21 : {
40726 : /* %typemap(freearg) (GDALEDTComponentHS*** pcomps, size_t* pnCount) */
40727 21 : GDALExtendedDataTypeFreeComponents(*arg2, *arg3);
40728 : }
40729 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40730 : return resultobj;
40731 0 : fail:
40732 0 : {
40733 : /* %typemap(freearg) (GDALEDTComponentHS*** pcomps, size_t* pnCount) */
40734 0 : GDALExtendedDataTypeFreeComponents(*arg2, *arg3);
40735 : }
40736 : return NULL;
40737 : }
40738 :
40739 :
40740 8 : SWIGINTERN PyObject *_wrap_ExtendedDataType_CanConvertTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40741 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40742 8 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
40743 8 : GDALExtendedDataTypeHS *arg2 = (GDALExtendedDataTypeHS *) 0 ;
40744 8 : void *argp1 = 0 ;
40745 8 : int res1 = 0 ;
40746 8 : void *argp2 = 0 ;
40747 8 : int res2 = 0 ;
40748 8 : PyObject *swig_obj[2] ;
40749 8 : bool result;
40750 :
40751 8 : if (!SWIG_Python_UnpackTuple(args, "ExtendedDataType_CanConvertTo", 2, 2, swig_obj)) SWIG_fail;
40752 8 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
40753 8 : if (!SWIG_IsOK(res1)) {
40754 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtendedDataType_CanConvertTo" "', argument " "1"" of type '" "GDALExtendedDataTypeHS *""'");
40755 : }
40756 8 : arg1 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp1);
40757 8 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
40758 8 : if (!SWIG_IsOK(res2)) {
40759 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExtendedDataType_CanConvertTo" "', argument " "2"" of type '" "GDALExtendedDataTypeHS *""'");
40760 : }
40761 8 : arg2 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp2);
40762 8 : {
40763 8 : if (!arg2) {
40764 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
40765 : }
40766 : }
40767 7 : {
40768 7 : const int bLocalUseExceptions = GetUseExceptions();
40769 7 : if ( bLocalUseExceptions ) {
40770 0 : pushErrorHandler();
40771 : }
40772 7 : {
40773 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40774 7 : result = (bool)GDALExtendedDataTypeHS_CanConvertTo(arg1,arg2);
40775 7 : SWIG_PYTHON_THREAD_END_ALLOW;
40776 : }
40777 7 : if ( bLocalUseExceptions ) {
40778 0 : popErrorHandler();
40779 : }
40780 : #ifndef SED_HACKS
40781 : if ( bLocalUseExceptions ) {
40782 : CPLErr eclass = CPLGetLastErrorType();
40783 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40784 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40785 : }
40786 : }
40787 : #endif
40788 : }
40789 7 : resultobj = SWIG_From_bool(static_cast< bool >(result));
40790 8 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40791 : return resultobj;
40792 : fail:
40793 : return NULL;
40794 : }
40795 :
40796 :
40797 101 : SWIGINTERN PyObject *_wrap_ExtendedDataType_Equals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40798 101 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40799 101 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
40800 101 : GDALExtendedDataTypeHS *arg2 = (GDALExtendedDataTypeHS *) 0 ;
40801 101 : void *argp1 = 0 ;
40802 101 : int res1 = 0 ;
40803 101 : void *argp2 = 0 ;
40804 101 : int res2 = 0 ;
40805 101 : PyObject *swig_obj[2] ;
40806 101 : bool result;
40807 :
40808 101 : if (!SWIG_Python_UnpackTuple(args, "ExtendedDataType_Equals", 2, 2, swig_obj)) SWIG_fail;
40809 101 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
40810 101 : if (!SWIG_IsOK(res1)) {
40811 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtendedDataType_Equals" "', argument " "1"" of type '" "GDALExtendedDataTypeHS *""'");
40812 : }
40813 101 : arg1 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp1);
40814 101 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
40815 101 : if (!SWIG_IsOK(res2)) {
40816 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExtendedDataType_Equals" "', argument " "2"" of type '" "GDALExtendedDataTypeHS *""'");
40817 : }
40818 101 : arg2 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp2);
40819 101 : {
40820 101 : if (!arg2) {
40821 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
40822 : }
40823 : }
40824 100 : {
40825 100 : const int bLocalUseExceptions = GetUseExceptions();
40826 100 : if ( bLocalUseExceptions ) {
40827 38 : pushErrorHandler();
40828 : }
40829 100 : {
40830 100 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40831 100 : result = (bool)GDALExtendedDataTypeHS_Equals(arg1,arg2);
40832 100 : SWIG_PYTHON_THREAD_END_ALLOW;
40833 : }
40834 100 : if ( bLocalUseExceptions ) {
40835 38 : popErrorHandler();
40836 : }
40837 : #ifndef SED_HACKS
40838 : if ( bLocalUseExceptions ) {
40839 : CPLErr eclass = CPLGetLastErrorType();
40840 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40841 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40842 : }
40843 : }
40844 : #endif
40845 : }
40846 100 : resultobj = SWIG_From_bool(static_cast< bool >(result));
40847 101 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40848 : return resultobj;
40849 : fail:
40850 : return NULL;
40851 : }
40852 :
40853 :
40854 277 : SWIGINTERN PyObject *ExtendedDataType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40855 277 : PyObject *obj;
40856 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
40857 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALExtendedDataTypeHS, SWIG_NewClientData(obj));
40858 277 : return SWIG_Py_Void();
40859 : }
40860 :
40861 61 : SWIGINTERN PyObject *_wrap_delete_EDTComponent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40862 61 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40863 61 : GDALEDTComponentHS *arg1 = (GDALEDTComponentHS *) 0 ;
40864 61 : void *argp1 = 0 ;
40865 61 : int res1 = 0 ;
40866 61 : PyObject *swig_obj[1] ;
40867 :
40868 61 : if (!args) SWIG_fail;
40869 61 : swig_obj[0] = args;
40870 61 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALEDTComponentHS, SWIG_POINTER_DISOWN | 0 );
40871 61 : if (!SWIG_IsOK(res1)) {
40872 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EDTComponent" "', argument " "1"" of type '" "GDALEDTComponentHS *""'");
40873 : }
40874 61 : arg1 = reinterpret_cast< GDALEDTComponentHS * >(argp1);
40875 61 : {
40876 61 : const int bLocalUseExceptions = GetUseExceptions();
40877 61 : if ( bLocalUseExceptions ) {
40878 23 : pushErrorHandler();
40879 : }
40880 61 : {
40881 61 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40882 61 : delete_GDALEDTComponentHS(arg1);
40883 61 : SWIG_PYTHON_THREAD_END_ALLOW;
40884 : }
40885 61 : if ( bLocalUseExceptions ) {
40886 23 : popErrorHandler();
40887 : }
40888 : #ifndef SED_HACKS
40889 : if ( bLocalUseExceptions ) {
40890 : CPLErr eclass = CPLGetLastErrorType();
40891 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40892 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40893 : }
40894 : }
40895 : #endif
40896 : }
40897 61 : resultobj = SWIG_Py_Void();
40898 61 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40899 : return resultobj;
40900 : fail:
40901 : return NULL;
40902 : }
40903 :
40904 :
40905 20 : SWIGINTERN PyObject *_wrap_EDTComponent_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40906 20 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40907 20 : char *arg1 = (char *) 0 ;
40908 20 : size_t arg2 ;
40909 20 : GDALExtendedDataTypeHS *arg3 = (GDALExtendedDataTypeHS *) 0 ;
40910 20 : int res1 ;
40911 20 : char *buf1 = 0 ;
40912 20 : int alloc1 = 0 ;
40913 20 : size_t val2 ;
40914 20 : int ecode2 = 0 ;
40915 20 : void *argp3 = 0 ;
40916 20 : int res3 = 0 ;
40917 20 : PyObject *swig_obj[3] ;
40918 20 : GDALEDTComponentHS *result = 0 ;
40919 :
40920 20 : if (!SWIG_Python_UnpackTuple(args, "EDTComponent_Create", 3, 3, swig_obj)) SWIG_fail;
40921 20 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
40922 20 : if (!SWIG_IsOK(res1)) {
40923 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EDTComponent_Create" "', argument " "1"" of type '" "char const *""'");
40924 : }
40925 20 : arg1 = reinterpret_cast< char * >(buf1);
40926 20 : ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
40927 20 : if (!SWIG_IsOK(ecode2)) {
40928 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EDTComponent_Create" "', argument " "2"" of type '" "size_t""'");
40929 : }
40930 20 : arg2 = static_cast< size_t >(val2);
40931 20 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALExtendedDataTypeHS, 0 | 0 );
40932 20 : if (!SWIG_IsOK(res3)) {
40933 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EDTComponent_Create" "', argument " "3"" of type '" "GDALExtendedDataTypeHS *""'");
40934 : }
40935 20 : arg3 = reinterpret_cast< GDALExtendedDataTypeHS * >(argp3);
40936 20 : {
40937 20 : if (!arg1) {
40938 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
40939 : }
40940 : }
40941 20 : {
40942 20 : if (!arg3) {
40943 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
40944 : }
40945 : }
40946 20 : {
40947 20 : const int bLocalUseExceptions = GetUseExceptions();
40948 20 : if ( bLocalUseExceptions ) {
40949 10 : pushErrorHandler();
40950 : }
40951 20 : {
40952 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
40953 20 : result = (GDALEDTComponentHS *)GDALEDTComponentHS_Create((char const *)arg1,arg2,arg3);
40954 20 : SWIG_PYTHON_THREAD_END_ALLOW;
40955 : }
40956 20 : if ( bLocalUseExceptions ) {
40957 10 : popErrorHandler();
40958 : }
40959 : #ifndef SED_HACKS
40960 : if ( bLocalUseExceptions ) {
40961 : CPLErr eclass = CPLGetLastErrorType();
40962 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
40963 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
40964 : }
40965 : }
40966 : #endif
40967 : }
40968 20 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALEDTComponentHS, SWIG_POINTER_OWN | 0 );
40969 20 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
40970 20 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
40971 : return resultobj;
40972 0 : fail:
40973 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
40974 : return NULL;
40975 : }
40976 :
40977 :
40978 33 : SWIGINTERN PyObject *_wrap_EDTComponent_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40979 33 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
40980 33 : GDALEDTComponentHS *arg1 = (GDALEDTComponentHS *) 0 ;
40981 33 : void *argp1 = 0 ;
40982 33 : int res1 = 0 ;
40983 33 : PyObject *swig_obj[1] ;
40984 33 : char *result = 0 ;
40985 :
40986 33 : if (!args) SWIG_fail;
40987 33 : swig_obj[0] = args;
40988 33 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALEDTComponentHS, 0 | 0 );
40989 33 : if (!SWIG_IsOK(res1)) {
40990 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EDTComponent_GetName" "', argument " "1"" of type '" "GDALEDTComponentHS *""'");
40991 : }
40992 33 : arg1 = reinterpret_cast< GDALEDTComponentHS * >(argp1);
40993 33 : {
40994 33 : const int bLocalUseExceptions = GetUseExceptions();
40995 33 : if ( bLocalUseExceptions ) {
40996 13 : pushErrorHandler();
40997 : }
40998 33 : {
40999 33 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41000 33 : result = (char *)GDALEDTComponentHS_GetName(arg1);
41001 33 : SWIG_PYTHON_THREAD_END_ALLOW;
41002 : }
41003 33 : if ( bLocalUseExceptions ) {
41004 13 : popErrorHandler();
41005 : }
41006 : #ifndef SED_HACKS
41007 : if ( bLocalUseExceptions ) {
41008 : CPLErr eclass = CPLGetLastErrorType();
41009 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41010 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41011 : }
41012 : }
41013 : #endif
41014 : }
41015 33 : resultobj = SWIG_FromCharPtr((const char *)result);
41016 33 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41017 : return resultobj;
41018 : fail:
41019 : return NULL;
41020 : }
41021 :
41022 :
41023 31 : SWIGINTERN PyObject *_wrap_EDTComponent_GetOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41024 31 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41025 31 : GDALEDTComponentHS *arg1 = (GDALEDTComponentHS *) 0 ;
41026 31 : void *argp1 = 0 ;
41027 31 : int res1 = 0 ;
41028 31 : PyObject *swig_obj[1] ;
41029 31 : size_t result;
41030 :
41031 31 : if (!args) SWIG_fail;
41032 31 : swig_obj[0] = args;
41033 31 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALEDTComponentHS, 0 | 0 );
41034 31 : if (!SWIG_IsOK(res1)) {
41035 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EDTComponent_GetOffset" "', argument " "1"" of type '" "GDALEDTComponentHS *""'");
41036 : }
41037 31 : arg1 = reinterpret_cast< GDALEDTComponentHS * >(argp1);
41038 31 : {
41039 31 : const int bLocalUseExceptions = GetUseExceptions();
41040 31 : if ( bLocalUseExceptions ) {
41041 13 : pushErrorHandler();
41042 : }
41043 31 : {
41044 31 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41045 31 : result = GDALEDTComponentHS_GetOffset(arg1);
41046 31 : SWIG_PYTHON_THREAD_END_ALLOW;
41047 : }
41048 31 : if ( bLocalUseExceptions ) {
41049 13 : popErrorHandler();
41050 : }
41051 : #ifndef SED_HACKS
41052 : if ( bLocalUseExceptions ) {
41053 : CPLErr eclass = CPLGetLastErrorType();
41054 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41055 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41056 : }
41057 : }
41058 : #endif
41059 : }
41060 31 : resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41061 31 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41062 : return resultobj;
41063 : fail:
41064 : return NULL;
41065 : }
41066 :
41067 :
41068 49 : SWIGINTERN PyObject *_wrap_EDTComponent_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41069 49 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41070 49 : GDALEDTComponentHS *arg1 = (GDALEDTComponentHS *) 0 ;
41071 49 : void *argp1 = 0 ;
41072 49 : int res1 = 0 ;
41073 49 : PyObject *swig_obj[1] ;
41074 49 : GDALExtendedDataTypeHS *result = 0 ;
41075 :
41076 49 : if (!args) SWIG_fail;
41077 49 : swig_obj[0] = args;
41078 49 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALEDTComponentHS, 0 | 0 );
41079 49 : if (!SWIG_IsOK(res1)) {
41080 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EDTComponent_GetType" "', argument " "1"" of type '" "GDALEDTComponentHS *""'");
41081 : }
41082 49 : arg1 = reinterpret_cast< GDALEDTComponentHS * >(argp1);
41083 49 : {
41084 49 : const int bLocalUseExceptions = GetUseExceptions();
41085 49 : if ( bLocalUseExceptions ) {
41086 21 : pushErrorHandler();
41087 : }
41088 49 : {
41089 49 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41090 49 : result = (GDALExtendedDataTypeHS *)GDALEDTComponentHS_GetType(arg1);
41091 49 : SWIG_PYTHON_THREAD_END_ALLOW;
41092 : }
41093 49 : if ( bLocalUseExceptions ) {
41094 21 : popErrorHandler();
41095 : }
41096 : #ifndef SED_HACKS
41097 : if ( bLocalUseExceptions ) {
41098 : CPLErr eclass = CPLGetLastErrorType();
41099 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41100 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41101 : }
41102 : }
41103 : #endif
41104 : }
41105 49 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALExtendedDataTypeHS, SWIG_POINTER_OWN | 0 );
41106 49 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41107 : return resultobj;
41108 : fail:
41109 : return NULL;
41110 : }
41111 :
41112 :
41113 277 : SWIGINTERN PyObject *EDTComponent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41114 277 : PyObject *obj;
41115 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
41116 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALEDTComponentHS, SWIG_NewClientData(obj));
41117 277 : return SWIG_Py_Void();
41118 : }
41119 :
41120 13 : SWIGINTERN PyObject *_wrap_CreateRasterAttributeTableFromMDArrays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41121 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41122 13 : GDALRATTableType arg1 ;
41123 13 : int arg2 ;
41124 13 : GDALMDArrayHS **arg3 = (GDALMDArrayHS **) 0 ;
41125 13 : int arg4 = (int) 0 ;
41126 13 : GDALRATFieldUsage *arg5 = (GDALRATFieldUsage *) NULL ;
41127 13 : int val1 ;
41128 13 : int ecode1 = 0 ;
41129 13 : PyObject *swig_obj[3] ;
41130 13 : GDALRasterAttributeTableShadow *result = 0 ;
41131 :
41132 13 : if (!SWIG_Python_UnpackTuple(args, "CreateRasterAttributeTableFromMDArrays", 2, 3, swig_obj)) SWIG_fail;
41133 13 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
41134 13 : if (!SWIG_IsOK(ecode1)) {
41135 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CreateRasterAttributeTableFromMDArrays" "', argument " "1"" of type '" "GDALRATTableType""'");
41136 : }
41137 13 : arg1 = static_cast< GDALRATTableType >(val1);
41138 13 : {
41139 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALMDArrayHS *optional_##GDALMDArrayHS)*/
41140 13 : if ( !PySequence_Check(swig_obj[1]) ) {
41141 1 : PyErr_SetString(PyExc_TypeError, "not a sequence");
41142 1 : SWIG_fail;
41143 : }
41144 12 : Py_ssize_t size = PySequence_Size(swig_obj[1]);
41145 12 : if( size > (Py_ssize_t)INT_MAX ) {
41146 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
41147 0 : SWIG_fail;
41148 : }
41149 12 : if( (size_t)size > SIZE_MAX / sizeof(GDALMDArrayHS*) ) {
41150 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
41151 0 : SWIG_fail;
41152 : }
41153 12 : arg2 = (int)size;
41154 12 : arg3 = (GDALMDArrayHS**) VSIMalloc(arg2*sizeof(GDALMDArrayHS*));
41155 12 : if( !arg3) {
41156 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
41157 0 : SWIG_fail;
41158 : }
41159 :
41160 26 : for( int i = 0; i<arg2; i++ ) {
41161 16 : PyObject *o = PySequence_GetItem(swig_obj[1],i);
41162 16 : GDALMDArrayHS* rawobjectpointer = NULL;
41163 16 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_EXCEPTION | 0 ));
41164 16 : if (!rawobjectpointer) {
41165 2 : Py_DECREF(o);
41166 2 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALMDArrayHS");
41167 2 : SWIG_fail;
41168 : }
41169 14 : arg3[i] = rawobjectpointer;
41170 14 : Py_DECREF(o);
41171 :
41172 : }
41173 : }
41174 10 : if (swig_obj[2]) {
41175 6 : {
41176 : /* %typemap(in) (int nUsages, GDALRATFieldUsage *paeUsages)*/
41177 6 : if ( !PySequence_Check(swig_obj[2]) ) {
41178 1 : PyErr_SetString(PyExc_TypeError, "not a sequence");
41179 1 : SWIG_fail;
41180 : }
41181 5 : Py_ssize_t size = PySequence_Size(swig_obj[2]);
41182 5 : if( size > (Py_ssize_t)INT_MAX ) {
41183 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
41184 0 : SWIG_fail;
41185 : }
41186 5 : if( (size_t)size > SIZE_MAX / sizeof(int) ) {
41187 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
41188 0 : SWIG_fail;
41189 : }
41190 5 : arg4 = (int)size;
41191 5 : arg5 = (GDALRATFieldUsage*) VSIMalloc(arg4*sizeof(GDALRATFieldUsage));
41192 5 : if( !arg5) {
41193 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
41194 0 : SWIG_fail;
41195 : }
41196 :
41197 10 : for( int i = 0; i<arg4; i++ ) {
41198 8 : PyObject *o = PySequence_GetItem(swig_obj[2],i);
41199 8 : int nVal = 0;
41200 8 : if ( !PyArg_Parse(o,"i",&nVal) ) {
41201 1 : PyErr_SetString(PyExc_TypeError, "not a valid GDALRATFieldUsage");
41202 1 : Py_DECREF(o);
41203 3 : SWIG_fail;
41204 : }
41205 7 : Py_DECREF(o);
41206 7 : if( nVal < 0 || nVal >= GFU_MaxCount )
41207 : {
41208 2 : PyErr_SetString(PyExc_TypeError, "not a valid GDALRATFieldUsage");
41209 2 : SWIG_fail;
41210 : }
41211 5 : (arg5)[i] = static_cast<GDALRATFieldUsage>(nVal);
41212 : }
41213 : }
41214 : }
41215 6 : {
41216 6 : const int bLocalUseExceptions = GetUseExceptions();
41217 6 : if ( bLocalUseExceptions ) {
41218 6 : pushErrorHandler();
41219 : }
41220 6 : {
41221 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41222 6 : result = (GDALRasterAttributeTableShadow *)CreateRasterAttributeTableFromMDArrays(arg1,arg2,arg3,arg4,arg5);
41223 6 : SWIG_PYTHON_THREAD_END_ALLOW;
41224 : }
41225 6 : if ( bLocalUseExceptions ) {
41226 6 : popErrorHandler();
41227 : }
41228 : #ifndef SED_HACKS
41229 : if ( bLocalUseExceptions ) {
41230 : CPLErr eclass = CPLGetLastErrorType();
41231 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41232 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41233 : }
41234 : }
41235 : #endif
41236 : }
41237 6 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALRasterAttributeTableShadow, SWIG_POINTER_OWN | 0 );
41238 6 : {
41239 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALMDArrayHS **poObjects)*/
41240 6 : CPLFree( arg3 );
41241 : }
41242 6 : {
41243 : /* %typemap(freearg) (int nUsages, GDALRATFieldUsage *paeUsages)*/
41244 6 : CPLFree( arg5 );
41245 : }
41246 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41247 : return resultobj;
41248 7 : fail:
41249 7 : {
41250 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALMDArrayHS **poObjects)*/
41251 7 : CPLFree( arg3 );
41252 : }
41253 7 : {
41254 : /* %typemap(freearg) (int nUsages, GDALRATFieldUsage *paeUsages)*/
41255 7 : CPLFree( arg5 );
41256 : }
41257 : return NULL;
41258 : }
41259 :
41260 :
41261 18112 : SWIGINTERN PyObject *_wrap_Band_XSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41262 18112 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41263 18112 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
41264 18112 : void *argp1 = 0 ;
41265 18112 : int res1 = 0 ;
41266 18112 : PyObject *swig_obj[1] ;
41267 18112 : int result;
41268 :
41269 18112 : if (!args) SWIG_fail;
41270 18112 : swig_obj[0] = args;
41271 18112 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
41272 18112 : if (!SWIG_IsOK(res1)) {
41273 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_XSize_get" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
41274 : }
41275 18112 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
41276 18112 : {
41277 18112 : const int bLocalUseExceptions = GetUseExceptions();
41278 18112 : if ( bLocalUseExceptions ) {
41279 14990 : pushErrorHandler();
41280 : }
41281 18112 : {
41282 18112 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41283 18112 : result = (int)GDALRasterBandShadow_XSize_get(arg1);
41284 18112 : SWIG_PYTHON_THREAD_END_ALLOW;
41285 : }
41286 18112 : if ( bLocalUseExceptions ) {
41287 14990 : popErrorHandler();
41288 : }
41289 : #ifndef SED_HACKS
41290 : if ( bLocalUseExceptions ) {
41291 : CPLErr eclass = CPLGetLastErrorType();
41292 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41293 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41294 : }
41295 : }
41296 : #endif
41297 : }
41298 18112 : resultobj = SWIG_From_int(static_cast< int >(result));
41299 18112 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41300 : return resultobj;
41301 : fail:
41302 : return NULL;
41303 : }
41304 :
41305 :
41306 16977 : SWIGINTERN PyObject *_wrap_Band_YSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41307 16977 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41308 16977 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
41309 16977 : void *argp1 = 0 ;
41310 16977 : int res1 = 0 ;
41311 16977 : PyObject *swig_obj[1] ;
41312 16977 : int result;
41313 :
41314 16977 : if (!args) SWIG_fail;
41315 16977 : swig_obj[0] = args;
41316 16977 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
41317 16977 : if (!SWIG_IsOK(res1)) {
41318 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_YSize_get" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
41319 : }
41320 16977 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
41321 16977 : {
41322 16977 : const int bLocalUseExceptions = GetUseExceptions();
41323 16977 : if ( bLocalUseExceptions ) {
41324 13913 : pushErrorHandler();
41325 : }
41326 16977 : {
41327 16977 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41328 16977 : result = (int)GDALRasterBandShadow_YSize_get(arg1);
41329 16977 : SWIG_PYTHON_THREAD_END_ALLOW;
41330 : }
41331 16977 : if ( bLocalUseExceptions ) {
41332 13913 : popErrorHandler();
41333 : }
41334 : #ifndef SED_HACKS
41335 : if ( bLocalUseExceptions ) {
41336 : CPLErr eclass = CPLGetLastErrorType();
41337 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41338 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41339 : }
41340 : }
41341 : #endif
41342 : }
41343 16977 : resultobj = SWIG_From_int(static_cast< int >(result));
41344 16977 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41345 : return resultobj;
41346 : fail:
41347 : return NULL;
41348 : }
41349 :
41350 :
41351 849953 : SWIGINTERN PyObject *_wrap_Band_DataType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41352 849953 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41353 849953 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
41354 849953 : void *argp1 = 0 ;
41355 849953 : int res1 = 0 ;
41356 849953 : PyObject *swig_obj[1] ;
41357 849953 : GDALDataType result;
41358 :
41359 849953 : if (!args) SWIG_fail;
41360 849953 : swig_obj[0] = args;
41361 849953 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
41362 849953 : if (!SWIG_IsOK(res1)) {
41363 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_DataType_get" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
41364 : }
41365 849953 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
41366 849953 : {
41367 849953 : const int bLocalUseExceptions = GetUseExceptions();
41368 849953 : if ( bLocalUseExceptions ) {
41369 837804 : pushErrorHandler();
41370 : }
41371 849953 : {
41372 849953 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41373 849953 : result = (GDALDataType)GDALRasterBandShadow_DataType_get(arg1);
41374 849953 : SWIG_PYTHON_THREAD_END_ALLOW;
41375 : }
41376 849953 : if ( bLocalUseExceptions ) {
41377 837804 : popErrorHandler();
41378 : }
41379 : #ifndef SED_HACKS
41380 : if ( bLocalUseExceptions ) {
41381 : CPLErr eclass = CPLGetLastErrorType();
41382 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41383 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41384 : }
41385 : }
41386 : #endif
41387 : }
41388 849953 : resultobj = SWIG_From_int(static_cast< int >(result));
41389 849953 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41390 : return resultobj;
41391 : fail:
41392 : return NULL;
41393 : }
41394 :
41395 :
41396 68 : SWIGINTERN PyObject *_wrap_Band_GetDataset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41397 68 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41398 68 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
41399 68 : void *argp1 = 0 ;
41400 68 : int res1 = 0 ;
41401 68 : PyObject *swig_obj[1] ;
41402 68 : GDALDatasetShadow *result = 0 ;
41403 :
41404 68 : if (!args) SWIG_fail;
41405 68 : swig_obj[0] = args;
41406 68 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
41407 68 : if (!SWIG_IsOK(res1)) {
41408 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetDataset" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
41409 : }
41410 68 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
41411 68 : {
41412 68 : const int bLocalUseExceptions = GetUseExceptions();
41413 68 : if ( bLocalUseExceptions ) {
41414 8 : pushErrorHandler();
41415 : }
41416 68 : {
41417 68 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41418 68 : result = (GDALDatasetShadow *)GDALRasterBandShadow_GetDataset(arg1);
41419 68 : SWIG_PYTHON_THREAD_END_ALLOW;
41420 : }
41421 68 : if ( bLocalUseExceptions ) {
41422 8 : popErrorHandler();
41423 : }
41424 : #ifndef SED_HACKS
41425 : if ( bLocalUseExceptions ) {
41426 : CPLErr eclass = CPLGetLastErrorType();
41427 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41428 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41429 : }
41430 : }
41431 : #endif
41432 : }
41433 68 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
41434 68 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41435 : return resultobj;
41436 : fail:
41437 : return NULL;
41438 : }
41439 :
41440 :
41441 8 : SWIGINTERN PyObject *_wrap_Band_GetBand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41442 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41443 8 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
41444 8 : void *argp1 = 0 ;
41445 8 : int res1 = 0 ;
41446 8 : PyObject *swig_obj[1] ;
41447 8 : int result;
41448 :
41449 8 : if (!args) SWIG_fail;
41450 8 : swig_obj[0] = args;
41451 8 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
41452 8 : if (!SWIG_IsOK(res1)) {
41453 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetBand" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
41454 : }
41455 8 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
41456 8 : {
41457 8 : const int bLocalUseExceptions = GetUseExceptions();
41458 8 : if ( bLocalUseExceptions ) {
41459 8 : pushErrorHandler();
41460 : }
41461 8 : {
41462 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41463 8 : result = (int)GDALRasterBandShadow_GetBand(arg1);
41464 8 : SWIG_PYTHON_THREAD_END_ALLOW;
41465 : }
41466 8 : if ( bLocalUseExceptions ) {
41467 8 : popErrorHandler();
41468 : }
41469 : #ifndef SED_HACKS
41470 : if ( bLocalUseExceptions ) {
41471 : CPLErr eclass = CPLGetLastErrorType();
41472 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41473 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41474 : }
41475 : }
41476 : #endif
41477 : }
41478 8 : resultobj = SWIG_From_int(static_cast< int >(result));
41479 8 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41480 : return resultobj;
41481 : fail:
41482 : return NULL;
41483 : }
41484 :
41485 :
41486 472 : SWIGINTERN PyObject *_wrap_Band_GetBlockSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41487 472 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41488 472 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
41489 472 : int *arg2 = (int *) 0 ;
41490 472 : int *arg3 = (int *) 0 ;
41491 472 : void *argp1 = 0 ;
41492 472 : int res1 = 0 ;
41493 472 : int temp2 ;
41494 472 : int res2 = SWIG_TMPOBJ ;
41495 472 : int temp3 ;
41496 472 : int res3 = SWIG_TMPOBJ ;
41497 472 : PyObject *swig_obj[1] ;
41498 :
41499 472 : arg2 = &temp2;
41500 472 : arg3 = &temp3;
41501 472 : if (!args) SWIG_fail;
41502 472 : swig_obj[0] = args;
41503 472 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
41504 472 : if (!SWIG_IsOK(res1)) {
41505 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetBlockSize" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
41506 : }
41507 472 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
41508 472 : {
41509 472 : const int bLocalUseExceptions = GetUseExceptions();
41510 472 : if ( bLocalUseExceptions ) {
41511 208 : pushErrorHandler();
41512 : }
41513 472 : {
41514 472 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41515 472 : GDALRasterBandShadow_GetBlockSize(arg1,arg2,arg3);
41516 472 : SWIG_PYTHON_THREAD_END_ALLOW;
41517 : }
41518 472 : if ( bLocalUseExceptions ) {
41519 208 : popErrorHandler();
41520 : }
41521 : #ifndef SED_HACKS
41522 : if ( bLocalUseExceptions ) {
41523 : CPLErr eclass = CPLGetLastErrorType();
41524 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41525 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41526 : }
41527 : }
41528 : #endif
41529 : }
41530 472 : resultobj = SWIG_Py_Void();
41531 472 : if (ReturnSame(SWIG_IsTmpObj(res2))) {
41532 472 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
41533 : } else {
41534 0 : int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
41535 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
41536 : }
41537 472 : if (ReturnSame(SWIG_IsTmpObj(res3))) {
41538 472 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
41539 : } else {
41540 0 : int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
41541 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
41542 : }
41543 472 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41544 : return resultobj;
41545 : fail:
41546 : return NULL;
41547 : }
41548 :
41549 :
41550 6 : SWIGINTERN PyObject *_wrap_Band_GetActualBlockSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41551 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41552 6 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
41553 6 : int arg2 ;
41554 6 : int arg3 ;
41555 6 : int *arg4 = (int *) 0 ;
41556 6 : int *arg5 = (int *) 0 ;
41557 6 : int *arg6 = (int *) 0 ;
41558 6 : void *argp1 = 0 ;
41559 6 : int res1 = 0 ;
41560 6 : int val2 ;
41561 6 : int ecode2 = 0 ;
41562 6 : int val3 ;
41563 6 : int ecode3 = 0 ;
41564 6 : int nxvalid4 = 0 ;
41565 6 : int nyvalid4 = 0 ;
41566 6 : int isvalid4 = 0 ;
41567 6 : PyObject *swig_obj[3] ;
41568 :
41569 6 : {
41570 : /* %typemap(in) (int *pnxvalid, int *pnyvalid, int* pisvalid) */
41571 6 : arg4 = &nxvalid4;
41572 6 : arg5 = &nyvalid4;
41573 6 : arg6 = &isvalid4;
41574 : }
41575 6 : if (!SWIG_Python_UnpackTuple(args, "Band_GetActualBlockSize", 3, 3, swig_obj)) SWIG_fail;
41576 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
41577 6 : if (!SWIG_IsOK(res1)) {
41578 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetActualBlockSize" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
41579 : }
41580 6 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
41581 6 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
41582 6 : if (!SWIG_IsOK(ecode2)) {
41583 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_GetActualBlockSize" "', argument " "2"" of type '" "int""'");
41584 : }
41585 6 : arg2 = static_cast< int >(val2);
41586 6 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
41587 6 : if (!SWIG_IsOK(ecode3)) {
41588 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_GetActualBlockSize" "', argument " "3"" of type '" "int""'");
41589 : }
41590 6 : arg3 = static_cast< int >(val3);
41591 6 : {
41592 6 : const int bLocalUseExceptions = GetUseExceptions();
41593 6 : if ( bLocalUseExceptions ) {
41594 0 : pushErrorHandler();
41595 : }
41596 6 : {
41597 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41598 6 : GDALRasterBandShadow_GetActualBlockSize(arg1,arg2,arg3,arg4,arg5,arg6);
41599 6 : SWIG_PYTHON_THREAD_END_ALLOW;
41600 : }
41601 6 : if ( bLocalUseExceptions ) {
41602 0 : popErrorHandler();
41603 : }
41604 : #ifndef SED_HACKS
41605 : if ( bLocalUseExceptions ) {
41606 : CPLErr eclass = CPLGetLastErrorType();
41607 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41608 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41609 : }
41610 : }
41611 : #endif
41612 : }
41613 6 : resultobj = SWIG_Py_Void();
41614 6 : {
41615 : /* %typemap(argout) (int *pnxvalid, int *pnyvalid, int* pisvalid) */
41616 6 : PyObject *r;
41617 6 : if ( !*arg6 ) {
41618 4 : Py_INCREF(Py_None);
41619 4 : r = Py_None;
41620 : }
41621 : else {
41622 2 : r = PyTuple_New( 2 );
41623 2 : PyTuple_SetItem( r, 0, PyLong_FromLong(*arg4) );
41624 2 : PyTuple_SetItem( r, 1, PyLong_FromLong(*arg5) );
41625 : }
41626 : #if SWIG_VERSION >= 0x040300
41627 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
41628 : #else
41629 6 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
41630 : #endif
41631 : }
41632 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41633 : return resultobj;
41634 : fail:
41635 : return NULL;
41636 : }
41637 :
41638 :
41639 840 : SWIGINTERN PyObject *_wrap_Band_GetColorInterpretation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41640 840 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41641 840 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
41642 840 : void *argp1 = 0 ;
41643 840 : int res1 = 0 ;
41644 840 : PyObject *swig_obj[1] ;
41645 840 : GDALColorInterp result;
41646 :
41647 840 : if (!args) SWIG_fail;
41648 840 : swig_obj[0] = args;
41649 840 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
41650 840 : if (!SWIG_IsOK(res1)) {
41651 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetColorInterpretation" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
41652 : }
41653 840 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
41654 840 : {
41655 840 : const int bLocalUseExceptions = GetUseExceptions();
41656 840 : if ( bLocalUseExceptions ) {
41657 294 : pushErrorHandler();
41658 : }
41659 840 : {
41660 840 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41661 840 : result = (GDALColorInterp)GDALRasterBandShadow_GetColorInterpretation(arg1);
41662 840 : SWIG_PYTHON_THREAD_END_ALLOW;
41663 : }
41664 840 : if ( bLocalUseExceptions ) {
41665 294 : popErrorHandler();
41666 : }
41667 : #ifndef SED_HACKS
41668 : if ( bLocalUseExceptions ) {
41669 : CPLErr eclass = CPLGetLastErrorType();
41670 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41671 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41672 : }
41673 : }
41674 : #endif
41675 : }
41676 840 : resultobj = SWIG_From_int(static_cast< int >(result));
41677 840 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41678 : return resultobj;
41679 : fail:
41680 : return NULL;
41681 : }
41682 :
41683 :
41684 182 : SWIGINTERN PyObject *_wrap_Band_GetRasterColorInterpretation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41685 182 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41686 182 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
41687 182 : void *argp1 = 0 ;
41688 182 : int res1 = 0 ;
41689 182 : PyObject *swig_obj[1] ;
41690 182 : GDALColorInterp result;
41691 :
41692 182 : if (!args) SWIG_fail;
41693 182 : swig_obj[0] = args;
41694 182 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
41695 182 : if (!SWIG_IsOK(res1)) {
41696 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetRasterColorInterpretation" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
41697 : }
41698 182 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
41699 182 : {
41700 182 : const int bLocalUseExceptions = GetUseExceptions();
41701 182 : if ( bLocalUseExceptions ) {
41702 64 : pushErrorHandler();
41703 : }
41704 182 : {
41705 182 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41706 182 : result = (GDALColorInterp)GDALRasterBandShadow_GetRasterColorInterpretation(arg1);
41707 182 : SWIG_PYTHON_THREAD_END_ALLOW;
41708 : }
41709 182 : if ( bLocalUseExceptions ) {
41710 64 : popErrorHandler();
41711 : }
41712 : #ifndef SED_HACKS
41713 : if ( bLocalUseExceptions ) {
41714 : CPLErr eclass = CPLGetLastErrorType();
41715 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41716 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41717 : }
41718 : }
41719 : #endif
41720 : }
41721 182 : resultobj = SWIG_From_int(static_cast< int >(result));
41722 182 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41723 : return resultobj;
41724 : fail:
41725 : return NULL;
41726 : }
41727 :
41728 :
41729 693 : SWIGINTERN PyObject *_wrap_Band_SetColorInterpretation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41730 693 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41731 693 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
41732 693 : GDALColorInterp arg2 ;
41733 693 : void *argp1 = 0 ;
41734 693 : int res1 = 0 ;
41735 693 : int val2 ;
41736 693 : int ecode2 = 0 ;
41737 693 : PyObject *swig_obj[2] ;
41738 693 : CPLErr result;
41739 :
41740 693 : if (!SWIG_Python_UnpackTuple(args, "Band_SetColorInterpretation", 2, 2, swig_obj)) SWIG_fail;
41741 693 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
41742 693 : if (!SWIG_IsOK(res1)) {
41743 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetColorInterpretation" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
41744 : }
41745 693 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
41746 693 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
41747 693 : if (!SWIG_IsOK(ecode2)) {
41748 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_SetColorInterpretation" "', argument " "2"" of type '" "GDALColorInterp""'");
41749 : }
41750 693 : arg2 = static_cast< GDALColorInterp >(val2);
41751 693 : {
41752 693 : const int bLocalUseExceptions = GetUseExceptions();
41753 693 : if ( bLocalUseExceptions ) {
41754 324 : pushErrorHandler();
41755 : }
41756 693 : {
41757 693 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41758 693 : result = (CPLErr)GDALRasterBandShadow_SetColorInterpretation(arg1,arg2);
41759 693 : SWIG_PYTHON_THREAD_END_ALLOW;
41760 : }
41761 693 : if ( bLocalUseExceptions ) {
41762 324 : popErrorHandler();
41763 : }
41764 : #ifndef SED_HACKS
41765 : if ( bLocalUseExceptions ) {
41766 : CPLErr eclass = CPLGetLastErrorType();
41767 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41768 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41769 : }
41770 : }
41771 : #endif
41772 : }
41773 693 : resultobj = SWIG_From_int(static_cast< int >(result));
41774 693 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41775 : return resultobj;
41776 : fail:
41777 : return NULL;
41778 : }
41779 :
41780 :
41781 409 : SWIGINTERN PyObject *_wrap_Band_SetRasterColorInterpretation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41782 409 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41783 409 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
41784 409 : GDALColorInterp arg2 ;
41785 409 : void *argp1 = 0 ;
41786 409 : int res1 = 0 ;
41787 409 : int val2 ;
41788 409 : int ecode2 = 0 ;
41789 409 : PyObject *swig_obj[2] ;
41790 409 : CPLErr result;
41791 :
41792 409 : if (!SWIG_Python_UnpackTuple(args, "Band_SetRasterColorInterpretation", 2, 2, swig_obj)) SWIG_fail;
41793 409 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
41794 409 : if (!SWIG_IsOK(res1)) {
41795 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetRasterColorInterpretation" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
41796 : }
41797 409 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
41798 409 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
41799 409 : if (!SWIG_IsOK(ecode2)) {
41800 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_SetRasterColorInterpretation" "', argument " "2"" of type '" "GDALColorInterp""'");
41801 : }
41802 409 : arg2 = static_cast< GDALColorInterp >(val2);
41803 409 : {
41804 409 : const int bLocalUseExceptions = GetUseExceptions();
41805 409 : if ( bLocalUseExceptions ) {
41806 355 : pushErrorHandler();
41807 : }
41808 409 : {
41809 409 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41810 409 : result = (CPLErr)GDALRasterBandShadow_SetRasterColorInterpretation(arg1,arg2);
41811 409 : SWIG_PYTHON_THREAD_END_ALLOW;
41812 : }
41813 409 : if ( bLocalUseExceptions ) {
41814 355 : popErrorHandler();
41815 : }
41816 : #ifndef SED_HACKS
41817 : if ( bLocalUseExceptions ) {
41818 : CPLErr eclass = CPLGetLastErrorType();
41819 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41820 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41821 : }
41822 : }
41823 : #endif
41824 : }
41825 409 : resultobj = SWIG_From_int(static_cast< int >(result));
41826 409 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41827 : return resultobj;
41828 : fail:
41829 : return NULL;
41830 : }
41831 :
41832 :
41833 410206 : SWIGINTERN PyObject *_wrap_Band_GetNoDataValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41834 410206 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41835 410206 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
41836 410206 : double *arg2 = (double *) 0 ;
41837 410206 : int *arg3 = (int *) 0 ;
41838 410206 : void *argp1 = 0 ;
41839 410206 : int res1 = 0 ;
41840 410206 : double tmpval2 ;
41841 410206 : int tmphasval2 ;
41842 410206 : PyObject *swig_obj[1] ;
41843 :
41844 410206 : {
41845 : /* %typemap(python,in,numinputs=0) (double *val, int *hasval) */
41846 410206 : arg2 = &tmpval2;
41847 410206 : arg3 = &tmphasval2;
41848 : }
41849 410206 : if (!args) SWIG_fail;
41850 410206 : swig_obj[0] = args;
41851 410206 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
41852 410206 : if (!SWIG_IsOK(res1)) {
41853 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetNoDataValue" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
41854 : }
41855 410206 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
41856 410206 : {
41857 410206 : const int bLocalUseExceptions = GetUseExceptions();
41858 410206 : if ( bLocalUseExceptions ) {
41859 410003 : pushErrorHandler();
41860 : }
41861 410206 : {
41862 410206 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41863 410206 : GDALRasterBandShadow_GetNoDataValue(arg1,arg2,arg3);
41864 410206 : SWIG_PYTHON_THREAD_END_ALLOW;
41865 : }
41866 410206 : if ( bLocalUseExceptions ) {
41867 410003 : popErrorHandler();
41868 : }
41869 : #ifndef SED_HACKS
41870 : if ( bLocalUseExceptions ) {
41871 : CPLErr eclass = CPLGetLastErrorType();
41872 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41873 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41874 : }
41875 : }
41876 : #endif
41877 : }
41878 410206 : resultobj = SWIG_Py_Void();
41879 410206 : {
41880 : /* %typemap(python,argout) (double *val, int *hasval) */
41881 410206 : PyObject *r;
41882 410206 : if ( !*arg3 ) {
41883 463 : Py_INCREF(Py_None);
41884 463 : r = Py_None;
41885 : }
41886 : else {
41887 409743 : r = PyFloat_FromDouble( *arg2 );
41888 : }
41889 : #if SWIG_VERSION >= 0x040300
41890 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
41891 : #else
41892 410206 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
41893 : #endif
41894 : }
41895 410206 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41896 : return resultobj;
41897 : fail:
41898 : return NULL;
41899 : }
41900 :
41901 :
41902 31 : SWIGINTERN PyObject *_wrap_Band_GetNoDataValueAsInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41903 31 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41904 31 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
41905 31 : GIntBig *arg2 = (GIntBig *) 0 ;
41906 31 : int *arg3 = (int *) 0 ;
41907 31 : void *argp1 = 0 ;
41908 31 : int res1 = 0 ;
41909 31 : GIntBig tmpval2 ;
41910 31 : int tmphasval2 ;
41911 31 : PyObject *swig_obj[1] ;
41912 :
41913 31 : {
41914 : /* %typemap(python,in,numinputs=0) (GIntBig *val, int *hasval) */
41915 31 : arg2 = &tmpval2;
41916 31 : arg3 = &tmphasval2;
41917 : }
41918 31 : if (!args) SWIG_fail;
41919 31 : swig_obj[0] = args;
41920 31 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
41921 31 : if (!SWIG_IsOK(res1)) {
41922 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetNoDataValueAsInt64" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
41923 : }
41924 31 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
41925 31 : {
41926 31 : const int bLocalUseExceptions = GetUseExceptions();
41927 31 : if ( bLocalUseExceptions ) {
41928 22 : pushErrorHandler();
41929 : }
41930 31 : {
41931 31 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
41932 31 : GDALRasterBandShadow_GetNoDataValueAsInt64(arg1,arg2,arg3);
41933 31 : SWIG_PYTHON_THREAD_END_ALLOW;
41934 : }
41935 31 : if ( bLocalUseExceptions ) {
41936 22 : popErrorHandler();
41937 : }
41938 : #ifndef SED_HACKS
41939 : if ( bLocalUseExceptions ) {
41940 : CPLErr eclass = CPLGetLastErrorType();
41941 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
41942 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
41943 : }
41944 : }
41945 : #endif
41946 : }
41947 31 : resultobj = SWIG_Py_Void();
41948 31 : {
41949 : /* %typemap(python,argout) (GIntBig *val, int *hasval) */
41950 31 : PyObject *r;
41951 31 : if ( !*arg3 ) {
41952 10 : Py_INCREF(Py_None);
41953 10 : r = Py_None;
41954 : }
41955 : else {
41956 21 : r = PyLong_FromLongLong( *arg2 );
41957 : }
41958 : #if SWIG_VERSION >= 0x040300
41959 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
41960 : #else
41961 31 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
41962 : #endif
41963 : }
41964 31 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
41965 : return resultobj;
41966 : fail:
41967 : return NULL;
41968 : }
41969 :
41970 :
41971 22 : SWIGINTERN PyObject *_wrap_Band_GetNoDataValueAsUInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41972 22 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
41973 22 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
41974 22 : GUIntBig *arg2 = (GUIntBig *) 0 ;
41975 22 : int *arg3 = (int *) 0 ;
41976 22 : void *argp1 = 0 ;
41977 22 : int res1 = 0 ;
41978 22 : GUIntBig tmpval2 ;
41979 22 : int tmphasval2 ;
41980 22 : PyObject *swig_obj[1] ;
41981 :
41982 22 : {
41983 : /* %typemap(python,in,numinputs=0) (GUIntBig *val, int *hasval) */
41984 22 : arg2 = &tmpval2;
41985 22 : arg3 = &tmphasval2;
41986 : }
41987 22 : if (!args) SWIG_fail;
41988 22 : swig_obj[0] = args;
41989 22 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
41990 22 : if (!SWIG_IsOK(res1)) {
41991 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetNoDataValueAsUInt64" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
41992 : }
41993 22 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
41994 22 : {
41995 22 : const int bLocalUseExceptions = GetUseExceptions();
41996 22 : if ( bLocalUseExceptions ) {
41997 13 : pushErrorHandler();
41998 : }
41999 22 : {
42000 22 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42001 22 : GDALRasterBandShadow_GetNoDataValueAsUInt64(arg1,arg2,arg3);
42002 22 : SWIG_PYTHON_THREAD_END_ALLOW;
42003 : }
42004 22 : if ( bLocalUseExceptions ) {
42005 13 : popErrorHandler();
42006 : }
42007 : #ifndef SED_HACKS
42008 : if ( bLocalUseExceptions ) {
42009 : CPLErr eclass = CPLGetLastErrorType();
42010 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42011 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42012 : }
42013 : }
42014 : #endif
42015 : }
42016 22 : resultobj = SWIG_Py_Void();
42017 22 : {
42018 : /* %typemap(python,argout) (GUIntBig *val, int *hasval) */
42019 22 : PyObject *r;
42020 22 : if ( !*arg3 ) {
42021 4 : Py_INCREF(Py_None);
42022 4 : r = Py_None;
42023 : }
42024 : else {
42025 18 : r = PyLong_FromUnsignedLongLong( *arg2 );
42026 : }
42027 : #if SWIG_VERSION >= 0x040300
42028 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
42029 : #else
42030 22 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
42031 : #endif
42032 : }
42033 22 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42034 : return resultobj;
42035 : fail:
42036 : return NULL;
42037 : }
42038 :
42039 :
42040 686 : SWIGINTERN PyObject *_wrap_Band_SetNoDataValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42041 686 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42042 686 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42043 686 : double arg2 ;
42044 686 : void *argp1 = 0 ;
42045 686 : int res1 = 0 ;
42046 686 : double val2 ;
42047 686 : int ecode2 = 0 ;
42048 686 : PyObject *swig_obj[2] ;
42049 686 : CPLErr result;
42050 :
42051 686 : if (!SWIG_Python_UnpackTuple(args, "Band_SetNoDataValue", 2, 2, swig_obj)) SWIG_fail;
42052 686 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42053 686 : if (!SWIG_IsOK(res1)) {
42054 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetNoDataValue" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42055 : }
42056 686 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42057 686 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
42058 686 : if (!SWIG_IsOK(ecode2)) {
42059 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_SetNoDataValue" "', argument " "2"" of type '" "double""'");
42060 : }
42061 686 : arg2 = static_cast< double >(val2);
42062 686 : {
42063 686 : const int bLocalUseExceptions = GetUseExceptions();
42064 686 : if ( bLocalUseExceptions ) {
42065 507 : pushErrorHandler();
42066 : }
42067 686 : {
42068 686 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42069 686 : result = (CPLErr)GDALRasterBandShadow_SetNoDataValue(arg1,arg2);
42070 686 : SWIG_PYTHON_THREAD_END_ALLOW;
42071 : }
42072 686 : if ( bLocalUseExceptions ) {
42073 507 : popErrorHandler();
42074 : }
42075 : #ifndef SED_HACKS
42076 : if ( bLocalUseExceptions ) {
42077 : CPLErr eclass = CPLGetLastErrorType();
42078 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42079 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42080 : }
42081 : }
42082 : #endif
42083 : }
42084 686 : resultobj = SWIG_From_int(static_cast< int >(result));
42085 698 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42086 : return resultobj;
42087 : fail:
42088 : return NULL;
42089 : }
42090 :
42091 :
42092 21 : SWIGINTERN PyObject *_wrap_Band_SetNoDataValueAsInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42093 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42094 21 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42095 21 : GIntBig arg2 ;
42096 21 : void *argp1 = 0 ;
42097 21 : int res1 = 0 ;
42098 21 : PyObject *swig_obj[2] ;
42099 21 : CPLErr result;
42100 :
42101 21 : if (!SWIG_Python_UnpackTuple(args, "Band_SetNoDataValueAsInt64", 2, 2, swig_obj)) SWIG_fail;
42102 21 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42103 21 : if (!SWIG_IsOK(res1)) {
42104 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetNoDataValueAsInt64" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42105 : }
42106 21 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42107 21 : {
42108 21 : arg2 = (GIntBig)PyLong_AsLongLong(swig_obj[1]);
42109 : }
42110 21 : {
42111 21 : const int bLocalUseExceptions = GetUseExceptions();
42112 21 : if ( bLocalUseExceptions ) {
42113 10 : pushErrorHandler();
42114 : }
42115 21 : {
42116 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42117 21 : result = (CPLErr)GDALRasterBandShadow_SetNoDataValueAsInt64(arg1,arg2);
42118 21 : SWIG_PYTHON_THREAD_END_ALLOW;
42119 : }
42120 21 : if ( bLocalUseExceptions ) {
42121 10 : popErrorHandler();
42122 : }
42123 : #ifndef SED_HACKS
42124 : if ( bLocalUseExceptions ) {
42125 : CPLErr eclass = CPLGetLastErrorType();
42126 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42127 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42128 : }
42129 : }
42130 : #endif
42131 : }
42132 21 : resultobj = SWIG_From_int(static_cast< int >(result));
42133 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42134 : return resultobj;
42135 : fail:
42136 : return NULL;
42137 : }
42138 :
42139 :
42140 20 : SWIGINTERN PyObject *_wrap_Band_SetNoDataValueAsUInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42141 20 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42142 20 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42143 20 : GUIntBig arg2 ;
42144 20 : void *argp1 = 0 ;
42145 20 : int res1 = 0 ;
42146 20 : PyObject *swig_obj[2] ;
42147 20 : CPLErr result;
42148 :
42149 20 : if (!SWIG_Python_UnpackTuple(args, "Band_SetNoDataValueAsUInt64", 2, 2, swig_obj)) SWIG_fail;
42150 20 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42151 20 : if (!SWIG_IsOK(res1)) {
42152 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetNoDataValueAsUInt64" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42153 : }
42154 20 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42155 20 : {
42156 20 : arg2 = (GIntBig)PyLong_AsUnsignedLongLong(swig_obj[1]);
42157 : }
42158 20 : {
42159 20 : const int bLocalUseExceptions = GetUseExceptions();
42160 20 : if ( bLocalUseExceptions ) {
42161 9 : pushErrorHandler();
42162 : }
42163 20 : {
42164 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42165 20 : result = (CPLErr)GDALRasterBandShadow_SetNoDataValueAsUInt64(arg1,arg2);
42166 20 : SWIG_PYTHON_THREAD_END_ALLOW;
42167 : }
42168 20 : if ( bLocalUseExceptions ) {
42169 9 : popErrorHandler();
42170 : }
42171 : #ifndef SED_HACKS
42172 : if ( bLocalUseExceptions ) {
42173 : CPLErr eclass = CPLGetLastErrorType();
42174 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42175 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42176 : }
42177 : }
42178 : #endif
42179 : }
42180 20 : resultobj = SWIG_From_int(static_cast< int >(result));
42181 20 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42182 : return resultobj;
42183 : fail:
42184 : return NULL;
42185 : }
42186 :
42187 :
42188 53 : SWIGINTERN PyObject *_wrap_Band_DeleteNoDataValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42189 53 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42190 53 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42191 53 : void *argp1 = 0 ;
42192 53 : int res1 = 0 ;
42193 53 : PyObject *swig_obj[1] ;
42194 53 : CPLErr result;
42195 :
42196 53 : if (!args) SWIG_fail;
42197 53 : swig_obj[0] = args;
42198 53 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42199 53 : if (!SWIG_IsOK(res1)) {
42200 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_DeleteNoDataValue" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42201 : }
42202 53 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42203 53 : {
42204 53 : const int bLocalUseExceptions = GetUseExceptions();
42205 53 : if ( bLocalUseExceptions ) {
42206 42 : pushErrorHandler();
42207 : }
42208 53 : {
42209 53 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42210 53 : result = (CPLErr)GDALRasterBandShadow_DeleteNoDataValue(arg1);
42211 53 : SWIG_PYTHON_THREAD_END_ALLOW;
42212 : }
42213 53 : if ( bLocalUseExceptions ) {
42214 42 : popErrorHandler();
42215 : }
42216 : #ifndef SED_HACKS
42217 : if ( bLocalUseExceptions ) {
42218 : CPLErr eclass = CPLGetLastErrorType();
42219 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42220 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42221 : }
42222 : }
42223 : #endif
42224 : }
42225 53 : resultobj = SWIG_From_int(static_cast< int >(result));
42226 53 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42227 : return resultobj;
42228 : fail:
42229 : return NULL;
42230 : }
42231 :
42232 :
42233 69 : SWIGINTERN PyObject *_wrap_Band_GetUnitType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42234 69 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42235 69 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42236 69 : void *argp1 = 0 ;
42237 69 : int res1 = 0 ;
42238 69 : PyObject *swig_obj[1] ;
42239 69 : char *result = 0 ;
42240 :
42241 69 : if (!args) SWIG_fail;
42242 69 : swig_obj[0] = args;
42243 69 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42244 69 : if (!SWIG_IsOK(res1)) {
42245 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetUnitType" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42246 : }
42247 69 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42248 69 : {
42249 69 : const int bLocalUseExceptions = GetUseExceptions();
42250 69 : if ( bLocalUseExceptions ) {
42251 38 : pushErrorHandler();
42252 : }
42253 69 : {
42254 69 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42255 69 : result = (char *)GDALRasterBandShadow_GetUnitType(arg1);
42256 69 : SWIG_PYTHON_THREAD_END_ALLOW;
42257 : }
42258 69 : if ( bLocalUseExceptions ) {
42259 38 : popErrorHandler();
42260 : }
42261 : #ifndef SED_HACKS
42262 : if ( bLocalUseExceptions ) {
42263 : CPLErr eclass = CPLGetLastErrorType();
42264 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42265 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42266 : }
42267 : }
42268 : #endif
42269 : }
42270 69 : resultobj = SWIG_FromCharPtr((const char *)result);
42271 69 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42272 : return resultobj;
42273 : fail:
42274 : return NULL;
42275 : }
42276 :
42277 :
42278 38 : SWIGINTERN PyObject *_wrap_Band_SetUnitType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42279 38 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42280 38 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42281 38 : char *arg2 = (char *) 0 ;
42282 38 : void *argp1 = 0 ;
42283 38 : int res1 = 0 ;
42284 38 : int res2 ;
42285 38 : char *buf2 = 0 ;
42286 38 : int alloc2 = 0 ;
42287 38 : PyObject *swig_obj[2] ;
42288 38 : CPLErr result;
42289 :
42290 38 : if (!SWIG_Python_UnpackTuple(args, "Band_SetUnitType", 2, 2, swig_obj)) SWIG_fail;
42291 38 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42292 38 : if (!SWIG_IsOK(res1)) {
42293 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetUnitType" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42294 : }
42295 38 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42296 38 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
42297 38 : if (!SWIG_IsOK(res2)) {
42298 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Band_SetUnitType" "', argument " "2"" of type '" "char const *""'");
42299 : }
42300 38 : arg2 = reinterpret_cast< char * >(buf2);
42301 38 : {
42302 38 : const int bLocalUseExceptions = GetUseExceptions();
42303 38 : if ( bLocalUseExceptions ) {
42304 18 : pushErrorHandler();
42305 : }
42306 38 : {
42307 38 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42308 38 : result = (CPLErr)GDALRasterBandShadow_SetUnitType(arg1,(char const *)arg2);
42309 38 : SWIG_PYTHON_THREAD_END_ALLOW;
42310 : }
42311 38 : if ( bLocalUseExceptions ) {
42312 18 : popErrorHandler();
42313 : }
42314 : #ifndef SED_HACKS
42315 : if ( bLocalUseExceptions ) {
42316 : CPLErr eclass = CPLGetLastErrorType();
42317 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42318 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42319 : }
42320 : }
42321 : #endif
42322 : }
42323 38 : resultobj = SWIG_From_int(static_cast< int >(result));
42324 38 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
42325 38 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42326 : return resultobj;
42327 0 : fail:
42328 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
42329 : return NULL;
42330 : }
42331 :
42332 :
42333 17 : SWIGINTERN PyObject *_wrap_Band_GetRasterCategoryNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42334 17 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42335 17 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42336 17 : void *argp1 = 0 ;
42337 17 : int res1 = 0 ;
42338 17 : PyObject *swig_obj[1] ;
42339 17 : char **result = 0 ;
42340 :
42341 17 : if (!args) SWIG_fail;
42342 17 : swig_obj[0] = args;
42343 17 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42344 17 : if (!SWIG_IsOK(res1)) {
42345 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetRasterCategoryNames" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42346 : }
42347 17 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42348 17 : {
42349 17 : const int bLocalUseExceptions = GetUseExceptions();
42350 17 : if ( bLocalUseExceptions ) {
42351 0 : pushErrorHandler();
42352 : }
42353 17 : {
42354 17 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42355 17 : result = (char **)GDALRasterBandShadow_GetRasterCategoryNames(arg1);
42356 17 : SWIG_PYTHON_THREAD_END_ALLOW;
42357 : }
42358 17 : if ( bLocalUseExceptions ) {
42359 0 : popErrorHandler();
42360 : }
42361 : #ifndef SED_HACKS
42362 : if ( bLocalUseExceptions ) {
42363 : CPLErr eclass = CPLGetLastErrorType();
42364 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42365 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42366 : }
42367 : }
42368 : #endif
42369 : }
42370 17 : {
42371 : /* %typemap(out) char **options -> ( string ) */
42372 17 : bool bErr = false;
42373 17 : resultobj = CSLToList(result, &bErr);
42374 17 : if( bErr ) {
42375 0 : SWIG_fail;
42376 : }
42377 : }
42378 17 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42379 : return resultobj;
42380 : fail:
42381 : return NULL;
42382 : }
42383 :
42384 :
42385 0 : SWIGINTERN PyObject *_wrap_Band_SetRasterCategoryNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42386 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42387 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42388 0 : char **arg2 = (char **) 0 ;
42389 0 : void *argp1 = 0 ;
42390 0 : int res1 = 0 ;
42391 0 : PyObject *swig_obj[2] ;
42392 0 : CPLErr result;
42393 :
42394 0 : if (!SWIG_Python_UnpackTuple(args, "Band_SetRasterCategoryNames", 2, 2, swig_obj)) SWIG_fail;
42395 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42396 0 : if (!SWIG_IsOK(res1)) {
42397 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetRasterCategoryNames" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42398 : }
42399 0 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42400 0 : {
42401 : /* %typemap(in) char **dict */
42402 0 : arg2 = NULL;
42403 0 : if ( PySequence_Check( swig_obj[1] ) ) {
42404 0 : int bErr = FALSE;
42405 0 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
42406 0 : if ( bErr )
42407 : {
42408 0 : SWIG_fail;
42409 : }
42410 : }
42411 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
42412 0 : int bErr = FALSE;
42413 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
42414 0 : if ( bErr )
42415 : {
42416 0 : SWIG_fail;
42417 : }
42418 : }
42419 : else {
42420 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
42421 0 : SWIG_fail;
42422 : }
42423 : }
42424 0 : {
42425 0 : const int bLocalUseExceptions = GetUseExceptions();
42426 0 : if ( bLocalUseExceptions ) {
42427 0 : pushErrorHandler();
42428 : }
42429 0 : {
42430 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42431 0 : result = (CPLErr)GDALRasterBandShadow_SetRasterCategoryNames(arg1,arg2);
42432 0 : SWIG_PYTHON_THREAD_END_ALLOW;
42433 : }
42434 0 : if ( bLocalUseExceptions ) {
42435 0 : popErrorHandler();
42436 : }
42437 : #ifndef SED_HACKS
42438 : if ( bLocalUseExceptions ) {
42439 : CPLErr eclass = CPLGetLastErrorType();
42440 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42441 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42442 : }
42443 : }
42444 : #endif
42445 : }
42446 0 : resultobj = SWIG_From_int(static_cast< int >(result));
42447 0 : {
42448 : /* %typemap(freearg) char **dict */
42449 0 : CSLDestroy( arg2 );
42450 : }
42451 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42452 : return resultobj;
42453 0 : fail:
42454 0 : {
42455 : /* %typemap(freearg) char **dict */
42456 0 : CSLDestroy( arg2 );
42457 : }
42458 : return NULL;
42459 : }
42460 :
42461 :
42462 97 : SWIGINTERN PyObject *_wrap_Band_GetMinimum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42463 97 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42464 97 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42465 97 : double *arg2 = (double *) 0 ;
42466 97 : int *arg3 = (int *) 0 ;
42467 97 : void *argp1 = 0 ;
42468 97 : int res1 = 0 ;
42469 97 : double tmpval2 ;
42470 97 : int tmphasval2 ;
42471 97 : PyObject *swig_obj[1] ;
42472 :
42473 97 : {
42474 : /* %typemap(python,in,numinputs=0) (double *val, int *hasval) */
42475 97 : arg2 = &tmpval2;
42476 97 : arg3 = &tmphasval2;
42477 : }
42478 97 : if (!args) SWIG_fail;
42479 97 : swig_obj[0] = args;
42480 97 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42481 97 : if (!SWIG_IsOK(res1)) {
42482 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetMinimum" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42483 : }
42484 97 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42485 97 : {
42486 97 : const int bLocalUseExceptions = GetUseExceptions();
42487 97 : if ( bLocalUseExceptions ) {
42488 61 : pushErrorHandler();
42489 : }
42490 97 : {
42491 97 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42492 97 : GDALRasterBandShadow_GetMinimum(arg1,arg2,arg3);
42493 97 : SWIG_PYTHON_THREAD_END_ALLOW;
42494 : }
42495 97 : if ( bLocalUseExceptions ) {
42496 61 : popErrorHandler();
42497 : }
42498 : #ifndef SED_HACKS
42499 : if ( bLocalUseExceptions ) {
42500 : CPLErr eclass = CPLGetLastErrorType();
42501 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42502 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42503 : }
42504 : }
42505 : #endif
42506 : }
42507 97 : resultobj = SWIG_Py_Void();
42508 97 : {
42509 : /* %typemap(python,argout) (double *val, int *hasval) */
42510 97 : PyObject *r;
42511 97 : if ( !*arg3 ) {
42512 28 : Py_INCREF(Py_None);
42513 28 : r = Py_None;
42514 : }
42515 : else {
42516 69 : r = PyFloat_FromDouble( *arg2 );
42517 : }
42518 : #if SWIG_VERSION >= 0x040300
42519 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
42520 : #else
42521 97 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
42522 : #endif
42523 : }
42524 97 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42525 : return resultobj;
42526 : fail:
42527 : return NULL;
42528 : }
42529 :
42530 :
42531 87 : SWIGINTERN PyObject *_wrap_Band_GetMaximum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42532 87 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42533 87 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42534 87 : double *arg2 = (double *) 0 ;
42535 87 : int *arg3 = (int *) 0 ;
42536 87 : void *argp1 = 0 ;
42537 87 : int res1 = 0 ;
42538 87 : double tmpval2 ;
42539 87 : int tmphasval2 ;
42540 87 : PyObject *swig_obj[1] ;
42541 :
42542 87 : {
42543 : /* %typemap(python,in,numinputs=0) (double *val, int *hasval) */
42544 87 : arg2 = &tmpval2;
42545 87 : arg3 = &tmphasval2;
42546 : }
42547 87 : if (!args) SWIG_fail;
42548 87 : swig_obj[0] = args;
42549 87 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42550 87 : if (!SWIG_IsOK(res1)) {
42551 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetMaximum" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42552 : }
42553 87 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42554 87 : {
42555 87 : const int bLocalUseExceptions = GetUseExceptions();
42556 87 : if ( bLocalUseExceptions ) {
42557 57 : pushErrorHandler();
42558 : }
42559 87 : {
42560 87 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42561 87 : GDALRasterBandShadow_GetMaximum(arg1,arg2,arg3);
42562 87 : SWIG_PYTHON_THREAD_END_ALLOW;
42563 : }
42564 87 : if ( bLocalUseExceptions ) {
42565 57 : popErrorHandler();
42566 : }
42567 : #ifndef SED_HACKS
42568 : if ( bLocalUseExceptions ) {
42569 : CPLErr eclass = CPLGetLastErrorType();
42570 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42571 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42572 : }
42573 : }
42574 : #endif
42575 : }
42576 87 : resultobj = SWIG_Py_Void();
42577 87 : {
42578 : /* %typemap(python,argout) (double *val, int *hasval) */
42579 87 : PyObject *r;
42580 87 : if ( !*arg3 ) {
42581 25 : Py_INCREF(Py_None);
42582 25 : r = Py_None;
42583 : }
42584 : else {
42585 62 : r = PyFloat_FromDouble( *arg2 );
42586 : }
42587 : #if SWIG_VERSION >= 0x040300
42588 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
42589 : #else
42590 87 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
42591 : #endif
42592 : }
42593 87 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42594 : return resultobj;
42595 : fail:
42596 : return NULL;
42597 : }
42598 :
42599 :
42600 151 : SWIGINTERN PyObject *_wrap_Band_GetOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42601 151 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42602 151 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42603 151 : double *arg2 = (double *) 0 ;
42604 151 : int *arg3 = (int *) 0 ;
42605 151 : void *argp1 = 0 ;
42606 151 : int res1 = 0 ;
42607 151 : double tmpval2 ;
42608 151 : int tmphasval2 ;
42609 151 : PyObject *swig_obj[1] ;
42610 :
42611 151 : {
42612 : /* %typemap(python,in,numinputs=0) (double *val, int *hasval) */
42613 151 : arg2 = &tmpval2;
42614 151 : arg3 = &tmphasval2;
42615 : }
42616 151 : if (!args) SWIG_fail;
42617 151 : swig_obj[0] = args;
42618 151 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42619 151 : if (!SWIG_IsOK(res1)) {
42620 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetOffset" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42621 : }
42622 151 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42623 151 : {
42624 151 : const int bLocalUseExceptions = GetUseExceptions();
42625 151 : if ( bLocalUseExceptions ) {
42626 98 : pushErrorHandler();
42627 : }
42628 151 : {
42629 151 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42630 151 : GDALRasterBandShadow_GetOffset(arg1,arg2,arg3);
42631 151 : SWIG_PYTHON_THREAD_END_ALLOW;
42632 : }
42633 151 : if ( bLocalUseExceptions ) {
42634 98 : popErrorHandler();
42635 : }
42636 : #ifndef SED_HACKS
42637 : if ( bLocalUseExceptions ) {
42638 : CPLErr eclass = CPLGetLastErrorType();
42639 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42640 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42641 : }
42642 : }
42643 : #endif
42644 : }
42645 151 : resultobj = SWIG_Py_Void();
42646 151 : {
42647 : /* %typemap(python,argout) (double *val, int *hasval) */
42648 151 : PyObject *r;
42649 151 : if ( !*arg3 ) {
42650 47 : Py_INCREF(Py_None);
42651 47 : r = Py_None;
42652 : }
42653 : else {
42654 104 : r = PyFloat_FromDouble( *arg2 );
42655 : }
42656 : #if SWIG_VERSION >= 0x040300
42657 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
42658 : #else
42659 151 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
42660 : #endif
42661 : }
42662 151 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42663 : return resultobj;
42664 : fail:
42665 : return NULL;
42666 : }
42667 :
42668 :
42669 149 : SWIGINTERN PyObject *_wrap_Band_GetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42670 149 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42671 149 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42672 149 : double *arg2 = (double *) 0 ;
42673 149 : int *arg3 = (int *) 0 ;
42674 149 : void *argp1 = 0 ;
42675 149 : int res1 = 0 ;
42676 149 : double tmpval2 ;
42677 149 : int tmphasval2 ;
42678 149 : PyObject *swig_obj[1] ;
42679 :
42680 149 : {
42681 : /* %typemap(python,in,numinputs=0) (double *val, int *hasval) */
42682 149 : arg2 = &tmpval2;
42683 149 : arg3 = &tmphasval2;
42684 : }
42685 149 : if (!args) SWIG_fail;
42686 149 : swig_obj[0] = args;
42687 149 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42688 149 : if (!SWIG_IsOK(res1)) {
42689 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetScale" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42690 : }
42691 149 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42692 149 : {
42693 149 : const int bLocalUseExceptions = GetUseExceptions();
42694 149 : if ( bLocalUseExceptions ) {
42695 97 : pushErrorHandler();
42696 : }
42697 149 : {
42698 149 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42699 149 : GDALRasterBandShadow_GetScale(arg1,arg2,arg3);
42700 149 : SWIG_PYTHON_THREAD_END_ALLOW;
42701 : }
42702 149 : if ( bLocalUseExceptions ) {
42703 97 : popErrorHandler();
42704 : }
42705 : #ifndef SED_HACKS
42706 : if ( bLocalUseExceptions ) {
42707 : CPLErr eclass = CPLGetLastErrorType();
42708 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42709 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42710 : }
42711 : }
42712 : #endif
42713 : }
42714 149 : resultobj = SWIG_Py_Void();
42715 149 : {
42716 : /* %typemap(python,argout) (double *val, int *hasval) */
42717 149 : PyObject *r;
42718 149 : if ( !*arg3 ) {
42719 47 : Py_INCREF(Py_None);
42720 47 : r = Py_None;
42721 : }
42722 : else {
42723 102 : r = PyFloat_FromDouble( *arg2 );
42724 : }
42725 : #if SWIG_VERSION >= 0x040300
42726 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
42727 : #else
42728 149 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
42729 : #endif
42730 : }
42731 149 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42732 : return resultobj;
42733 : fail:
42734 : return NULL;
42735 : }
42736 :
42737 :
42738 86 : SWIGINTERN PyObject *_wrap_Band_SetOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42739 86 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42740 86 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42741 86 : double arg2 ;
42742 86 : void *argp1 = 0 ;
42743 86 : int res1 = 0 ;
42744 86 : double val2 ;
42745 86 : int ecode2 = 0 ;
42746 86 : PyObject *swig_obj[2] ;
42747 86 : CPLErr result;
42748 :
42749 86 : if (!SWIG_Python_UnpackTuple(args, "Band_SetOffset", 2, 2, swig_obj)) SWIG_fail;
42750 86 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42751 86 : if (!SWIG_IsOK(res1)) {
42752 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetOffset" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42753 : }
42754 86 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42755 86 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
42756 86 : if (!SWIG_IsOK(ecode2)) {
42757 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_SetOffset" "', argument " "2"" of type '" "double""'");
42758 : }
42759 86 : arg2 = static_cast< double >(val2);
42760 86 : {
42761 86 : const int bLocalUseExceptions = GetUseExceptions();
42762 86 : if ( bLocalUseExceptions ) {
42763 64 : pushErrorHandler();
42764 : }
42765 86 : {
42766 86 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42767 86 : result = (CPLErr)GDALRasterBandShadow_SetOffset(arg1,arg2);
42768 86 : SWIG_PYTHON_THREAD_END_ALLOW;
42769 : }
42770 86 : if ( bLocalUseExceptions ) {
42771 64 : popErrorHandler();
42772 : }
42773 : #ifndef SED_HACKS
42774 : if ( bLocalUseExceptions ) {
42775 : CPLErr eclass = CPLGetLastErrorType();
42776 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42777 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42778 : }
42779 : }
42780 : #endif
42781 : }
42782 86 : resultobj = SWIG_From_int(static_cast< int >(result));
42783 86 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42784 : return resultobj;
42785 : fail:
42786 : return NULL;
42787 : }
42788 :
42789 :
42790 87 : SWIGINTERN PyObject *_wrap_Band_SetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42791 87 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42792 87 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42793 87 : double arg2 ;
42794 87 : void *argp1 = 0 ;
42795 87 : int res1 = 0 ;
42796 87 : double val2 ;
42797 87 : int ecode2 = 0 ;
42798 87 : PyObject *swig_obj[2] ;
42799 87 : CPLErr result;
42800 :
42801 87 : if (!SWIG_Python_UnpackTuple(args, "Band_SetScale", 2, 2, swig_obj)) SWIG_fail;
42802 87 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42803 87 : if (!SWIG_IsOK(res1)) {
42804 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetScale" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42805 : }
42806 87 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42807 87 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
42808 87 : if (!SWIG_IsOK(ecode2)) {
42809 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_SetScale" "', argument " "2"" of type '" "double""'");
42810 : }
42811 87 : arg2 = static_cast< double >(val2);
42812 87 : {
42813 87 : const int bLocalUseExceptions = GetUseExceptions();
42814 87 : if ( bLocalUseExceptions ) {
42815 64 : pushErrorHandler();
42816 : }
42817 87 : {
42818 87 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42819 87 : result = (CPLErr)GDALRasterBandShadow_SetScale(arg1,arg2);
42820 87 : SWIG_PYTHON_THREAD_END_ALLOW;
42821 : }
42822 87 : if ( bLocalUseExceptions ) {
42823 64 : popErrorHandler();
42824 : }
42825 : #ifndef SED_HACKS
42826 : if ( bLocalUseExceptions ) {
42827 : CPLErr eclass = CPLGetLastErrorType();
42828 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42829 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42830 : }
42831 : }
42832 : #endif
42833 : }
42834 87 : resultobj = SWIG_From_int(static_cast< int >(result));
42835 87 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42836 : return resultobj;
42837 : fail:
42838 : return NULL;
42839 : }
42840 :
42841 :
42842 140 : SWIGINTERN PyObject *_wrap_Band_GetStatistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42843 140 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42844 140 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42845 140 : int arg2 ;
42846 140 : int arg3 ;
42847 140 : double *arg4 = (double *) 0 ;
42848 140 : double *arg5 = (double *) 0 ;
42849 140 : double *arg6 = (double *) 0 ;
42850 140 : double *arg7 = (double *) 0 ;
42851 140 : void *argp1 = 0 ;
42852 140 : int res1 = 0 ;
42853 140 : int val2 ;
42854 140 : int ecode2 = 0 ;
42855 140 : int val3 ;
42856 140 : int ecode3 = 0 ;
42857 140 : double temp4 ;
42858 140 : int res4 = SWIG_TMPOBJ ;
42859 140 : double temp5 ;
42860 140 : int res5 = SWIG_TMPOBJ ;
42861 140 : double temp6 ;
42862 140 : int res6 = SWIG_TMPOBJ ;
42863 140 : double temp7 ;
42864 140 : int res7 = SWIG_TMPOBJ ;
42865 140 : PyObject *swig_obj[3] ;
42866 140 : CPLErr result;
42867 :
42868 140 : arg4 = &temp4;
42869 140 : arg5 = &temp5;
42870 140 : arg6 = &temp6;
42871 140 : arg7 = &temp7;
42872 140 : if (!SWIG_Python_UnpackTuple(args, "Band_GetStatistics", 3, 3, swig_obj)) SWIG_fail;
42873 140 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42874 140 : if (!SWIG_IsOK(res1)) {
42875 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetStatistics" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42876 : }
42877 140 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
42878 140 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
42879 140 : if (!SWIG_IsOK(ecode2)) {
42880 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_GetStatistics" "', argument " "2"" of type '" "int""'");
42881 : }
42882 140 : arg2 = static_cast< int >(val2);
42883 140 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
42884 140 : if (!SWIG_IsOK(ecode3)) {
42885 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_GetStatistics" "', argument " "3"" of type '" "int""'");
42886 : }
42887 140 : arg3 = static_cast< int >(val3);
42888 140 : {
42889 140 : const int bLocalUseExceptions = GetUseExceptions();
42890 140 : if ( bLocalUseExceptions ) {
42891 104 : pushErrorHandler();
42892 : }
42893 140 : {
42894 140 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
42895 140 : result = (CPLErr)GDALRasterBandShadow_GetStatistics(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
42896 140 : SWIG_PYTHON_THREAD_END_ALLOW;
42897 : }
42898 140 : if ( bLocalUseExceptions ) {
42899 104 : popErrorHandler();
42900 : }
42901 : #ifndef SED_HACKS
42902 : if ( bLocalUseExceptions ) {
42903 : CPLErr eclass = CPLGetLastErrorType();
42904 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
42905 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
42906 : }
42907 : }
42908 : #endif
42909 : }
42910 140 : {
42911 : /* %typemap(out) IF_ERROR_RETURN_NONE */
42912 : }
42913 140 : if (ReturnSame(SWIG_IsTmpObj(res4))) {
42914 140 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
42915 : } else {
42916 0 : int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
42917 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
42918 : }
42919 140 : if (ReturnSame(SWIG_IsTmpObj(res5))) {
42920 140 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
42921 : } else {
42922 0 : int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
42923 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
42924 : }
42925 140 : if (ReturnSame(SWIG_IsTmpObj(res6))) {
42926 140 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
42927 : } else {
42928 0 : int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
42929 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
42930 : }
42931 140 : if (ReturnSame(SWIG_IsTmpObj(res7))) {
42932 140 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
42933 : } else {
42934 0 : int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
42935 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
42936 : }
42937 140 : {
42938 : /* %typemap(ret) IF_ERROR_RETURN_NONE */
42939 140 : if (result != CE_None ) {
42940 29 : Py_XDECREF( resultobj );
42941 29 : resultobj = Py_None;
42942 29 : Py_INCREF(resultobj);
42943 : }
42944 : }
42945 144 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
42946 : return resultobj;
42947 : fail:
42948 : return NULL;
42949 : }
42950 :
42951 :
42952 168 : SWIGINTERN PyObject *_wrap_Band_ComputeStatistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42953 168 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
42954 168 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
42955 168 : bool arg2 ;
42956 168 : double *arg3 = (double *) 0 ;
42957 168 : double *arg4 = (double *) 0 ;
42958 168 : double *arg5 = (double *) 0 ;
42959 168 : double *arg6 = (double *) 0 ;
42960 168 : GDALProgressFunc arg7 = (GDALProgressFunc) NULL ;
42961 168 : void *arg8 = (void *) NULL ;
42962 168 : void *argp1 = 0 ;
42963 168 : int res1 = 0 ;
42964 168 : bool val2 ;
42965 168 : int ecode2 = 0 ;
42966 168 : double temp3 ;
42967 168 : int res3 = SWIG_TMPOBJ ;
42968 168 : double temp4 ;
42969 168 : int res4 = SWIG_TMPOBJ ;
42970 168 : double temp5 ;
42971 168 : int res5 = SWIG_TMPOBJ ;
42972 168 : double temp6 ;
42973 168 : int res6 = SWIG_TMPOBJ ;
42974 168 : PyObject * obj0 = 0 ;
42975 168 : PyObject * obj1 = 0 ;
42976 168 : PyObject * obj2 = 0 ;
42977 168 : PyObject * obj3 = 0 ;
42978 168 : char * kwnames[] = {
42979 : (char *)"self", (char *)"approx_ok", (char *)"callback", (char *)"callback_data", NULL
42980 : };
42981 168 : CPLErr result;
42982 :
42983 : /* %typemap(arginit) ( const char* callback_data=NULL) */
42984 168 : PyProgressData *psProgressInfo;
42985 168 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
42986 168 : psProgressInfo->nLastReported = -1;
42987 168 : psProgressInfo->psPyCallback = NULL;
42988 168 : psProgressInfo->psPyCallbackData = NULL;
42989 168 : arg8 = psProgressInfo;
42990 168 : arg3 = &temp3;
42991 168 : arg4 = &temp4;
42992 168 : arg5 = &temp5;
42993 168 : arg6 = &temp6;
42994 168 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:Band_ComputeStatistics", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
42995 168 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
42996 168 : if (!SWIG_IsOK(res1)) {
42997 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_ComputeStatistics" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
42998 : }
42999 168 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
43000 168 : ecode2 = SWIG_AsVal_bool(obj1, &val2);
43001 168 : if (!SWIG_IsOK(ecode2)) {
43002 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_ComputeStatistics" "', argument " "2"" of type '" "bool""'");
43003 : }
43004 168 : arg2 = static_cast< bool >(val2);
43005 168 : if (obj2) {
43006 3 : {
43007 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
43008 : /* callback_func typemap */
43009 :
43010 : /* In some cases 0 is passed instead of None. */
43011 : /* See https://github.com/OSGeo/gdal/pull/219 */
43012 3 : if ( PyLong_Check(obj2) || PyInt_Check(obj2) )
43013 : {
43014 0 : if( PyLong_AsLong(obj2) == 0 )
43015 : {
43016 0 : obj2 = Py_None;
43017 : }
43018 : }
43019 :
43020 3 : if (obj2 && obj2 != Py_None ) {
43021 3 : void* cbfunction = NULL;
43022 3 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj2,
43023 : (void**)&cbfunction,
43024 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
43025 : SWIG_POINTER_EXCEPTION | 0 ));
43026 :
43027 3 : if ( cbfunction == GDALTermProgress ) {
43028 : arg7 = GDALTermProgress;
43029 : } else {
43030 3 : if (!PyCallable_Check(obj2)) {
43031 0 : PyErr_SetString( PyExc_RuntimeError,
43032 : "Object given is not a Python function" );
43033 0 : SWIG_fail;
43034 : }
43035 3 : psProgressInfo->psPyCallback = obj2;
43036 3 : arg7 = PyProgressProxy;
43037 : }
43038 :
43039 : }
43040 :
43041 : }
43042 : }
43043 168 : if (obj3) {
43044 3 : {
43045 : /* %typemap(in) ( void* callback_data=NULL) */
43046 3 : psProgressInfo->psPyCallbackData = obj3 ;
43047 : }
43048 : }
43049 168 : {
43050 168 : const int bLocalUseExceptions = GetUseExceptions();
43051 168 : if ( bLocalUseExceptions ) {
43052 83 : pushErrorHandler();
43053 : }
43054 168 : {
43055 168 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43056 168 : result = (CPLErr)GDALRasterBandShadow_ComputeStatistics(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
43057 168 : SWIG_PYTHON_THREAD_END_ALLOW;
43058 : }
43059 168 : if ( bLocalUseExceptions ) {
43060 83 : popErrorHandler();
43061 : }
43062 : #ifndef SED_HACKS
43063 : if ( bLocalUseExceptions ) {
43064 : CPLErr eclass = CPLGetLastErrorType();
43065 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
43066 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
43067 : }
43068 : }
43069 : #endif
43070 : }
43071 168 : {
43072 : /* %typemap(out) IF_ERROR_RETURN_NONE */
43073 : }
43074 168 : if (ReturnSame(SWIG_IsTmpObj(res3))) {
43075 168 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
43076 : } else {
43077 0 : int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
43078 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
43079 : }
43080 168 : if (ReturnSame(SWIG_IsTmpObj(res4))) {
43081 168 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
43082 : } else {
43083 0 : int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
43084 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
43085 : }
43086 168 : if (ReturnSame(SWIG_IsTmpObj(res5))) {
43087 168 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
43088 : } else {
43089 0 : int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
43090 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
43091 : }
43092 168 : if (ReturnSame(SWIG_IsTmpObj(res6))) {
43093 168 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
43094 : } else {
43095 0 : int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
43096 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
43097 : }
43098 168 : {
43099 : /* %typemap(freearg) ( void* callback_data=NULL) */
43100 :
43101 168 : CPLFree(psProgressInfo);
43102 :
43103 : }
43104 168 : {
43105 : /* %typemap(ret) IF_ERROR_RETURN_NONE */
43106 168 : if (result != CE_None ) {
43107 1 : Py_XDECREF( resultobj );
43108 1 : resultobj = Py_None;
43109 1 : Py_INCREF(resultobj);
43110 : }
43111 : }
43112 168 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
43113 : return resultobj;
43114 0 : fail:
43115 0 : {
43116 : /* %typemap(freearg) ( void* callback_data=NULL) */
43117 :
43118 0 : CPLFree(psProgressInfo);
43119 :
43120 : }
43121 : return NULL;
43122 : }
43123 :
43124 :
43125 2 : SWIGINTERN PyObject *_wrap_Band_SetStatistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43126 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
43127 2 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
43128 2 : double arg2 ;
43129 2 : double arg3 ;
43130 2 : double arg4 ;
43131 2 : double arg5 ;
43132 2 : void *argp1 = 0 ;
43133 2 : int res1 = 0 ;
43134 2 : double val2 ;
43135 2 : int ecode2 = 0 ;
43136 2 : double val3 ;
43137 2 : int ecode3 = 0 ;
43138 2 : double val4 ;
43139 2 : int ecode4 = 0 ;
43140 2 : double val5 ;
43141 2 : int ecode5 = 0 ;
43142 2 : PyObject *swig_obj[5] ;
43143 2 : CPLErr result;
43144 :
43145 2 : if (!SWIG_Python_UnpackTuple(args, "Band_SetStatistics", 5, 5, swig_obj)) SWIG_fail;
43146 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
43147 2 : if (!SWIG_IsOK(res1)) {
43148 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetStatistics" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
43149 : }
43150 2 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
43151 2 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
43152 2 : if (!SWIG_IsOK(ecode2)) {
43153 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_SetStatistics" "', argument " "2"" of type '" "double""'");
43154 : }
43155 2 : arg2 = static_cast< double >(val2);
43156 2 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
43157 2 : if (!SWIG_IsOK(ecode3)) {
43158 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_SetStatistics" "', argument " "3"" of type '" "double""'");
43159 : }
43160 2 : arg3 = static_cast< double >(val3);
43161 2 : ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
43162 2 : if (!SWIG_IsOK(ecode4)) {
43163 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Band_SetStatistics" "', argument " "4"" of type '" "double""'");
43164 : }
43165 2 : arg4 = static_cast< double >(val4);
43166 2 : ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
43167 2 : if (!SWIG_IsOK(ecode5)) {
43168 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Band_SetStatistics" "', argument " "5"" of type '" "double""'");
43169 : }
43170 2 : arg5 = static_cast< double >(val5);
43171 2 : {
43172 2 : const int bLocalUseExceptions = GetUseExceptions();
43173 2 : if ( bLocalUseExceptions ) {
43174 2 : pushErrorHandler();
43175 : }
43176 2 : {
43177 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43178 2 : result = (CPLErr)GDALRasterBandShadow_SetStatistics(arg1,arg2,arg3,arg4,arg5);
43179 2 : SWIG_PYTHON_THREAD_END_ALLOW;
43180 : }
43181 2 : if ( bLocalUseExceptions ) {
43182 2 : popErrorHandler();
43183 : }
43184 : #ifndef SED_HACKS
43185 : if ( bLocalUseExceptions ) {
43186 : CPLErr eclass = CPLGetLastErrorType();
43187 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
43188 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
43189 : }
43190 : }
43191 : #endif
43192 : }
43193 2 : resultobj = SWIG_From_int(static_cast< int >(result));
43194 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
43195 : return resultobj;
43196 : fail:
43197 : return NULL;
43198 : }
43199 :
43200 :
43201 536 : SWIGINTERN PyObject *_wrap_Band_GetOverviewCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43202 536 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
43203 536 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
43204 536 : void *argp1 = 0 ;
43205 536 : int res1 = 0 ;
43206 536 : PyObject *swig_obj[1] ;
43207 536 : int result;
43208 :
43209 536 : if (!args) SWIG_fail;
43210 536 : swig_obj[0] = args;
43211 536 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
43212 536 : if (!SWIG_IsOK(res1)) {
43213 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetOverviewCount" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
43214 : }
43215 536 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
43216 536 : {
43217 536 : const int bLocalUseExceptions = GetUseExceptions();
43218 536 : if ( bLocalUseExceptions ) {
43219 345 : pushErrorHandler();
43220 : }
43221 536 : {
43222 536 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43223 536 : result = (int)GDALRasterBandShadow_GetOverviewCount(arg1);
43224 536 : SWIG_PYTHON_THREAD_END_ALLOW;
43225 : }
43226 536 : if ( bLocalUseExceptions ) {
43227 345 : popErrorHandler();
43228 : }
43229 : #ifndef SED_HACKS
43230 : if ( bLocalUseExceptions ) {
43231 : CPLErr eclass = CPLGetLastErrorType();
43232 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
43233 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
43234 : }
43235 : }
43236 : #endif
43237 : }
43238 536 : resultobj = SWIG_From_int(static_cast< int >(result));
43239 546 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
43240 : return resultobj;
43241 : fail:
43242 : return NULL;
43243 : }
43244 :
43245 :
43246 5597 : SWIGINTERN PyObject *_wrap_Band_GetOverview(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43247 5597 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
43248 5597 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
43249 5597 : int arg2 ;
43250 5597 : void *argp1 = 0 ;
43251 5597 : int res1 = 0 ;
43252 5597 : int val2 ;
43253 5597 : int ecode2 = 0 ;
43254 5597 : PyObject *swig_obj[2] ;
43255 5597 : GDALRasterBandShadow *result = 0 ;
43256 :
43257 5597 : if (!SWIG_Python_UnpackTuple(args, "Band_GetOverview", 2, 2, swig_obj)) SWIG_fail;
43258 5597 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
43259 5597 : if (!SWIG_IsOK(res1)) {
43260 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetOverview" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
43261 : }
43262 5597 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
43263 5597 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
43264 5597 : if (!SWIG_IsOK(ecode2)) {
43265 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_GetOverview" "', argument " "2"" of type '" "int""'");
43266 : }
43267 5597 : arg2 = static_cast< int >(val2);
43268 5597 : {
43269 5597 : const int bLocalUseExceptions = GetUseExceptions();
43270 5597 : if ( bLocalUseExceptions ) {
43271 4600 : pushErrorHandler();
43272 : }
43273 5597 : {
43274 5597 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43275 5597 : result = (GDALRasterBandShadow *)GDALRasterBandShadow_GetOverview(arg1,arg2);
43276 5597 : SWIG_PYTHON_THREAD_END_ALLOW;
43277 : }
43278 5597 : if ( bLocalUseExceptions ) {
43279 4600 : popErrorHandler();
43280 : }
43281 : #ifndef SED_HACKS
43282 : if ( bLocalUseExceptions ) {
43283 : CPLErr eclass = CPLGetLastErrorType();
43284 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
43285 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
43286 : }
43287 : }
43288 : #endif
43289 : }
43290 5597 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
43291 5599 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
43292 : return resultobj;
43293 : fail:
43294 : return NULL;
43295 : }
43296 :
43297 :
43298 2000 : SWIGINTERN PyObject *_wrap_Band_GetSampleOverview(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43299 2000 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
43300 2000 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
43301 2000 : GUIntBig arg2 ;
43302 2000 : void *argp1 = 0 ;
43303 2000 : int res1 = 0 ;
43304 2000 : PyObject *swig_obj[2] ;
43305 2000 : GDALRasterBandShadow *result = 0 ;
43306 :
43307 2000 : if (!SWIG_Python_UnpackTuple(args, "Band_GetSampleOverview", 2, 2, swig_obj)) SWIG_fail;
43308 2000 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
43309 2000 : if (!SWIG_IsOK(res1)) {
43310 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetSampleOverview" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
43311 : }
43312 2000 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
43313 2000 : {
43314 2000 : arg2 = (GIntBig)PyLong_AsUnsignedLongLong(swig_obj[1]);
43315 : }
43316 2000 : {
43317 2000 : const int bLocalUseExceptions = GetUseExceptions();
43318 2000 : if ( bLocalUseExceptions ) {
43319 2000 : pushErrorHandler();
43320 : }
43321 2000 : {
43322 2000 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43323 2000 : result = (GDALRasterBandShadow *)GDALRasterBandShadow_GetSampleOverview(arg1,arg2);
43324 2000 : SWIG_PYTHON_THREAD_END_ALLOW;
43325 : }
43326 2000 : if ( bLocalUseExceptions ) {
43327 2000 : popErrorHandler();
43328 : }
43329 : #ifndef SED_HACKS
43330 : if ( bLocalUseExceptions ) {
43331 : CPLErr eclass = CPLGetLastErrorType();
43332 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
43333 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
43334 : }
43335 : }
43336 : #endif
43337 : }
43338 2000 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
43339 2000 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
43340 : return resultobj;
43341 : fail:
43342 : return NULL;
43343 : }
43344 :
43345 :
43346 38754 : SWIGINTERN PyObject *_wrap_Band_Checksum(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43347 38754 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
43348 38754 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
43349 38754 : int arg2 = (int) 0 ;
43350 38754 : int arg3 = (int) 0 ;
43351 38754 : int *arg4 = (int *) 0 ;
43352 38754 : int *arg5 = (int *) 0 ;
43353 38754 : void *argp1 = 0 ;
43354 38754 : int res1 = 0 ;
43355 38754 : int val2 ;
43356 38754 : int ecode2 = 0 ;
43357 38754 : int val3 ;
43358 38754 : int ecode3 = 0 ;
43359 38754 : int val4 ;
43360 38754 : int val5 ;
43361 38754 : PyObject * obj0 = 0 ;
43362 38754 : PyObject * obj1 = 0 ;
43363 38754 : PyObject * obj2 = 0 ;
43364 38754 : PyObject * obj3 = 0 ;
43365 38754 : PyObject * obj4 = 0 ;
43366 38754 : char * kwnames[] = {
43367 : (char *)"self", (char *)"xoff", (char *)"yoff", (char *)"xsize", (char *)"ysize", NULL
43368 : };
43369 38754 : int result;
43370 :
43371 38754 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOO:Band_Checksum", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
43372 38754 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
43373 38754 : if (!SWIG_IsOK(res1)) {
43374 12 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_Checksum" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
43375 : }
43376 38748 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
43377 38748 : if (obj1) {
43378 366 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43379 366 : if (!SWIG_IsOK(ecode2)) {
43380 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_Checksum" "', argument " "2"" of type '" "int""'");
43381 : }
43382 : arg2 = static_cast< int >(val2);
43383 : }
43384 38748 : if (obj2) {
43385 366 : ecode3 = SWIG_AsVal_int(obj2, &val3);
43386 366 : if (!SWIG_IsOK(ecode3)) {
43387 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_Checksum" "', argument " "3"" of type '" "int""'");
43388 : }
43389 : arg3 = static_cast< int >(val3);
43390 : }
43391 38748 : if (obj3) {
43392 366 : {
43393 : /* %typemap(in) (int *optional_##int) */
43394 366 : if ( obj3 == Py_None ) {
43395 : arg4 = 0;
43396 : }
43397 366 : else if ( PyArg_Parse( obj3,"i" ,&val4 ) ) {
43398 : arg4 = (int *) &val4;
43399 : }
43400 : else {
43401 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
43402 0 : SWIG_fail;
43403 : }
43404 : }
43405 : }
43406 38748 : if (obj4) {
43407 366 : {
43408 : /* %typemap(in) (int *optional_##int) */
43409 366 : if ( obj4 == Py_None ) {
43410 : arg5 = 0;
43411 : }
43412 366 : else if ( PyArg_Parse( obj4,"i" ,&val5 ) ) {
43413 : arg5 = (int *) &val5;
43414 : }
43415 : else {
43416 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
43417 0 : SWIG_fail;
43418 : }
43419 : }
43420 : }
43421 38748 : {
43422 38748 : const int bLocalUseExceptions = GetUseExceptions();
43423 38748 : if ( bLocalUseExceptions ) {
43424 35207 : pushErrorHandler();
43425 : }
43426 38748 : {
43427 38748 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43428 38748 : result = (int)GDALRasterBandShadow_Checksum(arg1,arg2,arg3,arg4,arg5);
43429 38748 : SWIG_PYTHON_THREAD_END_ALLOW;
43430 : }
43431 38748 : if ( bLocalUseExceptions ) {
43432 35207 : popErrorHandler();
43433 : }
43434 : #ifndef SED_HACKS
43435 : if ( bLocalUseExceptions ) {
43436 : CPLErr eclass = CPLGetLastErrorType();
43437 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
43438 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
43439 : }
43440 : }
43441 : #endif
43442 : }
43443 38748 : resultobj = SWIG_From_int(static_cast< int >(result));
43444 38872 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
43445 : return resultobj;
43446 : fail:
43447 : return NULL;
43448 : }
43449 :
43450 :
43451 1515 : SWIGINTERN PyObject *_wrap_Band_ComputeRasterMinMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43452 1515 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
43453 1515 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
43454 1515 : double *arg2 ;
43455 1515 : int *arg3 = (int *) 0 ;
43456 1515 : bool arg4 = (bool) false ;
43457 1515 : bool arg5 = (bool) false ;
43458 1515 : void *argp1 = 0 ;
43459 1515 : int res1 = 0 ;
43460 1515 : double argout2[2] ;
43461 1515 : int isvalid2 ;
43462 1515 : bool val4 ;
43463 1515 : int ecode4 = 0 ;
43464 1515 : bool val5 ;
43465 1515 : int ecode5 = 0 ;
43466 1515 : PyObject * obj0 = 0 ;
43467 1515 : PyObject * obj1 = 0 ;
43468 1515 : PyObject * obj2 = 0 ;
43469 1515 : char * kwnames[] = {
43470 : (char *)"self", (char *)"approx_ok", (char *)"can_return_none", NULL
43471 : };
43472 :
43473 1515 : {
43474 : /* %typemap(in,numinputs=0) (double argout2[2], int* isvalid2) */
43475 1515 : arg2 = argout2;
43476 1515 : arg3 = &isvalid2;
43477 : }
43478 1515 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:Band_ComputeRasterMinMax", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
43479 1515 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
43480 1515 : if (!SWIG_IsOK(res1)) {
43481 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_ComputeRasterMinMax" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
43482 : }
43483 1515 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
43484 1515 : if (obj1) {
43485 204 : ecode4 = SWIG_AsVal_bool(obj1, &val4);
43486 204 : if (!SWIG_IsOK(ecode4)) {
43487 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Band_ComputeRasterMinMax" "', argument " "4"" of type '" "bool""'");
43488 : }
43489 : arg4 = static_cast< bool >(val4);
43490 : }
43491 1515 : if (obj2) {
43492 13 : ecode5 = SWIG_AsVal_bool(obj2, &val5);
43493 13 : if (!SWIG_IsOK(ecode5)) {
43494 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Band_ComputeRasterMinMax" "', argument " "5"" of type '" "bool""'");
43495 : }
43496 : arg5 = static_cast< bool >(val5);
43497 : }
43498 1515 : {
43499 1515 : const int bLocalUseExceptions = GetUseExceptions();
43500 1515 : if ( bLocalUseExceptions ) {
43501 1018 : pushErrorHandler();
43502 : }
43503 1515 : {
43504 1515 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43505 1515 : GDALRasterBandShadow_ComputeRasterMinMax(arg1,arg2,arg3,arg4,arg5);
43506 1515 : SWIG_PYTHON_THREAD_END_ALLOW;
43507 : }
43508 1515 : if ( bLocalUseExceptions ) {
43509 1018 : popErrorHandler();
43510 : }
43511 : #ifndef SED_HACKS
43512 : if ( bLocalUseExceptions ) {
43513 : CPLErr eclass = CPLGetLastErrorType();
43514 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
43515 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
43516 : }
43517 : }
43518 : #endif
43519 : }
43520 1515 : resultobj = SWIG_Py_Void();
43521 1515 : {
43522 : /* %typemap(argout) (double argout[2], int* isvalid) */
43523 1515 : PyObject *r;
43524 1515 : if ( !*arg3 ) {
43525 6 : Py_INCREF(Py_None);
43526 6 : r = Py_None;
43527 : }
43528 : else {
43529 1509 : r = CreateTupleFromDoubleArray(arg2, 2);
43530 : }
43531 : #if 0x040001 >= 0x040300
43532 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
43533 : #else
43534 1515 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
43535 : #endif
43536 : }
43537 1531 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
43538 : return resultobj;
43539 : fail:
43540 : return NULL;
43541 : }
43542 :
43543 :
43544 18 : SWIGINTERN PyObject *_wrap_Band_ComputeBandStats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43545 18 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
43546 18 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
43547 18 : double *arg2 ;
43548 18 : int arg3 = (int) 1 ;
43549 18 : void *argp1 = 0 ;
43550 18 : int res1 = 0 ;
43551 18 : double argout2[2] ;
43552 18 : int val3 ;
43553 18 : int ecode3 = 0 ;
43554 18 : PyObject *swig_obj[2] ;
43555 :
43556 18 : {
43557 : /* %typemap(in,numinputs=0) (double argout2[ANY]) */
43558 18 : memset(argout2, 0, sizeof(argout2));
43559 18 : arg2 = argout2;
43560 : }
43561 18 : if (!SWIG_Python_UnpackTuple(args, "Band_ComputeBandStats", 1, 2, swig_obj)) SWIG_fail;
43562 18 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
43563 18 : if (!SWIG_IsOK(res1)) {
43564 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_ComputeBandStats" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
43565 : }
43566 18 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
43567 18 : if (swig_obj[1]) {
43568 0 : ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
43569 0 : if (!SWIG_IsOK(ecode3)) {
43570 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_ComputeBandStats" "', argument " "3"" of type '" "int""'");
43571 : }
43572 : arg3 = static_cast< int >(val3);
43573 : }
43574 18 : {
43575 18 : const int bLocalUseExceptions = GetUseExceptions();
43576 18 : if ( bLocalUseExceptions ) {
43577 11 : pushErrorHandler();
43578 : }
43579 18 : {
43580 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43581 18 : GDALRasterBandShadow_ComputeBandStats(arg1,arg2,arg3);
43582 18 : SWIG_PYTHON_THREAD_END_ALLOW;
43583 : }
43584 18 : if ( bLocalUseExceptions ) {
43585 11 : popErrorHandler();
43586 : }
43587 : #ifndef SED_HACKS
43588 : if ( bLocalUseExceptions ) {
43589 : CPLErr eclass = CPLGetLastErrorType();
43590 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
43591 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
43592 : }
43593 : }
43594 : #endif
43595 : }
43596 18 : resultobj = SWIG_Py_Void();
43597 18 : {
43598 : /* %typemap(argout) (double argout[ANY]) */
43599 18 : PyObject *out = CreateTupleFromDoubleArray( arg2, 2 );
43600 : #if SWIG_VERSION >= 0x040300
43601 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
43602 : #else
43603 18 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
43604 : #endif
43605 : }
43606 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
43607 : return resultobj;
43608 : fail:
43609 : return NULL;
43610 : }
43611 :
43612 :
43613 268618 : SWIGINTERN PyObject *_wrap_Band_Fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43614 268618 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
43615 268618 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
43616 268618 : double arg2 ;
43617 268618 : double arg3 = (double) 0.0 ;
43618 268618 : void *argp1 = 0 ;
43619 268618 : int res1 = 0 ;
43620 268618 : double val2 ;
43621 268618 : int ecode2 = 0 ;
43622 268618 : double val3 ;
43623 268618 : int ecode3 = 0 ;
43624 268618 : PyObject *swig_obj[3] ;
43625 268618 : CPLErr result;
43626 :
43627 268618 : if (!SWIG_Python_UnpackTuple(args, "Band_Fill", 2, 3, swig_obj)) SWIG_fail;
43628 268618 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
43629 268618 : if (!SWIG_IsOK(res1)) {
43630 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_Fill" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
43631 : }
43632 268618 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
43633 268618 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
43634 268618 : if (!SWIG_IsOK(ecode2)) {
43635 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_Fill" "', argument " "2"" of type '" "double""'");
43636 : }
43637 268618 : arg2 = static_cast< double >(val2);
43638 268618 : if (swig_obj[2]) {
43639 266 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
43640 266 : if (!SWIG_IsOK(ecode3)) {
43641 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_Fill" "', argument " "3"" of type '" "double""'");
43642 : }
43643 266 : arg3 = static_cast< double >(val3);
43644 : }
43645 268618 : {
43646 268618 : const int bLocalUseExceptions = GetUseExceptions();
43647 268618 : if ( bLocalUseExceptions ) {
43648 168735 : pushErrorHandler();
43649 : }
43650 268618 : {
43651 268618 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43652 268618 : result = (CPLErr)GDALRasterBandShadow_Fill(arg1,arg2,arg3);
43653 268618 : SWIG_PYTHON_THREAD_END_ALLOW;
43654 : }
43655 268618 : if ( bLocalUseExceptions ) {
43656 168735 : popErrorHandler();
43657 : }
43658 : #ifndef SED_HACKS
43659 : if ( bLocalUseExceptions ) {
43660 : CPLErr eclass = CPLGetLastErrorType();
43661 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
43662 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
43663 : }
43664 : }
43665 : #endif
43666 : }
43667 268618 : resultobj = SWIG_From_int(static_cast< int >(result));
43668 268628 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
43669 : return resultobj;
43670 : fail:
43671 : return NULL;
43672 : }
43673 :
43674 :
43675 9150 : SWIGINTERN PyObject *_wrap_Band_WriteRaster(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43676 9150 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
43677 9150 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
43678 9150 : int arg2 ;
43679 9150 : int arg3 ;
43680 9150 : int arg4 ;
43681 9150 : int arg5 ;
43682 9150 : GIntBig arg6 ;
43683 9150 : char *arg7 = (char *) 0 ;
43684 9150 : int *arg8 = (int *) 0 ;
43685 9150 : int *arg9 = (int *) 0 ;
43686 9150 : GDALDataType *arg10 = (GDALDataType *) 0 ;
43687 9150 : GIntBig *arg11 = (GIntBig *) 0 ;
43688 9150 : GIntBig *arg12 = (GIntBig *) 0 ;
43689 9150 : void *argp1 = 0 ;
43690 9150 : int res1 = 0 ;
43691 9150 : int val2 ;
43692 9150 : int ecode2 = 0 ;
43693 9150 : int val3 ;
43694 9150 : int ecode3 = 0 ;
43695 9150 : int val4 ;
43696 9150 : int ecode4 = 0 ;
43697 9150 : int val5 ;
43698 9150 : int ecode5 = 0 ;
43699 9150 : int alloc6 = 0 ;
43700 9150 : bool viewIsValid6 = false ;
43701 9150 : Py_buffer view6 ;
43702 9150 : int val8 ;
43703 9150 : int val9 ;
43704 9150 : GDALDataType val10 ;
43705 9150 : GIntBig val11 ;
43706 9150 : GIntBig val12 ;
43707 9150 : PyObject * obj0 = 0 ;
43708 9150 : PyObject * obj1 = 0 ;
43709 9150 : PyObject * obj2 = 0 ;
43710 9150 : PyObject * obj3 = 0 ;
43711 9150 : PyObject * obj4 = 0 ;
43712 9150 : PyObject * obj5 = 0 ;
43713 9150 : PyObject * obj6 = 0 ;
43714 9150 : PyObject * obj7 = 0 ;
43715 9150 : PyObject * obj8 = 0 ;
43716 9150 : PyObject * obj9 = 0 ;
43717 9150 : PyObject * obj10 = 0 ;
43718 9150 : char * kwnames[] = {
43719 : (char *)"self", (char *)"xoff", (char *)"yoff", (char *)"xsize", (char *)"ysize", (char *)"buf_len", (char *)"buf_xsize", (char *)"buf_ysize", (char *)"buf_type", (char *)"buf_pixel_space", (char *)"buf_line_space", NULL
43720 : };
43721 9150 : CPLErr result;
43722 :
43723 9150 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|OOOOO:Band_WriteRaster", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10)) SWIG_fail;
43724 9150 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
43725 9150 : if (!SWIG_IsOK(res1)) {
43726 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_WriteRaster" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
43727 : }
43728 9150 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
43729 9150 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43730 9150 : if (!SWIG_IsOK(ecode2)) {
43731 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_WriteRaster" "', argument " "2"" of type '" "int""'");
43732 : }
43733 9150 : arg2 = static_cast< int >(val2);
43734 9150 : ecode3 = SWIG_AsVal_int(obj2, &val3);
43735 9150 : if (!SWIG_IsOK(ecode3)) {
43736 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_WriteRaster" "', argument " "3"" of type '" "int""'");
43737 : }
43738 9150 : arg3 = static_cast< int >(val3);
43739 9150 : ecode4 = SWIG_AsVal_int(obj3, &val4);
43740 9150 : if (!SWIG_IsOK(ecode4)) {
43741 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Band_WriteRaster" "', argument " "4"" of type '" "int""'");
43742 : }
43743 9150 : arg4 = static_cast< int >(val4);
43744 9150 : ecode5 = SWIG_AsVal_int(obj4, &val5);
43745 9150 : if (!SWIG_IsOK(ecode5)) {
43746 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Band_WriteRaster" "', argument " "5"" of type '" "int""'");
43747 : }
43748 9150 : arg5 = static_cast< int >(val5);
43749 9150 : {
43750 : /* %typemap(in,numinputs=1) (GIntBig nLen, char *pBuf ) */
43751 9150 : char* ptr = NULL;
43752 9150 : if( !GetBufferAsCharPtrGIntBigSize(obj5, &arg6, &ptr, &alloc6, &viewIsValid6, &view6) ) {
43753 1 : SWIG_fail;
43754 : }
43755 9149 : arg7 = (char *)ptr;
43756 : }
43757 9149 : if (obj6) {
43758 9149 : {
43759 : /* %typemap(in) (int *optional_##int) */
43760 9149 : if ( obj6 == Py_None ) {
43761 : arg8 = 0;
43762 : }
43763 9149 : else if ( PyArg_Parse( obj6,"i" ,&val8 ) ) {
43764 : arg8 = (int *) &val8;
43765 : }
43766 : else {
43767 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
43768 0 : SWIG_fail;
43769 : }
43770 : }
43771 : }
43772 9149 : if (obj7) {
43773 9149 : {
43774 : /* %typemap(in) (int *optional_##int) */
43775 9149 : if ( obj7 == Py_None ) {
43776 : arg9 = 0;
43777 : }
43778 9149 : else if ( PyArg_Parse( obj7,"i" ,&val9 ) ) {
43779 : arg9 = (int *) &val9;
43780 : }
43781 : else {
43782 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
43783 0 : SWIG_fail;
43784 : }
43785 : }
43786 : }
43787 9149 : if (obj8) {
43788 9149 : {
43789 : /* %typemap(in) (GDALDataType *optional_GDALDataType) */
43790 9149 : int intval = 0;
43791 9149 : if ( obj8 == Py_None ) {
43792 : arg10 = NULL;
43793 : }
43794 18298 : else if ( SWIG_IsOK(SWIG_AsVal_int(obj8, &intval)) ) {
43795 9149 : if( intval < GDT_Unknown || intval >= GDT_TypeCount )
43796 : {
43797 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
43798 : }
43799 9149 : val10 = static_cast<GDALDataType>(intval);
43800 9149 : arg10 = &val10;
43801 : }
43802 : else {
43803 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
43804 0 : SWIG_fail;
43805 : }
43806 : }
43807 : }
43808 9149 : if (obj9) {
43809 9149 : {
43810 : /* %typemap(in) (GIntBig *optional_##GIntBig) */
43811 9149 : if ( obj9 == Py_None ) {
43812 : arg11 = 0;
43813 : }
43814 16 : else if ( PyArg_Parse( obj9,"L" ,&val11 ) ) {
43815 : arg11 = (GIntBig *) &val11;
43816 : }
43817 : else {
43818 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
43819 0 : SWIG_fail;
43820 : }
43821 : }
43822 : }
43823 9149 : if (obj10) {
43824 9149 : {
43825 : /* %typemap(in) (GIntBig *optional_##GIntBig) */
43826 9149 : if ( obj10 == Py_None ) {
43827 : arg12 = 0;
43828 : }
43829 12 : else if ( PyArg_Parse( obj10,"L" ,&val12 ) ) {
43830 : arg12 = (GIntBig *) &val12;
43831 : }
43832 : else {
43833 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
43834 0 : SWIG_fail;
43835 : }
43836 : }
43837 : }
43838 9149 : {
43839 9149 : const int bLocalUseExceptions = GetUseExceptions();
43840 9149 : if ( bLocalUseExceptions ) {
43841 8389 : pushErrorHandler();
43842 : }
43843 9149 : {
43844 9149 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43845 9149 : result = (CPLErr)GDALRasterBandShadow_WriteRaster(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
43846 9149 : SWIG_PYTHON_THREAD_END_ALLOW;
43847 : }
43848 9149 : if ( bLocalUseExceptions ) {
43849 8389 : popErrorHandler();
43850 : }
43851 : #ifndef SED_HACKS
43852 : if ( bLocalUseExceptions ) {
43853 : CPLErr eclass = CPLGetLastErrorType();
43854 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
43855 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
43856 : }
43857 : }
43858 : #endif
43859 : }
43860 9149 : resultobj = SWIG_From_int(static_cast< int >(result));
43861 9149 : {
43862 : /* %typemap(freearg) (GIntBig *nLen, char *pBuf ) */
43863 9149 : if( viewIsValid6 ) {
43864 3087 : PyBuffer_Release(&view6);
43865 : }
43866 6062 : else if (ReturnSame(alloc6) == SWIG_NEWOBJ ) {
43867 6062 : delete[] arg7;
43868 : }
43869 : }
43870 9157 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
43871 : return resultobj;
43872 1 : fail:
43873 1 : {
43874 : /* %typemap(freearg) (GIntBig *nLen, char *pBuf ) */
43875 1 : if( viewIsValid6 ) {
43876 0 : PyBuffer_Release(&view6);
43877 : }
43878 9150 : else if (ReturnSame(alloc6) == SWIG_NEWOBJ ) {
43879 0 : delete[] arg7;
43880 : }
43881 : }
43882 : return NULL;
43883 : }
43884 :
43885 :
43886 391 : SWIGINTERN PyObject *_wrap_Band_FlushCache(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43887 391 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
43888 391 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
43889 391 : void *argp1 = 0 ;
43890 391 : int res1 = 0 ;
43891 391 : PyObject *swig_obj[1] ;
43892 :
43893 391 : if (!args) SWIG_fail;
43894 391 : swig_obj[0] = args;
43895 391 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
43896 391 : if (!SWIG_IsOK(res1)) {
43897 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_FlushCache" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
43898 : }
43899 391 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
43900 391 : {
43901 391 : const int bLocalUseExceptions = GetUseExceptions();
43902 391 : if ( bLocalUseExceptions ) {
43903 5 : pushErrorHandler();
43904 : }
43905 391 : {
43906 391 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43907 391 : GDALRasterBandShadow_FlushCache(arg1);
43908 391 : SWIG_PYTHON_THREAD_END_ALLOW;
43909 : }
43910 391 : if ( bLocalUseExceptions ) {
43911 5 : popErrorHandler();
43912 : }
43913 : #ifndef SED_HACKS
43914 : if ( bLocalUseExceptions ) {
43915 : CPLErr eclass = CPLGetLastErrorType();
43916 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
43917 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
43918 : }
43919 : }
43920 : #endif
43921 : }
43922 391 : resultobj = SWIG_Py_Void();
43923 391 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
43924 : return resultobj;
43925 : fail:
43926 : return NULL;
43927 : }
43928 :
43929 :
43930 130 : SWIGINTERN PyObject *_wrap_Band_GetRasterColorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43931 130 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
43932 130 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
43933 130 : void *argp1 = 0 ;
43934 130 : int res1 = 0 ;
43935 130 : PyObject *swig_obj[1] ;
43936 130 : GDALColorTableShadow *result = 0 ;
43937 :
43938 130 : if (!args) SWIG_fail;
43939 130 : swig_obj[0] = args;
43940 130 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
43941 130 : if (!SWIG_IsOK(res1)) {
43942 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetRasterColorTable" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
43943 : }
43944 130 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
43945 130 : {
43946 130 : const int bLocalUseExceptions = GetUseExceptions();
43947 130 : if ( bLocalUseExceptions ) {
43948 91 : pushErrorHandler();
43949 : }
43950 130 : {
43951 130 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43952 130 : result = (GDALColorTableShadow *)GDALRasterBandShadow_GetRasterColorTable(arg1);
43953 130 : SWIG_PYTHON_THREAD_END_ALLOW;
43954 : }
43955 130 : if ( bLocalUseExceptions ) {
43956 91 : popErrorHandler();
43957 : }
43958 : #ifndef SED_HACKS
43959 : if ( bLocalUseExceptions ) {
43960 : CPLErr eclass = CPLGetLastErrorType();
43961 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
43962 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
43963 : }
43964 : }
43965 : #endif
43966 : }
43967 130 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALColorTableShadow, 0 | 0 );
43968 130 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
43969 : return resultobj;
43970 : fail:
43971 : return NULL;
43972 : }
43973 :
43974 :
43975 131 : SWIGINTERN PyObject *_wrap_Band_GetColorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43976 131 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
43977 131 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
43978 131 : void *argp1 = 0 ;
43979 131 : int res1 = 0 ;
43980 131 : PyObject *swig_obj[1] ;
43981 131 : GDALColorTableShadow *result = 0 ;
43982 :
43983 131 : if (!args) SWIG_fail;
43984 131 : swig_obj[0] = args;
43985 131 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
43986 131 : if (!SWIG_IsOK(res1)) {
43987 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetColorTable" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
43988 : }
43989 131 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
43990 131 : {
43991 131 : const int bLocalUseExceptions = GetUseExceptions();
43992 131 : if ( bLocalUseExceptions ) {
43993 107 : pushErrorHandler();
43994 : }
43995 131 : {
43996 131 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
43997 131 : result = (GDALColorTableShadow *)GDALRasterBandShadow_GetColorTable(arg1);
43998 131 : SWIG_PYTHON_THREAD_END_ALLOW;
43999 : }
44000 131 : if ( bLocalUseExceptions ) {
44001 107 : popErrorHandler();
44002 : }
44003 : #ifndef SED_HACKS
44004 : if ( bLocalUseExceptions ) {
44005 : CPLErr eclass = CPLGetLastErrorType();
44006 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
44007 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
44008 : }
44009 : }
44010 : #endif
44011 : }
44012 131 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALColorTableShadow, 0 | 0 );
44013 139 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
44014 : return resultobj;
44015 : fail:
44016 : return NULL;
44017 : }
44018 :
44019 :
44020 46 : SWIGINTERN PyObject *_wrap_Band_SetRasterColorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44021 46 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
44022 46 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
44023 46 : GDALColorTableShadow *arg2 = (GDALColorTableShadow *) 0 ;
44024 46 : void *argp1 = 0 ;
44025 46 : int res1 = 0 ;
44026 46 : void *argp2 = 0 ;
44027 46 : int res2 = 0 ;
44028 46 : PyObject *swig_obj[2] ;
44029 46 : int result;
44030 :
44031 46 : if (!SWIG_Python_UnpackTuple(args, "Band_SetRasterColorTable", 2, 2, swig_obj)) SWIG_fail;
44032 46 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
44033 46 : if (!SWIG_IsOK(res1)) {
44034 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetRasterColorTable" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
44035 : }
44036 46 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
44037 46 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALColorTableShadow, 0 | 0 );
44038 46 : if (!SWIG_IsOK(res2)) {
44039 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Band_SetRasterColorTable" "', argument " "2"" of type '" "GDALColorTableShadow *""'");
44040 : }
44041 46 : arg2 = reinterpret_cast< GDALColorTableShadow * >(argp2);
44042 46 : {
44043 46 : const int bLocalUseExceptions = GetUseExceptions();
44044 46 : if ( bLocalUseExceptions ) {
44045 24 : pushErrorHandler();
44046 : }
44047 46 : {
44048 46 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44049 46 : result = (int)GDALRasterBandShadow_SetRasterColorTable(arg1,arg2);
44050 46 : SWIG_PYTHON_THREAD_END_ALLOW;
44051 : }
44052 46 : if ( bLocalUseExceptions ) {
44053 24 : popErrorHandler();
44054 : }
44055 : #ifndef SED_HACKS
44056 : if ( bLocalUseExceptions ) {
44057 : CPLErr eclass = CPLGetLastErrorType();
44058 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
44059 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
44060 : }
44061 : }
44062 : #endif
44063 : }
44064 46 : resultobj = SWIG_From_int(static_cast< int >(result));
44065 46 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
44066 : return resultobj;
44067 : fail:
44068 : return NULL;
44069 : }
44070 :
44071 :
44072 30 : SWIGINTERN PyObject *_wrap_Band_SetColorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44073 30 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
44074 30 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
44075 30 : GDALColorTableShadow *arg2 = (GDALColorTableShadow *) 0 ;
44076 30 : void *argp1 = 0 ;
44077 30 : int res1 = 0 ;
44078 30 : void *argp2 = 0 ;
44079 30 : int res2 = 0 ;
44080 30 : PyObject *swig_obj[2] ;
44081 30 : int result;
44082 :
44083 30 : if (!SWIG_Python_UnpackTuple(args, "Band_SetColorTable", 2, 2, swig_obj)) SWIG_fail;
44084 30 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
44085 30 : if (!SWIG_IsOK(res1)) {
44086 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetColorTable" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
44087 : }
44088 30 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
44089 30 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALColorTableShadow, 0 | 0 );
44090 30 : if (!SWIG_IsOK(res2)) {
44091 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Band_SetColorTable" "', argument " "2"" of type '" "GDALColorTableShadow *""'");
44092 : }
44093 30 : arg2 = reinterpret_cast< GDALColorTableShadow * >(argp2);
44094 30 : {
44095 30 : const int bLocalUseExceptions = GetUseExceptions();
44096 30 : if ( bLocalUseExceptions ) {
44097 14 : pushErrorHandler();
44098 : }
44099 30 : {
44100 30 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44101 30 : result = (int)GDALRasterBandShadow_SetColorTable(arg1,arg2);
44102 30 : SWIG_PYTHON_THREAD_END_ALLOW;
44103 : }
44104 30 : if ( bLocalUseExceptions ) {
44105 14 : popErrorHandler();
44106 : }
44107 : #ifndef SED_HACKS
44108 : if ( bLocalUseExceptions ) {
44109 : CPLErr eclass = CPLGetLastErrorType();
44110 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
44111 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
44112 : }
44113 : }
44114 : #endif
44115 : }
44116 30 : resultobj = SWIG_From_int(static_cast< int >(result));
44117 30 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
44118 : return resultobj;
44119 : fail:
44120 : return NULL;
44121 : }
44122 :
44123 :
44124 81 : SWIGINTERN PyObject *_wrap_Band_GetDefaultRAT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44125 81 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
44126 81 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
44127 81 : void *argp1 = 0 ;
44128 81 : int res1 = 0 ;
44129 81 : PyObject *swig_obj[1] ;
44130 81 : GDALRasterAttributeTableShadow *result = 0 ;
44131 :
44132 81 : if (!args) SWIG_fail;
44133 81 : swig_obj[0] = args;
44134 81 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
44135 81 : if (!SWIG_IsOK(res1)) {
44136 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetDefaultRAT" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
44137 : }
44138 81 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
44139 81 : {
44140 81 : const int bLocalUseExceptions = GetUseExceptions();
44141 81 : if ( bLocalUseExceptions ) {
44142 74 : pushErrorHandler();
44143 : }
44144 81 : {
44145 81 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44146 81 : result = (GDALRasterAttributeTableShadow *)GDALRasterBandShadow_GetDefaultRAT(arg1);
44147 81 : SWIG_PYTHON_THREAD_END_ALLOW;
44148 : }
44149 81 : if ( bLocalUseExceptions ) {
44150 74 : popErrorHandler();
44151 : }
44152 : #ifndef SED_HACKS
44153 : if ( bLocalUseExceptions ) {
44154 : CPLErr eclass = CPLGetLastErrorType();
44155 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
44156 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
44157 : }
44158 : }
44159 : #endif
44160 : }
44161 81 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
44162 85 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
44163 : return resultobj;
44164 : fail:
44165 : return NULL;
44166 : }
44167 :
44168 :
44169 25 : SWIGINTERN PyObject *_wrap_Band_SetDefaultRAT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44170 25 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
44171 25 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
44172 25 : GDALRasterAttributeTableShadow *arg2 = (GDALRasterAttributeTableShadow *) 0 ;
44173 25 : void *argp1 = 0 ;
44174 25 : int res1 = 0 ;
44175 25 : void *argp2 = 0 ;
44176 25 : int res2 = 0 ;
44177 25 : PyObject *swig_obj[2] ;
44178 25 : int result;
44179 :
44180 25 : if (!SWIG_Python_UnpackTuple(args, "Band_SetDefaultRAT", 2, 2, swig_obj)) SWIG_fail;
44181 25 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
44182 25 : if (!SWIG_IsOK(res1)) {
44183 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetDefaultRAT" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
44184 : }
44185 25 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
44186 25 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALRasterAttributeTableShadow, 0 | 0 );
44187 25 : if (!SWIG_IsOK(res2)) {
44188 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Band_SetDefaultRAT" "', argument " "2"" of type '" "GDALRasterAttributeTableShadow *""'");
44189 : }
44190 25 : arg2 = reinterpret_cast< GDALRasterAttributeTableShadow * >(argp2);
44191 25 : {
44192 25 : const int bLocalUseExceptions = GetUseExceptions();
44193 25 : if ( bLocalUseExceptions ) {
44194 23 : pushErrorHandler();
44195 : }
44196 25 : {
44197 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44198 25 : result = (int)GDALRasterBandShadow_SetDefaultRAT(arg1,arg2);
44199 25 : SWIG_PYTHON_THREAD_END_ALLOW;
44200 : }
44201 25 : if ( bLocalUseExceptions ) {
44202 23 : popErrorHandler();
44203 : }
44204 : #ifndef SED_HACKS
44205 : if ( bLocalUseExceptions ) {
44206 : CPLErr eclass = CPLGetLastErrorType();
44207 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
44208 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
44209 : }
44210 : }
44211 : #endif
44212 : }
44213 25 : resultobj = SWIG_From_int(static_cast< int >(result));
44214 25 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
44215 : return resultobj;
44216 : fail:
44217 : return NULL;
44218 : }
44219 :
44220 :
44221 10826 : SWIGINTERN PyObject *_wrap_Band_GetMaskBand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44222 10826 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
44223 10826 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
44224 10826 : void *argp1 = 0 ;
44225 10826 : int res1 = 0 ;
44226 10826 : PyObject *swig_obj[1] ;
44227 10826 : GDALRasterBandShadow *result = 0 ;
44228 :
44229 10826 : if (!args) SWIG_fail;
44230 10826 : swig_obj[0] = args;
44231 10826 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
44232 10826 : if (!SWIG_IsOK(res1)) {
44233 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetMaskBand" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
44234 : }
44235 10826 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
44236 10826 : {
44237 10826 : const int bLocalUseExceptions = GetUseExceptions();
44238 10826 : if ( bLocalUseExceptions ) {
44239 10464 : pushErrorHandler();
44240 : }
44241 10826 : {
44242 10826 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44243 10826 : result = (GDALRasterBandShadow *)GDALRasterBandShadow_GetMaskBand(arg1);
44244 10826 : SWIG_PYTHON_THREAD_END_ALLOW;
44245 : }
44246 10826 : if ( bLocalUseExceptions ) {
44247 10464 : popErrorHandler();
44248 : }
44249 : #ifndef SED_HACKS
44250 : if ( bLocalUseExceptions ) {
44251 : CPLErr eclass = CPLGetLastErrorType();
44252 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
44253 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
44254 : }
44255 : }
44256 : #endif
44257 : }
44258 10826 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
44259 10826 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
44260 : return resultobj;
44261 : fail:
44262 : return NULL;
44263 : }
44264 :
44265 :
44266 454 : SWIGINTERN PyObject *_wrap_Band_GetMaskFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44267 454 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
44268 454 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
44269 454 : void *argp1 = 0 ;
44270 454 : int res1 = 0 ;
44271 454 : PyObject *swig_obj[1] ;
44272 454 : int result;
44273 :
44274 454 : if (!args) SWIG_fail;
44275 454 : swig_obj[0] = args;
44276 454 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
44277 454 : if (!SWIG_IsOK(res1)) {
44278 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetMaskFlags" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
44279 : }
44280 454 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
44281 454 : {
44282 454 : const int bLocalUseExceptions = GetUseExceptions();
44283 454 : if ( bLocalUseExceptions ) {
44284 295 : pushErrorHandler();
44285 : }
44286 454 : {
44287 454 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44288 454 : result = (int)GDALRasterBandShadow_GetMaskFlags(arg1);
44289 454 : SWIG_PYTHON_THREAD_END_ALLOW;
44290 : }
44291 454 : if ( bLocalUseExceptions ) {
44292 295 : popErrorHandler();
44293 : }
44294 : #ifndef SED_HACKS
44295 : if ( bLocalUseExceptions ) {
44296 : CPLErr eclass = CPLGetLastErrorType();
44297 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
44298 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
44299 : }
44300 : }
44301 : #endif
44302 : }
44303 454 : resultobj = SWIG_From_int(static_cast< int >(result));
44304 454 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
44305 : return resultobj;
44306 : fail:
44307 : return NULL;
44308 : }
44309 :
44310 :
44311 34 : SWIGINTERN PyObject *_wrap_Band_CreateMaskBand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44312 34 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
44313 34 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
44314 34 : int arg2 ;
44315 34 : void *argp1 = 0 ;
44316 34 : int res1 = 0 ;
44317 34 : int val2 ;
44318 34 : int ecode2 = 0 ;
44319 34 : PyObject *swig_obj[2] ;
44320 34 : CPLErr result;
44321 :
44322 34 : if (!SWIG_Python_UnpackTuple(args, "Band_CreateMaskBand", 2, 2, swig_obj)) SWIG_fail;
44323 34 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
44324 34 : if (!SWIG_IsOK(res1)) {
44325 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_CreateMaskBand" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
44326 : }
44327 34 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
44328 34 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
44329 34 : if (!SWIG_IsOK(ecode2)) {
44330 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_CreateMaskBand" "', argument " "2"" of type '" "int""'");
44331 : }
44332 34 : arg2 = static_cast< int >(val2);
44333 34 : {
44334 34 : const int bLocalUseExceptions = GetUseExceptions();
44335 34 : if ( bLocalUseExceptions ) {
44336 17 : pushErrorHandler();
44337 : }
44338 34 : {
44339 34 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44340 34 : result = (CPLErr)GDALRasterBandShadow_CreateMaskBand(arg1,arg2);
44341 34 : SWIG_PYTHON_THREAD_END_ALLOW;
44342 : }
44343 34 : if ( bLocalUseExceptions ) {
44344 17 : popErrorHandler();
44345 : }
44346 : #ifndef SED_HACKS
44347 : if ( bLocalUseExceptions ) {
44348 : CPLErr eclass = CPLGetLastErrorType();
44349 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
44350 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
44351 : }
44352 : }
44353 : #endif
44354 : }
44355 34 : resultobj = SWIG_From_int(static_cast< int >(result));
44356 38 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
44357 : return resultobj;
44358 : fail:
44359 : return NULL;
44360 : }
44361 :
44362 :
44363 37 : SWIGINTERN PyObject *_wrap_Band_IsMaskBand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44364 37 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
44365 37 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
44366 37 : void *argp1 = 0 ;
44367 37 : int res1 = 0 ;
44368 37 : PyObject *swig_obj[1] ;
44369 37 : bool result;
44370 :
44371 37 : if (!args) SWIG_fail;
44372 37 : swig_obj[0] = args;
44373 37 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
44374 37 : if (!SWIG_IsOK(res1)) {
44375 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_IsMaskBand" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
44376 : }
44377 37 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
44378 37 : {
44379 37 : const int bLocalUseExceptions = GetUseExceptions();
44380 37 : if ( bLocalUseExceptions ) {
44381 9 : pushErrorHandler();
44382 : }
44383 37 : {
44384 37 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44385 37 : result = (bool)GDALRasterBandShadow_IsMaskBand(arg1);
44386 37 : SWIG_PYTHON_THREAD_END_ALLOW;
44387 : }
44388 37 : if ( bLocalUseExceptions ) {
44389 9 : popErrorHandler();
44390 : }
44391 : #ifndef SED_HACKS
44392 : if ( bLocalUseExceptions ) {
44393 : CPLErr eclass = CPLGetLastErrorType();
44394 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
44395 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
44396 : }
44397 : }
44398 : #endif
44399 : }
44400 37 : resultobj = SWIG_From_bool(static_cast< bool >(result));
44401 37 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
44402 : return resultobj;
44403 : fail:
44404 : return NULL;
44405 : }
44406 :
44407 :
44408 27 : SWIGINTERN PyObject *_wrap_Band_GetHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44409 27 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
44410 27 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
44411 27 : double arg2 = (double) -0.5 ;
44412 27 : double arg3 = (double) 255.5 ;
44413 27 : int arg4 = (int) 256 ;
44414 27 : GUIntBig *arg5 = (GUIntBig *) NULL ;
44415 27 : int arg6 = (int) 0 ;
44416 27 : int arg7 = (int) 1 ;
44417 27 : GDALProgressFunc arg8 = (GDALProgressFunc) NULL ;
44418 27 : void *arg9 = (void *) NULL ;
44419 27 : void *argp1 = 0 ;
44420 27 : int res1 = 0 ;
44421 27 : double val2 ;
44422 27 : int ecode2 = 0 ;
44423 27 : double val3 ;
44424 27 : int ecode3 = 0 ;
44425 27 : int val6 ;
44426 27 : int ecode6 = 0 ;
44427 27 : int val7 ;
44428 27 : int ecode7 = 0 ;
44429 27 : PyObject * obj0 = 0 ;
44430 27 : PyObject * obj1 = 0 ;
44431 27 : PyObject * obj2 = 0 ;
44432 27 : PyObject * obj3 = 0 ;
44433 27 : PyObject * obj4 = 0 ;
44434 27 : PyObject * obj5 = 0 ;
44435 27 : PyObject * obj6 = 0 ;
44436 27 : PyObject * obj7 = 0 ;
44437 27 : char * kwnames[] = {
44438 : (char *)"self", (char *)"min", (char *)"max", (char *)"buckets", (char *)"include_out_of_range", (char *)"approx_ok", (char *)"callback", (char *)"callback_data", NULL
44439 : };
44440 27 : CPLErr result;
44441 :
44442 27 : {
44443 : /* %typemap(in) int buckets, GUIntBig* panHistogram -> list */
44444 27 : arg5 = (GUIntBig *) VSICalloc(sizeof(GUIntBig),arg4);
44445 : }
44446 : /* %typemap(arginit) ( const char* callback_data=NULL) */
44447 27 : PyProgressData *psProgressInfo;
44448 27 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
44449 27 : psProgressInfo->nLastReported = -1;
44450 27 : psProgressInfo->psPyCallback = NULL;
44451 27 : psProgressInfo->psPyCallbackData = NULL;
44452 27 : arg9 = psProgressInfo;
44453 27 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOO:Band_GetHistogram", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
44454 27 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
44455 27 : if (!SWIG_IsOK(res1)) {
44456 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetHistogram" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
44457 : }
44458 27 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
44459 27 : if (obj1) {
44460 18 : ecode2 = SWIG_AsVal_double(obj1, &val2);
44461 18 : if (!SWIG_IsOK(ecode2)) {
44462 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_GetHistogram" "', argument " "2"" of type '" "double""'");
44463 : }
44464 18 : arg2 = static_cast< double >(val2);
44465 : }
44466 27 : if (obj2) {
44467 16 : ecode3 = SWIG_AsVal_double(obj2, &val3);
44468 16 : if (!SWIG_IsOK(ecode3)) {
44469 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_GetHistogram" "', argument " "3"" of type '" "double""'");
44470 : }
44471 16 : arg3 = static_cast< double >(val3);
44472 : }
44473 27 : if (obj3) {
44474 16 : {
44475 : /* %typemap(in) int buckets, GUIntBig* panHistogram -> list */
44476 16 : int requested_buckets = 0;
44477 32 : CPL_IGNORE_RET_VAL(SWIG_AsVal_int(obj3, &requested_buckets));
44478 16 : if( requested_buckets != arg4 )
44479 : {
44480 16 : arg4 = requested_buckets;
44481 16 : if (requested_buckets <= 0 || (size_t)requested_buckets > SIZE_MAX / sizeof(GUIntBig))
44482 : {
44483 1 : PyErr_SetString( PyExc_RuntimeError, "Bad value for buckets" );
44484 1 : SWIG_fail;
44485 : }
44486 15 : void* tmp = VSIRealloc(arg5, sizeof(GUIntBig) * requested_buckets);
44487 15 : if( !tmp) {
44488 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
44489 0 : SWIG_fail;
44490 : }
44491 : arg5 = (GUIntBig *)tmp;
44492 : }
44493 15 : if (arg5 == NULL)
44494 : {
44495 0 : PyErr_SetString( PyExc_RuntimeError, "Cannot allocate buckets" );
44496 0 : SWIG_fail;
44497 : }
44498 : }
44499 : }
44500 26 : if (obj4) {
44501 15 : ecode6 = SWIG_AsVal_int(obj4, &val6);
44502 15 : if (!SWIG_IsOK(ecode6)) {
44503 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Band_GetHistogram" "', argument " "6"" of type '" "int""'");
44504 : }
44505 : arg6 = static_cast< int >(val6);
44506 : }
44507 26 : if (obj5) {
44508 17 : ecode7 = SWIG_AsVal_int(obj5, &val7);
44509 17 : if (!SWIG_IsOK(ecode7)) {
44510 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Band_GetHistogram" "', argument " "7"" of type '" "int""'");
44511 : }
44512 : arg7 = static_cast< int >(val7);
44513 : }
44514 26 : if (obj6) {
44515 0 : {
44516 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
44517 : /* callback_func typemap */
44518 :
44519 : /* In some cases 0 is passed instead of None. */
44520 : /* See https://github.com/OSGeo/gdal/pull/219 */
44521 0 : if ( PyLong_Check(obj6) || PyInt_Check(obj6) )
44522 : {
44523 0 : if( PyLong_AsLong(obj6) == 0 )
44524 : {
44525 0 : obj6 = Py_None;
44526 : }
44527 : }
44528 :
44529 0 : if (obj6 && obj6 != Py_None ) {
44530 0 : void* cbfunction = NULL;
44531 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj6,
44532 : (void**)&cbfunction,
44533 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
44534 : SWIG_POINTER_EXCEPTION | 0 ));
44535 :
44536 0 : if ( cbfunction == GDALTermProgress ) {
44537 : arg8 = GDALTermProgress;
44538 : } else {
44539 0 : if (!PyCallable_Check(obj6)) {
44540 0 : PyErr_SetString( PyExc_RuntimeError,
44541 : "Object given is not a Python function" );
44542 0 : SWIG_fail;
44543 : }
44544 0 : psProgressInfo->psPyCallback = obj6;
44545 0 : arg8 = PyProgressProxy;
44546 : }
44547 :
44548 : }
44549 :
44550 : }
44551 : }
44552 26 : if (obj7) {
44553 0 : {
44554 : /* %typemap(in) ( void* callback_data=NULL) */
44555 0 : psProgressInfo->psPyCallbackData = obj7 ;
44556 : }
44557 : }
44558 26 : {
44559 26 : const int bLocalUseExceptions = GetUseExceptions();
44560 26 : if ( bLocalUseExceptions ) {
44561 4 : pushErrorHandler();
44562 : }
44563 26 : {
44564 26 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44565 26 : result = (CPLErr)GDALRasterBandShadow_GetHistogram(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
44566 26 : SWIG_PYTHON_THREAD_END_ALLOW;
44567 : }
44568 26 : if ( bLocalUseExceptions ) {
44569 4 : popErrorHandler();
44570 : }
44571 : #ifndef SED_HACKS
44572 : if ( bLocalUseExceptions ) {
44573 : CPLErr eclass = CPLGetLastErrorType();
44574 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
44575 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
44576 : }
44577 : }
44578 : #endif
44579 : }
44580 26 : resultobj = SWIG_From_int(static_cast< int >(result));
44581 26 : {
44582 : /* %typemap(out) int buckets, GUIntBig* panHistogram -> list */
44583 26 : GUIntBig *integerarray = arg5;
44584 26 : Py_DECREF( resultobj );
44585 26 : if ( integerarray == NULL ) {
44586 0 : resultobj = Py_None;
44587 0 : Py_INCREF( resultobj );
44588 : }
44589 : else {
44590 26 : resultobj = PyList_New( arg4 );
44591 26 : if( !resultobj ) {
44592 0 : SWIG_fail;
44593 : }
44594 2924 : for ( int i = 0; i < arg4; ++i ) {
44595 2898 : char szTmp[32];
44596 2898 : snprintf(szTmp, sizeof(szTmp), CPL_FRMT_GUIB, integerarray[i]);
44597 2898 : PyObject *o = PyLong_FromString(szTmp, NULL, 10);
44598 2898 : PyList_SetItem(resultobj, i, o );
44599 : }
44600 : }
44601 : }
44602 26 : {
44603 : /* %typemap(freearg) (int buckets, GUIntBig* panHistogram)*/
44604 26 : VSIFree( arg5 );
44605 : }
44606 26 : {
44607 : /* %typemap(freearg) ( void* callback_data=NULL) */
44608 :
44609 26 : CPLFree(psProgressInfo);
44610 :
44611 : }
44612 27 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
44613 : return resultobj;
44614 1 : fail:
44615 1 : {
44616 : /* %typemap(freearg) (int buckets, GUIntBig* panHistogram)*/
44617 1 : VSIFree( arg5 );
44618 : }
44619 1 : {
44620 : /* %typemap(freearg) ( void* callback_data=NULL) */
44621 :
44622 1 : CPLFree(psProgressInfo);
44623 :
44624 : }
44625 : return NULL;
44626 : }
44627 :
44628 :
44629 13 : SWIGINTERN PyObject *_wrap_Band_GetDefaultHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44630 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
44631 13 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
44632 13 : double *arg2 = (double *) NULL ;
44633 13 : double *arg3 = (double *) NULL ;
44634 13 : int *arg4 = (int *) NULL ;
44635 13 : GUIntBig **arg5 = (GUIntBig **) NULL ;
44636 13 : int arg6 = (int) 1 ;
44637 13 : GDALProgressFunc arg7 = (GDALProgressFunc) NULL ;
44638 13 : void *arg8 = (void *) NULL ;
44639 13 : void *argp1 = 0 ;
44640 13 : int res1 = 0 ;
44641 13 : double val2 ;
44642 13 : double val3 ;
44643 13 : void *argp4 = 0 ;
44644 13 : int res4 = 0 ;
44645 13 : void *argp5 = 0 ;
44646 13 : int res5 = 0 ;
44647 13 : int val6 ;
44648 13 : int ecode6 = 0 ;
44649 13 : PyObject * obj0 = 0 ;
44650 13 : PyObject * obj1 = 0 ;
44651 13 : PyObject * obj2 = 0 ;
44652 13 : PyObject * obj3 = 0 ;
44653 13 : PyObject * obj4 = 0 ;
44654 13 : PyObject * obj5 = 0 ;
44655 13 : PyObject * obj6 = 0 ;
44656 13 : PyObject * obj7 = 0 ;
44657 13 : char * kwnames[] = {
44658 : (char *)"self", (char *)"min_ret", (char *)"max_ret", (char *)"buckets_ret", (char *)"ppanHistogram", (char *)"force", (char *)"callback", (char *)"callback_data", NULL
44659 : };
44660 13 : CPLErr result;
44661 :
44662 13 : double min_val = 0.0, max_val = 0.0;
44663 13 : int buckets_val = 0;
44664 13 : GUIntBig *panHistogram = NULL;
44665 :
44666 13 : arg2 = &min_val;
44667 13 : arg3 = &max_val;
44668 13 : arg4 = &buckets_val;
44669 13 : arg5 = &panHistogram;
44670 : /* %typemap(arginit) ( const char* callback_data=NULL) */
44671 13 : PyProgressData *psProgressInfo;
44672 13 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
44673 13 : psProgressInfo->nLastReported = -1;
44674 13 : psProgressInfo->psPyCallback = NULL;
44675 13 : psProgressInfo->psPyCallbackData = NULL;
44676 13 : arg8 = psProgressInfo;
44677 13 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOO:Band_GetDefaultHistogram", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
44678 13 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
44679 13 : if (!SWIG_IsOK(res1)) {
44680 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetDefaultHistogram" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
44681 : }
44682 13 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
44683 13 : if (obj1) {
44684 0 : {
44685 : /* %typemap(in) (double *optional_##double) */
44686 0 : if ( obj1 == Py_None ) {
44687 : arg2 = 0;
44688 : }
44689 0 : else if ( PyArg_Parse( obj1,"d" ,&val2 ) ) {
44690 : arg2 = (double *) &val2;
44691 : }
44692 : else {
44693 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
44694 0 : SWIG_fail;
44695 : }
44696 : }
44697 : }
44698 13 : if (obj2) {
44699 0 : {
44700 : /* %typemap(in) (double *optional_##double) */
44701 0 : if ( obj2 == Py_None ) {
44702 : arg3 = 0;
44703 : }
44704 0 : else if ( PyArg_Parse( obj2,"d" ,&val3 ) ) {
44705 : arg3 = (double *) &val3;
44706 : }
44707 : else {
44708 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
44709 0 : SWIG_fail;
44710 : }
44711 : }
44712 : }
44713 13 : if (obj3) {
44714 0 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 );
44715 0 : if (!SWIG_IsOK(res4)) {
44716 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Band_GetDefaultHistogram" "', argument " "4"" of type '" "int *""'");
44717 : }
44718 0 : arg4 = reinterpret_cast< int * >(argp4);
44719 : }
44720 13 : if (obj4) {
44721 0 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_p_GUIntBig, 0 | 0 );
44722 0 : if (!SWIG_IsOK(res5)) {
44723 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Band_GetDefaultHistogram" "', argument " "5"" of type '" "GUIntBig **""'");
44724 : }
44725 0 : arg5 = reinterpret_cast< GUIntBig ** >(argp5);
44726 : }
44727 13 : if (obj5) {
44728 5 : ecode6 = SWIG_AsVal_int(obj5, &val6);
44729 5 : if (!SWIG_IsOK(ecode6)) {
44730 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Band_GetDefaultHistogram" "', argument " "6"" of type '" "int""'");
44731 : }
44732 : arg6 = static_cast< int >(val6);
44733 : }
44734 13 : if (obj6) {
44735 1 : {
44736 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
44737 : /* callback_func typemap */
44738 :
44739 : /* In some cases 0 is passed instead of None. */
44740 : /* See https://github.com/OSGeo/gdal/pull/219 */
44741 1 : if ( PyLong_Check(obj6) || PyInt_Check(obj6) )
44742 : {
44743 0 : if( PyLong_AsLong(obj6) == 0 )
44744 : {
44745 0 : obj6 = Py_None;
44746 : }
44747 : }
44748 :
44749 1 : if (obj6 && obj6 != Py_None ) {
44750 1 : void* cbfunction = NULL;
44751 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj6,
44752 : (void**)&cbfunction,
44753 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
44754 : SWIG_POINTER_EXCEPTION | 0 ));
44755 :
44756 1 : if ( cbfunction == GDALTermProgress ) {
44757 : arg7 = GDALTermProgress;
44758 : } else {
44759 1 : if (!PyCallable_Check(obj6)) {
44760 0 : PyErr_SetString( PyExc_RuntimeError,
44761 : "Object given is not a Python function" );
44762 0 : SWIG_fail;
44763 : }
44764 1 : psProgressInfo->psPyCallback = obj6;
44765 1 : arg7 = PyProgressProxy;
44766 : }
44767 :
44768 : }
44769 :
44770 : }
44771 : }
44772 13 : if (obj7) {
44773 0 : {
44774 : /* %typemap(in) ( void* callback_data=NULL) */
44775 0 : psProgressInfo->psPyCallbackData = obj7 ;
44776 : }
44777 : }
44778 13 : {
44779 13 : const int bLocalUseExceptions = GetUseExceptions();
44780 13 : if ( bLocalUseExceptions ) {
44781 4 : pushErrorHandler();
44782 : }
44783 13 : {
44784 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44785 13 : result = (CPLErr)GDALRasterBandShadow_GetDefaultHistogram(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
44786 13 : SWIG_PYTHON_THREAD_END_ALLOW;
44787 : }
44788 13 : if ( bLocalUseExceptions ) {
44789 4 : popErrorHandler();
44790 : }
44791 : #ifndef SED_HACKS
44792 : if ( bLocalUseExceptions ) {
44793 : CPLErr eclass = CPLGetLastErrorType();
44794 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
44795 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
44796 : }
44797 : }
44798 : #endif
44799 : }
44800 13 : resultobj = SWIG_From_int(static_cast< int >(result));
44801 13 : {
44802 13 : int i;
44803 13 : PyObject *psList = NULL;
44804 :
44805 13 : Py_XDECREF(resultobj);
44806 :
44807 13 : if (panHistogram)
44808 : {
44809 12 : psList = PyList_New(buckets_val);
44810 12 : if( !psList ) {
44811 0 : SWIG_fail;
44812 : }
44813 2321 : for( i = 0; i < buckets_val; i++ )
44814 2309 : PyList_SetItem(psList, i, Py_BuildValue("K", panHistogram[i] ));
44815 :
44816 12 : CPLFree( panHistogram );
44817 :
44818 12 : resultobj = Py_BuildValue( "(ddiO)", min_val, max_val, buckets_val, psList );
44819 12 : Py_XDECREF(psList);
44820 : }
44821 : else
44822 : {
44823 1 : resultobj = Py_None;
44824 1 : Py_INCREF(resultobj);
44825 : }
44826 : }
44827 13 : {
44828 : /* %typemap(freearg) ( void* callback_data=NULL) */
44829 :
44830 13 : CPLFree(psProgressInfo);
44831 :
44832 : }
44833 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
44834 : return resultobj;
44835 0 : fail:
44836 0 : {
44837 : /* %typemap(freearg) ( void* callback_data=NULL) */
44838 :
44839 0 : CPLFree(psProgressInfo);
44840 :
44841 : }
44842 : return NULL;
44843 : }
44844 :
44845 :
44846 5 : SWIGINTERN PyObject *_wrap_Band_SetDefaultHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44847 5 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
44848 5 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
44849 5 : double arg2 ;
44850 5 : double arg3 ;
44851 5 : int arg4 ;
44852 5 : GUIntBig *arg5 = (GUIntBig *) 0 ;
44853 5 : void *argp1 = 0 ;
44854 5 : int res1 = 0 ;
44855 5 : double val2 ;
44856 5 : int ecode2 = 0 ;
44857 5 : double val3 ;
44858 5 : int ecode3 = 0 ;
44859 5 : PyObject *swig_obj[4] ;
44860 5 : CPLErr result;
44861 :
44862 5 : if (!SWIG_Python_UnpackTuple(args, "Band_SetDefaultHistogram", 4, 4, swig_obj)) SWIG_fail;
44863 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
44864 5 : if (!SWIG_IsOK(res1)) {
44865 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetDefaultHistogram" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
44866 : }
44867 5 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
44868 5 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
44869 5 : if (!SWIG_IsOK(ecode2)) {
44870 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_SetDefaultHistogram" "', argument " "2"" of type '" "double""'");
44871 : }
44872 5 : arg2 = static_cast< double >(val2);
44873 5 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
44874 5 : if (!SWIG_IsOK(ecode3)) {
44875 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_SetDefaultHistogram" "', argument " "3"" of type '" "double""'");
44876 : }
44877 5 : arg3 = static_cast< double >(val3);
44878 5 : {
44879 : /* %typemap(in,numinputs=1) (int nList, GUIntBig* pList)*/
44880 5 : arg5 = CreateCGUIntBigListFromSequence(swig_obj[3], &arg4);
44881 5 : if( arg4 < 0 ) {
44882 0 : SWIG_fail;
44883 : }
44884 : }
44885 5 : {
44886 5 : const int bLocalUseExceptions = GetUseExceptions();
44887 5 : if ( bLocalUseExceptions ) {
44888 5 : pushErrorHandler();
44889 : }
44890 5 : {
44891 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44892 5 : result = (CPLErr)GDALRasterBandShadow_SetDefaultHistogram(arg1,arg2,arg3,arg4,arg5);
44893 5 : SWIG_PYTHON_THREAD_END_ALLOW;
44894 : }
44895 5 : if ( bLocalUseExceptions ) {
44896 5 : popErrorHandler();
44897 : }
44898 : #ifndef SED_HACKS
44899 : if ( bLocalUseExceptions ) {
44900 : CPLErr eclass = CPLGetLastErrorType();
44901 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
44902 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
44903 : }
44904 : }
44905 : #endif
44906 : }
44907 5 : resultobj = SWIG_From_int(static_cast< int >(result));
44908 5 : {
44909 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
44910 5 : free(arg5);
44911 : }
44912 5 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
44913 : return resultobj;
44914 0 : fail:
44915 0 : {
44916 : /* %typemap(freearg) (int nList, GUIntBig* pList) */
44917 0 : free(arg5);
44918 : }
44919 0 : return NULL;
44920 : }
44921 :
44922 :
44923 17 : SWIGINTERN PyObject *_wrap_Band_HasArbitraryOverviews(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44924 17 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
44925 17 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
44926 17 : void *argp1 = 0 ;
44927 17 : int res1 = 0 ;
44928 17 : PyObject *swig_obj[1] ;
44929 17 : bool result;
44930 :
44931 17 : if (!args) SWIG_fail;
44932 17 : swig_obj[0] = args;
44933 17 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
44934 17 : if (!SWIG_IsOK(res1)) {
44935 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_HasArbitraryOverviews" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
44936 : }
44937 17 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
44938 17 : {
44939 17 : const int bLocalUseExceptions = GetUseExceptions();
44940 17 : if ( bLocalUseExceptions ) {
44941 0 : pushErrorHandler();
44942 : }
44943 17 : {
44944 17 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44945 17 : result = (bool)GDALRasterBandShadow_HasArbitraryOverviews(arg1);
44946 17 : SWIG_PYTHON_THREAD_END_ALLOW;
44947 : }
44948 17 : if ( bLocalUseExceptions ) {
44949 0 : popErrorHandler();
44950 : }
44951 : #ifndef SED_HACKS
44952 : if ( bLocalUseExceptions ) {
44953 : CPLErr eclass = CPLGetLastErrorType();
44954 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
44955 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
44956 : }
44957 : }
44958 : #endif
44959 : }
44960 17 : resultobj = SWIG_From_bool(static_cast< bool >(result));
44961 17 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
44962 : return resultobj;
44963 : fail:
44964 : return NULL;
44965 : }
44966 :
44967 :
44968 10 : SWIGINTERN PyObject *_wrap_Band_GetCategoryNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44969 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
44970 10 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
44971 10 : void *argp1 = 0 ;
44972 10 : int res1 = 0 ;
44973 10 : PyObject *swig_obj[1] ;
44974 10 : char **result = 0 ;
44975 :
44976 10 : if (!args) SWIG_fail;
44977 10 : swig_obj[0] = args;
44978 10 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
44979 10 : if (!SWIG_IsOK(res1)) {
44980 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetCategoryNames" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
44981 : }
44982 10 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
44983 10 : {
44984 10 : const int bLocalUseExceptions = GetUseExceptions();
44985 10 : if ( bLocalUseExceptions ) {
44986 8 : pushErrorHandler();
44987 : }
44988 10 : {
44989 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
44990 10 : result = (char **)GDALRasterBandShadow_GetCategoryNames(arg1);
44991 10 : SWIG_PYTHON_THREAD_END_ALLOW;
44992 : }
44993 10 : if ( bLocalUseExceptions ) {
44994 8 : popErrorHandler();
44995 : }
44996 : #ifndef SED_HACKS
44997 : if ( bLocalUseExceptions ) {
44998 : CPLErr eclass = CPLGetLastErrorType();
44999 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
45000 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
45001 : }
45002 : }
45003 : #endif
45004 : }
45005 10 : {
45006 : /* %typemap(out) char **options -> ( string ) */
45007 10 : bool bErr = false;
45008 10 : resultobj = CSLToList(result, &bErr);
45009 10 : if( bErr ) {
45010 0 : SWIG_fail;
45011 : }
45012 : }
45013 10 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
45014 : return resultobj;
45015 : fail:
45016 : return NULL;
45017 : }
45018 :
45019 :
45020 2 : SWIGINTERN PyObject *_wrap_Band_SetCategoryNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45021 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
45022 2 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
45023 2 : char **arg2 = (char **) 0 ;
45024 2 : void *argp1 = 0 ;
45025 2 : int res1 = 0 ;
45026 2 : PyObject *swig_obj[2] ;
45027 2 : CPLErr result;
45028 :
45029 2 : if (!SWIG_Python_UnpackTuple(args, "Band_SetCategoryNames", 2, 2, swig_obj)) SWIG_fail;
45030 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
45031 2 : if (!SWIG_IsOK(res1)) {
45032 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_SetCategoryNames" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
45033 : }
45034 2 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
45035 2 : {
45036 : /* %typemap(in) char **dict */
45037 2 : arg2 = NULL;
45038 2 : if ( PySequence_Check( swig_obj[1] ) ) {
45039 2 : int bErr = FALSE;
45040 2 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
45041 2 : if ( bErr )
45042 : {
45043 0 : SWIG_fail;
45044 : }
45045 : }
45046 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
45047 0 : int bErr = FALSE;
45048 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
45049 0 : if ( bErr )
45050 : {
45051 0 : SWIG_fail;
45052 : }
45053 : }
45054 : else {
45055 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
45056 0 : SWIG_fail;
45057 : }
45058 : }
45059 2 : {
45060 2 : const int bLocalUseExceptions = GetUseExceptions();
45061 2 : if ( bLocalUseExceptions ) {
45062 2 : pushErrorHandler();
45063 : }
45064 2 : {
45065 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45066 2 : result = (CPLErr)GDALRasterBandShadow_SetCategoryNames(arg1,arg2);
45067 2 : SWIG_PYTHON_THREAD_END_ALLOW;
45068 : }
45069 2 : if ( bLocalUseExceptions ) {
45070 2 : popErrorHandler();
45071 : }
45072 : #ifndef SED_HACKS
45073 : if ( bLocalUseExceptions ) {
45074 : CPLErr eclass = CPLGetLastErrorType();
45075 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
45076 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
45077 : }
45078 : }
45079 : #endif
45080 : }
45081 2 : resultobj = SWIG_From_int(static_cast< int >(result));
45082 2 : {
45083 : /* %typemap(freearg) char **dict */
45084 2 : CSLDestroy( arg2 );
45085 : }
45086 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
45087 : return resultobj;
45088 0 : fail:
45089 0 : {
45090 : /* %typemap(freearg) char **dict */
45091 0 : CSLDestroy( arg2 );
45092 : }
45093 : return NULL;
45094 : }
45095 :
45096 :
45097 1 : SWIGINTERN PyObject *_wrap_Band_GetVirtualMem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45098 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
45099 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
45100 1 : GDALRWFlag arg2 ;
45101 1 : int arg3 ;
45102 1 : int arg4 ;
45103 1 : int arg5 ;
45104 1 : int arg6 ;
45105 1 : int arg7 ;
45106 1 : int arg8 ;
45107 1 : GDALDataType arg9 ;
45108 1 : size_t arg10 ;
45109 1 : size_t arg11 ;
45110 1 : char **arg12 = (char **) NULL ;
45111 1 : void *argp1 = 0 ;
45112 1 : int res1 = 0 ;
45113 1 : int val2 ;
45114 1 : int ecode2 = 0 ;
45115 1 : int val3 ;
45116 1 : int ecode3 = 0 ;
45117 1 : int val4 ;
45118 1 : int ecode4 = 0 ;
45119 1 : int val5 ;
45120 1 : int ecode5 = 0 ;
45121 1 : int val6 ;
45122 1 : int ecode6 = 0 ;
45123 1 : int val7 ;
45124 1 : int ecode7 = 0 ;
45125 1 : int val8 ;
45126 1 : int ecode8 = 0 ;
45127 1 : size_t val10 ;
45128 1 : int ecode10 = 0 ;
45129 1 : size_t val11 ;
45130 1 : int ecode11 = 0 ;
45131 1 : PyObject * obj0 = 0 ;
45132 1 : PyObject * obj1 = 0 ;
45133 1 : PyObject * obj2 = 0 ;
45134 1 : PyObject * obj3 = 0 ;
45135 1 : PyObject * obj4 = 0 ;
45136 1 : PyObject * obj5 = 0 ;
45137 1 : PyObject * obj6 = 0 ;
45138 1 : PyObject * obj7 = 0 ;
45139 1 : PyObject * obj8 = 0 ;
45140 1 : PyObject * obj9 = 0 ;
45141 1 : PyObject * obj10 = 0 ;
45142 1 : PyObject * obj11 = 0 ;
45143 1 : char * kwnames[] = {
45144 : (char *)"self", (char *)"eRWFlag", (char *)"nXOff", (char *)"nYOff", (char *)"nXSize", (char *)"nYSize", (char *)"nBufXSize", (char *)"nBufYSize", (char *)"eBufType", (char *)"nCacheSize", (char *)"nPageSizeHint", (char *)"options", NULL
45145 : };
45146 1 : CPLVirtualMemShadow *result = 0 ;
45147 :
45148 1 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOO|O:Band_GetVirtualMem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11)) SWIG_fail;
45149 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
45150 1 : if (!SWIG_IsOK(res1)) {
45151 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetVirtualMem" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
45152 : }
45153 1 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
45154 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
45155 1 : if (!SWIG_IsOK(ecode2)) {
45156 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_GetVirtualMem" "', argument " "2"" of type '" "GDALRWFlag""'");
45157 : }
45158 1 : arg2 = static_cast< GDALRWFlag >(val2);
45159 1 : ecode3 = SWIG_AsVal_int(obj2, &val3);
45160 1 : if (!SWIG_IsOK(ecode3)) {
45161 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_GetVirtualMem" "', argument " "3"" of type '" "int""'");
45162 : }
45163 1 : arg3 = static_cast< int >(val3);
45164 1 : ecode4 = SWIG_AsVal_int(obj3, &val4);
45165 1 : if (!SWIG_IsOK(ecode4)) {
45166 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Band_GetVirtualMem" "', argument " "4"" of type '" "int""'");
45167 : }
45168 1 : arg4 = static_cast< int >(val4);
45169 1 : ecode5 = SWIG_AsVal_int(obj4, &val5);
45170 1 : if (!SWIG_IsOK(ecode5)) {
45171 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Band_GetVirtualMem" "', argument " "5"" of type '" "int""'");
45172 : }
45173 1 : arg5 = static_cast< int >(val5);
45174 1 : ecode6 = SWIG_AsVal_int(obj5, &val6);
45175 1 : if (!SWIG_IsOK(ecode6)) {
45176 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Band_GetVirtualMem" "', argument " "6"" of type '" "int""'");
45177 : }
45178 1 : arg6 = static_cast< int >(val6);
45179 1 : ecode7 = SWIG_AsVal_int(obj6, &val7);
45180 1 : if (!SWIG_IsOK(ecode7)) {
45181 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Band_GetVirtualMem" "', argument " "7"" of type '" "int""'");
45182 : }
45183 1 : arg7 = static_cast< int >(val7);
45184 1 : ecode8 = SWIG_AsVal_int(obj7, &val8);
45185 1 : if (!SWIG_IsOK(ecode8)) {
45186 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Band_GetVirtualMem" "', argument " "8"" of type '" "int""'");
45187 : }
45188 1 : arg8 = static_cast< int >(val8);
45189 1 : {
45190 : // %typemap(in) GDALDataType
45191 1 : int val = 0;
45192 1 : int ecode = SWIG_AsVal_int(obj8, &val);
45193 1 : if (!SWIG_IsOK(ecode)) {
45194 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
45195 : }
45196 1 : if( val < GDT_Unknown || val >= GDT_TypeCount )
45197 : {
45198 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
45199 : }
45200 1 : arg9 = static_cast<GDALDataType>(val);
45201 : }
45202 1 : ecode10 = SWIG_AsVal_size_t(obj9, &val10);
45203 1 : if (!SWIG_IsOK(ecode10)) {
45204 0 : SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Band_GetVirtualMem" "', argument " "10"" of type '" "size_t""'");
45205 : }
45206 1 : arg10 = static_cast< size_t >(val10);
45207 1 : ecode11 = SWIG_AsVal_size_t(obj10, &val11);
45208 1 : if (!SWIG_IsOK(ecode11)) {
45209 0 : SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Band_GetVirtualMem" "', argument " "11"" of type '" "size_t""'");
45210 : }
45211 1 : arg11 = static_cast< size_t >(val11);
45212 1 : if (obj11) {
45213 0 : {
45214 : /* %typemap(in) char **dict */
45215 0 : arg12 = NULL;
45216 0 : if ( PySequence_Check( obj11 ) ) {
45217 0 : int bErr = FALSE;
45218 0 : arg12 = CSLFromPySequence(obj11, &bErr);
45219 0 : if ( bErr )
45220 : {
45221 0 : SWIG_fail;
45222 : }
45223 : }
45224 0 : else if ( PyMapping_Check( obj11 ) ) {
45225 0 : int bErr = FALSE;
45226 0 : arg12 = CSLFromPyMapping(obj11, &bErr);
45227 0 : if ( bErr )
45228 : {
45229 0 : SWIG_fail;
45230 : }
45231 : }
45232 : else {
45233 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
45234 0 : SWIG_fail;
45235 : }
45236 : }
45237 : }
45238 1 : {
45239 1 : const int bLocalUseExceptions = GetUseExceptions();
45240 1 : if ( bLocalUseExceptions ) {
45241 1 : pushErrorHandler();
45242 : }
45243 1 : {
45244 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45245 1 : result = (CPLVirtualMemShadow *)GDALRasterBandShadow_GetVirtualMem(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
45246 1 : SWIG_PYTHON_THREAD_END_ALLOW;
45247 : }
45248 1 : if ( bLocalUseExceptions ) {
45249 1 : popErrorHandler();
45250 : }
45251 : #ifndef SED_HACKS
45252 : if ( bLocalUseExceptions ) {
45253 : CPLErr eclass = CPLGetLastErrorType();
45254 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
45255 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
45256 : }
45257 : }
45258 : #endif
45259 : }
45260 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CPLVirtualMemShadow, SWIG_POINTER_OWN | 0 );
45261 1 : {
45262 : /* %typemap(freearg) char **dict */
45263 1 : CSLDestroy( arg12 );
45264 : }
45265 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
45266 : return resultobj;
45267 0 : fail:
45268 0 : {
45269 : /* %typemap(freearg) char **dict */
45270 0 : CSLDestroy( arg12 );
45271 : }
45272 : return NULL;
45273 : }
45274 :
45275 :
45276 21 : SWIGINTERN PyObject *_wrap_Band_GetVirtualMemAuto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45277 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
45278 21 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
45279 21 : GDALRWFlag arg2 ;
45280 21 : char **arg3 = (char **) NULL ;
45281 21 : void *argp1 = 0 ;
45282 21 : int res1 = 0 ;
45283 21 : int val2 ;
45284 21 : int ecode2 = 0 ;
45285 21 : PyObject * obj0 = 0 ;
45286 21 : PyObject * obj1 = 0 ;
45287 21 : PyObject * obj2 = 0 ;
45288 21 : char * kwnames[] = {
45289 : (char *)"self", (char *)"eRWFlag", (char *)"options", NULL
45290 : };
45291 21 : CPLVirtualMemShadow *result = 0 ;
45292 :
45293 21 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Band_GetVirtualMemAuto", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
45294 21 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
45295 21 : if (!SWIG_IsOK(res1)) {
45296 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetVirtualMemAuto" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
45297 : }
45298 21 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
45299 21 : ecode2 = SWIG_AsVal_int(obj1, &val2);
45300 21 : if (!SWIG_IsOK(ecode2)) {
45301 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_GetVirtualMemAuto" "', argument " "2"" of type '" "GDALRWFlag""'");
45302 : }
45303 21 : arg2 = static_cast< GDALRWFlag >(val2);
45304 21 : if (obj2) {
45305 0 : {
45306 : /* %typemap(in) char **dict */
45307 0 : arg3 = NULL;
45308 0 : if ( PySequence_Check( obj2 ) ) {
45309 0 : int bErr = FALSE;
45310 0 : arg3 = CSLFromPySequence(obj2, &bErr);
45311 0 : if ( bErr )
45312 : {
45313 0 : SWIG_fail;
45314 : }
45315 : }
45316 0 : else if ( PyMapping_Check( obj2 ) ) {
45317 0 : int bErr = FALSE;
45318 0 : arg3 = CSLFromPyMapping(obj2, &bErr);
45319 0 : if ( bErr )
45320 : {
45321 0 : SWIG_fail;
45322 : }
45323 : }
45324 : else {
45325 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
45326 0 : SWIG_fail;
45327 : }
45328 : }
45329 : }
45330 21 : {
45331 21 : const int bLocalUseExceptions = GetUseExceptions();
45332 21 : if ( bLocalUseExceptions ) {
45333 21 : pushErrorHandler();
45334 : }
45335 21 : {
45336 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45337 21 : result = (CPLVirtualMemShadow *)GDALRasterBandShadow_GetVirtualMemAuto(arg1,arg2,arg3);
45338 21 : SWIG_PYTHON_THREAD_END_ALLOW;
45339 : }
45340 21 : if ( bLocalUseExceptions ) {
45341 21 : popErrorHandler();
45342 : }
45343 : #ifndef SED_HACKS
45344 : if ( bLocalUseExceptions ) {
45345 : CPLErr eclass = CPLGetLastErrorType();
45346 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
45347 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
45348 : }
45349 : }
45350 : #endif
45351 : }
45352 21 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CPLVirtualMemShadow, SWIG_POINTER_OWN | 0 );
45353 21 : {
45354 : /* %typemap(freearg) char **dict */
45355 21 : CSLDestroy( arg3 );
45356 : }
45357 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
45358 : return resultobj;
45359 0 : fail:
45360 0 : {
45361 : /* %typemap(freearg) char **dict */
45362 0 : CSLDestroy( arg3 );
45363 : }
45364 : return NULL;
45365 : }
45366 :
45367 :
45368 1 : SWIGINTERN PyObject *_wrap_Band_GetTiledVirtualMem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45369 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
45370 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
45371 1 : GDALRWFlag arg2 ;
45372 1 : int arg3 ;
45373 1 : int arg4 ;
45374 1 : int arg5 ;
45375 1 : int arg6 ;
45376 1 : int arg7 ;
45377 1 : int arg8 ;
45378 1 : GDALDataType arg9 ;
45379 1 : size_t arg10 ;
45380 1 : char **arg11 = (char **) NULL ;
45381 1 : void *argp1 = 0 ;
45382 1 : int res1 = 0 ;
45383 1 : int val2 ;
45384 1 : int ecode2 = 0 ;
45385 1 : int val3 ;
45386 1 : int ecode3 = 0 ;
45387 1 : int val4 ;
45388 1 : int ecode4 = 0 ;
45389 1 : int val5 ;
45390 1 : int ecode5 = 0 ;
45391 1 : int val6 ;
45392 1 : int ecode6 = 0 ;
45393 1 : int val7 ;
45394 1 : int ecode7 = 0 ;
45395 1 : int val8 ;
45396 1 : int ecode8 = 0 ;
45397 1 : size_t val10 ;
45398 1 : int ecode10 = 0 ;
45399 1 : PyObject * obj0 = 0 ;
45400 1 : PyObject * obj1 = 0 ;
45401 1 : PyObject * obj2 = 0 ;
45402 1 : PyObject * obj3 = 0 ;
45403 1 : PyObject * obj4 = 0 ;
45404 1 : PyObject * obj5 = 0 ;
45405 1 : PyObject * obj6 = 0 ;
45406 1 : PyObject * obj7 = 0 ;
45407 1 : PyObject * obj8 = 0 ;
45408 1 : PyObject * obj9 = 0 ;
45409 1 : PyObject * obj10 = 0 ;
45410 1 : char * kwnames[] = {
45411 : (char *)"self", (char *)"eRWFlag", (char *)"nXOff", (char *)"nYOff", (char *)"nXSize", (char *)"nYSize", (char *)"nTileXSize", (char *)"nTileYSize", (char *)"eBufType", (char *)"nCacheSize", (char *)"options", NULL
45412 : };
45413 1 : CPLVirtualMemShadow *result = 0 ;
45414 :
45415 1 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOO|O:Band_GetTiledVirtualMem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10)) SWIG_fail;
45416 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
45417 1 : if (!SWIG_IsOK(res1)) {
45418 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetTiledVirtualMem" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
45419 : }
45420 1 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
45421 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
45422 1 : if (!SWIG_IsOK(ecode2)) {
45423 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_GetTiledVirtualMem" "', argument " "2"" of type '" "GDALRWFlag""'");
45424 : }
45425 1 : arg2 = static_cast< GDALRWFlag >(val2);
45426 1 : ecode3 = SWIG_AsVal_int(obj2, &val3);
45427 1 : if (!SWIG_IsOK(ecode3)) {
45428 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_GetTiledVirtualMem" "', argument " "3"" of type '" "int""'");
45429 : }
45430 1 : arg3 = static_cast< int >(val3);
45431 1 : ecode4 = SWIG_AsVal_int(obj3, &val4);
45432 1 : if (!SWIG_IsOK(ecode4)) {
45433 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Band_GetTiledVirtualMem" "', argument " "4"" of type '" "int""'");
45434 : }
45435 1 : arg4 = static_cast< int >(val4);
45436 1 : ecode5 = SWIG_AsVal_int(obj4, &val5);
45437 1 : if (!SWIG_IsOK(ecode5)) {
45438 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Band_GetTiledVirtualMem" "', argument " "5"" of type '" "int""'");
45439 : }
45440 1 : arg5 = static_cast< int >(val5);
45441 1 : ecode6 = SWIG_AsVal_int(obj5, &val6);
45442 1 : if (!SWIG_IsOK(ecode6)) {
45443 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Band_GetTiledVirtualMem" "', argument " "6"" of type '" "int""'");
45444 : }
45445 1 : arg6 = static_cast< int >(val6);
45446 1 : ecode7 = SWIG_AsVal_int(obj6, &val7);
45447 1 : if (!SWIG_IsOK(ecode7)) {
45448 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Band_GetTiledVirtualMem" "', argument " "7"" of type '" "int""'");
45449 : }
45450 1 : arg7 = static_cast< int >(val7);
45451 1 : ecode8 = SWIG_AsVal_int(obj7, &val8);
45452 1 : if (!SWIG_IsOK(ecode8)) {
45453 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Band_GetTiledVirtualMem" "', argument " "8"" of type '" "int""'");
45454 : }
45455 1 : arg8 = static_cast< int >(val8);
45456 1 : {
45457 : // %typemap(in) GDALDataType
45458 1 : int val = 0;
45459 1 : int ecode = SWIG_AsVal_int(obj8, &val);
45460 1 : if (!SWIG_IsOK(ecode)) {
45461 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
45462 : }
45463 1 : if( val < GDT_Unknown || val >= GDT_TypeCount )
45464 : {
45465 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
45466 : }
45467 1 : arg9 = static_cast<GDALDataType>(val);
45468 : }
45469 1 : ecode10 = SWIG_AsVal_size_t(obj9, &val10);
45470 1 : if (!SWIG_IsOK(ecode10)) {
45471 0 : SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Band_GetTiledVirtualMem" "', argument " "10"" of type '" "size_t""'");
45472 : }
45473 1 : arg10 = static_cast< size_t >(val10);
45474 1 : if (obj10) {
45475 0 : {
45476 : /* %typemap(in) char **dict */
45477 0 : arg11 = NULL;
45478 0 : if ( PySequence_Check( obj10 ) ) {
45479 0 : int bErr = FALSE;
45480 0 : arg11 = CSLFromPySequence(obj10, &bErr);
45481 0 : if ( bErr )
45482 : {
45483 0 : SWIG_fail;
45484 : }
45485 : }
45486 0 : else if ( PyMapping_Check( obj10 ) ) {
45487 0 : int bErr = FALSE;
45488 0 : arg11 = CSLFromPyMapping(obj10, &bErr);
45489 0 : if ( bErr )
45490 : {
45491 0 : SWIG_fail;
45492 : }
45493 : }
45494 : else {
45495 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
45496 0 : SWIG_fail;
45497 : }
45498 : }
45499 : }
45500 1 : {
45501 1 : const int bLocalUseExceptions = GetUseExceptions();
45502 1 : if ( bLocalUseExceptions ) {
45503 1 : pushErrorHandler();
45504 : }
45505 1 : {
45506 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45507 1 : result = (CPLVirtualMemShadow *)GDALRasterBandShadow_GetTiledVirtualMem(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
45508 1 : SWIG_PYTHON_THREAD_END_ALLOW;
45509 : }
45510 1 : if ( bLocalUseExceptions ) {
45511 1 : popErrorHandler();
45512 : }
45513 : #ifndef SED_HACKS
45514 : if ( bLocalUseExceptions ) {
45515 : CPLErr eclass = CPLGetLastErrorType();
45516 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
45517 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
45518 : }
45519 : }
45520 : #endif
45521 : }
45522 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CPLVirtualMemShadow, SWIG_POINTER_OWN | 0 );
45523 1 : {
45524 : /* %typemap(freearg) char **dict */
45525 1 : CSLDestroy( arg11 );
45526 : }
45527 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
45528 : return resultobj;
45529 0 : fail:
45530 0 : {
45531 : /* %typemap(freearg) char **dict */
45532 0 : CSLDestroy( arg11 );
45533 : }
45534 : return NULL;
45535 : }
45536 :
45537 :
45538 29 : SWIGINTERN PyObject *_wrap_Band_GetDataCoverageStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45539 29 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
45540 29 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
45541 29 : int arg2 ;
45542 29 : int arg3 ;
45543 29 : int arg4 ;
45544 29 : int arg5 ;
45545 29 : int arg6 = (int) 0 ;
45546 29 : double *arg7 = (double *) NULL ;
45547 29 : void *argp1 = 0 ;
45548 29 : int res1 = 0 ;
45549 29 : int val2 ;
45550 29 : int ecode2 = 0 ;
45551 29 : int val3 ;
45552 29 : int ecode3 = 0 ;
45553 29 : int val4 ;
45554 29 : int ecode4 = 0 ;
45555 29 : int val5 ;
45556 29 : int ecode5 = 0 ;
45557 29 : int val6 ;
45558 29 : int ecode6 = 0 ;
45559 29 : double temp7 ;
45560 29 : int res7 = SWIG_TMPOBJ ;
45561 29 : PyObject *swig_obj[6] ;
45562 29 : int result;
45563 :
45564 29 : arg7 = &temp7;
45565 29 : if (!SWIG_Python_UnpackTuple(args, "Band_GetDataCoverageStatus", 5, 6, swig_obj)) SWIG_fail;
45566 29 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
45567 29 : if (!SWIG_IsOK(res1)) {
45568 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_GetDataCoverageStatus" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
45569 : }
45570 29 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
45571 29 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
45572 29 : if (!SWIG_IsOK(ecode2)) {
45573 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_GetDataCoverageStatus" "', argument " "2"" of type '" "int""'");
45574 : }
45575 29 : arg2 = static_cast< int >(val2);
45576 29 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
45577 29 : if (!SWIG_IsOK(ecode3)) {
45578 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_GetDataCoverageStatus" "', argument " "3"" of type '" "int""'");
45579 : }
45580 29 : arg3 = static_cast< int >(val3);
45581 29 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
45582 29 : if (!SWIG_IsOK(ecode4)) {
45583 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Band_GetDataCoverageStatus" "', argument " "4"" of type '" "int""'");
45584 : }
45585 29 : arg4 = static_cast< int >(val4);
45586 29 : ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
45587 29 : if (!SWIG_IsOK(ecode5)) {
45588 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Band_GetDataCoverageStatus" "', argument " "5"" of type '" "int""'");
45589 : }
45590 29 : arg5 = static_cast< int >(val5);
45591 29 : if (swig_obj[5]) {
45592 0 : ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
45593 0 : if (!SWIG_IsOK(ecode6)) {
45594 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Band_GetDataCoverageStatus" "', argument " "6"" of type '" "int""'");
45595 : }
45596 : arg6 = static_cast< int >(val6);
45597 : }
45598 29 : {
45599 29 : const int bLocalUseExceptions = GetUseExceptions();
45600 29 : if ( bLocalUseExceptions ) {
45601 9 : pushErrorHandler();
45602 : }
45603 29 : {
45604 29 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45605 29 : result = (int)GDALRasterBandShadow_GetDataCoverageStatus(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
45606 29 : SWIG_PYTHON_THREAD_END_ALLOW;
45607 : }
45608 29 : if ( bLocalUseExceptions ) {
45609 9 : popErrorHandler();
45610 : }
45611 : #ifndef SED_HACKS
45612 : if ( bLocalUseExceptions ) {
45613 : CPLErr eclass = CPLGetLastErrorType();
45614 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
45615 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
45616 : }
45617 : }
45618 : #endif
45619 : }
45620 29 : resultobj = SWIG_From_int(static_cast< int >(result));
45621 29 : if (ReturnSame(SWIG_IsTmpObj(res7))) {
45622 29 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
45623 : } else {
45624 0 : int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
45625 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
45626 : }
45627 31 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
45628 : return resultobj;
45629 : fail:
45630 : return NULL;
45631 : }
45632 :
45633 :
45634 2 : SWIGINTERN PyObject *_wrap_Band_AdviseRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45635 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
45636 2 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
45637 2 : int arg2 ;
45638 2 : int arg3 ;
45639 2 : int arg4 ;
45640 2 : int arg5 ;
45641 2 : int *arg6 = (int *) 0 ;
45642 2 : int *arg7 = (int *) 0 ;
45643 2 : GDALDataType *arg8 = (GDALDataType *) 0 ;
45644 2 : char **arg9 = (char **) NULL ;
45645 2 : void *argp1 = 0 ;
45646 2 : int res1 = 0 ;
45647 2 : int val2 ;
45648 2 : int ecode2 = 0 ;
45649 2 : int val3 ;
45650 2 : int ecode3 = 0 ;
45651 2 : int val4 ;
45652 2 : int ecode4 = 0 ;
45653 2 : int val5 ;
45654 2 : int ecode5 = 0 ;
45655 2 : void *argp6 = 0 ;
45656 2 : int res6 = 0 ;
45657 2 : void *argp7 = 0 ;
45658 2 : int res7 = 0 ;
45659 2 : int val8 ;
45660 2 : PyObject *swig_obj[9] ;
45661 2 : CPLErr result;
45662 :
45663 2 : if (!SWIG_Python_UnpackTuple(args, "Band_AdviseRead", 5, 9, swig_obj)) SWIG_fail;
45664 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
45665 2 : if (!SWIG_IsOK(res1)) {
45666 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_AdviseRead" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
45667 : }
45668 2 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
45669 2 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
45670 2 : if (!SWIG_IsOK(ecode2)) {
45671 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_AdviseRead" "', argument " "2"" of type '" "int""'");
45672 : }
45673 2 : arg2 = static_cast< int >(val2);
45674 2 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
45675 2 : if (!SWIG_IsOK(ecode3)) {
45676 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_AdviseRead" "', argument " "3"" of type '" "int""'");
45677 : }
45678 2 : arg3 = static_cast< int >(val3);
45679 2 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
45680 2 : if (!SWIG_IsOK(ecode4)) {
45681 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Band_AdviseRead" "', argument " "4"" of type '" "int""'");
45682 : }
45683 2 : arg4 = static_cast< int >(val4);
45684 2 : ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
45685 2 : if (!SWIG_IsOK(ecode5)) {
45686 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Band_AdviseRead" "', argument " "5"" of type '" "int""'");
45687 : }
45688 2 : arg5 = static_cast< int >(val5);
45689 2 : if (swig_obj[5]) {
45690 0 : res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_int, 0 | 0 );
45691 0 : if (!SWIG_IsOK(res6)) {
45692 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Band_AdviseRead" "', argument " "6"" of type '" "int *""'");
45693 : }
45694 0 : arg6 = reinterpret_cast< int * >(argp6);
45695 : }
45696 2 : if (swig_obj[6]) {
45697 0 : res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_int, 0 | 0 );
45698 0 : if (!SWIG_IsOK(res7)) {
45699 0 : SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Band_AdviseRead" "', argument " "7"" of type '" "int *""'");
45700 : }
45701 0 : arg7 = reinterpret_cast< int * >(argp7);
45702 : }
45703 2 : if (swig_obj[7]) {
45704 0 : {
45705 : /* %typemap(in) (int *optional_##int) */
45706 0 : if ( swig_obj[7] == Py_None ) {
45707 : arg8 = 0;
45708 : }
45709 0 : else if ( PyArg_Parse( swig_obj[7],"i" ,&val8 ) ) {
45710 : arg8 = (GDALDataType *) &val8;
45711 : }
45712 : else {
45713 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
45714 0 : SWIG_fail;
45715 : }
45716 : }
45717 : }
45718 2 : if (swig_obj[8]) {
45719 0 : {
45720 : /* %typemap(in) char **dict */
45721 0 : arg9 = NULL;
45722 0 : if ( PySequence_Check( swig_obj[8] ) ) {
45723 0 : int bErr = FALSE;
45724 0 : arg9 = CSLFromPySequence(swig_obj[8], &bErr);
45725 0 : if ( bErr )
45726 : {
45727 0 : SWIG_fail;
45728 : }
45729 : }
45730 0 : else if ( PyMapping_Check( swig_obj[8] ) ) {
45731 0 : int bErr = FALSE;
45732 0 : arg9 = CSLFromPyMapping(swig_obj[8], &bErr);
45733 0 : if ( bErr )
45734 : {
45735 0 : SWIG_fail;
45736 : }
45737 : }
45738 : else {
45739 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
45740 0 : SWIG_fail;
45741 : }
45742 : }
45743 : }
45744 2 : {
45745 2 : const int bLocalUseExceptions = GetUseExceptions();
45746 2 : if ( bLocalUseExceptions ) {
45747 0 : pushErrorHandler();
45748 : }
45749 2 : {
45750 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45751 2 : result = (CPLErr)GDALRasterBandShadow_AdviseRead(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
45752 2 : SWIG_PYTHON_THREAD_END_ALLOW;
45753 : }
45754 2 : if ( bLocalUseExceptions ) {
45755 0 : popErrorHandler();
45756 : }
45757 : #ifndef SED_HACKS
45758 : if ( bLocalUseExceptions ) {
45759 : CPLErr eclass = CPLGetLastErrorType();
45760 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
45761 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
45762 : }
45763 : }
45764 : #endif
45765 : }
45766 2 : resultobj = SWIG_From_int(static_cast< int >(result));
45767 2 : {
45768 : /* %typemap(freearg) char **dict */
45769 2 : CSLDestroy( arg9 );
45770 : }
45771 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
45772 : return resultobj;
45773 0 : fail:
45774 0 : {
45775 : /* %typemap(freearg) char **dict */
45776 0 : CSLDestroy( arg9 );
45777 : }
45778 : return NULL;
45779 : }
45780 :
45781 :
45782 69 : SWIGINTERN PyObject *_wrap_Band_InterpolateAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45783 69 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
45784 69 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
45785 69 : double arg2 ;
45786 69 : double arg3 ;
45787 69 : GDALRIOResampleAlg arg4 ;
45788 69 : double *arg5 = (double *) 0 ;
45789 69 : double *arg6 = (double *) 0 ;
45790 69 : void *argp1 = 0 ;
45791 69 : int res1 = 0 ;
45792 69 : double val2 ;
45793 69 : int ecode2 = 0 ;
45794 69 : double val3 ;
45795 69 : int ecode3 = 0 ;
45796 69 : double temp5 ;
45797 69 : int res5 = SWIG_TMPOBJ ;
45798 69 : double temp6 ;
45799 69 : int res6 = SWIG_TMPOBJ ;
45800 69 : PyObject *swig_obj[4] ;
45801 69 : CPLErr result;
45802 :
45803 69 : arg5 = &temp5;
45804 69 : arg6 = &temp6;
45805 69 : if (!SWIG_Python_UnpackTuple(args, "Band_InterpolateAtPoint", 4, 4, swig_obj)) SWIG_fail;
45806 69 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
45807 69 : if (!SWIG_IsOK(res1)) {
45808 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_InterpolateAtPoint" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
45809 : }
45810 69 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
45811 69 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
45812 69 : if (!SWIG_IsOK(ecode2)) {
45813 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_InterpolateAtPoint" "', argument " "2"" of type '" "double""'");
45814 : }
45815 69 : arg2 = static_cast< double >(val2);
45816 69 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
45817 69 : if (!SWIG_IsOK(ecode3)) {
45818 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_InterpolateAtPoint" "', argument " "3"" of type '" "double""'");
45819 : }
45820 69 : arg3 = static_cast< double >(val3);
45821 69 : {
45822 : // %typemap(in) GDALRIOResampleAlg
45823 69 : int val = 0;
45824 69 : int ecode = SWIG_AsVal_int(swig_obj[3], &val);
45825 69 : if (!SWIG_IsOK(ecode)) {
45826 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALRIOResampleAlg");
45827 : }
45828 69 : if( val < 0 ||
45829 69 : ( val >= static_cast<int>(GRIORA_RESERVED_START) &&
45830 69 : val <= static_cast<int>(GRIORA_RESERVED_END) ) ||
45831 : val > static_cast<int>(GRIORA_LAST) )
45832 : {
45833 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for resample_alg");
45834 : }
45835 69 : arg4 = static_cast< GDALRIOResampleAlg >(val);
45836 : }
45837 69 : {
45838 69 : const int bLocalUseExceptions = GetUseExceptions();
45839 69 : if ( bLocalUseExceptions ) {
45840 68 : pushErrorHandler();
45841 : }
45842 69 : {
45843 69 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45844 69 : result = (CPLErr)GDALRasterBandShadow_InterpolateAtPoint(arg1,arg2,arg3,arg4,arg5,arg6);
45845 69 : SWIG_PYTHON_THREAD_END_ALLOW;
45846 : }
45847 69 : if ( bLocalUseExceptions ) {
45848 68 : popErrorHandler();
45849 : }
45850 : #ifndef SED_HACKS
45851 : if ( bLocalUseExceptions ) {
45852 : CPLErr eclass = CPLGetLastErrorType();
45853 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
45854 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
45855 : }
45856 : }
45857 : #endif
45858 : }
45859 69 : resultobj = SWIG_From_int(static_cast< int >(result));
45860 69 : if (ReturnSame(SWIG_IsTmpObj(res5))) {
45861 69 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
45862 : } else {
45863 0 : int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
45864 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
45865 : }
45866 69 : if (ReturnSame(SWIG_IsTmpObj(res6))) {
45867 69 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
45868 : } else {
45869 0 : int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
45870 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
45871 : }
45872 71 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
45873 : return resultobj;
45874 : fail:
45875 : return NULL;
45876 : }
45877 :
45878 :
45879 15 : SWIGINTERN PyObject *_wrap_Band_InterpolateAtGeolocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45880 15 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
45881 15 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
45882 15 : double arg2 ;
45883 15 : double arg3 ;
45884 15 : OSRSpatialReferenceShadow *arg4 = (OSRSpatialReferenceShadow *) 0 ;
45885 15 : GDALRIOResampleAlg arg5 ;
45886 15 : double *arg6 = (double *) 0 ;
45887 15 : double *arg7 = (double *) 0 ;
45888 15 : char **arg8 = (char **) NULL ;
45889 15 : void *argp1 = 0 ;
45890 15 : int res1 = 0 ;
45891 15 : double val2 ;
45892 15 : int ecode2 = 0 ;
45893 15 : double val3 ;
45894 15 : int ecode3 = 0 ;
45895 15 : void *argp4 = 0 ;
45896 15 : int res4 = 0 ;
45897 15 : double temp6 ;
45898 15 : int res6 = SWIG_TMPOBJ ;
45899 15 : double temp7 ;
45900 15 : int res7 = SWIG_TMPOBJ ;
45901 15 : PyObject *swig_obj[6] ;
45902 15 : CPLErr result;
45903 :
45904 15 : arg6 = &temp6;
45905 15 : arg7 = &temp7;
45906 15 : if (!SWIG_Python_UnpackTuple(args, "Band_InterpolateAtGeolocation", 5, 6, swig_obj)) SWIG_fail;
45907 15 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
45908 15 : if (!SWIG_IsOK(res1)) {
45909 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_InterpolateAtGeolocation" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
45910 : }
45911 15 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
45912 15 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
45913 15 : if (!SWIG_IsOK(ecode2)) {
45914 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_InterpolateAtGeolocation" "', argument " "2"" of type '" "double""'");
45915 : }
45916 15 : arg2 = static_cast< double >(val2);
45917 15 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
45918 15 : if (!SWIG_IsOK(ecode3)) {
45919 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_InterpolateAtGeolocation" "', argument " "3"" of type '" "double""'");
45920 : }
45921 15 : arg3 = static_cast< double >(val3);
45922 15 : res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 | 0 );
45923 15 : if (!SWIG_IsOK(res4)) {
45924 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Band_InterpolateAtGeolocation" "', argument " "4"" of type '" "OSRSpatialReferenceShadow *""'");
45925 : }
45926 15 : arg4 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp4);
45927 15 : {
45928 : // %typemap(in) GDALRIOResampleAlg
45929 15 : int val = 0;
45930 15 : int ecode = SWIG_AsVal_int(swig_obj[4], &val);
45931 15 : if (!SWIG_IsOK(ecode)) {
45932 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALRIOResampleAlg");
45933 : }
45934 15 : if( val < 0 ||
45935 15 : ( val >= static_cast<int>(GRIORA_RESERVED_START) &&
45936 15 : val <= static_cast<int>(GRIORA_RESERVED_END) ) ||
45937 : val > static_cast<int>(GRIORA_LAST) )
45938 : {
45939 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for resample_alg");
45940 : }
45941 15 : arg5 = static_cast< GDALRIOResampleAlg >(val);
45942 : }
45943 15 : if (swig_obj[5]) {
45944 0 : {
45945 : /* %typemap(in) char **dict */
45946 0 : arg8 = NULL;
45947 0 : if ( PySequence_Check( swig_obj[5] ) ) {
45948 0 : int bErr = FALSE;
45949 0 : arg8 = CSLFromPySequence(swig_obj[5], &bErr);
45950 0 : if ( bErr )
45951 : {
45952 0 : SWIG_fail;
45953 : }
45954 : }
45955 0 : else if ( PyMapping_Check( swig_obj[5] ) ) {
45956 0 : int bErr = FALSE;
45957 0 : arg8 = CSLFromPyMapping(swig_obj[5], &bErr);
45958 0 : if ( bErr )
45959 : {
45960 0 : SWIG_fail;
45961 : }
45962 : }
45963 : else {
45964 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
45965 0 : SWIG_fail;
45966 : }
45967 : }
45968 : }
45969 15 : {
45970 15 : const int bLocalUseExceptions = GetUseExceptions();
45971 15 : if ( bLocalUseExceptions ) {
45972 15 : pushErrorHandler();
45973 : }
45974 15 : {
45975 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
45976 15 : result = (CPLErr)GDALRasterBandShadow_InterpolateAtGeolocation(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
45977 15 : SWIG_PYTHON_THREAD_END_ALLOW;
45978 : }
45979 15 : if ( bLocalUseExceptions ) {
45980 15 : popErrorHandler();
45981 : }
45982 : #ifndef SED_HACKS
45983 : if ( bLocalUseExceptions ) {
45984 : CPLErr eclass = CPLGetLastErrorType();
45985 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
45986 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
45987 : }
45988 : }
45989 : #endif
45990 : }
45991 15 : resultobj = SWIG_From_int(static_cast< int >(result));
45992 15 : if (ReturnSame(SWIG_IsTmpObj(res6))) {
45993 15 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
45994 : } else {
45995 0 : int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
45996 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
45997 : }
45998 15 : if (ReturnSame(SWIG_IsTmpObj(res7))) {
45999 15 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
46000 : } else {
46001 0 : int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
46002 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
46003 : }
46004 15 : {
46005 : /* %typemap(freearg) char **dict */
46006 15 : CSLDestroy( arg8 );
46007 : }
46008 17 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46009 : return resultobj;
46010 0 : fail:
46011 0 : {
46012 : /* %typemap(freearg) char **dict */
46013 0 : CSLDestroy( arg8 );
46014 : }
46015 : return NULL;
46016 : }
46017 :
46018 :
46019 2 : SWIGINTERN PyObject *_wrap_Band_ComputeMinMaxLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46020 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46021 2 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
46022 2 : double *arg2 = (double *) 0 ;
46023 2 : double *arg3 = (double *) 0 ;
46024 2 : int *arg4 = (int *) 0 ;
46025 2 : int *arg5 = (int *) 0 ;
46026 2 : int *arg6 = (int *) 0 ;
46027 2 : int *arg7 = (int *) 0 ;
46028 2 : void *argp1 = 0 ;
46029 2 : int res1 = 0 ;
46030 2 : double temp2 ;
46031 2 : int res2 = SWIG_TMPOBJ ;
46032 2 : double temp3 ;
46033 2 : int res3 = SWIG_TMPOBJ ;
46034 2 : int temp4 ;
46035 2 : int res4 = SWIG_TMPOBJ ;
46036 2 : int temp5 ;
46037 2 : int res5 = SWIG_TMPOBJ ;
46038 2 : int temp6 ;
46039 2 : int res6 = SWIG_TMPOBJ ;
46040 2 : int temp7 ;
46041 2 : int res7 = SWIG_TMPOBJ ;
46042 2 : PyObject *swig_obj[1] ;
46043 2 : CPLErr result;
46044 :
46045 2 : arg2 = &temp2;
46046 2 : arg3 = &temp3;
46047 2 : arg4 = &temp4;
46048 2 : arg5 = &temp5;
46049 2 : arg6 = &temp6;
46050 2 : arg7 = &temp7;
46051 2 : if (!args) SWIG_fail;
46052 2 : swig_obj[0] = args;
46053 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
46054 2 : if (!SWIG_IsOK(res1)) {
46055 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_ComputeMinMaxLocation" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
46056 : }
46057 2 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
46058 2 : {
46059 2 : const int bLocalUseExceptions = GetUseExceptions();
46060 2 : if ( bLocalUseExceptions ) {
46061 0 : pushErrorHandler();
46062 : }
46063 2 : {
46064 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
46065 2 : result = (CPLErr)GDALRasterBandShadow_ComputeMinMaxLocation(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46066 2 : SWIG_PYTHON_THREAD_END_ALLOW;
46067 : }
46068 2 : if ( bLocalUseExceptions ) {
46069 0 : popErrorHandler();
46070 : }
46071 : #ifndef SED_HACKS
46072 : if ( bLocalUseExceptions ) {
46073 : CPLErr eclass = CPLGetLastErrorType();
46074 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
46075 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
46076 : }
46077 : }
46078 : #endif
46079 : }
46080 2 : resultobj = SWIG_From_int(static_cast< int >(result));
46081 2 : if (ReturnSame(SWIG_IsTmpObj(res2))) {
46082 2 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
46083 : } else {
46084 0 : int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
46085 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
46086 : }
46087 2 : if (ReturnSame(SWIG_IsTmpObj(res3))) {
46088 2 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
46089 : } else {
46090 0 : int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
46091 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
46092 : }
46093 2 : if (ReturnSame(SWIG_IsTmpObj(res4))) {
46094 2 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
46095 : } else {
46096 0 : int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
46097 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
46098 : }
46099 2 : if (ReturnSame(SWIG_IsTmpObj(res5))) {
46100 2 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
46101 : } else {
46102 0 : int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
46103 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
46104 : }
46105 2 : if (ReturnSame(SWIG_IsTmpObj(res6))) {
46106 2 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
46107 : } else {
46108 0 : int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
46109 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
46110 : }
46111 2 : if (ReturnSame(SWIG_IsTmpObj(res7))) {
46112 2 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg7)));
46113 : } else {
46114 0 : int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
46115 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
46116 : }
46117 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46118 : return resultobj;
46119 : fail:
46120 : return NULL;
46121 : }
46122 :
46123 :
46124 24 : SWIGINTERN PyObject *_wrap_Band_AsMDArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46125 24 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46126 24 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
46127 24 : void *argp1 = 0 ;
46128 24 : int res1 = 0 ;
46129 24 : PyObject *swig_obj[1] ;
46130 24 : GDALMDArrayHS *result = 0 ;
46131 :
46132 24 : if (!args) SWIG_fail;
46133 24 : swig_obj[0] = args;
46134 24 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
46135 24 : if (!SWIG_IsOK(res1)) {
46136 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_AsMDArray" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
46137 : }
46138 24 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
46139 24 : {
46140 24 : const int bLocalUseExceptions = GetUseExceptions();
46141 24 : if ( bLocalUseExceptions ) {
46142 3 : pushErrorHandler();
46143 : }
46144 24 : {
46145 24 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
46146 24 : result = (GDALMDArrayHS *)GDALRasterBandShadow_AsMDArray(arg1);
46147 24 : SWIG_PYTHON_THREAD_END_ALLOW;
46148 : }
46149 24 : if ( bLocalUseExceptions ) {
46150 3 : popErrorHandler();
46151 : }
46152 : #ifndef SED_HACKS
46153 : if ( bLocalUseExceptions ) {
46154 : CPLErr eclass = CPLGetLastErrorType();
46155 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
46156 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
46157 : }
46158 : }
46159 : #endif
46160 : }
46161 24 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMDArrayHS, SWIG_POINTER_OWN | 0 );
46162 24 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46163 : return resultobj;
46164 : fail:
46165 : return NULL;
46166 : }
46167 :
46168 :
46169 4902 : SWIGINTERN PyObject *_wrap_Band__EnablePixelTypeSignedByteWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46170 4902 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46171 4902 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
46172 4902 : bool arg2 ;
46173 4902 : void *argp1 = 0 ;
46174 4902 : int res1 = 0 ;
46175 4902 : bool val2 ;
46176 4902 : int ecode2 = 0 ;
46177 4902 : PyObject *swig_obj[2] ;
46178 :
46179 4902 : if (!SWIG_Python_UnpackTuple(args, "Band__EnablePixelTypeSignedByteWarning", 2, 2, swig_obj)) SWIG_fail;
46180 4902 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
46181 4902 : if (!SWIG_IsOK(res1)) {
46182 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band__EnablePixelTypeSignedByteWarning" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
46183 : }
46184 4902 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
46185 4902 : ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
46186 4902 : if (!SWIG_IsOK(ecode2)) {
46187 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band__EnablePixelTypeSignedByteWarning" "', argument " "2"" of type '" "bool""'");
46188 : }
46189 4902 : arg2 = static_cast< bool >(val2);
46190 4902 : {
46191 4902 : const int bLocalUseExceptions = GetUseExceptions();
46192 4902 : if ( bLocalUseExceptions ) {
46193 4494 : pushErrorHandler();
46194 : }
46195 4902 : {
46196 4902 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
46197 4902 : GDALRasterBandShadow__EnablePixelTypeSignedByteWarning(arg1,arg2);
46198 4902 : SWIG_PYTHON_THREAD_END_ALLOW;
46199 : }
46200 4902 : if ( bLocalUseExceptions ) {
46201 4494 : popErrorHandler();
46202 : }
46203 : #ifndef SED_HACKS
46204 : if ( bLocalUseExceptions ) {
46205 : CPLErr eclass = CPLGetLastErrorType();
46206 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
46207 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
46208 : }
46209 : }
46210 : #endif
46211 : }
46212 4902 : resultobj = SWIG_Py_Void();
46213 4902 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46214 : return resultobj;
46215 : fail:
46216 : return NULL;
46217 : }
46218 :
46219 :
46220 6 : SWIGINTERN PyObject *_wrap_Band_UnaryOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46221 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46222 6 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
46223 6 : GDALRasterAlgebraUnaryOperation arg2 ;
46224 6 : void *argp1 = 0 ;
46225 6 : int res1 = 0 ;
46226 6 : int val2 ;
46227 6 : int ecode2 = 0 ;
46228 6 : PyObject *swig_obj[2] ;
46229 6 : GDALComputedRasterBandShadow *result = 0 ;
46230 :
46231 6 : if (!SWIG_Python_UnpackTuple(args, "Band_UnaryOp", 2, 2, swig_obj)) SWIG_fail;
46232 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
46233 6 : if (!SWIG_IsOK(res1)) {
46234 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_UnaryOp" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
46235 : }
46236 6 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
46237 6 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
46238 6 : if (!SWIG_IsOK(ecode2)) {
46239 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_UnaryOp" "', argument " "2"" of type '" "GDALRasterAlgebraUnaryOperation""'");
46240 : }
46241 6 : arg2 = static_cast< GDALRasterAlgebraUnaryOperation >(val2);
46242 6 : {
46243 6 : const int bLocalUseExceptions = GetUseExceptions();
46244 6 : if ( bLocalUseExceptions ) {
46245 6 : pushErrorHandler();
46246 : }
46247 6 : {
46248 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
46249 6 : result = (GDALComputedRasterBandShadow *)GDALRasterBandShadow_UnaryOp(arg1,arg2);
46250 6 : SWIG_PYTHON_THREAD_END_ALLOW;
46251 : }
46252 6 : if ( bLocalUseExceptions ) {
46253 6 : popErrorHandler();
46254 : }
46255 : #ifndef SED_HACKS
46256 : if ( bLocalUseExceptions ) {
46257 : CPLErr eclass = CPLGetLastErrorType();
46258 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
46259 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
46260 : }
46261 : }
46262 : #endif
46263 : }
46264 6 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALComputedRasterBandShadow, SWIG_POINTER_OWN | 0 );
46265 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46266 : return resultobj;
46267 : fail:
46268 : return NULL;
46269 : }
46270 :
46271 :
46272 57 : SWIGINTERN PyObject *_wrap_Band_BinaryOpBand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46273 57 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46274 57 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
46275 57 : GDALRasterAlgebraBinaryOperation arg2 ;
46276 57 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
46277 57 : void *argp1 = 0 ;
46278 57 : int res1 = 0 ;
46279 57 : int val2 ;
46280 57 : int ecode2 = 0 ;
46281 57 : void *argp3 = 0 ;
46282 57 : int res3 = 0 ;
46283 57 : PyObject *swig_obj[3] ;
46284 57 : GDALComputedRasterBandShadow *result = 0 ;
46285 :
46286 57 : if (!SWIG_Python_UnpackTuple(args, "Band_BinaryOpBand", 3, 3, swig_obj)) SWIG_fail;
46287 57 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
46288 57 : if (!SWIG_IsOK(res1)) {
46289 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_BinaryOpBand" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
46290 : }
46291 57 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
46292 57 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
46293 57 : if (!SWIG_IsOK(ecode2)) {
46294 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_BinaryOpBand" "', argument " "2"" of type '" "GDALRasterAlgebraBinaryOperation""'");
46295 : }
46296 57 : arg2 = static_cast< GDALRasterAlgebraBinaryOperation >(val2);
46297 57 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
46298 57 : if (!SWIG_IsOK(res3)) {
46299 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Band_BinaryOpBand" "', argument " "3"" of type '" "GDALRasterBandShadow *""'");
46300 : }
46301 57 : arg3 = reinterpret_cast< GDALRasterBandShadow * >(argp3);
46302 57 : {
46303 57 : if (!arg3) {
46304 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
46305 : }
46306 : }
46307 57 : {
46308 57 : const int bLocalUseExceptions = GetUseExceptions();
46309 57 : if ( bLocalUseExceptions ) {
46310 57 : pushErrorHandler();
46311 : }
46312 57 : {
46313 57 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
46314 57 : result = (GDALComputedRasterBandShadow *)GDALRasterBandShadow_BinaryOpBand(arg1,arg2,arg3);
46315 57 : SWIG_PYTHON_THREAD_END_ALLOW;
46316 : }
46317 57 : if ( bLocalUseExceptions ) {
46318 57 : popErrorHandler();
46319 : }
46320 : #ifndef SED_HACKS
46321 : if ( bLocalUseExceptions ) {
46322 : CPLErr eclass = CPLGetLastErrorType();
46323 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
46324 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
46325 : }
46326 : }
46327 : #endif
46328 : }
46329 57 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALComputedRasterBandShadow, SWIG_POINTER_OWN | 0 );
46330 83 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46331 : return resultobj;
46332 : fail:
46333 : return NULL;
46334 : }
46335 :
46336 :
46337 59 : SWIGINTERN PyObject *_wrap_Band_BinaryOpDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46338 59 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46339 59 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
46340 59 : GDALRasterAlgebraBinaryOperation arg2 ;
46341 59 : double arg3 ;
46342 59 : void *argp1 = 0 ;
46343 59 : int res1 = 0 ;
46344 59 : int val2 ;
46345 59 : int ecode2 = 0 ;
46346 59 : double val3 ;
46347 59 : int ecode3 = 0 ;
46348 59 : PyObject *swig_obj[3] ;
46349 59 : GDALComputedRasterBandShadow *result = 0 ;
46350 :
46351 59 : if (!SWIG_Python_UnpackTuple(args, "Band_BinaryOpDouble", 3, 3, swig_obj)) SWIG_fail;
46352 59 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
46353 59 : if (!SWIG_IsOK(res1)) {
46354 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_BinaryOpDouble" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
46355 : }
46356 59 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
46357 59 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
46358 59 : if (!SWIG_IsOK(ecode2)) {
46359 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_BinaryOpDouble" "', argument " "2"" of type '" "GDALRasterAlgebraBinaryOperation""'");
46360 : }
46361 59 : arg2 = static_cast< GDALRasterAlgebraBinaryOperation >(val2);
46362 59 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
46363 59 : if (!SWIG_IsOK(ecode3)) {
46364 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_BinaryOpDouble" "', argument " "3"" of type '" "double""'");
46365 : }
46366 59 : arg3 = static_cast< double >(val3);
46367 59 : {
46368 59 : const int bLocalUseExceptions = GetUseExceptions();
46369 59 : if ( bLocalUseExceptions ) {
46370 59 : pushErrorHandler();
46371 : }
46372 59 : {
46373 59 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
46374 59 : result = (GDALComputedRasterBandShadow *)GDALRasterBandShadow_BinaryOpDouble(arg1,arg2,arg3);
46375 59 : SWIG_PYTHON_THREAD_END_ALLOW;
46376 : }
46377 59 : if ( bLocalUseExceptions ) {
46378 59 : popErrorHandler();
46379 : }
46380 : #ifndef SED_HACKS
46381 : if ( bLocalUseExceptions ) {
46382 : CPLErr eclass = CPLGetLastErrorType();
46383 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
46384 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
46385 : }
46386 : }
46387 : #endif
46388 : }
46389 59 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALComputedRasterBandShadow, SWIG_POINTER_OWN | 0 );
46390 59 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46391 : return resultobj;
46392 : fail:
46393 : return NULL;
46394 : }
46395 :
46396 :
46397 18 : SWIGINTERN PyObject *_wrap_Band_BinaryOpDoubleToBand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46398 18 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46399 18 : double arg1 ;
46400 18 : GDALRasterAlgebraBinaryOperation arg2 ;
46401 18 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
46402 18 : double val1 ;
46403 18 : int ecode1 = 0 ;
46404 18 : int val2 ;
46405 18 : int ecode2 = 0 ;
46406 18 : void *argp3 = 0 ;
46407 18 : int res3 = 0 ;
46408 18 : PyObject *swig_obj[3] ;
46409 18 : GDALComputedRasterBandShadow *result = 0 ;
46410 :
46411 18 : if (!SWIG_Python_UnpackTuple(args, "Band_BinaryOpDoubleToBand", 3, 3, swig_obj)) SWIG_fail;
46412 18 : ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
46413 18 : if (!SWIG_IsOK(ecode1)) {
46414 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Band_BinaryOpDoubleToBand" "', argument " "1"" of type '" "double""'");
46415 : }
46416 18 : arg1 = static_cast< double >(val1);
46417 18 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
46418 18 : if (!SWIG_IsOK(ecode2)) {
46419 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_BinaryOpDoubleToBand" "', argument " "2"" of type '" "GDALRasterAlgebraBinaryOperation""'");
46420 : }
46421 18 : arg2 = static_cast< GDALRasterAlgebraBinaryOperation >(val2);
46422 18 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
46423 18 : if (!SWIG_IsOK(res3)) {
46424 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Band_BinaryOpDoubleToBand" "', argument " "3"" of type '" "GDALRasterBandShadow *""'");
46425 : }
46426 18 : arg3 = reinterpret_cast< GDALRasterBandShadow * >(argp3);
46427 18 : {
46428 18 : if (!arg3) {
46429 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
46430 : }
46431 : }
46432 18 : {
46433 18 : const int bLocalUseExceptions = GetUseExceptions();
46434 18 : if ( bLocalUseExceptions ) {
46435 18 : pushErrorHandler();
46436 : }
46437 18 : {
46438 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
46439 18 : result = (GDALComputedRasterBandShadow *)GDALRasterBandShadow_BinaryOpDoubleToBand(arg1,arg2,arg3);
46440 18 : SWIG_PYTHON_THREAD_END_ALLOW;
46441 : }
46442 18 : if ( bLocalUseExceptions ) {
46443 18 : popErrorHandler();
46444 : }
46445 : #ifndef SED_HACKS
46446 : if ( bLocalUseExceptions ) {
46447 : CPLErr eclass = CPLGetLastErrorType();
46448 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
46449 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
46450 : }
46451 : }
46452 : #endif
46453 : }
46454 18 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALComputedRasterBandShadow, SWIG_POINTER_OWN | 0 );
46455 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46456 : return resultobj;
46457 : fail:
46458 : return NULL;
46459 : }
46460 :
46461 :
46462 12 : SWIGINTERN PyObject *_wrap_Band_IfThenElse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46463 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46464 12 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
46465 12 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
46466 12 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
46467 12 : void *argp1 = 0 ;
46468 12 : int res1 = 0 ;
46469 12 : void *argp2 = 0 ;
46470 12 : int res2 = 0 ;
46471 12 : void *argp3 = 0 ;
46472 12 : int res3 = 0 ;
46473 12 : PyObject *swig_obj[3] ;
46474 12 : GDALComputedRasterBandShadow *result = 0 ;
46475 :
46476 12 : if (!SWIG_Python_UnpackTuple(args, "Band_IfThenElse", 3, 3, swig_obj)) SWIG_fail;
46477 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
46478 12 : if (!SWIG_IsOK(res1)) {
46479 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_IfThenElse" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
46480 : }
46481 12 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
46482 12 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
46483 12 : if (!SWIG_IsOK(res2)) {
46484 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Band_IfThenElse" "', argument " "2"" of type '" "GDALRasterBandShadow *""'");
46485 : }
46486 12 : arg2 = reinterpret_cast< GDALRasterBandShadow * >(argp2);
46487 12 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
46488 12 : if (!SWIG_IsOK(res3)) {
46489 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Band_IfThenElse" "', argument " "3"" of type '" "GDALRasterBandShadow *""'");
46490 : }
46491 12 : arg3 = reinterpret_cast< GDALRasterBandShadow * >(argp3);
46492 12 : {
46493 12 : if (!arg1) {
46494 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
46495 : }
46496 : }
46497 12 : {
46498 12 : if (!arg2) {
46499 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
46500 : }
46501 : }
46502 12 : {
46503 12 : if (!arg3) {
46504 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
46505 : }
46506 : }
46507 12 : {
46508 12 : const int bLocalUseExceptions = GetUseExceptions();
46509 12 : if ( bLocalUseExceptions ) {
46510 12 : pushErrorHandler();
46511 : }
46512 12 : {
46513 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
46514 12 : result = (GDALComputedRasterBandShadow *)GDALRasterBandShadow_IfThenElse(arg1,arg2,arg3);
46515 12 : SWIG_PYTHON_THREAD_END_ALLOW;
46516 : }
46517 12 : if ( bLocalUseExceptions ) {
46518 12 : popErrorHandler();
46519 : }
46520 : #ifndef SED_HACKS
46521 : if ( bLocalUseExceptions ) {
46522 : CPLErr eclass = CPLGetLastErrorType();
46523 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
46524 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
46525 : }
46526 : }
46527 : #endif
46528 : }
46529 12 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALComputedRasterBandShadow, SWIG_POINTER_OWN | 0 );
46530 16 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46531 : return resultobj;
46532 : fail:
46533 : return NULL;
46534 : }
46535 :
46536 :
46537 16 : SWIGINTERN PyObject *_wrap_Band_AsType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46538 16 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46539 16 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
46540 16 : GDALDataType arg2 ;
46541 16 : void *argp1 = 0 ;
46542 16 : int res1 = 0 ;
46543 16 : PyObject *swig_obj[2] ;
46544 16 : GDALComputedRasterBandShadow *result = 0 ;
46545 :
46546 16 : if (!SWIG_Python_UnpackTuple(args, "Band_AsType", 2, 2, swig_obj)) SWIG_fail;
46547 16 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
46548 16 : if (!SWIG_IsOK(res1)) {
46549 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_AsType" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
46550 : }
46551 16 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
46552 16 : {
46553 : // %typemap(in) GDALDataType
46554 16 : int val = 0;
46555 16 : int ecode = SWIG_AsVal_int(swig_obj[1], &val);
46556 16 : if (!SWIG_IsOK(ecode)) {
46557 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
46558 : }
46559 16 : if( val < GDT_Unknown || val >= GDT_TypeCount )
46560 : {
46561 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
46562 : }
46563 16 : arg2 = static_cast<GDALDataType>(val);
46564 : }
46565 16 : {
46566 16 : const int bLocalUseExceptions = GetUseExceptions();
46567 16 : if ( bLocalUseExceptions ) {
46568 16 : pushErrorHandler();
46569 : }
46570 16 : {
46571 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
46572 16 : result = (GDALComputedRasterBandShadow *)GDALRasterBandShadow_AsType(arg1,arg2);
46573 16 : SWIG_PYTHON_THREAD_END_ALLOW;
46574 : }
46575 16 : if ( bLocalUseExceptions ) {
46576 16 : popErrorHandler();
46577 : }
46578 : #ifndef SED_HACKS
46579 : if ( bLocalUseExceptions ) {
46580 : CPLErr eclass = CPLGetLastErrorType();
46581 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
46582 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
46583 : }
46584 : }
46585 : #endif
46586 : }
46587 16 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALComputedRasterBandShadow, SWIG_POINTER_OWN | 0 );
46588 18 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46589 : return resultobj;
46590 : fail:
46591 : return NULL;
46592 : }
46593 :
46594 :
46595 4 : SWIGINTERN PyObject *_wrap_Band_MaximumOfNBands(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46596 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46597 4 : int arg1 ;
46598 4 : GDALRasterBandShadow **arg2 = (GDALRasterBandShadow **) 0 ;
46599 4 : PyObject *swig_obj[1] ;
46600 4 : GDALComputedRasterBandShadow *result = 0 ;
46601 :
46602 4 : if (!args) SWIG_fail;
46603 4 : swig_obj[0] = args;
46604 4 : {
46605 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALRasterBandShadow *optional_##GDALRasterBandShadow)*/
46606 4 : if ( !PySequence_Check(swig_obj[0]) ) {
46607 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
46608 0 : SWIG_fail;
46609 : }
46610 4 : Py_ssize_t size = PySequence_Size(swig_obj[0]);
46611 4 : if( size > (Py_ssize_t)INT_MAX ) {
46612 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
46613 0 : SWIG_fail;
46614 : }
46615 4 : if( (size_t)size > SIZE_MAX / sizeof(GDALRasterBandShadow*) ) {
46616 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
46617 0 : SWIG_fail;
46618 : }
46619 4 : arg1 = (int)size;
46620 4 : arg2 = (GDALRasterBandShadow**) VSIMalloc(arg1*sizeof(GDALRasterBandShadow*));
46621 4 : if( !arg2) {
46622 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
46623 0 : SWIG_fail;
46624 : }
46625 :
46626 12 : for( int i = 0; i<arg1; i++ ) {
46627 8 : PyObject *o = PySequence_GetItem(swig_obj[0],i);
46628 8 : GDALRasterBandShadow* rawobjectpointer = NULL;
46629 8 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALRasterBandShadow, SWIG_POINTER_EXCEPTION | 0 ));
46630 8 : if (!rawobjectpointer) {
46631 0 : Py_DECREF(o);
46632 0 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALRasterBandShadow");
46633 0 : SWIG_fail;
46634 : }
46635 8 : arg2[i] = rawobjectpointer;
46636 8 : Py_DECREF(o);
46637 :
46638 : }
46639 : }
46640 4 : {
46641 4 : const int bLocalUseExceptions = GetUseExceptions();
46642 4 : if ( bLocalUseExceptions ) {
46643 4 : pushErrorHandler();
46644 : }
46645 4 : {
46646 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
46647 4 : result = (GDALComputedRasterBandShadow *)GDALRasterBandShadow_MaximumOfNBands(arg1,arg2);
46648 4 : SWIG_PYTHON_THREAD_END_ALLOW;
46649 : }
46650 4 : if ( bLocalUseExceptions ) {
46651 4 : popErrorHandler();
46652 : }
46653 : #ifndef SED_HACKS
46654 : if ( bLocalUseExceptions ) {
46655 : CPLErr eclass = CPLGetLastErrorType();
46656 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
46657 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
46658 : }
46659 : }
46660 : #endif
46661 : }
46662 4 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALComputedRasterBandShadow, SWIG_POINTER_OWN | 0 );
46663 4 : {
46664 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALRasterBandShadow **poObjects)*/
46665 4 : CPLFree( arg2 );
46666 : }
46667 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46668 : return resultobj;
46669 0 : fail:
46670 0 : {
46671 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALRasterBandShadow **poObjects)*/
46672 0 : CPLFree( arg2 );
46673 : }
46674 : return NULL;
46675 : }
46676 :
46677 :
46678 2 : SWIGINTERN PyObject *_wrap_Band_MaxConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46679 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46680 2 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
46681 2 : double arg2 ;
46682 2 : void *argp1 = 0 ;
46683 2 : int res1 = 0 ;
46684 2 : double val2 ;
46685 2 : int ecode2 = 0 ;
46686 2 : PyObject *swig_obj[2] ;
46687 2 : GDALComputedRasterBandShadow *result = 0 ;
46688 :
46689 2 : if (!SWIG_Python_UnpackTuple(args, "Band_MaxConstant", 2, 2, swig_obj)) SWIG_fail;
46690 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
46691 2 : if (!SWIG_IsOK(res1)) {
46692 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_MaxConstant" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
46693 : }
46694 2 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
46695 2 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
46696 2 : if (!SWIG_IsOK(ecode2)) {
46697 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_MaxConstant" "', argument " "2"" of type '" "double""'");
46698 : }
46699 2 : arg2 = static_cast< double >(val2);
46700 2 : {
46701 2 : const int bLocalUseExceptions = GetUseExceptions();
46702 2 : if ( bLocalUseExceptions ) {
46703 2 : pushErrorHandler();
46704 : }
46705 2 : {
46706 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
46707 2 : result = (GDALComputedRasterBandShadow *)GDALRasterBandShadow_MaxConstant(arg1,arg2);
46708 2 : SWIG_PYTHON_THREAD_END_ALLOW;
46709 : }
46710 2 : if ( bLocalUseExceptions ) {
46711 2 : popErrorHandler();
46712 : }
46713 : #ifndef SED_HACKS
46714 : if ( bLocalUseExceptions ) {
46715 : CPLErr eclass = CPLGetLastErrorType();
46716 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
46717 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
46718 : }
46719 : }
46720 : #endif
46721 : }
46722 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALComputedRasterBandShadow, SWIG_POINTER_OWN | 0 );
46723 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46724 : return resultobj;
46725 : fail:
46726 : return NULL;
46727 : }
46728 :
46729 :
46730 4 : SWIGINTERN PyObject *_wrap_Band_MinimumOfNBands(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46731 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46732 4 : int arg1 ;
46733 4 : GDALRasterBandShadow **arg2 = (GDALRasterBandShadow **) 0 ;
46734 4 : PyObject *swig_obj[1] ;
46735 4 : GDALComputedRasterBandShadow *result = 0 ;
46736 :
46737 4 : if (!args) SWIG_fail;
46738 4 : swig_obj[0] = args;
46739 4 : {
46740 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALRasterBandShadow *optional_##GDALRasterBandShadow)*/
46741 4 : if ( !PySequence_Check(swig_obj[0]) ) {
46742 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
46743 0 : SWIG_fail;
46744 : }
46745 4 : Py_ssize_t size = PySequence_Size(swig_obj[0]);
46746 4 : if( size > (Py_ssize_t)INT_MAX ) {
46747 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
46748 0 : SWIG_fail;
46749 : }
46750 4 : if( (size_t)size > SIZE_MAX / sizeof(GDALRasterBandShadow*) ) {
46751 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
46752 0 : SWIG_fail;
46753 : }
46754 4 : arg1 = (int)size;
46755 4 : arg2 = (GDALRasterBandShadow**) VSIMalloc(arg1*sizeof(GDALRasterBandShadow*));
46756 4 : if( !arg2) {
46757 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
46758 0 : SWIG_fail;
46759 : }
46760 :
46761 12 : for( int i = 0; i<arg1; i++ ) {
46762 8 : PyObject *o = PySequence_GetItem(swig_obj[0],i);
46763 8 : GDALRasterBandShadow* rawobjectpointer = NULL;
46764 8 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALRasterBandShadow, SWIG_POINTER_EXCEPTION | 0 ));
46765 8 : if (!rawobjectpointer) {
46766 0 : Py_DECREF(o);
46767 0 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALRasterBandShadow");
46768 0 : SWIG_fail;
46769 : }
46770 8 : arg2[i] = rawobjectpointer;
46771 8 : Py_DECREF(o);
46772 :
46773 : }
46774 : }
46775 4 : {
46776 4 : const int bLocalUseExceptions = GetUseExceptions();
46777 4 : if ( bLocalUseExceptions ) {
46778 4 : pushErrorHandler();
46779 : }
46780 4 : {
46781 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
46782 4 : result = (GDALComputedRasterBandShadow *)GDALRasterBandShadow_MinimumOfNBands(arg1,arg2);
46783 4 : SWIG_PYTHON_THREAD_END_ALLOW;
46784 : }
46785 4 : if ( bLocalUseExceptions ) {
46786 4 : popErrorHandler();
46787 : }
46788 : #ifndef SED_HACKS
46789 : if ( bLocalUseExceptions ) {
46790 : CPLErr eclass = CPLGetLastErrorType();
46791 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
46792 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
46793 : }
46794 : }
46795 : #endif
46796 : }
46797 4 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALComputedRasterBandShadow, SWIG_POINTER_OWN | 0 );
46798 4 : {
46799 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALRasterBandShadow **poObjects)*/
46800 4 : CPLFree( arg2 );
46801 : }
46802 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46803 : return resultobj;
46804 0 : fail:
46805 0 : {
46806 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALRasterBandShadow **poObjects)*/
46807 0 : CPLFree( arg2 );
46808 : }
46809 : return NULL;
46810 : }
46811 :
46812 :
46813 2 : SWIGINTERN PyObject *_wrap_Band_MinConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46814 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46815 2 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
46816 2 : double arg2 ;
46817 2 : void *argp1 = 0 ;
46818 2 : int res1 = 0 ;
46819 2 : double val2 ;
46820 2 : int ecode2 = 0 ;
46821 2 : PyObject *swig_obj[2] ;
46822 2 : GDALComputedRasterBandShadow *result = 0 ;
46823 :
46824 2 : if (!SWIG_Python_UnpackTuple(args, "Band_MinConstant", 2, 2, swig_obj)) SWIG_fail;
46825 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
46826 2 : if (!SWIG_IsOK(res1)) {
46827 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_MinConstant" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
46828 : }
46829 2 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
46830 2 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
46831 2 : if (!SWIG_IsOK(ecode2)) {
46832 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_MinConstant" "', argument " "2"" of type '" "double""'");
46833 : }
46834 2 : arg2 = static_cast< double >(val2);
46835 2 : {
46836 2 : const int bLocalUseExceptions = GetUseExceptions();
46837 2 : if ( bLocalUseExceptions ) {
46838 2 : pushErrorHandler();
46839 : }
46840 2 : {
46841 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
46842 2 : result = (GDALComputedRasterBandShadow *)GDALRasterBandShadow_MinConstant(arg1,arg2);
46843 2 : SWIG_PYTHON_THREAD_END_ALLOW;
46844 : }
46845 2 : if ( bLocalUseExceptions ) {
46846 2 : popErrorHandler();
46847 : }
46848 : #ifndef SED_HACKS
46849 : if ( bLocalUseExceptions ) {
46850 : CPLErr eclass = CPLGetLastErrorType();
46851 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
46852 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
46853 : }
46854 : }
46855 : #endif
46856 : }
46857 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALComputedRasterBandShadow, SWIG_POINTER_OWN | 0 );
46858 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46859 : return resultobj;
46860 : fail:
46861 : return NULL;
46862 : }
46863 :
46864 :
46865 3 : SWIGINTERN PyObject *_wrap_Band_MeanOfNBands(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46866 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46867 3 : int arg1 ;
46868 3 : GDALRasterBandShadow **arg2 = (GDALRasterBandShadow **) 0 ;
46869 3 : PyObject *swig_obj[1] ;
46870 3 : GDALComputedRasterBandShadow *result = 0 ;
46871 :
46872 3 : if (!args) SWIG_fail;
46873 3 : swig_obj[0] = args;
46874 3 : {
46875 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALRasterBandShadow *optional_##GDALRasterBandShadow)*/
46876 3 : if ( !PySequence_Check(swig_obj[0]) ) {
46877 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
46878 0 : SWIG_fail;
46879 : }
46880 3 : Py_ssize_t size = PySequence_Size(swig_obj[0]);
46881 3 : if( size > (Py_ssize_t)INT_MAX ) {
46882 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
46883 0 : SWIG_fail;
46884 : }
46885 3 : if( (size_t)size > SIZE_MAX / sizeof(GDALRasterBandShadow*) ) {
46886 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
46887 0 : SWIG_fail;
46888 : }
46889 3 : arg1 = (int)size;
46890 3 : arg2 = (GDALRasterBandShadow**) VSIMalloc(arg1*sizeof(GDALRasterBandShadow*));
46891 3 : if( !arg2) {
46892 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
46893 0 : SWIG_fail;
46894 : }
46895 :
46896 7 : for( int i = 0; i<arg1; i++ ) {
46897 4 : PyObject *o = PySequence_GetItem(swig_obj[0],i);
46898 4 : GDALRasterBandShadow* rawobjectpointer = NULL;
46899 4 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALRasterBandShadow, SWIG_POINTER_EXCEPTION | 0 ));
46900 4 : if (!rawobjectpointer) {
46901 0 : Py_DECREF(o);
46902 0 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALRasterBandShadow");
46903 0 : SWIG_fail;
46904 : }
46905 4 : arg2[i] = rawobjectpointer;
46906 4 : Py_DECREF(o);
46907 :
46908 : }
46909 : }
46910 3 : {
46911 3 : const int bLocalUseExceptions = GetUseExceptions();
46912 3 : if ( bLocalUseExceptions ) {
46913 3 : pushErrorHandler();
46914 : }
46915 3 : {
46916 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
46917 3 : result = (GDALComputedRasterBandShadow *)GDALRasterBandShadow_MeanOfNBands(arg1,arg2);
46918 3 : SWIG_PYTHON_THREAD_END_ALLOW;
46919 : }
46920 3 : if ( bLocalUseExceptions ) {
46921 3 : popErrorHandler();
46922 : }
46923 : #ifndef SED_HACKS
46924 : if ( bLocalUseExceptions ) {
46925 : CPLErr eclass = CPLGetLastErrorType();
46926 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
46927 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
46928 : }
46929 : }
46930 : #endif
46931 : }
46932 3 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALComputedRasterBandShadow, SWIG_POINTER_OWN | 0 );
46933 3 : {
46934 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALRasterBandShadow **poObjects)*/
46935 3 : CPLFree( arg2 );
46936 : }
46937 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
46938 : return resultobj;
46939 0 : fail:
46940 0 : {
46941 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALRasterBandShadow **poObjects)*/
46942 0 : CPLFree( arg2 );
46943 : }
46944 : return NULL;
46945 : }
46946 :
46947 :
46948 10259 : SWIGINTERN PyObject *_wrap_Band_ReadRaster1(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46949 10259 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
46950 10259 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
46951 10259 : double arg2 ;
46952 10259 : double arg3 ;
46953 10259 : double arg4 ;
46954 10259 : double arg5 ;
46955 10259 : void **arg6 = (void **) 0 ;
46956 10259 : int *arg7 = (int *) 0 ;
46957 10259 : int *arg8 = (int *) 0 ;
46958 10259 : GDALDataType *arg9 = (GDALDataType *) 0 ;
46959 10259 : GIntBig *arg10 = (GIntBig *) 0 ;
46960 10259 : GIntBig *arg11 = (GIntBig *) 0 ;
46961 10259 : GDALRIOResampleAlg arg12 = (GDALRIOResampleAlg) GRIORA_NearestNeighbour ;
46962 10259 : GDALProgressFunc arg13 = (GDALProgressFunc) NULL ;
46963 10259 : void *arg14 = (void *) NULL ;
46964 10259 : void *arg15 = (void *) NULL ;
46965 10259 : void *argp1 = 0 ;
46966 10259 : int res1 = 0 ;
46967 10259 : double val2 ;
46968 10259 : int ecode2 = 0 ;
46969 10259 : double val3 ;
46970 10259 : int ecode3 = 0 ;
46971 10259 : double val4 ;
46972 10259 : int ecode4 = 0 ;
46973 10259 : double val5 ;
46974 10259 : int ecode5 = 0 ;
46975 10259 : void *pyObject6 = NULL ;
46976 10259 : int val7 ;
46977 10259 : int val8 ;
46978 10259 : GDALDataType val9 ;
46979 10259 : GIntBig val10 ;
46980 10259 : GIntBig val11 ;
46981 10259 : PyObject * obj0 = 0 ;
46982 10259 : PyObject * obj1 = 0 ;
46983 10259 : PyObject * obj2 = 0 ;
46984 10259 : PyObject * obj3 = 0 ;
46985 10259 : PyObject * obj4 = 0 ;
46986 10259 : PyObject * obj5 = 0 ;
46987 10259 : PyObject * obj6 = 0 ;
46988 10259 : PyObject * obj7 = 0 ;
46989 10259 : PyObject * obj8 = 0 ;
46990 10259 : PyObject * obj9 = 0 ;
46991 10259 : PyObject * obj10 = 0 ;
46992 10259 : PyObject * obj11 = 0 ;
46993 10259 : PyObject * obj12 = 0 ;
46994 10259 : PyObject * obj13 = 0 ;
46995 10259 : char * kwnames[] = {
46996 : (char *)"self", (char *)"xoff", (char *)"yoff", (char *)"xsize", (char *)"ysize", (char *)"buf_xsize", (char *)"buf_ysize", (char *)"buf_type", (char *)"buf_pixel_space", (char *)"buf_line_space", (char *)"resample_alg", (char *)"callback", (char *)"callback_data", (char *)"inputOutputBuf", NULL
46997 : };
46998 10259 : CPLErr result;
46999 :
47000 : /* %typemap(arginit) ( const char* callback_data=NULL) */
47001 10259 : PyProgressData *psProgressInfo;
47002 10259 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
47003 10259 : psProgressInfo->nLastReported = -1;
47004 10259 : psProgressInfo->psPyCallback = NULL;
47005 10259 : psProgressInfo->psPyCallbackData = NULL;
47006 10259 : arg14 = psProgressInfo;
47007 10259 : {
47008 : /* %typemap(in,numinputs=0) ( void **outPythonObject ) ( void *pyObject6 = NULL ) */
47009 10259 : arg6 = &pyObject6;
47010 : }
47011 10259 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OOOOOOOOO:Band_ReadRaster1", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13)) SWIG_fail;
47012 10259 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
47013 10259 : if (!SWIG_IsOK(res1)) {
47014 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_ReadRaster1" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
47015 : }
47016 10259 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
47017 10259 : ecode2 = SWIG_AsVal_double(obj1, &val2);
47018 10259 : if (!SWIG_IsOK(ecode2)) {
47019 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_ReadRaster1" "', argument " "2"" of type '" "double""'");
47020 : }
47021 10259 : arg2 = static_cast< double >(val2);
47022 10259 : ecode3 = SWIG_AsVal_double(obj2, &val3);
47023 10259 : if (!SWIG_IsOK(ecode3)) {
47024 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_ReadRaster1" "', argument " "3"" of type '" "double""'");
47025 : }
47026 10259 : arg3 = static_cast< double >(val3);
47027 10259 : ecode4 = SWIG_AsVal_double(obj3, &val4);
47028 10259 : if (!SWIG_IsOK(ecode4)) {
47029 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Band_ReadRaster1" "', argument " "4"" of type '" "double""'");
47030 : }
47031 10259 : arg4 = static_cast< double >(val4);
47032 10259 : ecode5 = SWIG_AsVal_double(obj4, &val5);
47033 10259 : if (!SWIG_IsOK(ecode5)) {
47034 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Band_ReadRaster1" "', argument " "5"" of type '" "double""'");
47035 : }
47036 10259 : arg5 = static_cast< double >(val5);
47037 10259 : if (obj5) {
47038 10259 : {
47039 : /* %typemap(in) (int *optional_##int) */
47040 10259 : if ( obj5 == Py_None ) {
47041 : arg7 = 0;
47042 : }
47043 1564 : else if ( PyArg_Parse( obj5,"i" ,&val7 ) ) {
47044 : arg7 = (int *) &val7;
47045 : }
47046 : else {
47047 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
47048 0 : SWIG_fail;
47049 : }
47050 : }
47051 : }
47052 10259 : if (obj6) {
47053 10259 : {
47054 : /* %typemap(in) (int *optional_##int) */
47055 10259 : if ( obj6 == Py_None ) {
47056 : arg8 = 0;
47057 : }
47058 1562 : else if ( PyArg_Parse( obj6,"i" ,&val8 ) ) {
47059 : arg8 = (int *) &val8;
47060 : }
47061 : else {
47062 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
47063 0 : SWIG_fail;
47064 : }
47065 : }
47066 : }
47067 10259 : if (obj7) {
47068 10259 : {
47069 : /* %typemap(in) (GDALDataType *optional_GDALDataType) */
47070 10259 : int intval = 0;
47071 10259 : if ( obj7 == Py_None ) {
47072 : arg9 = NULL;
47073 : }
47074 2302 : else if ( SWIG_IsOK(SWIG_AsVal_int(obj7, &intval)) ) {
47075 1151 : if( intval < GDT_Unknown || intval >= GDT_TypeCount )
47076 : {
47077 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
47078 : }
47079 1151 : val9 = static_cast<GDALDataType>(intval);
47080 1151 : arg9 = &val9;
47081 : }
47082 : else {
47083 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
47084 0 : SWIG_fail;
47085 : }
47086 : }
47087 : }
47088 10259 : if (obj8) {
47089 10259 : {
47090 : /* %typemap(in) (GIntBig *optional_##GIntBig) */
47091 10259 : if ( obj8 == Py_None ) {
47092 : arg10 = 0;
47093 : }
47094 181 : else if ( PyArg_Parse( obj8,"L" ,&val10 ) ) {
47095 : arg10 = (GIntBig *) &val10;
47096 : }
47097 : else {
47098 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
47099 0 : SWIG_fail;
47100 : }
47101 : }
47102 : }
47103 10259 : if (obj9) {
47104 10259 : {
47105 : /* %typemap(in) (GIntBig *optional_##GIntBig) */
47106 10259 : if ( obj9 == Py_None ) {
47107 : arg11 = 0;
47108 : }
47109 36 : else if ( PyArg_Parse( obj9,"L" ,&val11 ) ) {
47110 : arg11 = (GIntBig *) &val11;
47111 : }
47112 : else {
47113 0 : PyErr_SetString( PyExc_TypeError, "Invalid Parameter" );
47114 0 : SWIG_fail;
47115 : }
47116 : }
47117 : }
47118 10259 : if (obj10) {
47119 10259 : {
47120 : // %typemap(in) GDALRIOResampleAlg
47121 10259 : int val = 0;
47122 10259 : int ecode = SWIG_AsVal_int(obj10, &val);
47123 10259 : if (!SWIG_IsOK(ecode)) {
47124 1 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALRIOResampleAlg");
47125 : }
47126 10258 : if( val < 0 ||
47127 10257 : ( val >= static_cast<int>(GRIORA_RESERVED_START) &&
47128 10256 : val <= static_cast<int>(GRIORA_RESERVED_END) ) ||
47129 : val > static_cast<int>(GRIORA_LAST) )
47130 : {
47131 2 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for resample_alg");
47132 : }
47133 : arg12 = static_cast< GDALRIOResampleAlg >(val);
47134 : }
47135 : }
47136 10256 : if (obj11) {
47137 10256 : {
47138 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
47139 : /* callback_func typemap */
47140 :
47141 : /* In some cases 0 is passed instead of None. */
47142 : /* See https://github.com/OSGeo/gdal/pull/219 */
47143 10256 : if ( PyLong_Check(obj11) || PyInt_Check(obj11) )
47144 : {
47145 0 : if( PyLong_AsLong(obj11) == 0 )
47146 : {
47147 0 : obj11 = Py_None;
47148 : }
47149 : }
47150 :
47151 10256 : if (obj11 && obj11 != Py_None ) {
47152 19 : void* cbfunction = NULL;
47153 19 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj11,
47154 : (void**)&cbfunction,
47155 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
47156 : SWIG_POINTER_EXCEPTION | 0 ));
47157 :
47158 19 : if ( cbfunction == GDALTermProgress ) {
47159 : arg13 = GDALTermProgress;
47160 : } else {
47161 19 : if (!PyCallable_Check(obj11)) {
47162 0 : PyErr_SetString( PyExc_RuntimeError,
47163 : "Object given is not a Python function" );
47164 0 : SWIG_fail;
47165 : }
47166 19 : psProgressInfo->psPyCallback = obj11;
47167 19 : arg13 = PyProgressProxy;
47168 : }
47169 :
47170 : }
47171 :
47172 : }
47173 : }
47174 10256 : if (obj12) {
47175 10256 : {
47176 : /* %typemap(in) ( void* callback_data=NULL) */
47177 10256 : psProgressInfo->psPyCallbackData = obj12 ;
47178 : }
47179 : }
47180 10256 : if (obj13) {
47181 10256 : {
47182 : /* %typemap(in) ( void *inPythonObject ) */
47183 10256 : arg15 = obj13;
47184 : }
47185 : }
47186 10256 : {
47187 10256 : const int bLocalUseExceptions = GetUseExceptions();
47188 10256 : if ( bLocalUseExceptions ) {
47189 4864 : pushErrorHandler();
47190 : }
47191 10256 : {
47192 10256 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
47193 10256 : result = (CPLErr)GDALRasterBandShadow_ReadRaster1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
47194 10256 : SWIG_PYTHON_THREAD_END_ALLOW;
47195 : }
47196 10256 : if ( bLocalUseExceptions ) {
47197 4864 : popErrorHandler();
47198 : }
47199 : #ifndef SED_HACKS
47200 : if ( bLocalUseExceptions ) {
47201 : CPLErr eclass = CPLGetLastErrorType();
47202 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
47203 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
47204 : }
47205 : }
47206 : #endif
47207 : }
47208 10256 : resultobj = SWIG_From_int(static_cast< int >(result));
47209 10256 : {
47210 : /* %typemap(argout) ( void **outPythonObject ) */
47211 10256 : Py_XDECREF(resultobj);
47212 10256 : if (*arg6)
47213 : {
47214 : resultobj = (PyObject*)*arg6;
47215 : }
47216 : else
47217 : {
47218 50 : resultobj = Py_None;
47219 50 : Py_INCREF(resultobj);
47220 : }
47221 : }
47222 10256 : {
47223 : /* %typemap(freearg) ( void* callback_data=NULL) */
47224 :
47225 10256 : CPLFree(psProgressInfo);
47226 :
47227 : }
47228 10271 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
47229 : return resultobj;
47230 3 : fail:
47231 3 : {
47232 : /* %typemap(freearg) ( void* callback_data=NULL) */
47233 :
47234 3 : CPLFree(psProgressInfo);
47235 :
47236 : }
47237 : return NULL;
47238 : }
47239 :
47240 :
47241 90 : SWIGINTERN PyObject *_wrap_Band_ReadBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47242 90 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
47243 90 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
47244 90 : int arg2 ;
47245 90 : int arg3 ;
47246 90 : void **arg4 = (void **) 0 ;
47247 90 : void *arg5 = (void *) NULL ;
47248 90 : void *argp1 = 0 ;
47249 90 : int res1 = 0 ;
47250 90 : int val2 ;
47251 90 : int ecode2 = 0 ;
47252 90 : int val3 ;
47253 90 : int ecode3 = 0 ;
47254 90 : void *pyObject4 = NULL ;
47255 90 : PyObject * obj0 = 0 ;
47256 90 : PyObject * obj1 = 0 ;
47257 90 : PyObject * obj2 = 0 ;
47258 90 : PyObject * obj3 = 0 ;
47259 90 : char * kwnames[] = {
47260 : (char *)"self", (char *)"xoff", (char *)"yoff", (char *)"buf_obj", NULL
47261 : };
47262 90 : CPLErr result;
47263 :
47264 90 : {
47265 : /* %typemap(in,numinputs=0) ( void **outPythonObject ) ( void *pyObject4 = NULL ) */
47266 90 : arg4 = &pyObject4;
47267 : }
47268 90 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Band_ReadBlock", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
47269 90 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
47270 90 : if (!SWIG_IsOK(res1)) {
47271 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Band_ReadBlock" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
47272 : }
47273 90 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
47274 90 : ecode2 = SWIG_AsVal_int(obj1, &val2);
47275 90 : if (!SWIG_IsOK(ecode2)) {
47276 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Band_ReadBlock" "', argument " "2"" of type '" "int""'");
47277 : }
47278 90 : arg2 = static_cast< int >(val2);
47279 90 : ecode3 = SWIG_AsVal_int(obj2, &val3);
47280 90 : if (!SWIG_IsOK(ecode3)) {
47281 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Band_ReadBlock" "', argument " "3"" of type '" "int""'");
47282 : }
47283 90 : arg3 = static_cast< int >(val3);
47284 90 : if (obj3) {
47285 25 : {
47286 : /* %typemap(in) ( void *inPythonObject ) */
47287 25 : arg5 = obj3;
47288 : }
47289 : }
47290 90 : {
47291 90 : const int bLocalUseExceptions = GetUseExceptions();
47292 90 : if ( bLocalUseExceptions ) {
47293 34 : pushErrorHandler();
47294 : }
47295 90 : {
47296 90 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
47297 90 : result = (CPLErr)GDALRasterBandShadow_ReadBlock(arg1,arg2,arg3,arg4,arg5);
47298 90 : SWIG_PYTHON_THREAD_END_ALLOW;
47299 : }
47300 90 : if ( bLocalUseExceptions ) {
47301 34 : popErrorHandler();
47302 : }
47303 : #ifndef SED_HACKS
47304 : if ( bLocalUseExceptions ) {
47305 : CPLErr eclass = CPLGetLastErrorType();
47306 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
47307 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
47308 : }
47309 : }
47310 : #endif
47311 : }
47312 90 : resultobj = SWIG_From_int(static_cast< int >(result));
47313 90 : {
47314 : /* %typemap(argout) ( void **outPythonObject ) */
47315 90 : Py_XDECREF(resultobj);
47316 90 : if (*arg4)
47317 : {
47318 : resultobj = (PyObject*)*arg4;
47319 : }
47320 : else
47321 : {
47322 16 : resultobj = Py_None;
47323 16 : Py_INCREF(resultobj);
47324 : }
47325 : }
47326 90 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
47327 : return resultobj;
47328 : fail:
47329 : return NULL;
47330 : }
47331 :
47332 :
47333 277 : SWIGINTERN PyObject *Band_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47334 277 : PyObject *obj;
47335 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
47336 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALRasterBandShadow, SWIG_NewClientData(obj));
47337 277 : return SWIG_Py_Void();
47338 : }
47339 :
47340 163 : SWIGINTERN PyObject *_wrap_delete_ComputedBand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47341 163 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
47342 163 : GDALComputedRasterBandShadow *arg1 = (GDALComputedRasterBandShadow *) 0 ;
47343 163 : void *argp1 = 0 ;
47344 163 : int res1 = 0 ;
47345 163 : PyObject *swig_obj[1] ;
47346 :
47347 163 : if (!args) SWIG_fail;
47348 163 : swig_obj[0] = args;
47349 163 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALComputedRasterBandShadow, SWIG_POINTER_DISOWN | 0 );
47350 163 : if (!SWIG_IsOK(res1)) {
47351 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComputedBand" "', argument " "1"" of type '" "GDALComputedRasterBandShadow *""'");
47352 : }
47353 163 : arg1 = reinterpret_cast< GDALComputedRasterBandShadow * >(argp1);
47354 163 : {
47355 163 : const int bLocalUseExceptions = GetUseExceptions();
47356 163 : if ( bLocalUseExceptions ) {
47357 163 : pushErrorHandler();
47358 : }
47359 163 : {
47360 163 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
47361 163 : delete_GDALComputedRasterBandShadow(arg1);
47362 163 : SWIG_PYTHON_THREAD_END_ALLOW;
47363 : }
47364 163 : if ( bLocalUseExceptions ) {
47365 163 : popErrorHandler();
47366 : }
47367 : #ifndef SED_HACKS
47368 : if ( bLocalUseExceptions ) {
47369 : CPLErr eclass = CPLGetLastErrorType();
47370 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
47371 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
47372 : }
47373 : }
47374 : #endif
47375 : }
47376 163 : resultobj = SWIG_Py_Void();
47377 163 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
47378 : return resultobj;
47379 : fail:
47380 : return NULL;
47381 : }
47382 :
47383 :
47384 277 : SWIGINTERN PyObject *ComputedBand_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47385 277 : PyObject *obj;
47386 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
47387 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALComputedRasterBandShadow, SWIG_NewClientData(obj));
47388 277 : return SWIG_Py_Void();
47389 : }
47390 :
47391 56 : SWIGINTERN PyObject *_wrap_new_ColorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47392 56 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
47393 56 : GDALPaletteInterp arg1 = (GDALPaletteInterp) GPI_RGB ;
47394 56 : int val1 ;
47395 56 : int ecode1 = 0 ;
47396 56 : PyObject * obj0 = 0 ;
47397 56 : char * kwnames[] = {
47398 : (char *)"palette", NULL
47399 : };
47400 56 : GDALColorTableShadow *result = 0 ;
47401 :
47402 56 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_ColorTable", kwnames, &obj0)) SWIG_fail;
47403 56 : if (obj0) {
47404 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
47405 0 : if (!SWIG_IsOK(ecode1)) {
47406 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColorTable" "', argument " "1"" of type '" "GDALPaletteInterp""'");
47407 : }
47408 0 : arg1 = static_cast< GDALPaletteInterp >(val1);
47409 : }
47410 56 : {
47411 56 : const int bLocalUseExceptions = GetUseExceptions();
47412 56 : if ( bLocalUseExceptions ) {
47413 28 : pushErrorHandler();
47414 : }
47415 56 : {
47416 56 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
47417 56 : result = (GDALColorTableShadow *)new_GDALColorTableShadow(arg1);
47418 56 : SWIG_PYTHON_THREAD_END_ALLOW;
47419 : }
47420 56 : if ( bLocalUseExceptions ) {
47421 28 : popErrorHandler();
47422 : }
47423 : #ifndef SED_HACKS
47424 : if ( bLocalUseExceptions ) {
47425 : CPLErr eclass = CPLGetLastErrorType();
47426 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
47427 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
47428 : }
47429 : }
47430 : #endif
47431 : }
47432 56 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALColorTableShadow, SWIG_POINTER_NEW | 0 );
47433 56 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
47434 : return resultobj;
47435 : fail:
47436 : return NULL;
47437 : }
47438 :
47439 :
47440 68 : SWIGINTERN PyObject *_wrap_delete_ColorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47441 68 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
47442 68 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
47443 68 : void *argp1 = 0 ;
47444 68 : int res1 = 0 ;
47445 68 : PyObject *swig_obj[1] ;
47446 :
47447 68 : if (!args) SWIG_fail;
47448 68 : swig_obj[0] = args;
47449 68 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALColorTableShadow, SWIG_POINTER_DISOWN | 0 );
47450 68 : if (!SWIG_IsOK(res1)) {
47451 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColorTable" "', argument " "1"" of type '" "GDALColorTableShadow *""'");
47452 : }
47453 68 : arg1 = reinterpret_cast< GDALColorTableShadow * >(argp1);
47454 68 : {
47455 68 : const int bLocalUseExceptions = GetUseExceptions();
47456 68 : if ( bLocalUseExceptions ) {
47457 36 : pushErrorHandler();
47458 : }
47459 68 : {
47460 68 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
47461 68 : delete_GDALColorTableShadow(arg1);
47462 68 : SWIG_PYTHON_THREAD_END_ALLOW;
47463 : }
47464 68 : if ( bLocalUseExceptions ) {
47465 36 : popErrorHandler();
47466 : }
47467 : #ifndef SED_HACKS
47468 : if ( bLocalUseExceptions ) {
47469 : CPLErr eclass = CPLGetLastErrorType();
47470 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
47471 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
47472 : }
47473 : }
47474 : #endif
47475 : }
47476 68 : resultobj = SWIG_Py_Void();
47477 68 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
47478 : return resultobj;
47479 : fail:
47480 : return NULL;
47481 : }
47482 :
47483 :
47484 12 : SWIGINTERN PyObject *_wrap_ColorTable_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47485 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
47486 12 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
47487 12 : void *argp1 = 0 ;
47488 12 : int res1 = 0 ;
47489 12 : PyObject *swig_obj[1] ;
47490 12 : GDALColorTableShadow *result = 0 ;
47491 :
47492 12 : if (!args) SWIG_fail;
47493 12 : swig_obj[0] = args;
47494 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALColorTableShadow, 0 | 0 );
47495 12 : if (!SWIG_IsOK(res1)) {
47496 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorTable_Clone" "', argument " "1"" of type '" "GDALColorTableShadow *""'");
47497 : }
47498 12 : arg1 = reinterpret_cast< GDALColorTableShadow * >(argp1);
47499 12 : {
47500 12 : const int bLocalUseExceptions = GetUseExceptions();
47501 12 : if ( bLocalUseExceptions ) {
47502 8 : pushErrorHandler();
47503 : }
47504 12 : {
47505 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
47506 12 : result = (GDALColorTableShadow *)GDALColorTableShadow_Clone(arg1);
47507 12 : SWIG_PYTHON_THREAD_END_ALLOW;
47508 : }
47509 12 : if ( bLocalUseExceptions ) {
47510 8 : popErrorHandler();
47511 : }
47512 : #ifndef SED_HACKS
47513 : if ( bLocalUseExceptions ) {
47514 : CPLErr eclass = CPLGetLastErrorType();
47515 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
47516 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
47517 : }
47518 : }
47519 : #endif
47520 : }
47521 12 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALColorTableShadow, SWIG_POINTER_OWN | 0 );
47522 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
47523 : return resultobj;
47524 : fail:
47525 : return NULL;
47526 : }
47527 :
47528 :
47529 2 : SWIGINTERN PyObject *_wrap_ColorTable_GetPaletteInterpretation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47530 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
47531 2 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
47532 2 : void *argp1 = 0 ;
47533 2 : int res1 = 0 ;
47534 2 : PyObject *swig_obj[1] ;
47535 2 : GDALPaletteInterp result;
47536 :
47537 2 : if (!args) SWIG_fail;
47538 2 : swig_obj[0] = args;
47539 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALColorTableShadow, 0 | 0 );
47540 2 : if (!SWIG_IsOK(res1)) {
47541 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorTable_GetPaletteInterpretation" "', argument " "1"" of type '" "GDALColorTableShadow *""'");
47542 : }
47543 2 : arg1 = reinterpret_cast< GDALColorTableShadow * >(argp1);
47544 2 : {
47545 2 : const int bLocalUseExceptions = GetUseExceptions();
47546 2 : if ( bLocalUseExceptions ) {
47547 0 : pushErrorHandler();
47548 : }
47549 2 : {
47550 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
47551 2 : result = (GDALPaletteInterp)GDALColorTableShadow_GetPaletteInterpretation(arg1);
47552 2 : SWIG_PYTHON_THREAD_END_ALLOW;
47553 : }
47554 2 : if ( bLocalUseExceptions ) {
47555 0 : popErrorHandler();
47556 : }
47557 : #ifndef SED_HACKS
47558 : if ( bLocalUseExceptions ) {
47559 : CPLErr eclass = CPLGetLastErrorType();
47560 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
47561 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
47562 : }
47563 : }
47564 : #endif
47565 : }
47566 2 : resultobj = SWIG_From_int(static_cast< int >(result));
47567 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
47568 : return resultobj;
47569 : fail:
47570 : return NULL;
47571 : }
47572 :
47573 :
47574 73 : SWIGINTERN PyObject *_wrap_ColorTable_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47575 73 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
47576 73 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
47577 73 : void *argp1 = 0 ;
47578 73 : int res1 = 0 ;
47579 73 : PyObject *swig_obj[1] ;
47580 73 : int result;
47581 :
47582 73 : if (!args) SWIG_fail;
47583 73 : swig_obj[0] = args;
47584 73 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALColorTableShadow, 0 | 0 );
47585 73 : if (!SWIG_IsOK(res1)) {
47586 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorTable_GetCount" "', argument " "1"" of type '" "GDALColorTableShadow *""'");
47587 : }
47588 73 : arg1 = reinterpret_cast< GDALColorTableShadow * >(argp1);
47589 73 : {
47590 73 : const int bLocalUseExceptions = GetUseExceptions();
47591 73 : if ( bLocalUseExceptions ) {
47592 52 : pushErrorHandler();
47593 : }
47594 73 : {
47595 73 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
47596 73 : result = (int)GDALColorTableShadow_GetColorEntryCount(arg1);
47597 73 : SWIG_PYTHON_THREAD_END_ALLOW;
47598 : }
47599 73 : if ( bLocalUseExceptions ) {
47600 52 : popErrorHandler();
47601 : }
47602 : #ifndef SED_HACKS
47603 : if ( bLocalUseExceptions ) {
47604 : CPLErr eclass = CPLGetLastErrorType();
47605 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
47606 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
47607 : }
47608 : }
47609 : #endif
47610 : }
47611 73 : resultobj = SWIG_From_int(static_cast< int >(result));
47612 73 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
47613 : return resultobj;
47614 : fail:
47615 : return NULL;
47616 : }
47617 :
47618 :
47619 4719 : SWIGINTERN PyObject *_wrap_ColorTable_GetColorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47620 4719 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
47621 4719 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
47622 4719 : int arg2 ;
47623 4719 : void *argp1 = 0 ;
47624 4719 : int res1 = 0 ;
47625 4719 : int val2 ;
47626 4719 : int ecode2 = 0 ;
47627 4719 : PyObject *swig_obj[2] ;
47628 4719 : GDALColorEntry *result = 0 ;
47629 :
47630 4719 : if (!SWIG_Python_UnpackTuple(args, "ColorTable_GetColorEntry", 2, 2, swig_obj)) SWIG_fail;
47631 4719 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALColorTableShadow, 0 | 0 );
47632 4719 : if (!SWIG_IsOK(res1)) {
47633 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorTable_GetColorEntry" "', argument " "1"" of type '" "GDALColorTableShadow *""'");
47634 : }
47635 4719 : arg1 = reinterpret_cast< GDALColorTableShadow * >(argp1);
47636 4719 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
47637 4719 : if (!SWIG_IsOK(ecode2)) {
47638 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorTable_GetColorEntry" "', argument " "2"" of type '" "int""'");
47639 : }
47640 4719 : arg2 = static_cast< int >(val2);
47641 4719 : {
47642 4719 : const int bLocalUseExceptions = GetUseExceptions();
47643 4719 : if ( bLocalUseExceptions ) {
47644 4634 : pushErrorHandler();
47645 : }
47646 4719 : {
47647 4719 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
47648 4719 : result = (GDALColorEntry *)GDALColorTableShadow_GetColorEntry(arg1,arg2);
47649 4719 : SWIG_PYTHON_THREAD_END_ALLOW;
47650 : }
47651 4719 : if ( bLocalUseExceptions ) {
47652 4634 : popErrorHandler();
47653 : }
47654 : #ifndef SED_HACKS
47655 : if ( bLocalUseExceptions ) {
47656 : CPLErr eclass = CPLGetLastErrorType();
47657 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
47658 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
47659 : }
47660 : }
47661 : #endif
47662 : }
47663 4719 : {
47664 : /* %typemap(out) GDALColorEntry* */
47665 4719 : if ( result != NULL )
47666 4719 : resultobj = Py_BuildValue( "(hhhh)", (*result).c1,(*result).c2,(*result).c3,(*result).c4);
47667 : else
47668 : resultobj = NULL;
47669 : }
47670 4719 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
47671 : return resultobj;
47672 : fail:
47673 : return NULL;
47674 : }
47675 :
47676 :
47677 0 : SWIGINTERN PyObject *_wrap_ColorTable_GetColorEntryAsRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47678 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
47679 0 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
47680 0 : int arg2 ;
47681 0 : GDALColorEntry *arg3 = (GDALColorEntry *) 0 ;
47682 0 : void *argp1 = 0 ;
47683 0 : int res1 = 0 ;
47684 0 : int val2 ;
47685 0 : int ecode2 = 0 ;
47686 0 : GDALColorEntry ce3 ;
47687 0 : PyObject *swig_obj[3] ;
47688 0 : int result;
47689 :
47690 0 : if (!SWIG_Python_UnpackTuple(args, "ColorTable_GetColorEntryAsRGB", 3, 3, swig_obj)) SWIG_fail;
47691 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALColorTableShadow, 0 | 0 );
47692 0 : if (!SWIG_IsOK(res1)) {
47693 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorTable_GetColorEntryAsRGB" "', argument " "1"" of type '" "GDALColorTableShadow *""'");
47694 : }
47695 0 : arg1 = reinterpret_cast< GDALColorTableShadow * >(argp1);
47696 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
47697 0 : if (!SWIG_IsOK(ecode2)) {
47698 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorTable_GetColorEntryAsRGB" "', argument " "2"" of type '" "int""'");
47699 : }
47700 0 : arg2 = static_cast< int >(val2);
47701 0 : {
47702 : /* %typemap(in) GDALColorEntry* */
47703 0 : ce3.c4 = 255;
47704 0 : if (! PySequence_Check(swig_obj[2]) ) {
47705 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
47706 0 : SWIG_fail;
47707 : }
47708 0 : Py_ssize_t size = PySequence_Size(swig_obj[2]);
47709 0 : if ( size > 4 ) {
47710 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too long");
47711 0 : SWIG_fail;
47712 : }
47713 0 : if ( size < 3 ) {
47714 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too short");
47715 0 : SWIG_fail;
47716 : }
47717 0 : if ( !PyArg_ParseTuple( swig_obj[2],"hhh|h", &ce3.c1, &ce3.c2, &ce3.c3, &ce3.c4 ) ) {
47718 0 : PyErr_SetString(PyExc_TypeError, "Invalid values in ColorEntry sequence ");
47719 0 : SWIG_fail;
47720 : }
47721 0 : arg3 = &ce3;
47722 : }
47723 0 : {
47724 0 : const int bLocalUseExceptions = GetUseExceptions();
47725 0 : if ( bLocalUseExceptions ) {
47726 0 : pushErrorHandler();
47727 : }
47728 0 : {
47729 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
47730 0 : result = (int)GDALColorTableShadow_GetColorEntryAsRGB(arg1,arg2,arg3);
47731 0 : SWIG_PYTHON_THREAD_END_ALLOW;
47732 : }
47733 0 : if ( bLocalUseExceptions ) {
47734 0 : popErrorHandler();
47735 : }
47736 : #ifndef SED_HACKS
47737 : if ( bLocalUseExceptions ) {
47738 : CPLErr eclass = CPLGetLastErrorType();
47739 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
47740 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
47741 : }
47742 : }
47743 : #endif
47744 : }
47745 0 : resultobj = SWIG_From_int(static_cast< int >(result));
47746 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
47747 : return resultobj;
47748 : fail:
47749 : return NULL;
47750 : }
47751 :
47752 :
47753 1379 : SWIGINTERN PyObject *_wrap_ColorTable_SetColorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47754 1379 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
47755 1379 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
47756 1379 : int arg2 ;
47757 1379 : GDALColorEntry *arg3 = (GDALColorEntry *) 0 ;
47758 1379 : void *argp1 = 0 ;
47759 1379 : int res1 = 0 ;
47760 1379 : int val2 ;
47761 1379 : int ecode2 = 0 ;
47762 1379 : GDALColorEntry ce3 ;
47763 1379 : PyObject *swig_obj[3] ;
47764 :
47765 1379 : if (!SWIG_Python_UnpackTuple(args, "ColorTable_SetColorEntry", 3, 3, swig_obj)) SWIG_fail;
47766 1379 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALColorTableShadow, 0 | 0 );
47767 1379 : if (!SWIG_IsOK(res1)) {
47768 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorTable_SetColorEntry" "', argument " "1"" of type '" "GDALColorTableShadow *""'");
47769 : }
47770 1379 : arg1 = reinterpret_cast< GDALColorTableShadow * >(argp1);
47771 1379 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
47772 1379 : if (!SWIG_IsOK(ecode2)) {
47773 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorTable_SetColorEntry" "', argument " "2"" of type '" "int""'");
47774 : }
47775 1379 : arg2 = static_cast< int >(val2);
47776 1379 : {
47777 : /* %typemap(in) GDALColorEntry* */
47778 1379 : ce3.c4 = 255;
47779 1379 : if (! PySequence_Check(swig_obj[2]) ) {
47780 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
47781 0 : SWIG_fail;
47782 : }
47783 1379 : Py_ssize_t size = PySequence_Size(swig_obj[2]);
47784 1379 : if ( size > 4 ) {
47785 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too long");
47786 0 : SWIG_fail;
47787 : }
47788 1379 : if ( size < 3 ) {
47789 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too short");
47790 0 : SWIG_fail;
47791 : }
47792 1379 : if ( !PyArg_ParseTuple( swig_obj[2],"hhh|h", &ce3.c1, &ce3.c2, &ce3.c3, &ce3.c4 ) ) {
47793 0 : PyErr_SetString(PyExc_TypeError, "Invalid values in ColorEntry sequence ");
47794 0 : SWIG_fail;
47795 : }
47796 1379 : arg3 = &ce3;
47797 : }
47798 1379 : {
47799 1379 : const int bLocalUseExceptions = GetUseExceptions();
47800 1379 : if ( bLocalUseExceptions ) {
47801 1313 : pushErrorHandler();
47802 : }
47803 1379 : {
47804 1379 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
47805 1379 : GDALColorTableShadow_SetColorEntry(arg1,arg2,(GDALColorEntry const *)arg3);
47806 1379 : SWIG_PYTHON_THREAD_END_ALLOW;
47807 : }
47808 1379 : if ( bLocalUseExceptions ) {
47809 1313 : popErrorHandler();
47810 : }
47811 : #ifndef SED_HACKS
47812 : if ( bLocalUseExceptions ) {
47813 : CPLErr eclass = CPLGetLastErrorType();
47814 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
47815 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
47816 : }
47817 : }
47818 : #endif
47819 : }
47820 1379 : resultobj = SWIG_Py_Void();
47821 1379 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
47822 : return resultobj;
47823 : fail:
47824 : return NULL;
47825 : }
47826 :
47827 :
47828 1 : SWIGINTERN PyObject *_wrap_ColorTable_CreateColorRamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47829 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
47830 1 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
47831 1 : int arg2 ;
47832 1 : GDALColorEntry *arg3 = (GDALColorEntry *) 0 ;
47833 1 : int arg4 ;
47834 1 : GDALColorEntry *arg5 = (GDALColorEntry *) 0 ;
47835 1 : void *argp1 = 0 ;
47836 1 : int res1 = 0 ;
47837 1 : int val2 ;
47838 1 : int ecode2 = 0 ;
47839 1 : GDALColorEntry ce3 ;
47840 1 : int val4 ;
47841 1 : int ecode4 = 0 ;
47842 1 : GDALColorEntry ce5 ;
47843 1 : PyObject *swig_obj[5] ;
47844 :
47845 1 : if (!SWIG_Python_UnpackTuple(args, "ColorTable_CreateColorRamp", 5, 5, swig_obj)) SWIG_fail;
47846 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALColorTableShadow, 0 | 0 );
47847 1 : if (!SWIG_IsOK(res1)) {
47848 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorTable_CreateColorRamp" "', argument " "1"" of type '" "GDALColorTableShadow *""'");
47849 : }
47850 1 : arg1 = reinterpret_cast< GDALColorTableShadow * >(argp1);
47851 1 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
47852 1 : if (!SWIG_IsOK(ecode2)) {
47853 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorTable_CreateColorRamp" "', argument " "2"" of type '" "int""'");
47854 : }
47855 1 : arg2 = static_cast< int >(val2);
47856 1 : {
47857 : /* %typemap(in) GDALColorEntry* */
47858 1 : ce3.c4 = 255;
47859 1 : if (! PySequence_Check(swig_obj[2]) ) {
47860 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
47861 0 : SWIG_fail;
47862 : }
47863 1 : Py_ssize_t size = PySequence_Size(swig_obj[2]);
47864 1 : if ( size > 4 ) {
47865 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too long");
47866 0 : SWIG_fail;
47867 : }
47868 1 : if ( size < 3 ) {
47869 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too short");
47870 0 : SWIG_fail;
47871 : }
47872 1 : if ( !PyArg_ParseTuple( swig_obj[2],"hhh|h", &ce3.c1, &ce3.c2, &ce3.c3, &ce3.c4 ) ) {
47873 0 : PyErr_SetString(PyExc_TypeError, "Invalid values in ColorEntry sequence ");
47874 0 : SWIG_fail;
47875 : }
47876 1 : arg3 = &ce3;
47877 : }
47878 1 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
47879 1 : if (!SWIG_IsOK(ecode4)) {
47880 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ColorTable_CreateColorRamp" "', argument " "4"" of type '" "int""'");
47881 : }
47882 1 : arg4 = static_cast< int >(val4);
47883 1 : {
47884 : /* %typemap(in) GDALColorEntry* */
47885 1 : ce5.c4 = 255;
47886 1 : if (! PySequence_Check(swig_obj[4]) ) {
47887 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
47888 0 : SWIG_fail;
47889 : }
47890 1 : Py_ssize_t size = PySequence_Size(swig_obj[4]);
47891 1 : if ( size > 4 ) {
47892 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too long");
47893 0 : SWIG_fail;
47894 : }
47895 1 : if ( size < 3 ) {
47896 0 : PyErr_SetString(PyExc_TypeError, "ColorEntry sequence too short");
47897 0 : SWIG_fail;
47898 : }
47899 1 : if ( !PyArg_ParseTuple( swig_obj[4],"hhh|h", &ce5.c1, &ce5.c2, &ce5.c3, &ce5.c4 ) ) {
47900 0 : PyErr_SetString(PyExc_TypeError, "Invalid values in ColorEntry sequence ");
47901 0 : SWIG_fail;
47902 : }
47903 1 : arg5 = &ce5;
47904 : }
47905 1 : {
47906 1 : const int bLocalUseExceptions = GetUseExceptions();
47907 1 : if ( bLocalUseExceptions ) {
47908 1 : pushErrorHandler();
47909 : }
47910 1 : {
47911 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
47912 1 : GDALColorTableShadow_CreateColorRamp(arg1,arg2,(GDALColorEntry const *)arg3,arg4,(GDALColorEntry const *)arg5);
47913 1 : SWIG_PYTHON_THREAD_END_ALLOW;
47914 : }
47915 1 : if ( bLocalUseExceptions ) {
47916 1 : popErrorHandler();
47917 : }
47918 : #ifndef SED_HACKS
47919 : if ( bLocalUseExceptions ) {
47920 : CPLErr eclass = CPLGetLastErrorType();
47921 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
47922 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
47923 : }
47924 : }
47925 : #endif
47926 : }
47927 1 : resultobj = SWIG_Py_Void();
47928 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
47929 : return resultobj;
47930 : fail:
47931 : return NULL;
47932 : }
47933 :
47934 :
47935 277 : SWIGINTERN PyObject *ColorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47936 277 : PyObject *obj;
47937 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
47938 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALColorTableShadow, SWIG_NewClientData(obj));
47939 277 : return SWIG_Py_Void();
47940 : }
47941 :
47942 56 : SWIGINTERN PyObject *ColorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47943 56 : return SWIG_Python_InitShadowInstance(args);
47944 : }
47945 :
47946 60 : SWIGINTERN PyObject *_wrap_delete_SubdatasetInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47947 60 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
47948 60 : GDALSubdatasetInfoShadow *arg1 = (GDALSubdatasetInfoShadow *) 0 ;
47949 60 : void *argp1 = 0 ;
47950 60 : int res1 = 0 ;
47951 60 : PyObject *swig_obj[1] ;
47952 :
47953 60 : if (!args) SWIG_fail;
47954 60 : swig_obj[0] = args;
47955 60 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALSubdatasetInfo, SWIG_POINTER_DISOWN | 0 );
47956 60 : if (!SWIG_IsOK(res1)) {
47957 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SubdatasetInfo" "', argument " "1"" of type '" "GDALSubdatasetInfoShadow *""'");
47958 : }
47959 60 : arg1 = reinterpret_cast< GDALSubdatasetInfoShadow * >(argp1);
47960 60 : {
47961 60 : const int bLocalUseExceptions = GetUseExceptions();
47962 60 : if ( bLocalUseExceptions ) {
47963 36 : pushErrorHandler();
47964 : }
47965 60 : {
47966 60 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
47967 60 : delete_GDALSubdatasetInfoShadow(arg1);
47968 60 : SWIG_PYTHON_THREAD_END_ALLOW;
47969 : }
47970 60 : if ( bLocalUseExceptions ) {
47971 36 : popErrorHandler();
47972 : }
47973 : #ifndef SED_HACKS
47974 : if ( bLocalUseExceptions ) {
47975 : CPLErr eclass = CPLGetLastErrorType();
47976 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
47977 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
47978 : }
47979 : }
47980 : #endif
47981 : }
47982 60 : resultobj = SWIG_Py_Void();
47983 60 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
47984 : return resultobj;
47985 : fail:
47986 : return NULL;
47987 : }
47988 :
47989 :
47990 35 : SWIGINTERN PyObject *_wrap_SubdatasetInfo_GetPathComponent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47991 35 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
47992 35 : GDALSubdatasetInfoShadow *arg1 = (GDALSubdatasetInfoShadow *) 0 ;
47993 35 : void *argp1 = 0 ;
47994 35 : int res1 = 0 ;
47995 35 : PyObject *swig_obj[1] ;
47996 35 : retStringAndCPLFree *result = 0 ;
47997 :
47998 35 : if (!args) SWIG_fail;
47999 35 : swig_obj[0] = args;
48000 35 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALSubdatasetInfo, 0 | 0 );
48001 35 : if (!SWIG_IsOK(res1)) {
48002 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubdatasetInfo_GetPathComponent" "', argument " "1"" of type '" "GDALSubdatasetInfoShadow *""'");
48003 : }
48004 35 : arg1 = reinterpret_cast< GDALSubdatasetInfoShadow * >(argp1);
48005 35 : {
48006 35 : const int bLocalUseExceptions = GetUseExceptions();
48007 35 : if ( bLocalUseExceptions ) {
48008 19 : pushErrorHandler();
48009 : }
48010 35 : {
48011 35 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48012 35 : result = (retStringAndCPLFree *)GDALSubdatasetInfoShadow_GetPathComponent(arg1);
48013 35 : SWIG_PYTHON_THREAD_END_ALLOW;
48014 : }
48015 35 : if ( bLocalUseExceptions ) {
48016 19 : popErrorHandler();
48017 : }
48018 : #ifndef SED_HACKS
48019 : if ( bLocalUseExceptions ) {
48020 : CPLErr eclass = CPLGetLastErrorType();
48021 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48022 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48023 : }
48024 : }
48025 : #endif
48026 : }
48027 35 : {
48028 : /* %typemap(out) (retStringAndCPLFree*) */
48029 35 : Py_XDECREF(resultobj);
48030 35 : if(result)
48031 : {
48032 35 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
48033 35 : CPLFree(result);
48034 : }
48035 : else
48036 : {
48037 0 : resultobj = Py_None;
48038 0 : Py_INCREF(resultobj);
48039 : }
48040 : }
48041 35 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48042 : return resultobj;
48043 : fail:
48044 : return NULL;
48045 : }
48046 :
48047 :
48048 39 : SWIGINTERN PyObject *_wrap_SubdatasetInfo_GetSubdatasetComponent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48049 39 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48050 39 : GDALSubdatasetInfoShadow *arg1 = (GDALSubdatasetInfoShadow *) 0 ;
48051 39 : void *argp1 = 0 ;
48052 39 : int res1 = 0 ;
48053 39 : PyObject *swig_obj[1] ;
48054 39 : retStringAndCPLFree *result = 0 ;
48055 :
48056 39 : if (!args) SWIG_fail;
48057 39 : swig_obj[0] = args;
48058 39 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALSubdatasetInfo, 0 | 0 );
48059 39 : if (!SWIG_IsOK(res1)) {
48060 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubdatasetInfo_GetSubdatasetComponent" "', argument " "1"" of type '" "GDALSubdatasetInfoShadow *""'");
48061 : }
48062 39 : arg1 = reinterpret_cast< GDALSubdatasetInfoShadow * >(argp1);
48063 39 : {
48064 39 : const int bLocalUseExceptions = GetUseExceptions();
48065 39 : if ( bLocalUseExceptions ) {
48066 23 : pushErrorHandler();
48067 : }
48068 39 : {
48069 39 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48070 39 : result = (retStringAndCPLFree *)GDALSubdatasetInfoShadow_GetSubdatasetComponent(arg1);
48071 39 : SWIG_PYTHON_THREAD_END_ALLOW;
48072 : }
48073 39 : if ( bLocalUseExceptions ) {
48074 23 : popErrorHandler();
48075 : }
48076 : #ifndef SED_HACKS
48077 : if ( bLocalUseExceptions ) {
48078 : CPLErr eclass = CPLGetLastErrorType();
48079 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48080 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48081 : }
48082 : }
48083 : #endif
48084 : }
48085 39 : {
48086 : /* %typemap(out) (retStringAndCPLFree*) */
48087 39 : Py_XDECREF(resultobj);
48088 39 : if(result)
48089 : {
48090 39 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
48091 39 : CPLFree(result);
48092 : }
48093 : else
48094 : {
48095 0 : resultobj = Py_None;
48096 0 : Py_INCREF(resultobj);
48097 : }
48098 : }
48099 39 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48100 : return resultobj;
48101 : fail:
48102 : return NULL;
48103 : }
48104 :
48105 :
48106 21 : SWIGINTERN PyObject *_wrap_SubdatasetInfo_ModifyPathComponent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48107 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48108 21 : GDALSubdatasetInfoShadow *arg1 = (GDALSubdatasetInfoShadow *) 0 ;
48109 21 : char *arg2 = (char *) 0 ;
48110 21 : void *argp1 = 0 ;
48111 21 : int res1 = 0 ;
48112 21 : int res2 ;
48113 21 : char *buf2 = 0 ;
48114 21 : int alloc2 = 0 ;
48115 21 : PyObject *swig_obj[2] ;
48116 21 : retStringAndCPLFree *result = 0 ;
48117 :
48118 21 : if (!SWIG_Python_UnpackTuple(args, "SubdatasetInfo_ModifyPathComponent", 2, 2, swig_obj)) SWIG_fail;
48119 21 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALSubdatasetInfo, 0 | 0 );
48120 21 : if (!SWIG_IsOK(res1)) {
48121 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubdatasetInfo_ModifyPathComponent" "', argument " "1"" of type '" "GDALSubdatasetInfoShadow *""'");
48122 : }
48123 21 : arg1 = reinterpret_cast< GDALSubdatasetInfoShadow * >(argp1);
48124 21 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
48125 21 : if (!SWIG_IsOK(res2)) {
48126 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SubdatasetInfo_ModifyPathComponent" "', argument " "2"" of type '" "char const *""'");
48127 : }
48128 21 : arg2 = reinterpret_cast< char * >(buf2);
48129 21 : {
48130 21 : const int bLocalUseExceptions = GetUseExceptions();
48131 21 : if ( bLocalUseExceptions ) {
48132 11 : pushErrorHandler();
48133 : }
48134 21 : {
48135 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48136 21 : result = (retStringAndCPLFree *)GDALSubdatasetInfoShadow_ModifyPathComponent(arg1,(char const *)arg2);
48137 21 : SWIG_PYTHON_THREAD_END_ALLOW;
48138 : }
48139 21 : if ( bLocalUseExceptions ) {
48140 11 : popErrorHandler();
48141 : }
48142 : #ifndef SED_HACKS
48143 : if ( bLocalUseExceptions ) {
48144 : CPLErr eclass = CPLGetLastErrorType();
48145 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48146 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48147 : }
48148 : }
48149 : #endif
48150 : }
48151 21 : {
48152 : /* %typemap(out) (retStringAndCPLFree*) */
48153 21 : Py_XDECREF(resultobj);
48154 21 : if(result)
48155 : {
48156 21 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
48157 21 : CPLFree(result);
48158 : }
48159 : else
48160 : {
48161 0 : resultobj = Py_None;
48162 0 : Py_INCREF(resultobj);
48163 : }
48164 : }
48165 21 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
48166 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48167 : return resultobj;
48168 0 : fail:
48169 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
48170 : return NULL;
48171 : }
48172 :
48173 :
48174 277 : SWIGINTERN PyObject *SubdatasetInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48175 277 : PyObject *obj;
48176 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
48177 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALSubdatasetInfo, SWIG_NewClientData(obj));
48178 277 : return SWIG_Py_Void();
48179 : }
48180 :
48181 83 : SWIGINTERN PyObject *_wrap_GetSubdatasetInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48182 83 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48183 83 : char *arg1 = (char *) 0 ;
48184 83 : int res1 ;
48185 83 : char *buf1 = 0 ;
48186 83 : int alloc1 = 0 ;
48187 83 : PyObject *swig_obj[1] ;
48188 83 : GDALSubdatasetInfoShadow *result = 0 ;
48189 :
48190 83 : if (!args) SWIG_fail;
48191 83 : swig_obj[0] = args;
48192 83 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
48193 83 : if (!SWIG_IsOK(res1)) {
48194 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSubdatasetInfo" "', argument " "1"" of type '" "char const *""'");
48195 : }
48196 83 : arg1 = reinterpret_cast< char * >(buf1);
48197 83 : {
48198 83 : const int bLocalUseExceptions = GetUseExceptions();
48199 83 : if ( bLocalUseExceptions ) {
48200 51 : pushErrorHandler();
48201 : }
48202 83 : {
48203 83 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48204 83 : result = (GDALSubdatasetInfoShadow *)GetSubdatasetInfo((char const *)arg1);
48205 83 : SWIG_PYTHON_THREAD_END_ALLOW;
48206 : }
48207 83 : if ( bLocalUseExceptions ) {
48208 51 : popErrorHandler();
48209 : }
48210 : #ifndef SED_HACKS
48211 : if ( bLocalUseExceptions ) {
48212 : CPLErr eclass = CPLGetLastErrorType();
48213 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48214 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48215 : }
48216 : }
48217 : #endif
48218 : }
48219 83 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALSubdatasetInfo, SWIG_POINTER_OWN | 0 );
48220 83 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
48221 83 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48222 : return resultobj;
48223 0 : fail:
48224 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
48225 : return NULL;
48226 : }
48227 :
48228 :
48229 30 : SWIGINTERN PyObject *_wrap_new_Relationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48230 30 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48231 30 : char *arg1 = (char *) 0 ;
48232 30 : char *arg2 = (char *) 0 ;
48233 30 : char *arg3 = (char *) 0 ;
48234 30 : GDALRelationshipCardinality arg4 ;
48235 30 : int res1 ;
48236 30 : char *buf1 = 0 ;
48237 30 : int alloc1 = 0 ;
48238 30 : int res2 ;
48239 30 : char *buf2 = 0 ;
48240 30 : int alloc2 = 0 ;
48241 30 : int res3 ;
48242 30 : char *buf3 = 0 ;
48243 30 : int alloc3 = 0 ;
48244 30 : int val4 ;
48245 30 : int ecode4 = 0 ;
48246 30 : PyObject *swig_obj[4] ;
48247 30 : GDALRelationshipShadow *result = 0 ;
48248 :
48249 30 : if (!SWIG_Python_UnpackTuple(args, "new_Relationship", 4, 4, swig_obj)) SWIG_fail;
48250 30 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
48251 30 : if (!SWIG_IsOK(res1)) {
48252 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Relationship" "', argument " "1"" of type '" "char const *""'");
48253 : }
48254 30 : arg1 = reinterpret_cast< char * >(buf1);
48255 30 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
48256 30 : if (!SWIG_IsOK(res2)) {
48257 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Relationship" "', argument " "2"" of type '" "char const *""'");
48258 : }
48259 30 : arg2 = reinterpret_cast< char * >(buf2);
48260 30 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
48261 30 : if (!SWIG_IsOK(res3)) {
48262 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Relationship" "', argument " "3"" of type '" "char const *""'");
48263 : }
48264 30 : arg3 = reinterpret_cast< char * >(buf3);
48265 30 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
48266 30 : if (!SWIG_IsOK(ecode4)) {
48267 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Relationship" "', argument " "4"" of type '" "GDALRelationshipCardinality""'");
48268 : }
48269 30 : arg4 = static_cast< GDALRelationshipCardinality >(val4);
48270 30 : {
48271 30 : if (!arg1) {
48272 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
48273 : }
48274 : }
48275 29 : {
48276 29 : const int bLocalUseExceptions = GetUseExceptions();
48277 29 : if ( bLocalUseExceptions ) {
48278 2 : pushErrorHandler();
48279 : }
48280 29 : {
48281 29 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48282 29 : result = (GDALRelationshipShadow *)new_GDALRelationshipShadow((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4);
48283 29 : SWIG_PYTHON_THREAD_END_ALLOW;
48284 : }
48285 29 : if ( bLocalUseExceptions ) {
48286 2 : popErrorHandler();
48287 : }
48288 : #ifndef SED_HACKS
48289 : if ( bLocalUseExceptions ) {
48290 : CPLErr eclass = CPLGetLastErrorType();
48291 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48292 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48293 : }
48294 : }
48295 : #endif
48296 : }
48297 29 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALRelationshipShadow, SWIG_POINTER_NEW | 0 );
48298 29 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
48299 29 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
48300 29 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
48301 30 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48302 : return resultobj;
48303 1 : fail:
48304 1 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
48305 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
48306 1 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
48307 : return NULL;
48308 : }
48309 :
48310 :
48311 29 : SWIGINTERN PyObject *_wrap_delete_Relationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48312 29 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48313 29 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
48314 29 : void *argp1 = 0 ;
48315 29 : int res1 = 0 ;
48316 29 : PyObject *swig_obj[1] ;
48317 :
48318 29 : if (!args) SWIG_fail;
48319 29 : swig_obj[0] = args;
48320 29 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, SWIG_POINTER_DISOWN | 0 );
48321 29 : if (!SWIG_IsOK(res1)) {
48322 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Relationship" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
48323 : }
48324 29 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
48325 29 : {
48326 29 : const int bLocalUseExceptions = GetUseExceptions();
48327 29 : if ( bLocalUseExceptions ) {
48328 2 : pushErrorHandler();
48329 : }
48330 29 : {
48331 29 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48332 29 : delete_GDALRelationshipShadow(arg1);
48333 29 : SWIG_PYTHON_THREAD_END_ALLOW;
48334 : }
48335 29 : if ( bLocalUseExceptions ) {
48336 2 : popErrorHandler();
48337 : }
48338 : #ifndef SED_HACKS
48339 : if ( bLocalUseExceptions ) {
48340 : CPLErr eclass = CPLGetLastErrorType();
48341 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48342 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48343 : }
48344 : }
48345 : #endif
48346 : }
48347 29 : resultobj = SWIG_Py_Void();
48348 29 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48349 : return resultobj;
48350 : fail:
48351 : return NULL;
48352 : }
48353 :
48354 :
48355 31 : SWIGINTERN PyObject *_wrap_Relationship_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48356 31 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48357 31 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
48358 31 : void *argp1 = 0 ;
48359 31 : int res1 = 0 ;
48360 31 : PyObject *swig_obj[1] ;
48361 31 : char *result = 0 ;
48362 :
48363 31 : if (!args) SWIG_fail;
48364 31 : swig_obj[0] = args;
48365 31 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
48366 31 : if (!SWIG_IsOK(res1)) {
48367 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_GetName" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
48368 : }
48369 31 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
48370 31 : {
48371 31 : const int bLocalUseExceptions = GetUseExceptions();
48372 31 : if ( bLocalUseExceptions ) {
48373 8 : pushErrorHandler();
48374 : }
48375 31 : {
48376 31 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48377 31 : result = (char *)GDALRelationshipShadow_GetName(arg1);
48378 31 : SWIG_PYTHON_THREAD_END_ALLOW;
48379 : }
48380 31 : if ( bLocalUseExceptions ) {
48381 8 : popErrorHandler();
48382 : }
48383 : #ifndef SED_HACKS
48384 : if ( bLocalUseExceptions ) {
48385 : CPLErr eclass = CPLGetLastErrorType();
48386 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48387 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48388 : }
48389 : }
48390 : #endif
48391 : }
48392 31 : resultobj = SWIG_FromCharPtr((const char *)result);
48393 31 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48394 : return resultobj;
48395 : fail:
48396 : return NULL;
48397 : }
48398 :
48399 :
48400 47 : SWIGINTERN PyObject *_wrap_Relationship_GetCardinality(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48401 47 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48402 47 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
48403 47 : void *argp1 = 0 ;
48404 47 : int res1 = 0 ;
48405 47 : PyObject *swig_obj[1] ;
48406 47 : GDALRelationshipCardinality result;
48407 :
48408 47 : if (!args) SWIG_fail;
48409 47 : swig_obj[0] = args;
48410 47 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
48411 47 : if (!SWIG_IsOK(res1)) {
48412 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_GetCardinality" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
48413 : }
48414 47 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
48415 47 : {
48416 47 : const int bLocalUseExceptions = GetUseExceptions();
48417 47 : if ( bLocalUseExceptions ) {
48418 9 : pushErrorHandler();
48419 : }
48420 47 : {
48421 47 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48422 47 : result = (GDALRelationshipCardinality)GDALRelationshipShadow_GetCardinality(arg1);
48423 47 : SWIG_PYTHON_THREAD_END_ALLOW;
48424 : }
48425 47 : if ( bLocalUseExceptions ) {
48426 9 : popErrorHandler();
48427 : }
48428 : #ifndef SED_HACKS
48429 : if ( bLocalUseExceptions ) {
48430 : CPLErr eclass = CPLGetLastErrorType();
48431 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48432 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48433 : }
48434 : }
48435 : #endif
48436 : }
48437 47 : resultobj = SWIG_From_int(static_cast< int >(result));
48438 47 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48439 : return resultobj;
48440 : fail:
48441 : return NULL;
48442 : }
48443 :
48444 :
48445 49 : SWIGINTERN PyObject *_wrap_Relationship_GetLeftTableName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48446 49 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48447 49 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
48448 49 : void *argp1 = 0 ;
48449 49 : int res1 = 0 ;
48450 49 : PyObject *swig_obj[1] ;
48451 49 : char *result = 0 ;
48452 :
48453 49 : if (!args) SWIG_fail;
48454 49 : swig_obj[0] = args;
48455 49 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
48456 49 : if (!SWIG_IsOK(res1)) {
48457 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_GetLeftTableName" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
48458 : }
48459 49 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
48460 49 : {
48461 49 : const int bLocalUseExceptions = GetUseExceptions();
48462 49 : if ( bLocalUseExceptions ) {
48463 10 : pushErrorHandler();
48464 : }
48465 49 : {
48466 49 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48467 49 : result = (char *)GDALRelationshipShadow_GetLeftTableName(arg1);
48468 49 : SWIG_PYTHON_THREAD_END_ALLOW;
48469 : }
48470 49 : if ( bLocalUseExceptions ) {
48471 10 : popErrorHandler();
48472 : }
48473 : #ifndef SED_HACKS
48474 : if ( bLocalUseExceptions ) {
48475 : CPLErr eclass = CPLGetLastErrorType();
48476 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48477 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48478 : }
48479 : }
48480 : #endif
48481 : }
48482 49 : resultobj = SWIG_FromCharPtr((const char *)result);
48483 49 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48484 : return resultobj;
48485 : fail:
48486 : return NULL;
48487 : }
48488 :
48489 :
48490 49 : SWIGINTERN PyObject *_wrap_Relationship_GetRightTableName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48491 49 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48492 49 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
48493 49 : void *argp1 = 0 ;
48494 49 : int res1 = 0 ;
48495 49 : PyObject *swig_obj[1] ;
48496 49 : char *result = 0 ;
48497 :
48498 49 : if (!args) SWIG_fail;
48499 49 : swig_obj[0] = args;
48500 49 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
48501 49 : if (!SWIG_IsOK(res1)) {
48502 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_GetRightTableName" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
48503 : }
48504 49 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
48505 49 : {
48506 49 : const int bLocalUseExceptions = GetUseExceptions();
48507 49 : if ( bLocalUseExceptions ) {
48508 10 : pushErrorHandler();
48509 : }
48510 49 : {
48511 49 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48512 49 : result = (char *)GDALRelationshipShadow_GetRightTableName(arg1);
48513 49 : SWIG_PYTHON_THREAD_END_ALLOW;
48514 : }
48515 49 : if ( bLocalUseExceptions ) {
48516 10 : popErrorHandler();
48517 : }
48518 : #ifndef SED_HACKS
48519 : if ( bLocalUseExceptions ) {
48520 : CPLErr eclass = CPLGetLastErrorType();
48521 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48522 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48523 : }
48524 : }
48525 : #endif
48526 : }
48527 49 : resultobj = SWIG_FromCharPtr((const char *)result);
48528 49 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48529 : return resultobj;
48530 : fail:
48531 : return NULL;
48532 : }
48533 :
48534 :
48535 34 : SWIGINTERN PyObject *_wrap_Relationship_GetMappingTableName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48536 34 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48537 34 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
48538 34 : void *argp1 = 0 ;
48539 34 : int res1 = 0 ;
48540 34 : PyObject *swig_obj[1] ;
48541 34 : char *result = 0 ;
48542 :
48543 34 : if (!args) SWIG_fail;
48544 34 : swig_obj[0] = args;
48545 34 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
48546 34 : if (!SWIG_IsOK(res1)) {
48547 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_GetMappingTableName" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
48548 : }
48549 34 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
48550 34 : {
48551 34 : const int bLocalUseExceptions = GetUseExceptions();
48552 34 : if ( bLocalUseExceptions ) {
48553 11 : pushErrorHandler();
48554 : }
48555 34 : {
48556 34 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48557 34 : result = (char *)GDALRelationshipShadow_GetMappingTableName(arg1);
48558 34 : SWIG_PYTHON_THREAD_END_ALLOW;
48559 : }
48560 34 : if ( bLocalUseExceptions ) {
48561 11 : popErrorHandler();
48562 : }
48563 : #ifndef SED_HACKS
48564 : if ( bLocalUseExceptions ) {
48565 : CPLErr eclass = CPLGetLastErrorType();
48566 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48567 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48568 : }
48569 : }
48570 : #endif
48571 : }
48572 34 : resultobj = SWIG_FromCharPtr((const char *)result);
48573 34 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48574 : return resultobj;
48575 : fail:
48576 : return NULL;
48577 : }
48578 :
48579 :
48580 14 : SWIGINTERN PyObject *_wrap_Relationship_SetMappingTableName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48581 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48582 14 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
48583 14 : char *arg2 = (char *) 0 ;
48584 14 : void *argp1 = 0 ;
48585 14 : int res1 = 0 ;
48586 14 : PyObject *str2 = 0 ;
48587 14 : int bToFree2 = 0 ;
48588 14 : PyObject *swig_obj[2] ;
48589 :
48590 14 : if (!SWIG_Python_UnpackTuple(args, "Relationship_SetMappingTableName", 2, 2, swig_obj)) SWIG_fail;
48591 14 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
48592 14 : if (!SWIG_IsOK(res1)) {
48593 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_SetMappingTableName" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
48594 : }
48595 14 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
48596 14 : {
48597 : /* %typemap(in) (tostring argin) */
48598 14 : str2 = PyObject_Str( swig_obj[1] );
48599 14 : if ( str2 == 0 ) {
48600 0 : PyErr_SetString( PyExc_RuntimeError, "Unable to format argument as string");
48601 0 : SWIG_fail;
48602 : }
48603 :
48604 14 : arg2 = GDALPythonObjectToCStr(str2, &bToFree2);
48605 : }
48606 14 : {
48607 14 : const int bLocalUseExceptions = GetUseExceptions();
48608 14 : if ( bLocalUseExceptions ) {
48609 1 : pushErrorHandler();
48610 : }
48611 14 : {
48612 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48613 14 : GDALRelationshipShadow_SetMappingTableName(arg1,(char const *)arg2);
48614 14 : SWIG_PYTHON_THREAD_END_ALLOW;
48615 : }
48616 14 : if ( bLocalUseExceptions ) {
48617 1 : popErrorHandler();
48618 : }
48619 : #ifndef SED_HACKS
48620 : if ( bLocalUseExceptions ) {
48621 : CPLErr eclass = CPLGetLastErrorType();
48622 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48623 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48624 : }
48625 : }
48626 : #endif
48627 : }
48628 14 : resultobj = SWIG_Py_Void();
48629 14 : {
48630 : /* %typemap(freearg) (tostring argin) */
48631 14 : if ( str2 != NULL)
48632 : {
48633 14 : Py_DECREF(str2);
48634 : }
48635 14 : GDALPythonFreeCStr(arg2, bToFree2);
48636 : }
48637 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48638 : return resultobj;
48639 0 : fail:
48640 0 : {
48641 : /* %typemap(freearg) (tostring argin) */
48642 0 : if ( str2 != NULL)
48643 : {
48644 0 : Py_DECREF(str2);
48645 : }
48646 14 : GDALPythonFreeCStr(arg2, bToFree2);
48647 : }
48648 : return NULL;
48649 : }
48650 :
48651 :
48652 48 : SWIGINTERN PyObject *_wrap_Relationship_GetLeftTableFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48653 48 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48654 48 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
48655 48 : void *argp1 = 0 ;
48656 48 : int res1 = 0 ;
48657 48 : PyObject *swig_obj[1] ;
48658 48 : char **result = 0 ;
48659 :
48660 48 : if (!args) SWIG_fail;
48661 48 : swig_obj[0] = args;
48662 48 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
48663 48 : if (!SWIG_IsOK(res1)) {
48664 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_GetLeftTableFields" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
48665 : }
48666 48 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
48667 48 : {
48668 48 : const int bLocalUseExceptions = GetUseExceptions();
48669 48 : if ( bLocalUseExceptions ) {
48670 9 : pushErrorHandler();
48671 : }
48672 48 : {
48673 48 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48674 48 : result = (char **)GDALRelationshipShadow_GetLeftTableFields(arg1);
48675 48 : SWIG_PYTHON_THREAD_END_ALLOW;
48676 : }
48677 48 : if ( bLocalUseExceptions ) {
48678 9 : popErrorHandler();
48679 : }
48680 : #ifndef SED_HACKS
48681 : if ( bLocalUseExceptions ) {
48682 : CPLErr eclass = CPLGetLastErrorType();
48683 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48684 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48685 : }
48686 : }
48687 : #endif
48688 : }
48689 48 : {
48690 : /* %typemap(out) char **CSL -> ( string ) */
48691 48 : bool bErr = false;
48692 48 : resultobj = CSLToList(result, &bErr);
48693 48 : CSLDestroy(result);
48694 48 : if( bErr ) {
48695 0 : SWIG_fail;
48696 : }
48697 : }
48698 48 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48699 : return resultobj;
48700 : fail:
48701 : return NULL;
48702 : }
48703 :
48704 :
48705 48 : SWIGINTERN PyObject *_wrap_Relationship_GetRightTableFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48706 48 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48707 48 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
48708 48 : void *argp1 = 0 ;
48709 48 : int res1 = 0 ;
48710 48 : PyObject *swig_obj[1] ;
48711 48 : char **result = 0 ;
48712 :
48713 48 : if (!args) SWIG_fail;
48714 48 : swig_obj[0] = args;
48715 48 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
48716 48 : if (!SWIG_IsOK(res1)) {
48717 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_GetRightTableFields" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
48718 : }
48719 48 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
48720 48 : {
48721 48 : const int bLocalUseExceptions = GetUseExceptions();
48722 48 : if ( bLocalUseExceptions ) {
48723 9 : pushErrorHandler();
48724 : }
48725 48 : {
48726 48 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48727 48 : result = (char **)GDALRelationshipShadow_GetRightTableFields(arg1);
48728 48 : SWIG_PYTHON_THREAD_END_ALLOW;
48729 : }
48730 48 : if ( bLocalUseExceptions ) {
48731 9 : popErrorHandler();
48732 : }
48733 : #ifndef SED_HACKS
48734 : if ( bLocalUseExceptions ) {
48735 : CPLErr eclass = CPLGetLastErrorType();
48736 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48737 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48738 : }
48739 : }
48740 : #endif
48741 : }
48742 48 : {
48743 : /* %typemap(out) char **CSL -> ( string ) */
48744 48 : bool bErr = false;
48745 48 : resultobj = CSLToList(result, &bErr);
48746 48 : CSLDestroy(result);
48747 48 : if( bErr ) {
48748 0 : SWIG_fail;
48749 : }
48750 : }
48751 48 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48752 : return resultobj;
48753 : fail:
48754 : return NULL;
48755 : }
48756 :
48757 :
48758 37 : SWIGINTERN PyObject *_wrap_Relationship_SetLeftTableFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48759 37 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48760 37 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
48761 37 : char **arg2 = (char **) 0 ;
48762 37 : void *argp1 = 0 ;
48763 37 : int res1 = 0 ;
48764 37 : PyObject *swig_obj[2] ;
48765 :
48766 37 : if (!SWIG_Python_UnpackTuple(args, "Relationship_SetLeftTableFields", 2, 2, swig_obj)) SWIG_fail;
48767 37 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
48768 37 : if (!SWIG_IsOK(res1)) {
48769 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_SetLeftTableFields" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
48770 : }
48771 37 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
48772 37 : {
48773 : /* %typemap(in) char **dict */
48774 37 : arg2 = NULL;
48775 37 : if ( PySequence_Check( swig_obj[1] ) ) {
48776 37 : int bErr = FALSE;
48777 37 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
48778 37 : if ( bErr )
48779 : {
48780 0 : SWIG_fail;
48781 : }
48782 : }
48783 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
48784 0 : int bErr = FALSE;
48785 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
48786 0 : if ( bErr )
48787 : {
48788 0 : SWIG_fail;
48789 : }
48790 : }
48791 : else {
48792 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
48793 0 : SWIG_fail;
48794 : }
48795 : }
48796 37 : {
48797 37 : const int bLocalUseExceptions = GetUseExceptions();
48798 37 : if ( bLocalUseExceptions ) {
48799 1 : pushErrorHandler();
48800 : }
48801 37 : {
48802 37 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48803 37 : GDALRelationshipShadow_SetLeftTableFields(arg1,arg2);
48804 37 : SWIG_PYTHON_THREAD_END_ALLOW;
48805 : }
48806 37 : if ( bLocalUseExceptions ) {
48807 1 : popErrorHandler();
48808 : }
48809 : #ifndef SED_HACKS
48810 : if ( bLocalUseExceptions ) {
48811 : CPLErr eclass = CPLGetLastErrorType();
48812 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48813 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48814 : }
48815 : }
48816 : #endif
48817 : }
48818 37 : resultobj = SWIG_Py_Void();
48819 37 : {
48820 : /* %typemap(freearg) char **dict */
48821 37 : CSLDestroy( arg2 );
48822 : }
48823 37 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48824 : return resultobj;
48825 0 : fail:
48826 0 : {
48827 : /* %typemap(freearg) char **dict */
48828 0 : CSLDestroy( arg2 );
48829 : }
48830 : return NULL;
48831 : }
48832 :
48833 :
48834 38 : SWIGINTERN PyObject *_wrap_Relationship_SetRightTableFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48835 38 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48836 38 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
48837 38 : char **arg2 = (char **) 0 ;
48838 38 : void *argp1 = 0 ;
48839 38 : int res1 = 0 ;
48840 38 : PyObject *swig_obj[2] ;
48841 :
48842 38 : if (!SWIG_Python_UnpackTuple(args, "Relationship_SetRightTableFields", 2, 2, swig_obj)) SWIG_fail;
48843 38 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
48844 38 : if (!SWIG_IsOK(res1)) {
48845 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_SetRightTableFields" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
48846 : }
48847 38 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
48848 38 : {
48849 : /* %typemap(in) char **dict */
48850 38 : arg2 = NULL;
48851 38 : if ( PySequence_Check( swig_obj[1] ) ) {
48852 38 : int bErr = FALSE;
48853 38 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
48854 38 : if ( bErr )
48855 : {
48856 0 : SWIG_fail;
48857 : }
48858 : }
48859 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
48860 0 : int bErr = FALSE;
48861 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
48862 0 : if ( bErr )
48863 : {
48864 0 : SWIG_fail;
48865 : }
48866 : }
48867 : else {
48868 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
48869 0 : SWIG_fail;
48870 : }
48871 : }
48872 38 : {
48873 38 : const int bLocalUseExceptions = GetUseExceptions();
48874 38 : if ( bLocalUseExceptions ) {
48875 1 : pushErrorHandler();
48876 : }
48877 38 : {
48878 38 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48879 38 : GDALRelationshipShadow_SetRightTableFields(arg1,arg2);
48880 38 : SWIG_PYTHON_THREAD_END_ALLOW;
48881 : }
48882 38 : if ( bLocalUseExceptions ) {
48883 1 : popErrorHandler();
48884 : }
48885 : #ifndef SED_HACKS
48886 : if ( bLocalUseExceptions ) {
48887 : CPLErr eclass = CPLGetLastErrorType();
48888 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48889 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48890 : }
48891 : }
48892 : #endif
48893 : }
48894 38 : resultobj = SWIG_Py_Void();
48895 38 : {
48896 : /* %typemap(freearg) char **dict */
48897 38 : CSLDestroy( arg2 );
48898 : }
48899 38 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48900 : return resultobj;
48901 0 : fail:
48902 0 : {
48903 : /* %typemap(freearg) char **dict */
48904 0 : CSLDestroy( arg2 );
48905 : }
48906 : return NULL;
48907 : }
48908 :
48909 :
48910 23 : SWIGINTERN PyObject *_wrap_Relationship_GetLeftMappingTableFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48911 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48912 23 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
48913 23 : void *argp1 = 0 ;
48914 23 : int res1 = 0 ;
48915 23 : PyObject *swig_obj[1] ;
48916 23 : char **result = 0 ;
48917 :
48918 23 : if (!args) SWIG_fail;
48919 23 : swig_obj[0] = args;
48920 23 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
48921 23 : if (!SWIG_IsOK(res1)) {
48922 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_GetLeftMappingTableFields" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
48923 : }
48924 23 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
48925 23 : {
48926 23 : const int bLocalUseExceptions = GetUseExceptions();
48927 23 : if ( bLocalUseExceptions ) {
48928 5 : pushErrorHandler();
48929 : }
48930 23 : {
48931 23 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48932 23 : result = (char **)GDALRelationshipShadow_GetLeftMappingTableFields(arg1);
48933 23 : SWIG_PYTHON_THREAD_END_ALLOW;
48934 : }
48935 23 : if ( bLocalUseExceptions ) {
48936 5 : popErrorHandler();
48937 : }
48938 : #ifndef SED_HACKS
48939 : if ( bLocalUseExceptions ) {
48940 : CPLErr eclass = CPLGetLastErrorType();
48941 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48942 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48943 : }
48944 : }
48945 : #endif
48946 : }
48947 23 : {
48948 : /* %typemap(out) char **CSL -> ( string ) */
48949 23 : bool bErr = false;
48950 23 : resultobj = CSLToList(result, &bErr);
48951 23 : CSLDestroy(result);
48952 23 : if( bErr ) {
48953 0 : SWIG_fail;
48954 : }
48955 : }
48956 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
48957 : return resultobj;
48958 : fail:
48959 : return NULL;
48960 : }
48961 :
48962 :
48963 23 : SWIGINTERN PyObject *_wrap_Relationship_GetRightMappingTableFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48964 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
48965 23 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
48966 23 : void *argp1 = 0 ;
48967 23 : int res1 = 0 ;
48968 23 : PyObject *swig_obj[1] ;
48969 23 : char **result = 0 ;
48970 :
48971 23 : if (!args) SWIG_fail;
48972 23 : swig_obj[0] = args;
48973 23 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
48974 23 : if (!SWIG_IsOK(res1)) {
48975 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_GetRightMappingTableFields" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
48976 : }
48977 23 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
48978 23 : {
48979 23 : const int bLocalUseExceptions = GetUseExceptions();
48980 23 : if ( bLocalUseExceptions ) {
48981 5 : pushErrorHandler();
48982 : }
48983 23 : {
48984 23 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
48985 23 : result = (char **)GDALRelationshipShadow_GetRightMappingTableFields(arg1);
48986 23 : SWIG_PYTHON_THREAD_END_ALLOW;
48987 : }
48988 23 : if ( bLocalUseExceptions ) {
48989 5 : popErrorHandler();
48990 : }
48991 : #ifndef SED_HACKS
48992 : if ( bLocalUseExceptions ) {
48993 : CPLErr eclass = CPLGetLastErrorType();
48994 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
48995 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
48996 : }
48997 : }
48998 : #endif
48999 : }
49000 23 : {
49001 : /* %typemap(out) char **CSL -> ( string ) */
49002 23 : bool bErr = false;
49003 23 : resultobj = CSLToList(result, &bErr);
49004 23 : CSLDestroy(result);
49005 23 : if( bErr ) {
49006 0 : SWIG_fail;
49007 : }
49008 : }
49009 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
49010 : return resultobj;
49011 : fail:
49012 : return NULL;
49013 : }
49014 :
49015 :
49016 9 : SWIGINTERN PyObject *_wrap_Relationship_SetLeftMappingTableFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49017 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
49018 9 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
49019 9 : char **arg2 = (char **) 0 ;
49020 9 : void *argp1 = 0 ;
49021 9 : int res1 = 0 ;
49022 9 : PyObject *swig_obj[2] ;
49023 :
49024 9 : if (!SWIG_Python_UnpackTuple(args, "Relationship_SetLeftMappingTableFields", 2, 2, swig_obj)) SWIG_fail;
49025 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
49026 9 : if (!SWIG_IsOK(res1)) {
49027 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_SetLeftMappingTableFields" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
49028 : }
49029 9 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
49030 9 : {
49031 : /* %typemap(in) char **dict */
49032 9 : arg2 = NULL;
49033 9 : if ( PySequence_Check( swig_obj[1] ) ) {
49034 9 : int bErr = FALSE;
49035 9 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
49036 9 : if ( bErr )
49037 : {
49038 0 : SWIG_fail;
49039 : }
49040 : }
49041 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
49042 0 : int bErr = FALSE;
49043 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
49044 0 : if ( bErr )
49045 : {
49046 0 : SWIG_fail;
49047 : }
49048 : }
49049 : else {
49050 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
49051 0 : SWIG_fail;
49052 : }
49053 : }
49054 9 : {
49055 9 : const int bLocalUseExceptions = GetUseExceptions();
49056 9 : if ( bLocalUseExceptions ) {
49057 1 : pushErrorHandler();
49058 : }
49059 9 : {
49060 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
49061 9 : GDALRelationshipShadow_SetLeftMappingTableFields(arg1,arg2);
49062 9 : SWIG_PYTHON_THREAD_END_ALLOW;
49063 : }
49064 9 : if ( bLocalUseExceptions ) {
49065 1 : popErrorHandler();
49066 : }
49067 : #ifndef SED_HACKS
49068 : if ( bLocalUseExceptions ) {
49069 : CPLErr eclass = CPLGetLastErrorType();
49070 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
49071 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
49072 : }
49073 : }
49074 : #endif
49075 : }
49076 9 : resultobj = SWIG_Py_Void();
49077 9 : {
49078 : /* %typemap(freearg) char **dict */
49079 9 : CSLDestroy( arg2 );
49080 : }
49081 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
49082 : return resultobj;
49083 0 : fail:
49084 0 : {
49085 : /* %typemap(freearg) char **dict */
49086 0 : CSLDestroy( arg2 );
49087 : }
49088 : return NULL;
49089 : }
49090 :
49091 :
49092 9 : SWIGINTERN PyObject *_wrap_Relationship_SetRightMappingTableFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49093 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
49094 9 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
49095 9 : char **arg2 = (char **) 0 ;
49096 9 : void *argp1 = 0 ;
49097 9 : int res1 = 0 ;
49098 9 : PyObject *swig_obj[2] ;
49099 :
49100 9 : if (!SWIG_Python_UnpackTuple(args, "Relationship_SetRightMappingTableFields", 2, 2, swig_obj)) SWIG_fail;
49101 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
49102 9 : if (!SWIG_IsOK(res1)) {
49103 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_SetRightMappingTableFields" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
49104 : }
49105 9 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
49106 9 : {
49107 : /* %typemap(in) char **dict */
49108 9 : arg2 = NULL;
49109 9 : if ( PySequence_Check( swig_obj[1] ) ) {
49110 9 : int bErr = FALSE;
49111 9 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
49112 9 : if ( bErr )
49113 : {
49114 0 : SWIG_fail;
49115 : }
49116 : }
49117 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
49118 0 : int bErr = FALSE;
49119 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
49120 0 : if ( bErr )
49121 : {
49122 0 : SWIG_fail;
49123 : }
49124 : }
49125 : else {
49126 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
49127 0 : SWIG_fail;
49128 : }
49129 : }
49130 9 : {
49131 9 : const int bLocalUseExceptions = GetUseExceptions();
49132 9 : if ( bLocalUseExceptions ) {
49133 1 : pushErrorHandler();
49134 : }
49135 9 : {
49136 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
49137 9 : GDALRelationshipShadow_SetRightMappingTableFields(arg1,arg2);
49138 9 : SWIG_PYTHON_THREAD_END_ALLOW;
49139 : }
49140 9 : if ( bLocalUseExceptions ) {
49141 1 : popErrorHandler();
49142 : }
49143 : #ifndef SED_HACKS
49144 : if ( bLocalUseExceptions ) {
49145 : CPLErr eclass = CPLGetLastErrorType();
49146 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
49147 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
49148 : }
49149 : }
49150 : #endif
49151 : }
49152 9 : resultobj = SWIG_Py_Void();
49153 9 : {
49154 : /* %typemap(freearg) char **dict */
49155 9 : CSLDestroy( arg2 );
49156 : }
49157 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
49158 : return resultobj;
49159 0 : fail:
49160 0 : {
49161 : /* %typemap(freearg) char **dict */
49162 0 : CSLDestroy( arg2 );
49163 : }
49164 : return NULL;
49165 : }
49166 :
49167 :
49168 47 : SWIGINTERN PyObject *_wrap_Relationship_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49169 47 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
49170 47 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
49171 47 : void *argp1 = 0 ;
49172 47 : int res1 = 0 ;
49173 47 : PyObject *swig_obj[1] ;
49174 47 : GDALRelationshipType result;
49175 :
49176 47 : if (!args) SWIG_fail;
49177 47 : swig_obj[0] = args;
49178 47 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
49179 47 : if (!SWIG_IsOK(res1)) {
49180 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_GetType" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
49181 : }
49182 47 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
49183 47 : {
49184 47 : const int bLocalUseExceptions = GetUseExceptions();
49185 47 : if ( bLocalUseExceptions ) {
49186 9 : pushErrorHandler();
49187 : }
49188 47 : {
49189 47 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
49190 47 : result = (GDALRelationshipType)GDALRelationshipShadow_GetType(arg1);
49191 47 : SWIG_PYTHON_THREAD_END_ALLOW;
49192 : }
49193 47 : if ( bLocalUseExceptions ) {
49194 9 : popErrorHandler();
49195 : }
49196 : #ifndef SED_HACKS
49197 : if ( bLocalUseExceptions ) {
49198 : CPLErr eclass = CPLGetLastErrorType();
49199 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
49200 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
49201 : }
49202 : }
49203 : #endif
49204 : }
49205 47 : resultobj = SWIG_From_int(static_cast< int >(result));
49206 47 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
49207 : return resultobj;
49208 : fail:
49209 : return NULL;
49210 : }
49211 :
49212 :
49213 10 : SWIGINTERN PyObject *_wrap_Relationship_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49214 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
49215 10 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
49216 10 : GDALRelationshipType arg2 ;
49217 10 : void *argp1 = 0 ;
49218 10 : int res1 = 0 ;
49219 10 : int val2 ;
49220 10 : int ecode2 = 0 ;
49221 10 : PyObject *swig_obj[2] ;
49222 :
49223 10 : if (!SWIG_Python_UnpackTuple(args, "Relationship_SetType", 2, 2, swig_obj)) SWIG_fail;
49224 10 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
49225 10 : if (!SWIG_IsOK(res1)) {
49226 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_SetType" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
49227 : }
49228 10 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
49229 10 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
49230 10 : if (!SWIG_IsOK(ecode2)) {
49231 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Relationship_SetType" "', argument " "2"" of type '" "GDALRelationshipType""'");
49232 : }
49233 10 : arg2 = static_cast< GDALRelationshipType >(val2);
49234 10 : {
49235 10 : const int bLocalUseExceptions = GetUseExceptions();
49236 10 : if ( bLocalUseExceptions ) {
49237 1 : pushErrorHandler();
49238 : }
49239 10 : {
49240 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
49241 10 : GDALRelationshipShadow_SetType(arg1,arg2);
49242 10 : SWIG_PYTHON_THREAD_END_ALLOW;
49243 : }
49244 10 : if ( bLocalUseExceptions ) {
49245 1 : popErrorHandler();
49246 : }
49247 : #ifndef SED_HACKS
49248 : if ( bLocalUseExceptions ) {
49249 : CPLErr eclass = CPLGetLastErrorType();
49250 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
49251 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
49252 : }
49253 : }
49254 : #endif
49255 : }
49256 10 : resultobj = SWIG_Py_Void();
49257 10 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
49258 : return resultobj;
49259 : fail:
49260 : return NULL;
49261 : }
49262 :
49263 :
49264 14 : SWIGINTERN PyObject *_wrap_Relationship_GetForwardPathLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49265 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
49266 14 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
49267 14 : void *argp1 = 0 ;
49268 14 : int res1 = 0 ;
49269 14 : PyObject *swig_obj[1] ;
49270 14 : char *result = 0 ;
49271 :
49272 14 : if (!args) SWIG_fail;
49273 14 : swig_obj[0] = args;
49274 14 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
49275 14 : if (!SWIG_IsOK(res1)) {
49276 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_GetForwardPathLabel" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
49277 : }
49278 14 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
49279 14 : {
49280 14 : const int bLocalUseExceptions = GetUseExceptions();
49281 14 : if ( bLocalUseExceptions ) {
49282 4 : pushErrorHandler();
49283 : }
49284 14 : {
49285 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
49286 14 : result = (char *)GDALRelationshipShadow_GetForwardPathLabel(arg1);
49287 14 : SWIG_PYTHON_THREAD_END_ALLOW;
49288 : }
49289 14 : if ( bLocalUseExceptions ) {
49290 4 : popErrorHandler();
49291 : }
49292 : #ifndef SED_HACKS
49293 : if ( bLocalUseExceptions ) {
49294 : CPLErr eclass = CPLGetLastErrorType();
49295 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
49296 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
49297 : }
49298 : }
49299 : #endif
49300 : }
49301 14 : resultobj = SWIG_FromCharPtr((const char *)result);
49302 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
49303 : return resultobj;
49304 : fail:
49305 : return NULL;
49306 : }
49307 :
49308 :
49309 9 : SWIGINTERN PyObject *_wrap_Relationship_SetForwardPathLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49310 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
49311 9 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
49312 9 : char *arg2 = (char *) 0 ;
49313 9 : void *argp1 = 0 ;
49314 9 : int res1 = 0 ;
49315 9 : PyObject *str2 = 0 ;
49316 9 : int bToFree2 = 0 ;
49317 9 : PyObject *swig_obj[2] ;
49318 :
49319 9 : if (!SWIG_Python_UnpackTuple(args, "Relationship_SetForwardPathLabel", 2, 2, swig_obj)) SWIG_fail;
49320 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
49321 9 : if (!SWIG_IsOK(res1)) {
49322 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_SetForwardPathLabel" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
49323 : }
49324 9 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
49325 9 : {
49326 : /* %typemap(in) (tostring argin) */
49327 9 : str2 = PyObject_Str( swig_obj[1] );
49328 9 : if ( str2 == 0 ) {
49329 0 : PyErr_SetString( PyExc_RuntimeError, "Unable to format argument as string");
49330 0 : SWIG_fail;
49331 : }
49332 :
49333 9 : arg2 = GDALPythonObjectToCStr(str2, &bToFree2);
49334 : }
49335 9 : {
49336 9 : const int bLocalUseExceptions = GetUseExceptions();
49337 9 : if ( bLocalUseExceptions ) {
49338 1 : pushErrorHandler();
49339 : }
49340 9 : {
49341 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
49342 9 : GDALRelationshipShadow_SetForwardPathLabel(arg1,(char const *)arg2);
49343 9 : SWIG_PYTHON_THREAD_END_ALLOW;
49344 : }
49345 9 : if ( bLocalUseExceptions ) {
49346 1 : popErrorHandler();
49347 : }
49348 : #ifndef SED_HACKS
49349 : if ( bLocalUseExceptions ) {
49350 : CPLErr eclass = CPLGetLastErrorType();
49351 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
49352 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
49353 : }
49354 : }
49355 : #endif
49356 : }
49357 9 : resultobj = SWIG_Py_Void();
49358 9 : {
49359 : /* %typemap(freearg) (tostring argin) */
49360 9 : if ( str2 != NULL)
49361 : {
49362 9 : Py_DECREF(str2);
49363 : }
49364 9 : GDALPythonFreeCStr(arg2, bToFree2);
49365 : }
49366 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
49367 : return resultobj;
49368 0 : fail:
49369 0 : {
49370 : /* %typemap(freearg) (tostring argin) */
49371 0 : if ( str2 != NULL)
49372 : {
49373 0 : Py_DECREF(str2);
49374 : }
49375 9 : GDALPythonFreeCStr(arg2, bToFree2);
49376 : }
49377 : return NULL;
49378 : }
49379 :
49380 :
49381 14 : SWIGINTERN PyObject *_wrap_Relationship_GetBackwardPathLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49382 14 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
49383 14 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
49384 14 : void *argp1 = 0 ;
49385 14 : int res1 = 0 ;
49386 14 : PyObject *swig_obj[1] ;
49387 14 : char *result = 0 ;
49388 :
49389 14 : if (!args) SWIG_fail;
49390 14 : swig_obj[0] = args;
49391 14 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
49392 14 : if (!SWIG_IsOK(res1)) {
49393 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_GetBackwardPathLabel" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
49394 : }
49395 14 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
49396 14 : {
49397 14 : const int bLocalUseExceptions = GetUseExceptions();
49398 14 : if ( bLocalUseExceptions ) {
49399 4 : pushErrorHandler();
49400 : }
49401 14 : {
49402 14 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
49403 14 : result = (char *)GDALRelationshipShadow_GetBackwardPathLabel(arg1);
49404 14 : SWIG_PYTHON_THREAD_END_ALLOW;
49405 : }
49406 14 : if ( bLocalUseExceptions ) {
49407 4 : popErrorHandler();
49408 : }
49409 : #ifndef SED_HACKS
49410 : if ( bLocalUseExceptions ) {
49411 : CPLErr eclass = CPLGetLastErrorType();
49412 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
49413 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
49414 : }
49415 : }
49416 : #endif
49417 : }
49418 14 : resultobj = SWIG_FromCharPtr((const char *)result);
49419 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
49420 : return resultobj;
49421 : fail:
49422 : return NULL;
49423 : }
49424 :
49425 :
49426 9 : SWIGINTERN PyObject *_wrap_Relationship_SetBackwardPathLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49427 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
49428 9 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
49429 9 : char *arg2 = (char *) 0 ;
49430 9 : void *argp1 = 0 ;
49431 9 : int res1 = 0 ;
49432 9 : PyObject *str2 = 0 ;
49433 9 : int bToFree2 = 0 ;
49434 9 : PyObject *swig_obj[2] ;
49435 :
49436 9 : if (!SWIG_Python_UnpackTuple(args, "Relationship_SetBackwardPathLabel", 2, 2, swig_obj)) SWIG_fail;
49437 9 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
49438 9 : if (!SWIG_IsOK(res1)) {
49439 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_SetBackwardPathLabel" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
49440 : }
49441 9 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
49442 9 : {
49443 : /* %typemap(in) (tostring argin) */
49444 9 : str2 = PyObject_Str( swig_obj[1] );
49445 9 : if ( str2 == 0 ) {
49446 0 : PyErr_SetString( PyExc_RuntimeError, "Unable to format argument as string");
49447 0 : SWIG_fail;
49448 : }
49449 :
49450 9 : arg2 = GDALPythonObjectToCStr(str2, &bToFree2);
49451 : }
49452 9 : {
49453 9 : const int bLocalUseExceptions = GetUseExceptions();
49454 9 : if ( bLocalUseExceptions ) {
49455 1 : pushErrorHandler();
49456 : }
49457 9 : {
49458 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
49459 9 : GDALRelationshipShadow_SetBackwardPathLabel(arg1,(char const *)arg2);
49460 9 : SWIG_PYTHON_THREAD_END_ALLOW;
49461 : }
49462 9 : if ( bLocalUseExceptions ) {
49463 1 : popErrorHandler();
49464 : }
49465 : #ifndef SED_HACKS
49466 : if ( bLocalUseExceptions ) {
49467 : CPLErr eclass = CPLGetLastErrorType();
49468 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
49469 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
49470 : }
49471 : }
49472 : #endif
49473 : }
49474 9 : resultobj = SWIG_Py_Void();
49475 9 : {
49476 : /* %typemap(freearg) (tostring argin) */
49477 9 : if ( str2 != NULL)
49478 : {
49479 9 : Py_DECREF(str2);
49480 : }
49481 9 : GDALPythonFreeCStr(arg2, bToFree2);
49482 : }
49483 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
49484 : return resultobj;
49485 0 : fail:
49486 0 : {
49487 : /* %typemap(freearg) (tostring argin) */
49488 0 : if ( str2 != NULL)
49489 : {
49490 0 : Py_DECREF(str2);
49491 : }
49492 9 : GDALPythonFreeCStr(arg2, bToFree2);
49493 : }
49494 : return NULL;
49495 : }
49496 :
49497 :
49498 44 : SWIGINTERN PyObject *_wrap_Relationship_GetRelatedTableType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49499 44 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
49500 44 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
49501 44 : void *argp1 = 0 ;
49502 44 : int res1 = 0 ;
49503 44 : PyObject *swig_obj[1] ;
49504 44 : char *result = 0 ;
49505 :
49506 44 : if (!args) SWIG_fail;
49507 44 : swig_obj[0] = args;
49508 44 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
49509 44 : if (!SWIG_IsOK(res1)) {
49510 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_GetRelatedTableType" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
49511 : }
49512 44 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
49513 44 : {
49514 44 : const int bLocalUseExceptions = GetUseExceptions();
49515 44 : if ( bLocalUseExceptions ) {
49516 9 : pushErrorHandler();
49517 : }
49518 44 : {
49519 44 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
49520 44 : result = (char *)GDALRelationshipShadow_GetRelatedTableType(arg1);
49521 44 : SWIG_PYTHON_THREAD_END_ALLOW;
49522 : }
49523 44 : if ( bLocalUseExceptions ) {
49524 9 : popErrorHandler();
49525 : }
49526 : #ifndef SED_HACKS
49527 : if ( bLocalUseExceptions ) {
49528 : CPLErr eclass = CPLGetLastErrorType();
49529 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
49530 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
49531 : }
49532 : }
49533 : #endif
49534 : }
49535 44 : resultobj = SWIG_FromCharPtr((const char *)result);
49536 44 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
49537 : return resultobj;
49538 : fail:
49539 : return NULL;
49540 : }
49541 :
49542 :
49543 20 : SWIGINTERN PyObject *_wrap_Relationship_SetRelatedTableType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49544 20 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
49545 20 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
49546 20 : char *arg2 = (char *) 0 ;
49547 20 : void *argp1 = 0 ;
49548 20 : int res1 = 0 ;
49549 20 : PyObject *str2 = 0 ;
49550 20 : int bToFree2 = 0 ;
49551 20 : PyObject *swig_obj[2] ;
49552 :
49553 20 : if (!SWIG_Python_UnpackTuple(args, "Relationship_SetRelatedTableType", 2, 2, swig_obj)) SWIG_fail;
49554 20 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRelationshipShadow, 0 | 0 );
49555 20 : if (!SWIG_IsOK(res1)) {
49556 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Relationship_SetRelatedTableType" "', argument " "1"" of type '" "GDALRelationshipShadow *""'");
49557 : }
49558 20 : arg1 = reinterpret_cast< GDALRelationshipShadow * >(argp1);
49559 20 : {
49560 : /* %typemap(in) (tostring argin) */
49561 20 : str2 = PyObject_Str( swig_obj[1] );
49562 20 : if ( str2 == 0 ) {
49563 0 : PyErr_SetString( PyExc_RuntimeError, "Unable to format argument as string");
49564 0 : SWIG_fail;
49565 : }
49566 :
49567 20 : arg2 = GDALPythonObjectToCStr(str2, &bToFree2);
49568 : }
49569 20 : {
49570 20 : const int bLocalUseExceptions = GetUseExceptions();
49571 20 : if ( bLocalUseExceptions ) {
49572 1 : pushErrorHandler();
49573 : }
49574 20 : {
49575 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
49576 20 : GDALRelationshipShadow_SetRelatedTableType(arg1,(char const *)arg2);
49577 20 : SWIG_PYTHON_THREAD_END_ALLOW;
49578 : }
49579 20 : if ( bLocalUseExceptions ) {
49580 1 : popErrorHandler();
49581 : }
49582 : #ifndef SED_HACKS
49583 : if ( bLocalUseExceptions ) {
49584 : CPLErr eclass = CPLGetLastErrorType();
49585 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
49586 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
49587 : }
49588 : }
49589 : #endif
49590 : }
49591 20 : resultobj = SWIG_Py_Void();
49592 20 : {
49593 : /* %typemap(freearg) (tostring argin) */
49594 20 : if ( str2 != NULL)
49595 : {
49596 20 : Py_DECREF(str2);
49597 : }
49598 20 : GDALPythonFreeCStr(arg2, bToFree2);
49599 : }
49600 20 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
49601 : return resultobj;
49602 0 : fail:
49603 0 : {
49604 : /* %typemap(freearg) (tostring argin) */
49605 0 : if ( str2 != NULL)
49606 : {
49607 0 : Py_DECREF(str2);
49608 : }
49609 20 : GDALPythonFreeCStr(arg2, bToFree2);
49610 : }
49611 : return NULL;
49612 : }
49613 :
49614 :
49615 277 : SWIGINTERN PyObject *Relationship_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49616 277 : PyObject *obj;
49617 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
49618 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALRelationshipShadow, SWIG_NewClientData(obj));
49619 277 : return SWIG_Py_Void();
49620 : }
49621 :
49622 29 : SWIGINTERN PyObject *Relationship_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49623 29 : return SWIG_Python_InitShadowInstance(args);
49624 : }
49625 :
49626 3713 : SWIGINTERN PyObject *_wrap_TermProgress_nocb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49627 3713 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
49628 3713 : double arg1 ;
49629 3713 : char *arg2 = (char *) NULL ;
49630 3713 : void *arg3 = (void *) NULL ;
49631 3713 : double val1 ;
49632 3713 : int ecode1 = 0 ;
49633 3713 : int res2 ;
49634 3713 : char *buf2 = 0 ;
49635 3713 : int alloc2 = 0 ;
49636 3713 : int res3 ;
49637 3713 : PyObject * obj0 = 0 ;
49638 3713 : PyObject * obj1 = 0 ;
49639 3713 : PyObject * obj2 = 0 ;
49640 3713 : char * kwnames[] = {
49641 : (char *)"dfProgress", (char *)"pszMessage", (char *)"pData", NULL
49642 : };
49643 3713 : int result;
49644 :
49645 3713 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:TermProgress_nocb", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
49646 3713 : ecode1 = SWIG_AsVal_double(obj0, &val1);
49647 3713 : if (!SWIG_IsOK(ecode1)) {
49648 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TermProgress_nocb" "', argument " "1"" of type '" "double""'");
49649 : }
49650 3713 : arg1 = static_cast< double >(val1);
49651 3713 : if (obj1) {
49652 1347 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
49653 1347 : if (!SWIG_IsOK(res2)) {
49654 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TermProgress_nocb" "', argument " "2"" of type '" "char const *""'");
49655 : }
49656 1347 : arg2 = reinterpret_cast< char * >(buf2);
49657 : }
49658 3713 : if (obj2) {
49659 1347 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
49660 1347 : if (!SWIG_IsOK(res3)) {
49661 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TermProgress_nocb" "', argument " "3"" of type '" "void *""'");
49662 : }
49663 : }
49664 3713 : {
49665 3713 : const int bLocalUseExceptions = GetUseExceptions();
49666 3713 : if ( bLocalUseExceptions ) {
49667 3710 : pushErrorHandler();
49668 : }
49669 3713 : {
49670 3713 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
49671 3713 : result = (int)GDALTermProgress_nocb(arg1,(char const *)arg2,arg3);
49672 3713 : SWIG_PYTHON_THREAD_END_ALLOW;
49673 : }
49674 3713 : if ( bLocalUseExceptions ) {
49675 3710 : popErrorHandler();
49676 : }
49677 : #ifndef SED_HACKS
49678 : if ( bLocalUseExceptions ) {
49679 : CPLErr eclass = CPLGetLastErrorType();
49680 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
49681 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
49682 : }
49683 : }
49684 : #endif
49685 : }
49686 3713 : resultobj = SWIG_From_int(static_cast< int >(result));
49687 3713 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
49688 3713 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
49689 : return resultobj;
49690 0 : fail:
49691 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
49692 : return NULL;
49693 : }
49694 :
49695 :
49696 4 : SWIGINTERN PyObject *_wrap_ComputeMedianCutPCT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49697 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
49698 4 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
49699 4 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
49700 4 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
49701 4 : int arg4 ;
49702 4 : GDALColorTableShadow *arg5 = (GDALColorTableShadow *) 0 ;
49703 4 : GDALProgressFunc arg6 = (GDALProgressFunc) NULL ;
49704 4 : void *arg7 = (void *) NULL ;
49705 4 : void *argp1 = 0 ;
49706 4 : int res1 = 0 ;
49707 4 : void *argp2 = 0 ;
49708 4 : int res2 = 0 ;
49709 4 : void *argp3 = 0 ;
49710 4 : int res3 = 0 ;
49711 4 : int val4 ;
49712 4 : int ecode4 = 0 ;
49713 4 : void *argp5 = 0 ;
49714 4 : int res5 = 0 ;
49715 4 : PyObject * obj0 = 0 ;
49716 4 : PyObject * obj1 = 0 ;
49717 4 : PyObject * obj2 = 0 ;
49718 4 : PyObject * obj3 = 0 ;
49719 4 : PyObject * obj4 = 0 ;
49720 4 : PyObject * obj5 = 0 ;
49721 4 : PyObject * obj6 = 0 ;
49722 4 : char * kwnames[] = {
49723 : (char *)"red", (char *)"green", (char *)"blue", (char *)"num_colors", (char *)"colors", (char *)"callback", (char *)"callback_data", NULL
49724 : };
49725 4 : int result;
49726 :
49727 : /* %typemap(arginit) ( const char* callback_data=NULL) */
49728 4 : PyProgressData *psProgressInfo;
49729 4 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
49730 4 : psProgressInfo->nLastReported = -1;
49731 4 : psProgressInfo->psPyCallback = NULL;
49732 4 : psProgressInfo->psPyCallbackData = NULL;
49733 4 : arg7 = psProgressInfo;
49734 4 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OO:ComputeMedianCutPCT", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
49735 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
49736 4 : if (!SWIG_IsOK(res1)) {
49737 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComputeMedianCutPCT" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
49738 : }
49739 4 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
49740 4 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
49741 4 : if (!SWIG_IsOK(res2)) {
49742 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComputeMedianCutPCT" "', argument " "2"" of type '" "GDALRasterBandShadow *""'");
49743 : }
49744 4 : arg2 = reinterpret_cast< GDALRasterBandShadow * >(argp2);
49745 4 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
49746 4 : if (!SWIG_IsOK(res3)) {
49747 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ComputeMedianCutPCT" "', argument " "3"" of type '" "GDALRasterBandShadow *""'");
49748 : }
49749 4 : arg3 = reinterpret_cast< GDALRasterBandShadow * >(argp3);
49750 4 : ecode4 = SWIG_AsVal_int(obj3, &val4);
49751 4 : if (!SWIG_IsOK(ecode4)) {
49752 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ComputeMedianCutPCT" "', argument " "4"" of type '" "int""'");
49753 : }
49754 4 : arg4 = static_cast< int >(val4);
49755 4 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_GDALColorTableShadow, 0 | 0 );
49756 4 : if (!SWIG_IsOK(res5)) {
49757 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ComputeMedianCutPCT" "', argument " "5"" of type '" "GDALColorTableShadow *""'");
49758 : }
49759 4 : arg5 = reinterpret_cast< GDALColorTableShadow * >(argp5);
49760 4 : if (obj5) {
49761 3 : {
49762 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
49763 : /* callback_func typemap */
49764 :
49765 : /* In some cases 0 is passed instead of None. */
49766 : /* See https://github.com/OSGeo/gdal/pull/219 */
49767 3 : if ( PyLong_Check(obj5) || PyInt_Check(obj5) )
49768 : {
49769 0 : if( PyLong_AsLong(obj5) == 0 )
49770 : {
49771 0 : obj5 = Py_None;
49772 : }
49773 : }
49774 :
49775 3 : if (obj5 && obj5 != Py_None ) {
49776 3 : void* cbfunction = NULL;
49777 3 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj5,
49778 : (void**)&cbfunction,
49779 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
49780 : SWIG_POINTER_EXCEPTION | 0 ));
49781 :
49782 3 : if ( cbfunction == GDALTermProgress ) {
49783 : arg6 = GDALTermProgress;
49784 : } else {
49785 3 : if (!PyCallable_Check(obj5)) {
49786 0 : PyErr_SetString( PyExc_RuntimeError,
49787 : "Object given is not a Python function" );
49788 0 : SWIG_fail;
49789 : }
49790 3 : psProgressInfo->psPyCallback = obj5;
49791 3 : arg6 = PyProgressProxy;
49792 : }
49793 :
49794 : }
49795 :
49796 : }
49797 : }
49798 4 : if (obj6) {
49799 0 : {
49800 : /* %typemap(in) ( void* callback_data=NULL) */
49801 0 : psProgressInfo->psPyCallbackData = obj6 ;
49802 : }
49803 : }
49804 4 : {
49805 4 : if (!arg1) {
49806 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
49807 : }
49808 : }
49809 4 : {
49810 4 : if (!arg2) {
49811 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
49812 : }
49813 : }
49814 4 : {
49815 4 : if (!arg3) {
49816 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
49817 : }
49818 : }
49819 4 : {
49820 4 : if (!arg5) {
49821 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
49822 : }
49823 : }
49824 4 : {
49825 4 : const int bLocalUseExceptions = GetUseExceptions();
49826 4 : if ( bLocalUseExceptions ) {
49827 4 : pushErrorHandler();
49828 : }
49829 4 : {
49830 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
49831 4 : result = (int)ComputeMedianCutPCT(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49832 4 : SWIG_PYTHON_THREAD_END_ALLOW;
49833 : }
49834 4 : if ( bLocalUseExceptions ) {
49835 4 : popErrorHandler();
49836 : }
49837 : #ifndef SED_HACKS
49838 : if ( bLocalUseExceptions ) {
49839 : CPLErr eclass = CPLGetLastErrorType();
49840 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
49841 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
49842 : }
49843 : }
49844 : #endif
49845 : }
49846 4 : resultobj = SWIG_From_int(static_cast< int >(result));
49847 4 : {
49848 : /* %typemap(freearg) ( void* callback_data=NULL) */
49849 :
49850 4 : CPLFree(psProgressInfo);
49851 :
49852 : }
49853 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
49854 : return resultobj;
49855 0 : fail:
49856 0 : {
49857 : /* %typemap(freearg) ( void* callback_data=NULL) */
49858 :
49859 0 : CPLFree(psProgressInfo);
49860 :
49861 : }
49862 : return NULL;
49863 : }
49864 :
49865 :
49866 7 : SWIGINTERN PyObject *_wrap_DitherRGB2PCT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49867 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
49868 7 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
49869 7 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
49870 7 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
49871 7 : GDALRasterBandShadow *arg4 = (GDALRasterBandShadow *) 0 ;
49872 7 : GDALColorTableShadow *arg5 = (GDALColorTableShadow *) 0 ;
49873 7 : GDALProgressFunc arg6 = (GDALProgressFunc) NULL ;
49874 7 : void *arg7 = (void *) NULL ;
49875 7 : void *argp1 = 0 ;
49876 7 : int res1 = 0 ;
49877 7 : void *argp2 = 0 ;
49878 7 : int res2 = 0 ;
49879 7 : void *argp3 = 0 ;
49880 7 : int res3 = 0 ;
49881 7 : void *argp4 = 0 ;
49882 7 : int res4 = 0 ;
49883 7 : void *argp5 = 0 ;
49884 7 : int res5 = 0 ;
49885 7 : PyObject * obj0 = 0 ;
49886 7 : PyObject * obj1 = 0 ;
49887 7 : PyObject * obj2 = 0 ;
49888 7 : PyObject * obj3 = 0 ;
49889 7 : PyObject * obj4 = 0 ;
49890 7 : PyObject * obj5 = 0 ;
49891 7 : PyObject * obj6 = 0 ;
49892 7 : char * kwnames[] = {
49893 : (char *)"red", (char *)"green", (char *)"blue", (char *)"target", (char *)"colors", (char *)"callback", (char *)"callback_data", NULL
49894 : };
49895 7 : int result;
49896 :
49897 : /* %typemap(arginit) ( const char* callback_data=NULL) */
49898 7 : PyProgressData *psProgressInfo;
49899 7 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
49900 7 : psProgressInfo->nLastReported = -1;
49901 7 : psProgressInfo->psPyCallback = NULL;
49902 7 : psProgressInfo->psPyCallbackData = NULL;
49903 7 : arg7 = psProgressInfo;
49904 7 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OO:DitherRGB2PCT", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
49905 7 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
49906 7 : if (!SWIG_IsOK(res1)) {
49907 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DitherRGB2PCT" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
49908 : }
49909 7 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
49910 7 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
49911 7 : if (!SWIG_IsOK(res2)) {
49912 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DitherRGB2PCT" "', argument " "2"" of type '" "GDALRasterBandShadow *""'");
49913 : }
49914 7 : arg2 = reinterpret_cast< GDALRasterBandShadow * >(argp2);
49915 7 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
49916 7 : if (!SWIG_IsOK(res3)) {
49917 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DitherRGB2PCT" "', argument " "3"" of type '" "GDALRasterBandShadow *""'");
49918 : }
49919 7 : arg3 = reinterpret_cast< GDALRasterBandShadow * >(argp3);
49920 7 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
49921 7 : if (!SWIG_IsOK(res4)) {
49922 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DitherRGB2PCT" "', argument " "4"" of type '" "GDALRasterBandShadow *""'");
49923 : }
49924 7 : arg4 = reinterpret_cast< GDALRasterBandShadow * >(argp4);
49925 7 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_GDALColorTableShadow, 0 | 0 );
49926 7 : if (!SWIG_IsOK(res5)) {
49927 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DitherRGB2PCT" "', argument " "5"" of type '" "GDALColorTableShadow *""'");
49928 : }
49929 7 : arg5 = reinterpret_cast< GDALColorTableShadow * >(argp5);
49930 7 : if (obj5) {
49931 6 : {
49932 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
49933 : /* callback_func typemap */
49934 :
49935 : /* In some cases 0 is passed instead of None. */
49936 : /* See https://github.com/OSGeo/gdal/pull/219 */
49937 6 : if ( PyLong_Check(obj5) || PyInt_Check(obj5) )
49938 : {
49939 0 : if( PyLong_AsLong(obj5) == 0 )
49940 : {
49941 0 : obj5 = Py_None;
49942 : }
49943 : }
49944 :
49945 6 : if (obj5 && obj5 != Py_None ) {
49946 6 : void* cbfunction = NULL;
49947 6 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj5,
49948 : (void**)&cbfunction,
49949 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
49950 : SWIG_POINTER_EXCEPTION | 0 ));
49951 :
49952 6 : if ( cbfunction == GDALTermProgress ) {
49953 : arg6 = GDALTermProgress;
49954 : } else {
49955 6 : if (!PyCallable_Check(obj5)) {
49956 0 : PyErr_SetString( PyExc_RuntimeError,
49957 : "Object given is not a Python function" );
49958 0 : SWIG_fail;
49959 : }
49960 6 : psProgressInfo->psPyCallback = obj5;
49961 6 : arg6 = PyProgressProxy;
49962 : }
49963 :
49964 : }
49965 :
49966 : }
49967 : }
49968 7 : if (obj6) {
49969 0 : {
49970 : /* %typemap(in) ( void* callback_data=NULL) */
49971 0 : psProgressInfo->psPyCallbackData = obj6 ;
49972 : }
49973 : }
49974 7 : {
49975 7 : if (!arg1) {
49976 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
49977 : }
49978 : }
49979 7 : {
49980 7 : if (!arg2) {
49981 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
49982 : }
49983 : }
49984 7 : {
49985 7 : if (!arg3) {
49986 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
49987 : }
49988 : }
49989 7 : {
49990 7 : if (!arg4) {
49991 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
49992 : }
49993 : }
49994 7 : {
49995 7 : if (!arg5) {
49996 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
49997 : }
49998 : }
49999 7 : {
50000 7 : const int bLocalUseExceptions = GetUseExceptions();
50001 7 : if ( bLocalUseExceptions ) {
50002 7 : pushErrorHandler();
50003 : }
50004 7 : {
50005 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
50006 7 : result = (int)DitherRGB2PCT(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
50007 7 : SWIG_PYTHON_THREAD_END_ALLOW;
50008 : }
50009 7 : if ( bLocalUseExceptions ) {
50010 7 : popErrorHandler();
50011 : }
50012 : #ifndef SED_HACKS
50013 : if ( bLocalUseExceptions ) {
50014 : CPLErr eclass = CPLGetLastErrorType();
50015 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
50016 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
50017 : }
50018 : }
50019 : #endif
50020 : }
50021 7 : resultobj = SWIG_From_int(static_cast< int >(result));
50022 7 : {
50023 : /* %typemap(freearg) ( void* callback_data=NULL) */
50024 :
50025 7 : CPLFree(psProgressInfo);
50026 :
50027 : }
50028 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
50029 : return resultobj;
50030 0 : fail:
50031 0 : {
50032 : /* %typemap(freearg) ( void* callback_data=NULL) */
50033 :
50034 0 : CPLFree(psProgressInfo);
50035 :
50036 : }
50037 : return NULL;
50038 : }
50039 :
50040 :
50041 62 : SWIGINTERN PyObject *_wrap_ReprojectImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50042 62 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
50043 62 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
50044 62 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
50045 62 : char *arg3 = (char *) NULL ;
50046 62 : char *arg4 = (char *) NULL ;
50047 62 : GDALResampleAlg arg5 = (GDALResampleAlg) GRA_NearestNeighbour ;
50048 62 : double arg6 = (double) 0.0 ;
50049 62 : double arg7 = (double) 0.0 ;
50050 62 : GDALProgressFunc arg8 = (GDALProgressFunc) NULL ;
50051 62 : void *arg9 = (void *) NULL ;
50052 62 : char **arg10 = (char **) NULL ;
50053 62 : void *argp1 = 0 ;
50054 62 : int res1 = 0 ;
50055 62 : void *argp2 = 0 ;
50056 62 : int res2 = 0 ;
50057 62 : int res3 ;
50058 62 : char *buf3 = 0 ;
50059 62 : int alloc3 = 0 ;
50060 62 : int res4 ;
50061 62 : char *buf4 = 0 ;
50062 62 : int alloc4 = 0 ;
50063 62 : int val5 ;
50064 62 : int ecode5 = 0 ;
50065 62 : double val6 ;
50066 62 : int ecode6 = 0 ;
50067 62 : double val7 ;
50068 62 : int ecode7 = 0 ;
50069 62 : PyObject * obj0 = 0 ;
50070 62 : PyObject * obj1 = 0 ;
50071 62 : PyObject * obj2 = 0 ;
50072 62 : PyObject * obj3 = 0 ;
50073 62 : PyObject * obj4 = 0 ;
50074 62 : PyObject * obj5 = 0 ;
50075 62 : PyObject * obj6 = 0 ;
50076 62 : PyObject * obj7 = 0 ;
50077 62 : PyObject * obj8 = 0 ;
50078 62 : PyObject * obj9 = 0 ;
50079 62 : char * kwnames[] = {
50080 : (char *)"src_ds", (char *)"dst_ds", (char *)"src_wkt", (char *)"dst_wkt", (char *)"eResampleAlg", (char *)"WarpMemoryLimit", (char *)"maxerror", (char *)"callback", (char *)"callback_data", (char *)"options", NULL
50081 : };
50082 62 : CPLErr result;
50083 :
50084 : /* %typemap(arginit) ( const char* callback_data=NULL) */
50085 62 : PyProgressData *psProgressInfo;
50086 62 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
50087 62 : psProgressInfo->nLastReported = -1;
50088 62 : psProgressInfo->psPyCallback = NULL;
50089 62 : psProgressInfo->psPyCallbackData = NULL;
50090 62 : arg9 = psProgressInfo;
50091 62 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOOOOOOO:ReprojectImage", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9)) SWIG_fail;
50092 62 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
50093 62 : if (!SWIG_IsOK(res1)) {
50094 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReprojectImage" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
50095 : }
50096 62 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
50097 62 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
50098 62 : if (!SWIG_IsOK(res2)) {
50099 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReprojectImage" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
50100 : }
50101 62 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
50102 62 : if (obj2) {
50103 61 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
50104 61 : if (!SWIG_IsOK(res3)) {
50105 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ReprojectImage" "', argument " "3"" of type '" "char const *""'");
50106 : }
50107 61 : arg3 = reinterpret_cast< char * >(buf3);
50108 : }
50109 62 : if (obj3) {
50110 61 : res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
50111 61 : if (!SWIG_IsOK(res4)) {
50112 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ReprojectImage" "', argument " "4"" of type '" "char const *""'");
50113 : }
50114 61 : arg4 = reinterpret_cast< char * >(buf4);
50115 : }
50116 62 : if (obj4) {
50117 60 : ecode5 = SWIG_AsVal_int(obj4, &val5);
50118 60 : if (!SWIG_IsOK(ecode5)) {
50119 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ReprojectImage" "', argument " "5"" of type '" "GDALResampleAlg""'");
50120 : }
50121 60 : arg5 = static_cast< GDALResampleAlg >(val5);
50122 : }
50123 62 : if (obj5) {
50124 3 : ecode6 = SWIG_AsVal_double(obj5, &val6);
50125 3 : if (!SWIG_IsOK(ecode6)) {
50126 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ReprojectImage" "', argument " "6"" of type '" "double""'");
50127 : }
50128 3 : arg6 = static_cast< double >(val6);
50129 : }
50130 62 : if (obj6) {
50131 3 : ecode7 = SWIG_AsVal_double(obj6, &val7);
50132 3 : if (!SWIG_IsOK(ecode7)) {
50133 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ReprojectImage" "', argument " "7"" of type '" "double""'");
50134 : }
50135 3 : arg7 = static_cast< double >(val7);
50136 : }
50137 62 : if (obj7) {
50138 3 : {
50139 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
50140 : /* callback_func typemap */
50141 :
50142 : /* In some cases 0 is passed instead of None. */
50143 : /* See https://github.com/OSGeo/gdal/pull/219 */
50144 3 : if ( PyLong_Check(obj7) || PyInt_Check(obj7) )
50145 : {
50146 0 : if( PyLong_AsLong(obj7) == 0 )
50147 : {
50148 0 : obj7 = Py_None;
50149 : }
50150 : }
50151 :
50152 3 : if (obj7 && obj7 != Py_None ) {
50153 3 : void* cbfunction = NULL;
50154 3 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj7,
50155 : (void**)&cbfunction,
50156 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
50157 : SWIG_POINTER_EXCEPTION | 0 ));
50158 :
50159 3 : if ( cbfunction == GDALTermProgress ) {
50160 : arg8 = GDALTermProgress;
50161 : } else {
50162 3 : if (!PyCallable_Check(obj7)) {
50163 0 : PyErr_SetString( PyExc_RuntimeError,
50164 : "Object given is not a Python function" );
50165 0 : SWIG_fail;
50166 : }
50167 3 : psProgressInfo->psPyCallback = obj7;
50168 3 : arg8 = PyProgressProxy;
50169 : }
50170 :
50171 : }
50172 :
50173 : }
50174 : }
50175 62 : if (obj8) {
50176 3 : {
50177 : /* %typemap(in) ( void* callback_data=NULL) */
50178 3 : psProgressInfo->psPyCallbackData = obj8 ;
50179 : }
50180 : }
50181 62 : if (obj9) {
50182 1 : {
50183 : /* %typemap(in) char **dict */
50184 1 : arg10 = NULL;
50185 1 : if ( PySequence_Check( obj9 ) ) {
50186 1 : int bErr = FALSE;
50187 1 : arg10 = CSLFromPySequence(obj9, &bErr);
50188 1 : if ( bErr )
50189 : {
50190 0 : SWIG_fail;
50191 : }
50192 : }
50193 0 : else if ( PyMapping_Check( obj9 ) ) {
50194 0 : int bErr = FALSE;
50195 0 : arg10 = CSLFromPyMapping(obj9, &bErr);
50196 0 : if ( bErr )
50197 : {
50198 0 : SWIG_fail;
50199 : }
50200 : }
50201 : else {
50202 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
50203 0 : SWIG_fail;
50204 : }
50205 : }
50206 : }
50207 62 : {
50208 62 : if (!arg1) {
50209 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
50210 : }
50211 : }
50212 62 : {
50213 62 : if (!arg2) {
50214 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
50215 : }
50216 : }
50217 62 : {
50218 62 : const int bLocalUseExceptions = GetUseExceptions();
50219 62 : if ( bLocalUseExceptions ) {
50220 62 : pushErrorHandler();
50221 : }
50222 62 : {
50223 62 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
50224 62 : result = (CPLErr)ReprojectImage(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10);
50225 62 : SWIG_PYTHON_THREAD_END_ALLOW;
50226 : }
50227 62 : if ( bLocalUseExceptions ) {
50228 62 : popErrorHandler();
50229 : }
50230 : #ifndef SED_HACKS
50231 : if ( bLocalUseExceptions ) {
50232 : CPLErr eclass = CPLGetLastErrorType();
50233 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
50234 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
50235 : }
50236 : }
50237 : #endif
50238 : }
50239 62 : resultobj = SWIG_From_int(static_cast< int >(result));
50240 62 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
50241 62 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
50242 62 : {
50243 : /* %typemap(freearg) ( void* callback_data=NULL) */
50244 :
50245 62 : CPLFree(psProgressInfo);
50246 :
50247 : }
50248 62 : {
50249 : /* %typemap(freearg) char **dict */
50250 62 : CSLDestroy( arg10 );
50251 : }
50252 64 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
50253 : return resultobj;
50254 0 : fail:
50255 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
50256 0 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
50257 0 : {
50258 : /* %typemap(freearg) ( void* callback_data=NULL) */
50259 :
50260 0 : CPLFree(psProgressInfo);
50261 :
50262 : }
50263 0 : {
50264 : /* %typemap(freearg) char **dict */
50265 0 : CSLDestroy( arg10 );
50266 : }
50267 : return NULL;
50268 : }
50269 :
50270 :
50271 6 : SWIGINTERN PyObject *_wrap_ComputeProximity(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50272 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
50273 6 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
50274 6 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
50275 6 : char **arg3 = (char **) NULL ;
50276 6 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
50277 6 : void *arg5 = (void *) NULL ;
50278 6 : void *argp1 = 0 ;
50279 6 : int res1 = 0 ;
50280 6 : void *argp2 = 0 ;
50281 6 : int res2 = 0 ;
50282 6 : PyObject * obj0 = 0 ;
50283 6 : PyObject * obj1 = 0 ;
50284 6 : PyObject * obj2 = 0 ;
50285 6 : PyObject * obj3 = 0 ;
50286 6 : PyObject * obj4 = 0 ;
50287 6 : char * kwnames[] = {
50288 : (char *)"srcBand", (char *)"proximityBand", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
50289 : };
50290 6 : int result;
50291 :
50292 : /* %typemap(arginit) ( const char* callback_data=NULL) */
50293 6 : PyProgressData *psProgressInfo;
50294 6 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
50295 6 : psProgressInfo->nLastReported = -1;
50296 6 : psProgressInfo->psPyCallback = NULL;
50297 6 : psProgressInfo->psPyCallbackData = NULL;
50298 6 : arg5 = psProgressInfo;
50299 6 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:ComputeProximity", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
50300 6 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
50301 6 : if (!SWIG_IsOK(res1)) {
50302 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComputeProximity" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
50303 : }
50304 6 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
50305 6 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
50306 6 : if (!SWIG_IsOK(res2)) {
50307 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComputeProximity" "', argument " "2"" of type '" "GDALRasterBandShadow *""'");
50308 : }
50309 6 : arg2 = reinterpret_cast< GDALRasterBandShadow * >(argp2);
50310 6 : if (obj2) {
50311 5 : {
50312 : /* %typemap(in) char **dict */
50313 5 : arg3 = NULL;
50314 5 : if ( PySequence_Check( obj2 ) ) {
50315 5 : int bErr = FALSE;
50316 5 : arg3 = CSLFromPySequence(obj2, &bErr);
50317 5 : if ( bErr )
50318 : {
50319 0 : SWIG_fail;
50320 : }
50321 : }
50322 0 : else if ( PyMapping_Check( obj2 ) ) {
50323 0 : int bErr = FALSE;
50324 0 : arg3 = CSLFromPyMapping(obj2, &bErr);
50325 0 : if ( bErr )
50326 : {
50327 0 : SWIG_fail;
50328 : }
50329 : }
50330 : else {
50331 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
50332 0 : SWIG_fail;
50333 : }
50334 : }
50335 : }
50336 6 : if (obj3) {
50337 3 : {
50338 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
50339 : /* callback_func typemap */
50340 :
50341 : /* In some cases 0 is passed instead of None. */
50342 : /* See https://github.com/OSGeo/gdal/pull/219 */
50343 3 : if ( PyLong_Check(obj3) || PyInt_Check(obj3) )
50344 : {
50345 0 : if( PyLong_AsLong(obj3) == 0 )
50346 : {
50347 0 : obj3 = Py_None;
50348 : }
50349 : }
50350 :
50351 3 : if (obj3 && obj3 != Py_None ) {
50352 1 : void* cbfunction = NULL;
50353 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj3,
50354 : (void**)&cbfunction,
50355 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
50356 : SWIG_POINTER_EXCEPTION | 0 ));
50357 :
50358 1 : if ( cbfunction == GDALTermProgress ) {
50359 : arg4 = GDALTermProgress;
50360 : } else {
50361 1 : if (!PyCallable_Check(obj3)) {
50362 0 : PyErr_SetString( PyExc_RuntimeError,
50363 : "Object given is not a Python function" );
50364 0 : SWIG_fail;
50365 : }
50366 1 : psProgressInfo->psPyCallback = obj3;
50367 1 : arg4 = PyProgressProxy;
50368 : }
50369 :
50370 : }
50371 :
50372 : }
50373 : }
50374 6 : if (obj4) {
50375 0 : {
50376 : /* %typemap(in) ( void* callback_data=NULL) */
50377 0 : psProgressInfo->psPyCallbackData = obj4 ;
50378 : }
50379 : }
50380 6 : {
50381 6 : if (!arg1) {
50382 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
50383 : }
50384 : }
50385 6 : {
50386 6 : if (!arg2) {
50387 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
50388 : }
50389 : }
50390 6 : {
50391 6 : const int bLocalUseExceptions = GetUseExceptions();
50392 6 : if ( bLocalUseExceptions ) {
50393 6 : pushErrorHandler();
50394 : }
50395 6 : {
50396 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
50397 6 : result = (int)ComputeProximity(arg1,arg2,arg3,arg4,arg5);
50398 6 : SWIG_PYTHON_THREAD_END_ALLOW;
50399 : }
50400 6 : if ( bLocalUseExceptions ) {
50401 6 : popErrorHandler();
50402 : }
50403 : #ifndef SED_HACKS
50404 : if ( bLocalUseExceptions ) {
50405 : CPLErr eclass = CPLGetLastErrorType();
50406 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
50407 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
50408 : }
50409 : }
50410 : #endif
50411 : }
50412 6 : resultobj = SWIG_From_int(static_cast< int >(result));
50413 6 : {
50414 : /* %typemap(freearg) char **dict */
50415 6 : CSLDestroy( arg3 );
50416 : }
50417 6 : {
50418 : /* %typemap(freearg) ( void* callback_data=NULL) */
50419 :
50420 6 : CPLFree(psProgressInfo);
50421 :
50422 : }
50423 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
50424 : return resultobj;
50425 0 : fail:
50426 0 : {
50427 : /* %typemap(freearg) char **dict */
50428 0 : CSLDestroy( arg3 );
50429 : }
50430 0 : {
50431 : /* %typemap(freearg) ( void* callback_data=NULL) */
50432 :
50433 0 : CPLFree(psProgressInfo);
50434 :
50435 : }
50436 : return NULL;
50437 : }
50438 :
50439 :
50440 42 : SWIGINTERN PyObject *_wrap_RasterizeLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50441 42 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
50442 42 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
50443 42 : int arg2 ;
50444 42 : int *arg3 = (int *) 0 ;
50445 42 : OGRLayerShadow *arg4 = (OGRLayerShadow *) 0 ;
50446 42 : void *arg5 = (void *) NULL ;
50447 42 : void *arg6 = (void *) NULL ;
50448 42 : int arg7 = (int) 0 ;
50449 42 : double *arg8 = (double *) NULL ;
50450 42 : char **arg9 = (char **) NULL ;
50451 42 : GDALProgressFunc arg10 = (GDALProgressFunc) NULL ;
50452 42 : void *arg11 = (void *) NULL ;
50453 42 : void *argp1 = 0 ;
50454 42 : int res1 = 0 ;
50455 42 : void *argp4 = 0 ;
50456 42 : int res4 = 0 ;
50457 42 : int res5 ;
50458 42 : int res6 ;
50459 42 : PyObject * obj0 = 0 ;
50460 42 : PyObject * obj1 = 0 ;
50461 42 : PyObject * obj2 = 0 ;
50462 42 : PyObject * obj3 = 0 ;
50463 42 : PyObject * obj4 = 0 ;
50464 42 : PyObject * obj5 = 0 ;
50465 42 : PyObject * obj6 = 0 ;
50466 42 : PyObject * obj7 = 0 ;
50467 42 : PyObject * obj8 = 0 ;
50468 42 : char * kwnames[] = {
50469 : (char *)"dataset", (char *)"bands", (char *)"layer", (char *)"pfnTransformer", (char *)"pTransformArg", (char *)"burn_values", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
50470 : };
50471 42 : int result;
50472 :
50473 : /* %typemap(arginit) ( const char* callback_data=NULL) */
50474 42 : PyProgressData *psProgressInfo;
50475 42 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
50476 42 : psProgressInfo->nLastReported = -1;
50477 42 : psProgressInfo->psPyCallback = NULL;
50478 42 : psProgressInfo->psPyCallbackData = NULL;
50479 42 : arg11 = psProgressInfo;
50480 42 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOOOOO:RasterizeLayer", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
50481 42 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
50482 42 : if (!SWIG_IsOK(res1)) {
50483 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterizeLayer" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
50484 : }
50485 42 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
50486 42 : {
50487 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
50488 42 : arg3 = CreateCIntListFromSequence(obj1, &arg2);
50489 42 : if( arg2 < 0 ) {
50490 0 : SWIG_fail;
50491 : }
50492 : }
50493 42 : res4 = SWIG_ConvertPtr(obj2, &argp4,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
50494 42 : if (!SWIG_IsOK(res4)) {
50495 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RasterizeLayer" "', argument " "4"" of type '" "OGRLayerShadow *""'");
50496 : }
50497 42 : arg4 = reinterpret_cast< OGRLayerShadow * >(argp4);
50498 42 : if (obj3) {
50499 0 : res5 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg5), 0, 0);
50500 0 : if (!SWIG_IsOK(res5)) {
50501 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RasterizeLayer" "', argument " "5"" of type '" "void *""'");
50502 : }
50503 : }
50504 42 : if (obj4) {
50505 0 : res6 = SWIG_ConvertPtr(obj4,SWIG_as_voidptrptr(&arg6), 0, 0);
50506 0 : if (!SWIG_IsOK(res6)) {
50507 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "RasterizeLayer" "', argument " "6"" of type '" "void *""'");
50508 : }
50509 : }
50510 42 : if (obj5) {
50511 41 : {
50512 : /* %typemap(in,numinputs=1) (int nList, double* pList)*/
50513 41 : arg8 = CreateCDoubleListFromSequence(obj5, &arg7);
50514 41 : if( arg7 < 0 ) {
50515 0 : SWIG_fail;
50516 : }
50517 : }
50518 : }
50519 42 : if (obj6) {
50520 41 : {
50521 : /* %typemap(in) char **dict */
50522 41 : arg9 = NULL;
50523 41 : if ( PySequence_Check( obj6 ) ) {
50524 41 : int bErr = FALSE;
50525 41 : arg9 = CSLFromPySequence(obj6, &bErr);
50526 41 : if ( bErr )
50527 : {
50528 0 : SWIG_fail;
50529 : }
50530 : }
50531 0 : else if ( PyMapping_Check( obj6 ) ) {
50532 0 : int bErr = FALSE;
50533 0 : arg9 = CSLFromPyMapping(obj6, &bErr);
50534 0 : if ( bErr )
50535 : {
50536 0 : SWIG_fail;
50537 : }
50538 : }
50539 : else {
50540 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
50541 0 : SWIG_fail;
50542 : }
50543 : }
50544 : }
50545 42 : if (obj7) {
50546 0 : {
50547 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
50548 : /* callback_func typemap */
50549 :
50550 : /* In some cases 0 is passed instead of None. */
50551 : /* See https://github.com/OSGeo/gdal/pull/219 */
50552 0 : if ( PyLong_Check(obj7) || PyInt_Check(obj7) )
50553 : {
50554 0 : if( PyLong_AsLong(obj7) == 0 )
50555 : {
50556 0 : obj7 = Py_None;
50557 : }
50558 : }
50559 :
50560 0 : if (obj7 && obj7 != Py_None ) {
50561 0 : void* cbfunction = NULL;
50562 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj7,
50563 : (void**)&cbfunction,
50564 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
50565 : SWIG_POINTER_EXCEPTION | 0 ));
50566 :
50567 0 : if ( cbfunction == GDALTermProgress ) {
50568 : arg10 = GDALTermProgress;
50569 : } else {
50570 0 : if (!PyCallable_Check(obj7)) {
50571 0 : PyErr_SetString( PyExc_RuntimeError,
50572 : "Object given is not a Python function" );
50573 0 : SWIG_fail;
50574 : }
50575 0 : psProgressInfo->psPyCallback = obj7;
50576 0 : arg10 = PyProgressProxy;
50577 : }
50578 :
50579 : }
50580 :
50581 : }
50582 : }
50583 42 : if (obj8) {
50584 0 : {
50585 : /* %typemap(in) ( void* callback_data=NULL) */
50586 0 : psProgressInfo->psPyCallbackData = obj8 ;
50587 : }
50588 : }
50589 42 : {
50590 42 : if (!arg1) {
50591 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
50592 : }
50593 : }
50594 42 : {
50595 42 : if (!arg4) {
50596 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
50597 : }
50598 : }
50599 42 : {
50600 42 : const int bLocalUseExceptions = GetUseExceptions();
50601 42 : if ( bLocalUseExceptions ) {
50602 42 : pushErrorHandler();
50603 : }
50604 42 : {
50605 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
50606 42 : result = (int)RasterizeLayer(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
50607 42 : SWIG_PYTHON_THREAD_END_ALLOW;
50608 : }
50609 42 : if ( bLocalUseExceptions ) {
50610 42 : popErrorHandler();
50611 : }
50612 : #ifndef SED_HACKS
50613 : if ( bLocalUseExceptions ) {
50614 : CPLErr eclass = CPLGetLastErrorType();
50615 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
50616 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
50617 : }
50618 : }
50619 : #endif
50620 : }
50621 42 : resultobj = SWIG_From_int(static_cast< int >(result));
50622 42 : {
50623 : /* %typemap(freearg) (int nList, int* pList) */
50624 42 : free(arg3);
50625 : }
50626 42 : {
50627 : /* %typemap(freearg) (int nList, double* pList) */
50628 42 : free(arg8);
50629 : }
50630 42 : {
50631 : /* %typemap(freearg) char **dict */
50632 42 : CSLDestroy( arg9 );
50633 : }
50634 42 : {
50635 : /* %typemap(freearg) ( void* callback_data=NULL) */
50636 :
50637 42 : CPLFree(psProgressInfo);
50638 :
50639 : }
50640 42 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
50641 : return resultobj;
50642 0 : fail:
50643 0 : {
50644 : /* %typemap(freearg) (int nList, int* pList) */
50645 0 : free(arg3);
50646 : }
50647 0 : {
50648 : /* %typemap(freearg) (int nList, double* pList) */
50649 0 : free(arg8);
50650 : }
50651 0 : {
50652 : /* %typemap(freearg) char **dict */
50653 0 : CSLDestroy( arg9 );
50654 : }
50655 0 : {
50656 : /* %typemap(freearg) ( void* callback_data=NULL) */
50657 :
50658 0 : CPLFree(psProgressInfo);
50659 :
50660 : }
50661 : return NULL;
50662 : }
50663 :
50664 :
50665 21 : SWIGINTERN PyObject *_wrap_Polygonize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50666 21 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
50667 21 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
50668 21 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
50669 21 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
50670 21 : int arg4 ;
50671 21 : char **arg5 = (char **) NULL ;
50672 21 : GDALProgressFunc arg6 = (GDALProgressFunc) NULL ;
50673 21 : void *arg7 = (void *) NULL ;
50674 21 : void *argp1 = 0 ;
50675 21 : int res1 = 0 ;
50676 21 : void *argp2 = 0 ;
50677 21 : int res2 = 0 ;
50678 21 : void *argp3 = 0 ;
50679 21 : int res3 = 0 ;
50680 21 : int val4 ;
50681 21 : int ecode4 = 0 ;
50682 21 : PyObject * obj0 = 0 ;
50683 21 : PyObject * obj1 = 0 ;
50684 21 : PyObject * obj2 = 0 ;
50685 21 : PyObject * obj3 = 0 ;
50686 21 : PyObject * obj4 = 0 ;
50687 21 : PyObject * obj5 = 0 ;
50688 21 : PyObject * obj6 = 0 ;
50689 21 : char * kwnames[] = {
50690 : (char *)"srcBand", (char *)"maskBand", (char *)"outLayer", (char *)"iPixValField", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
50691 : };
50692 21 : int result;
50693 :
50694 : /* %typemap(arginit) ( const char* callback_data=NULL) */
50695 21 : PyProgressData *psProgressInfo;
50696 21 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
50697 21 : psProgressInfo->nLastReported = -1;
50698 21 : psProgressInfo->psPyCallback = NULL;
50699 21 : psProgressInfo->psPyCallbackData = NULL;
50700 21 : arg7 = psProgressInfo;
50701 21 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOO:Polygonize", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
50702 21 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
50703 21 : if (!SWIG_IsOK(res1)) {
50704 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygonize" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
50705 : }
50706 21 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
50707 21 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
50708 21 : if (!SWIG_IsOK(res2)) {
50709 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Polygonize" "', argument " "2"" of type '" "GDALRasterBandShadow *""'");
50710 : }
50711 21 : arg2 = reinterpret_cast< GDALRasterBandShadow * >(argp2);
50712 21 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
50713 21 : if (!SWIG_IsOK(res3)) {
50714 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Polygonize" "', argument " "3"" of type '" "OGRLayerShadow *""'");
50715 : }
50716 21 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
50717 21 : ecode4 = SWIG_AsVal_int(obj3, &val4);
50718 21 : if (!SWIG_IsOK(ecode4)) {
50719 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Polygonize" "', argument " "4"" of type '" "int""'");
50720 : }
50721 21 : arg4 = static_cast< int >(val4);
50722 21 : if (obj4) {
50723 14 : {
50724 : /* %typemap(in) char **dict */
50725 14 : arg5 = NULL;
50726 14 : if ( PySequence_Check( obj4 ) ) {
50727 14 : int bErr = FALSE;
50728 14 : arg5 = CSLFromPySequence(obj4, &bErr);
50729 14 : if ( bErr )
50730 : {
50731 0 : SWIG_fail;
50732 : }
50733 : }
50734 0 : else if ( PyMapping_Check( obj4 ) ) {
50735 0 : int bErr = FALSE;
50736 0 : arg5 = CSLFromPyMapping(obj4, &bErr);
50737 0 : if ( bErr )
50738 : {
50739 0 : SWIG_fail;
50740 : }
50741 : }
50742 : else {
50743 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
50744 0 : SWIG_fail;
50745 : }
50746 : }
50747 : }
50748 21 : if (obj5) {
50749 12 : {
50750 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
50751 : /* callback_func typemap */
50752 :
50753 : /* In some cases 0 is passed instead of None. */
50754 : /* See https://github.com/OSGeo/gdal/pull/219 */
50755 12 : if ( PyLong_Check(obj5) || PyInt_Check(obj5) )
50756 : {
50757 0 : if( PyLong_AsLong(obj5) == 0 )
50758 : {
50759 0 : obj5 = Py_None;
50760 : }
50761 : }
50762 :
50763 12 : if (obj5 && obj5 != Py_None ) {
50764 7 : void* cbfunction = NULL;
50765 7 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj5,
50766 : (void**)&cbfunction,
50767 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
50768 : SWIG_POINTER_EXCEPTION | 0 ));
50769 :
50770 7 : if ( cbfunction == GDALTermProgress ) {
50771 : arg6 = GDALTermProgress;
50772 : } else {
50773 7 : if (!PyCallable_Check(obj5)) {
50774 0 : PyErr_SetString( PyExc_RuntimeError,
50775 : "Object given is not a Python function" );
50776 0 : SWIG_fail;
50777 : }
50778 7 : psProgressInfo->psPyCallback = obj5;
50779 7 : arg6 = PyProgressProxy;
50780 : }
50781 :
50782 : }
50783 :
50784 : }
50785 : }
50786 21 : if (obj6) {
50787 0 : {
50788 : /* %typemap(in) ( void* callback_data=NULL) */
50789 0 : psProgressInfo->psPyCallbackData = obj6 ;
50790 : }
50791 : }
50792 21 : {
50793 21 : if (!arg1) {
50794 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
50795 : }
50796 : }
50797 21 : {
50798 21 : if (!arg3) {
50799 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
50800 : }
50801 : }
50802 21 : {
50803 21 : const int bLocalUseExceptions = GetUseExceptions();
50804 21 : if ( bLocalUseExceptions ) {
50805 21 : pushErrorHandler();
50806 : }
50807 21 : {
50808 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
50809 21 : result = (int)Polygonize(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
50810 21 : SWIG_PYTHON_THREAD_END_ALLOW;
50811 : }
50812 21 : if ( bLocalUseExceptions ) {
50813 21 : popErrorHandler();
50814 : }
50815 : #ifndef SED_HACKS
50816 : if ( bLocalUseExceptions ) {
50817 : CPLErr eclass = CPLGetLastErrorType();
50818 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
50819 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
50820 : }
50821 : }
50822 : #endif
50823 : }
50824 21 : resultobj = SWIG_From_int(static_cast< int >(result));
50825 21 : {
50826 : /* %typemap(freearg) char **dict */
50827 21 : CSLDestroy( arg5 );
50828 : }
50829 21 : {
50830 : /* %typemap(freearg) ( void* callback_data=NULL) */
50831 :
50832 21 : CPLFree(psProgressInfo);
50833 :
50834 : }
50835 21 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
50836 : return resultobj;
50837 0 : fail:
50838 0 : {
50839 : /* %typemap(freearg) char **dict */
50840 0 : CSLDestroy( arg5 );
50841 : }
50842 0 : {
50843 : /* %typemap(freearg) ( void* callback_data=NULL) */
50844 :
50845 0 : CPLFree(psProgressInfo);
50846 :
50847 : }
50848 : return NULL;
50849 : }
50850 :
50851 :
50852 1 : SWIGINTERN PyObject *_wrap_FPolygonize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50853 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
50854 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
50855 1 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
50856 1 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
50857 1 : int arg4 ;
50858 1 : char **arg5 = (char **) NULL ;
50859 1 : GDALProgressFunc arg6 = (GDALProgressFunc) NULL ;
50860 1 : void *arg7 = (void *) NULL ;
50861 1 : void *argp1 = 0 ;
50862 1 : int res1 = 0 ;
50863 1 : void *argp2 = 0 ;
50864 1 : int res2 = 0 ;
50865 1 : void *argp3 = 0 ;
50866 1 : int res3 = 0 ;
50867 1 : int val4 ;
50868 1 : int ecode4 = 0 ;
50869 1 : PyObject * obj0 = 0 ;
50870 1 : PyObject * obj1 = 0 ;
50871 1 : PyObject * obj2 = 0 ;
50872 1 : PyObject * obj3 = 0 ;
50873 1 : PyObject * obj4 = 0 ;
50874 1 : PyObject * obj5 = 0 ;
50875 1 : PyObject * obj6 = 0 ;
50876 1 : char * kwnames[] = {
50877 : (char *)"srcBand", (char *)"maskBand", (char *)"outLayer", (char *)"iPixValField", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
50878 : };
50879 1 : int result;
50880 :
50881 : /* %typemap(arginit) ( const char* callback_data=NULL) */
50882 1 : PyProgressData *psProgressInfo;
50883 1 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
50884 1 : psProgressInfo->nLastReported = -1;
50885 1 : psProgressInfo->psPyCallback = NULL;
50886 1 : psProgressInfo->psPyCallbackData = NULL;
50887 1 : arg7 = psProgressInfo;
50888 1 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOO:FPolygonize", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
50889 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
50890 1 : if (!SWIG_IsOK(res1)) {
50891 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FPolygonize" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
50892 : }
50893 1 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
50894 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
50895 1 : if (!SWIG_IsOK(res2)) {
50896 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FPolygonize" "', argument " "2"" of type '" "GDALRasterBandShadow *""'");
50897 : }
50898 1 : arg2 = reinterpret_cast< GDALRasterBandShadow * >(argp2);
50899 1 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
50900 1 : if (!SWIG_IsOK(res3)) {
50901 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FPolygonize" "', argument " "3"" of type '" "OGRLayerShadow *""'");
50902 : }
50903 1 : arg3 = reinterpret_cast< OGRLayerShadow * >(argp3);
50904 1 : ecode4 = SWIG_AsVal_int(obj3, &val4);
50905 1 : if (!SWIG_IsOK(ecode4)) {
50906 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FPolygonize" "', argument " "4"" of type '" "int""'");
50907 : }
50908 1 : arg4 = static_cast< int >(val4);
50909 1 : if (obj4) {
50910 0 : {
50911 : /* %typemap(in) char **dict */
50912 0 : arg5 = NULL;
50913 0 : if ( PySequence_Check( obj4 ) ) {
50914 0 : int bErr = FALSE;
50915 0 : arg5 = CSLFromPySequence(obj4, &bErr);
50916 0 : if ( bErr )
50917 : {
50918 0 : SWIG_fail;
50919 : }
50920 : }
50921 0 : else if ( PyMapping_Check( obj4 ) ) {
50922 0 : int bErr = FALSE;
50923 0 : arg5 = CSLFromPyMapping(obj4, &bErr);
50924 0 : if ( bErr )
50925 : {
50926 0 : SWIG_fail;
50927 : }
50928 : }
50929 : else {
50930 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
50931 0 : SWIG_fail;
50932 : }
50933 : }
50934 : }
50935 1 : if (obj5) {
50936 0 : {
50937 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
50938 : /* callback_func typemap */
50939 :
50940 : /* In some cases 0 is passed instead of None. */
50941 : /* See https://github.com/OSGeo/gdal/pull/219 */
50942 0 : if ( PyLong_Check(obj5) || PyInt_Check(obj5) )
50943 : {
50944 0 : if( PyLong_AsLong(obj5) == 0 )
50945 : {
50946 0 : obj5 = Py_None;
50947 : }
50948 : }
50949 :
50950 0 : if (obj5 && obj5 != Py_None ) {
50951 0 : void* cbfunction = NULL;
50952 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj5,
50953 : (void**)&cbfunction,
50954 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
50955 : SWIG_POINTER_EXCEPTION | 0 ));
50956 :
50957 0 : if ( cbfunction == GDALTermProgress ) {
50958 : arg6 = GDALTermProgress;
50959 : } else {
50960 0 : if (!PyCallable_Check(obj5)) {
50961 0 : PyErr_SetString( PyExc_RuntimeError,
50962 : "Object given is not a Python function" );
50963 0 : SWIG_fail;
50964 : }
50965 0 : psProgressInfo->psPyCallback = obj5;
50966 0 : arg6 = PyProgressProxy;
50967 : }
50968 :
50969 : }
50970 :
50971 : }
50972 : }
50973 1 : if (obj6) {
50974 0 : {
50975 : /* %typemap(in) ( void* callback_data=NULL) */
50976 0 : psProgressInfo->psPyCallbackData = obj6 ;
50977 : }
50978 : }
50979 1 : {
50980 1 : if (!arg1) {
50981 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
50982 : }
50983 : }
50984 1 : {
50985 1 : if (!arg3) {
50986 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
50987 : }
50988 : }
50989 1 : {
50990 1 : const int bLocalUseExceptions = GetUseExceptions();
50991 1 : if ( bLocalUseExceptions ) {
50992 1 : pushErrorHandler();
50993 : }
50994 1 : {
50995 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
50996 1 : result = (int)FPolygonize(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
50997 1 : SWIG_PYTHON_THREAD_END_ALLOW;
50998 : }
50999 1 : if ( bLocalUseExceptions ) {
51000 1 : popErrorHandler();
51001 : }
51002 : #ifndef SED_HACKS
51003 : if ( bLocalUseExceptions ) {
51004 : CPLErr eclass = CPLGetLastErrorType();
51005 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
51006 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
51007 : }
51008 : }
51009 : #endif
51010 : }
51011 1 : resultobj = SWIG_From_int(static_cast< int >(result));
51012 1 : {
51013 : /* %typemap(freearg) char **dict */
51014 1 : CSLDestroy( arg5 );
51015 : }
51016 1 : {
51017 : /* %typemap(freearg) ( void* callback_data=NULL) */
51018 :
51019 1 : CPLFree(psProgressInfo);
51020 :
51021 : }
51022 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
51023 : return resultobj;
51024 0 : fail:
51025 0 : {
51026 : /* %typemap(freearg) char **dict */
51027 0 : CSLDestroy( arg5 );
51028 : }
51029 0 : {
51030 : /* %typemap(freearg) ( void* callback_data=NULL) */
51031 :
51032 0 : CPLFree(psProgressInfo);
51033 :
51034 : }
51035 : return NULL;
51036 : }
51037 :
51038 :
51039 29 : SWIGINTERN PyObject *_wrap_FillNodata(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51040 29 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
51041 29 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
51042 29 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
51043 29 : double arg3 ;
51044 29 : int arg4 ;
51045 29 : char **arg5 = (char **) NULL ;
51046 29 : GDALProgressFunc arg6 = (GDALProgressFunc) NULL ;
51047 29 : void *arg7 = (void *) NULL ;
51048 29 : void *argp1 = 0 ;
51049 29 : int res1 = 0 ;
51050 29 : void *argp2 = 0 ;
51051 29 : int res2 = 0 ;
51052 29 : double val3 ;
51053 29 : int ecode3 = 0 ;
51054 29 : int val4 ;
51055 29 : int ecode4 = 0 ;
51056 29 : PyObject * obj0 = 0 ;
51057 29 : PyObject * obj1 = 0 ;
51058 29 : PyObject * obj2 = 0 ;
51059 29 : PyObject * obj3 = 0 ;
51060 29 : PyObject * obj4 = 0 ;
51061 29 : PyObject * obj5 = 0 ;
51062 29 : PyObject * obj6 = 0 ;
51063 29 : char * kwnames[] = {
51064 : (char *)"targetBand", (char *)"maskBand", (char *)"maxSearchDist", (char *)"smoothingIterations", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
51065 : };
51066 29 : int result;
51067 :
51068 : /* %typemap(arginit) ( const char* callback_data=NULL) */
51069 29 : PyProgressData *psProgressInfo;
51070 29 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
51071 29 : psProgressInfo->nLastReported = -1;
51072 29 : psProgressInfo->psPyCallback = NULL;
51073 29 : psProgressInfo->psPyCallbackData = NULL;
51074 29 : arg7 = psProgressInfo;
51075 29 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOO:FillNodata", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
51076 29 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
51077 29 : if (!SWIG_IsOK(res1)) {
51078 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FillNodata" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
51079 : }
51080 29 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
51081 29 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
51082 29 : if (!SWIG_IsOK(res2)) {
51083 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FillNodata" "', argument " "2"" of type '" "GDALRasterBandShadow *""'");
51084 : }
51085 29 : arg2 = reinterpret_cast< GDALRasterBandShadow * >(argp2);
51086 29 : ecode3 = SWIG_AsVal_double(obj2, &val3);
51087 29 : if (!SWIG_IsOK(ecode3)) {
51088 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FillNodata" "', argument " "3"" of type '" "double""'");
51089 : }
51090 29 : arg3 = static_cast< double >(val3);
51091 29 : ecode4 = SWIG_AsVal_int(obj3, &val4);
51092 29 : if (!SWIG_IsOK(ecode4)) {
51093 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FillNodata" "', argument " "4"" of type '" "int""'");
51094 : }
51095 29 : arg4 = static_cast< int >(val4);
51096 29 : if (obj4) {
51097 26 : {
51098 : /* %typemap(in) char **dict */
51099 26 : arg5 = NULL;
51100 26 : if ( PySequence_Check( obj4 ) ) {
51101 26 : int bErr = FALSE;
51102 26 : arg5 = CSLFromPySequence(obj4, &bErr);
51103 26 : if ( bErr )
51104 : {
51105 0 : SWIG_fail;
51106 : }
51107 : }
51108 0 : else if ( PyMapping_Check( obj4 ) ) {
51109 0 : int bErr = FALSE;
51110 0 : arg5 = CSLFromPyMapping(obj4, &bErr);
51111 0 : if ( bErr )
51112 : {
51113 0 : SWIG_fail;
51114 : }
51115 : }
51116 : else {
51117 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
51118 0 : SWIG_fail;
51119 : }
51120 : }
51121 : }
51122 29 : if (obj5) {
51123 4 : {
51124 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
51125 : /* callback_func typemap */
51126 :
51127 : /* In some cases 0 is passed instead of None. */
51128 : /* See https://github.com/OSGeo/gdal/pull/219 */
51129 4 : if ( PyLong_Check(obj5) || PyInt_Check(obj5) )
51130 : {
51131 0 : if( PyLong_AsLong(obj5) == 0 )
51132 : {
51133 0 : obj5 = Py_None;
51134 : }
51135 : }
51136 :
51137 4 : if (obj5 && obj5 != Py_None ) {
51138 4 : void* cbfunction = NULL;
51139 4 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj5,
51140 : (void**)&cbfunction,
51141 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
51142 : SWIG_POINTER_EXCEPTION | 0 ));
51143 :
51144 4 : if ( cbfunction == GDALTermProgress ) {
51145 : arg6 = GDALTermProgress;
51146 : } else {
51147 4 : if (!PyCallable_Check(obj5)) {
51148 0 : PyErr_SetString( PyExc_RuntimeError,
51149 : "Object given is not a Python function" );
51150 0 : SWIG_fail;
51151 : }
51152 4 : psProgressInfo->psPyCallback = obj5;
51153 4 : arg6 = PyProgressProxy;
51154 : }
51155 :
51156 : }
51157 :
51158 : }
51159 : }
51160 29 : if (obj6) {
51161 0 : {
51162 : /* %typemap(in) ( void* callback_data=NULL) */
51163 0 : psProgressInfo->psPyCallbackData = obj6 ;
51164 : }
51165 : }
51166 29 : {
51167 29 : if (!arg1) {
51168 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
51169 : }
51170 : }
51171 29 : {
51172 29 : const int bLocalUseExceptions = GetUseExceptions();
51173 29 : if ( bLocalUseExceptions ) {
51174 29 : pushErrorHandler();
51175 : }
51176 29 : {
51177 29 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
51178 29 : result = (int)FillNodata(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
51179 29 : SWIG_PYTHON_THREAD_END_ALLOW;
51180 : }
51181 29 : if ( bLocalUseExceptions ) {
51182 29 : popErrorHandler();
51183 : }
51184 : #ifndef SED_HACKS
51185 : if ( bLocalUseExceptions ) {
51186 : CPLErr eclass = CPLGetLastErrorType();
51187 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
51188 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
51189 : }
51190 : }
51191 : #endif
51192 : }
51193 29 : resultobj = SWIG_From_int(static_cast< int >(result));
51194 29 : {
51195 : /* %typemap(freearg) char **dict */
51196 29 : CSLDestroy( arg5 );
51197 : }
51198 29 : {
51199 : /* %typemap(freearg) ( void* callback_data=NULL) */
51200 :
51201 29 : CPLFree(psProgressInfo);
51202 :
51203 : }
51204 29 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
51205 : return resultobj;
51206 0 : fail:
51207 0 : {
51208 : /* %typemap(freearg) char **dict */
51209 0 : CSLDestroy( arg5 );
51210 : }
51211 0 : {
51212 : /* %typemap(freearg) ( void* callback_data=NULL) */
51213 :
51214 0 : CPLFree(psProgressInfo);
51215 :
51216 : }
51217 : return NULL;
51218 : }
51219 :
51220 :
51221 12 : SWIGINTERN PyObject *_wrap_SieveFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51222 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
51223 12 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
51224 12 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
51225 12 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
51226 12 : int arg4 ;
51227 12 : int arg5 = (int) 4 ;
51228 12 : char **arg6 = (char **) NULL ;
51229 12 : GDALProgressFunc arg7 = (GDALProgressFunc) NULL ;
51230 12 : void *arg8 = (void *) NULL ;
51231 12 : void *argp1 = 0 ;
51232 12 : int res1 = 0 ;
51233 12 : void *argp2 = 0 ;
51234 12 : int res2 = 0 ;
51235 12 : void *argp3 = 0 ;
51236 12 : int res3 = 0 ;
51237 12 : int val4 ;
51238 12 : int ecode4 = 0 ;
51239 12 : int val5 ;
51240 12 : int ecode5 = 0 ;
51241 12 : PyObject * obj0 = 0 ;
51242 12 : PyObject * obj1 = 0 ;
51243 12 : PyObject * obj2 = 0 ;
51244 12 : PyObject * obj3 = 0 ;
51245 12 : PyObject * obj4 = 0 ;
51246 12 : PyObject * obj5 = 0 ;
51247 12 : PyObject * obj6 = 0 ;
51248 12 : PyObject * obj7 = 0 ;
51249 12 : char * kwnames[] = {
51250 : (char *)"srcBand", (char *)"maskBand", (char *)"dstBand", (char *)"threshold", (char *)"connectedness", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
51251 : };
51252 12 : int result;
51253 :
51254 : /* %typemap(arginit) ( const char* callback_data=NULL) */
51255 12 : PyProgressData *psProgressInfo;
51256 12 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
51257 12 : psProgressInfo->nLastReported = -1;
51258 12 : psProgressInfo->psPyCallback = NULL;
51259 12 : psProgressInfo->psPyCallbackData = NULL;
51260 12 : arg8 = psProgressInfo;
51261 12 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOOO:SieveFilter", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
51262 12 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
51263 12 : if (!SWIG_IsOK(res1)) {
51264 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SieveFilter" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
51265 : }
51266 12 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
51267 12 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
51268 12 : if (!SWIG_IsOK(res2)) {
51269 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SieveFilter" "', argument " "2"" of type '" "GDALRasterBandShadow *""'");
51270 : }
51271 12 : arg2 = reinterpret_cast< GDALRasterBandShadow * >(argp2);
51272 12 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
51273 12 : if (!SWIG_IsOK(res3)) {
51274 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SieveFilter" "', argument " "3"" of type '" "GDALRasterBandShadow *""'");
51275 : }
51276 12 : arg3 = reinterpret_cast< GDALRasterBandShadow * >(argp3);
51277 12 : ecode4 = SWIG_AsVal_int(obj3, &val4);
51278 12 : if (!SWIG_IsOK(ecode4)) {
51279 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SieveFilter" "', argument " "4"" of type '" "int""'");
51280 : }
51281 12 : arg4 = static_cast< int >(val4);
51282 12 : if (obj4) {
51283 12 : ecode5 = SWIG_AsVal_int(obj4, &val5);
51284 12 : if (!SWIG_IsOK(ecode5)) {
51285 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SieveFilter" "', argument " "5"" of type '" "int""'");
51286 : }
51287 : arg5 = static_cast< int >(val5);
51288 : }
51289 12 : if (obj5) {
51290 0 : {
51291 : /* %typemap(in) char **dict */
51292 0 : arg6 = NULL;
51293 0 : if ( PySequence_Check( obj5 ) ) {
51294 0 : int bErr = FALSE;
51295 0 : arg6 = CSLFromPySequence(obj5, &bErr);
51296 0 : if ( bErr )
51297 : {
51298 0 : SWIG_fail;
51299 : }
51300 : }
51301 0 : else if ( PyMapping_Check( obj5 ) ) {
51302 0 : int bErr = FALSE;
51303 0 : arg6 = CSLFromPyMapping(obj5, &bErr);
51304 0 : if ( bErr )
51305 : {
51306 0 : SWIG_fail;
51307 : }
51308 : }
51309 : else {
51310 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
51311 0 : SWIG_fail;
51312 : }
51313 : }
51314 : }
51315 12 : if (obj6) {
51316 2 : {
51317 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
51318 : /* callback_func typemap */
51319 :
51320 : /* In some cases 0 is passed instead of None. */
51321 : /* See https://github.com/OSGeo/gdal/pull/219 */
51322 2 : if ( PyLong_Check(obj6) || PyInt_Check(obj6) )
51323 : {
51324 0 : if( PyLong_AsLong(obj6) == 0 )
51325 : {
51326 0 : obj6 = Py_None;
51327 : }
51328 : }
51329 :
51330 2 : if (obj6 && obj6 != Py_None ) {
51331 2 : void* cbfunction = NULL;
51332 2 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj6,
51333 : (void**)&cbfunction,
51334 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
51335 : SWIG_POINTER_EXCEPTION | 0 ));
51336 :
51337 2 : if ( cbfunction == GDALTermProgress ) {
51338 : arg7 = GDALTermProgress;
51339 : } else {
51340 2 : if (!PyCallable_Check(obj6)) {
51341 0 : PyErr_SetString( PyExc_RuntimeError,
51342 : "Object given is not a Python function" );
51343 0 : SWIG_fail;
51344 : }
51345 2 : psProgressInfo->psPyCallback = obj6;
51346 2 : arg7 = PyProgressProxy;
51347 : }
51348 :
51349 : }
51350 :
51351 : }
51352 : }
51353 12 : if (obj7) {
51354 0 : {
51355 : /* %typemap(in) ( void* callback_data=NULL) */
51356 0 : psProgressInfo->psPyCallbackData = obj7 ;
51357 : }
51358 : }
51359 12 : {
51360 12 : if (!arg1) {
51361 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
51362 : }
51363 : }
51364 12 : {
51365 12 : if (!arg3) {
51366 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
51367 : }
51368 : }
51369 12 : {
51370 12 : const int bLocalUseExceptions = GetUseExceptions();
51371 12 : if ( bLocalUseExceptions ) {
51372 12 : pushErrorHandler();
51373 : }
51374 12 : {
51375 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
51376 12 : result = (int)SieveFilter(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
51377 12 : SWIG_PYTHON_THREAD_END_ALLOW;
51378 : }
51379 12 : if ( bLocalUseExceptions ) {
51380 12 : popErrorHandler();
51381 : }
51382 : #ifndef SED_HACKS
51383 : if ( bLocalUseExceptions ) {
51384 : CPLErr eclass = CPLGetLastErrorType();
51385 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
51386 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
51387 : }
51388 : }
51389 : #endif
51390 : }
51391 12 : resultobj = SWIG_From_int(static_cast< int >(result));
51392 12 : {
51393 : /* %typemap(freearg) char **dict */
51394 12 : CSLDestroy( arg6 );
51395 : }
51396 12 : {
51397 : /* %typemap(freearg) ( void* callback_data=NULL) */
51398 :
51399 12 : CPLFree(psProgressInfo);
51400 :
51401 : }
51402 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
51403 : return resultobj;
51404 0 : fail:
51405 0 : {
51406 : /* %typemap(freearg) char **dict */
51407 0 : CSLDestroy( arg6 );
51408 : }
51409 0 : {
51410 : /* %typemap(freearg) ( void* callback_data=NULL) */
51411 :
51412 0 : CPLFree(psProgressInfo);
51413 :
51414 : }
51415 : return NULL;
51416 : }
51417 :
51418 :
51419 2 : SWIGINTERN PyObject *_wrap_RegenerateOverviews(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51420 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
51421 2 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
51422 2 : int arg2 ;
51423 2 : GDALRasterBandShadow **arg3 = (GDALRasterBandShadow **) 0 ;
51424 2 : char *arg4 = (char *) "average" ;
51425 2 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
51426 2 : void *arg6 = (void *) NULL ;
51427 2 : void *argp1 = 0 ;
51428 2 : int res1 = 0 ;
51429 2 : int res4 ;
51430 2 : char *buf4 = 0 ;
51431 2 : int alloc4 = 0 ;
51432 2 : PyObject * obj0 = 0 ;
51433 2 : PyObject * obj1 = 0 ;
51434 2 : PyObject * obj2 = 0 ;
51435 2 : PyObject * obj3 = 0 ;
51436 2 : PyObject * obj4 = 0 ;
51437 2 : char * kwnames[] = {
51438 : (char *)"srcBand", (char *)"overviewBandCount", (char *)"resampling", (char *)"callback", (char *)"callback_data", NULL
51439 : };
51440 2 : int result;
51441 :
51442 : /* %typemap(arginit) ( const char* callback_data=NULL) */
51443 2 : PyProgressData *psProgressInfo;
51444 2 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
51445 2 : psProgressInfo->nLastReported = -1;
51446 2 : psProgressInfo->psPyCallback = NULL;
51447 2 : psProgressInfo->psPyCallbackData = NULL;
51448 2 : arg6 = psProgressInfo;
51449 2 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:RegenerateOverviews", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
51450 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
51451 2 : if (!SWIG_IsOK(res1)) {
51452 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegenerateOverviews" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
51453 : }
51454 2 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
51455 2 : {
51456 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALRasterBandShadow *optional_##GDALRasterBandShadow)*/
51457 2 : if ( !PySequence_Check(obj1) ) {
51458 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
51459 0 : SWIG_fail;
51460 : }
51461 2 : Py_ssize_t size = PySequence_Size(obj1);
51462 2 : if( size > (Py_ssize_t)INT_MAX ) {
51463 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
51464 0 : SWIG_fail;
51465 : }
51466 2 : if( (size_t)size > SIZE_MAX / sizeof(GDALRasterBandShadow*) ) {
51467 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
51468 0 : SWIG_fail;
51469 : }
51470 2 : arg2 = (int)size;
51471 2 : arg3 = (GDALRasterBandShadow**) VSIMalloc(arg2*sizeof(GDALRasterBandShadow*));
51472 2 : if( !arg3) {
51473 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
51474 0 : SWIG_fail;
51475 : }
51476 :
51477 6 : for( int i = 0; i<arg2; i++ ) {
51478 4 : PyObject *o = PySequence_GetItem(obj1,i);
51479 4 : GDALRasterBandShadow* rawobjectpointer = NULL;
51480 4 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALRasterBandShadow, SWIG_POINTER_EXCEPTION | 0 ));
51481 4 : if (!rawobjectpointer) {
51482 0 : Py_DECREF(o);
51483 0 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALRasterBandShadow");
51484 0 : SWIG_fail;
51485 : }
51486 4 : arg3[i] = rawobjectpointer;
51487 4 : Py_DECREF(o);
51488 :
51489 : }
51490 : }
51491 2 : if (obj2) {
51492 2 : res4 = SWIG_AsCharPtrAndSize(obj2, &buf4, NULL, &alloc4);
51493 2 : if (!SWIG_IsOK(res4)) {
51494 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RegenerateOverviews" "', argument " "4"" of type '" "char const *""'");
51495 : }
51496 2 : arg4 = reinterpret_cast< char * >(buf4);
51497 : }
51498 2 : if (obj3) {
51499 0 : {
51500 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
51501 : /* callback_func typemap */
51502 :
51503 : /* In some cases 0 is passed instead of None. */
51504 : /* See https://github.com/OSGeo/gdal/pull/219 */
51505 0 : if ( PyLong_Check(obj3) || PyInt_Check(obj3) )
51506 : {
51507 0 : if( PyLong_AsLong(obj3) == 0 )
51508 : {
51509 0 : obj3 = Py_None;
51510 : }
51511 : }
51512 :
51513 0 : if (obj3 && obj3 != Py_None ) {
51514 0 : void* cbfunction = NULL;
51515 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj3,
51516 : (void**)&cbfunction,
51517 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
51518 : SWIG_POINTER_EXCEPTION | 0 ));
51519 :
51520 0 : if ( cbfunction == GDALTermProgress ) {
51521 : arg5 = GDALTermProgress;
51522 : } else {
51523 0 : if (!PyCallable_Check(obj3)) {
51524 0 : PyErr_SetString( PyExc_RuntimeError,
51525 : "Object given is not a Python function" );
51526 0 : SWIG_fail;
51527 : }
51528 0 : psProgressInfo->psPyCallback = obj3;
51529 0 : arg5 = PyProgressProxy;
51530 : }
51531 :
51532 : }
51533 :
51534 : }
51535 : }
51536 2 : if (obj4) {
51537 0 : {
51538 : /* %typemap(in) ( void* callback_data=NULL) */
51539 0 : psProgressInfo->psPyCallbackData = obj4 ;
51540 : }
51541 : }
51542 2 : {
51543 2 : if (!arg1) {
51544 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
51545 : }
51546 : }
51547 2 : {
51548 2 : const int bLocalUseExceptions = GetUseExceptions();
51549 2 : if ( bLocalUseExceptions ) {
51550 0 : pushErrorHandler();
51551 : }
51552 2 : {
51553 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
51554 2 : result = (int)RegenerateOverviews(arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
51555 2 : SWIG_PYTHON_THREAD_END_ALLOW;
51556 : }
51557 2 : if ( bLocalUseExceptions ) {
51558 0 : popErrorHandler();
51559 : }
51560 : #ifndef SED_HACKS
51561 : if ( bLocalUseExceptions ) {
51562 : CPLErr eclass = CPLGetLastErrorType();
51563 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
51564 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
51565 : }
51566 : }
51567 : #endif
51568 : }
51569 2 : resultobj = SWIG_From_int(static_cast< int >(result));
51570 2 : {
51571 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALRasterBandShadow **poObjects)*/
51572 2 : CPLFree( arg3 );
51573 : }
51574 2 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
51575 2 : {
51576 : /* %typemap(freearg) ( void* callback_data=NULL) */
51577 :
51578 2 : CPLFree(psProgressInfo);
51579 :
51580 : }
51581 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
51582 : return resultobj;
51583 0 : fail:
51584 0 : {
51585 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALRasterBandShadow **poObjects)*/
51586 0 : CPLFree( arg3 );
51587 : }
51588 0 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
51589 0 : {
51590 : /* %typemap(freearg) ( void* callback_data=NULL) */
51591 :
51592 0 : CPLFree(psProgressInfo);
51593 :
51594 : }
51595 : return NULL;
51596 : }
51597 :
51598 :
51599 248 : SWIGINTERN PyObject *_wrap_RegenerateOverview(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51600 248 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
51601 248 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
51602 248 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
51603 248 : char *arg3 = (char *) "average" ;
51604 248 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
51605 248 : void *arg5 = (void *) NULL ;
51606 248 : void *argp1 = 0 ;
51607 248 : int res1 = 0 ;
51608 248 : void *argp2 = 0 ;
51609 248 : int res2 = 0 ;
51610 248 : int res3 ;
51611 248 : char *buf3 = 0 ;
51612 248 : int alloc3 = 0 ;
51613 248 : PyObject * obj0 = 0 ;
51614 248 : PyObject * obj1 = 0 ;
51615 248 : PyObject * obj2 = 0 ;
51616 248 : PyObject * obj3 = 0 ;
51617 248 : PyObject * obj4 = 0 ;
51618 248 : char * kwnames[] = {
51619 : (char *)"srcBand", (char *)"overviewBand", (char *)"resampling", (char *)"callback", (char *)"callback_data", NULL
51620 : };
51621 248 : int result;
51622 :
51623 : /* %typemap(arginit) ( const char* callback_data=NULL) */
51624 248 : PyProgressData *psProgressInfo;
51625 248 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
51626 248 : psProgressInfo->nLastReported = -1;
51627 248 : psProgressInfo->psPyCallback = NULL;
51628 248 : psProgressInfo->psPyCallbackData = NULL;
51629 248 : arg5 = psProgressInfo;
51630 248 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:RegenerateOverview", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
51631 248 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
51632 248 : if (!SWIG_IsOK(res1)) {
51633 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegenerateOverview" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
51634 : }
51635 248 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
51636 248 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
51637 248 : if (!SWIG_IsOK(res2)) {
51638 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RegenerateOverview" "', argument " "2"" of type '" "GDALRasterBandShadow *""'");
51639 : }
51640 248 : arg2 = reinterpret_cast< GDALRasterBandShadow * >(argp2);
51641 248 : if (obj2) {
51642 248 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
51643 248 : if (!SWIG_IsOK(res3)) {
51644 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RegenerateOverview" "', argument " "3"" of type '" "char const *""'");
51645 : }
51646 248 : arg3 = reinterpret_cast< char * >(buf3);
51647 : }
51648 248 : if (obj3) {
51649 0 : {
51650 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
51651 : /* callback_func typemap */
51652 :
51653 : /* In some cases 0 is passed instead of None. */
51654 : /* See https://github.com/OSGeo/gdal/pull/219 */
51655 0 : if ( PyLong_Check(obj3) || PyInt_Check(obj3) )
51656 : {
51657 0 : if( PyLong_AsLong(obj3) == 0 )
51658 : {
51659 0 : obj3 = Py_None;
51660 : }
51661 : }
51662 :
51663 0 : if (obj3 && obj3 != Py_None ) {
51664 0 : void* cbfunction = NULL;
51665 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj3,
51666 : (void**)&cbfunction,
51667 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
51668 : SWIG_POINTER_EXCEPTION | 0 ));
51669 :
51670 0 : if ( cbfunction == GDALTermProgress ) {
51671 : arg4 = GDALTermProgress;
51672 : } else {
51673 0 : if (!PyCallable_Check(obj3)) {
51674 0 : PyErr_SetString( PyExc_RuntimeError,
51675 : "Object given is not a Python function" );
51676 0 : SWIG_fail;
51677 : }
51678 0 : psProgressInfo->psPyCallback = obj3;
51679 0 : arg4 = PyProgressProxy;
51680 : }
51681 :
51682 : }
51683 :
51684 : }
51685 : }
51686 248 : if (obj4) {
51687 0 : {
51688 : /* %typemap(in) ( void* callback_data=NULL) */
51689 0 : psProgressInfo->psPyCallbackData = obj4 ;
51690 : }
51691 : }
51692 248 : {
51693 248 : if (!arg1) {
51694 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
51695 : }
51696 : }
51697 248 : {
51698 248 : if (!arg2) {
51699 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
51700 : }
51701 : }
51702 248 : {
51703 248 : const int bLocalUseExceptions = GetUseExceptions();
51704 248 : if ( bLocalUseExceptions ) {
51705 246 : pushErrorHandler();
51706 : }
51707 248 : {
51708 248 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
51709 248 : result = (int)RegenerateOverview(arg1,arg2,(char const *)arg3,arg4,arg5);
51710 248 : SWIG_PYTHON_THREAD_END_ALLOW;
51711 : }
51712 248 : if ( bLocalUseExceptions ) {
51713 246 : popErrorHandler();
51714 : }
51715 : #ifndef SED_HACKS
51716 : if ( bLocalUseExceptions ) {
51717 : CPLErr eclass = CPLGetLastErrorType();
51718 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
51719 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
51720 : }
51721 : }
51722 : #endif
51723 : }
51724 248 : resultobj = SWIG_From_int(static_cast< int >(result));
51725 248 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
51726 248 : {
51727 : /* %typemap(freearg) ( void* callback_data=NULL) */
51728 :
51729 248 : CPLFree(psProgressInfo);
51730 :
51731 : }
51732 248 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
51733 : return resultobj;
51734 0 : fail:
51735 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
51736 0 : {
51737 : /* %typemap(freearg) ( void* callback_data=NULL) */
51738 :
51739 0 : CPLFree(psProgressInfo);
51740 :
51741 : }
51742 : return NULL;
51743 : }
51744 :
51745 :
51746 3 : SWIGINTERN PyObject *_wrap_ContourGenerate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51747 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
51748 3 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
51749 3 : double arg2 ;
51750 3 : double arg3 ;
51751 3 : int arg4 ;
51752 3 : double *arg5 = (double *) 0 ;
51753 3 : int arg6 ;
51754 3 : double arg7 ;
51755 3 : OGRLayerShadow *arg8 = (OGRLayerShadow *) 0 ;
51756 3 : int arg9 ;
51757 3 : int arg10 ;
51758 3 : GDALProgressFunc arg11 = (GDALProgressFunc) NULL ;
51759 3 : void *arg12 = (void *) NULL ;
51760 3 : void *argp1 = 0 ;
51761 3 : int res1 = 0 ;
51762 3 : double val2 ;
51763 3 : int ecode2 = 0 ;
51764 3 : double val3 ;
51765 3 : int ecode3 = 0 ;
51766 3 : int val6 ;
51767 3 : int ecode6 = 0 ;
51768 3 : double val7 ;
51769 3 : int ecode7 = 0 ;
51770 3 : void *argp8 = 0 ;
51771 3 : int res8 = 0 ;
51772 3 : int val9 ;
51773 3 : int ecode9 = 0 ;
51774 3 : int val10 ;
51775 3 : int ecode10 = 0 ;
51776 3 : PyObject * obj0 = 0 ;
51777 3 : PyObject * obj1 = 0 ;
51778 3 : PyObject * obj2 = 0 ;
51779 3 : PyObject * obj3 = 0 ;
51780 3 : PyObject * obj4 = 0 ;
51781 3 : PyObject * obj5 = 0 ;
51782 3 : PyObject * obj6 = 0 ;
51783 3 : PyObject * obj7 = 0 ;
51784 3 : PyObject * obj8 = 0 ;
51785 3 : PyObject * obj9 = 0 ;
51786 3 : PyObject * obj10 = 0 ;
51787 3 : char * kwnames[] = {
51788 : (char *)"srcBand", (char *)"contourInterval", (char *)"contourBase", (char *)"fixedLevelCount", (char *)"useNoData", (char *)"noDataValue", (char *)"dstLayer", (char *)"idField", (char *)"elevField", (char *)"callback", (char *)"callback_data", NULL
51789 : };
51790 3 : int result;
51791 :
51792 : /* %typemap(arginit) ( const char* callback_data=NULL) */
51793 3 : PyProgressData *psProgressInfo;
51794 3 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
51795 3 : psProgressInfo->nLastReported = -1;
51796 3 : psProgressInfo->psPyCallback = NULL;
51797 3 : psProgressInfo->psPyCallbackData = NULL;
51798 3 : arg12 = psProgressInfo;
51799 3 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOO|OO:ContourGenerate", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10)) SWIG_fail;
51800 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
51801 3 : if (!SWIG_IsOK(res1)) {
51802 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContourGenerate" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
51803 : }
51804 3 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
51805 3 : ecode2 = SWIG_AsVal_double(obj1, &val2);
51806 3 : if (!SWIG_IsOK(ecode2)) {
51807 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContourGenerate" "', argument " "2"" of type '" "double""'");
51808 : }
51809 3 : arg2 = static_cast< double >(val2);
51810 3 : ecode3 = SWIG_AsVal_double(obj2, &val3);
51811 3 : if (!SWIG_IsOK(ecode3)) {
51812 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContourGenerate" "', argument " "3"" of type '" "double""'");
51813 : }
51814 3 : arg3 = static_cast< double >(val3);
51815 3 : {
51816 : /* %typemap(in,numinputs=1) (int nList, double* pList)*/
51817 3 : arg5 = CreateCDoubleListFromSequence(obj3, &arg4);
51818 3 : if( arg4 < 0 ) {
51819 0 : SWIG_fail;
51820 : }
51821 : }
51822 3 : ecode6 = SWIG_AsVal_int(obj4, &val6);
51823 3 : if (!SWIG_IsOK(ecode6)) {
51824 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ContourGenerate" "', argument " "6"" of type '" "int""'");
51825 : }
51826 3 : arg6 = static_cast< int >(val6);
51827 3 : ecode7 = SWIG_AsVal_double(obj5, &val7);
51828 3 : if (!SWIG_IsOK(ecode7)) {
51829 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ContourGenerate" "', argument " "7"" of type '" "double""'");
51830 : }
51831 3 : arg7 = static_cast< double >(val7);
51832 3 : res8 = SWIG_ConvertPtr(obj6, &argp8,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
51833 3 : if (!SWIG_IsOK(res8)) {
51834 0 : SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ContourGenerate" "', argument " "8"" of type '" "OGRLayerShadow *""'");
51835 : }
51836 3 : arg8 = reinterpret_cast< OGRLayerShadow * >(argp8);
51837 3 : ecode9 = SWIG_AsVal_int(obj7, &val9);
51838 3 : if (!SWIG_IsOK(ecode9)) {
51839 0 : SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ContourGenerate" "', argument " "9"" of type '" "int""'");
51840 : }
51841 3 : arg9 = static_cast< int >(val9);
51842 3 : ecode10 = SWIG_AsVal_int(obj8, &val10);
51843 3 : if (!SWIG_IsOK(ecode10)) {
51844 0 : SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ContourGenerate" "', argument " "10"" of type '" "int""'");
51845 : }
51846 3 : arg10 = static_cast< int >(val10);
51847 3 : if (obj9) {
51848 0 : {
51849 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
51850 : /* callback_func typemap */
51851 :
51852 : /* In some cases 0 is passed instead of None. */
51853 : /* See https://github.com/OSGeo/gdal/pull/219 */
51854 0 : if ( PyLong_Check(obj9) || PyInt_Check(obj9) )
51855 : {
51856 0 : if( PyLong_AsLong(obj9) == 0 )
51857 : {
51858 0 : obj9 = Py_None;
51859 : }
51860 : }
51861 :
51862 0 : if (obj9 && obj9 != Py_None ) {
51863 0 : void* cbfunction = NULL;
51864 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj9,
51865 : (void**)&cbfunction,
51866 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
51867 : SWIG_POINTER_EXCEPTION | 0 ));
51868 :
51869 0 : if ( cbfunction == GDALTermProgress ) {
51870 : arg11 = GDALTermProgress;
51871 : } else {
51872 0 : if (!PyCallable_Check(obj9)) {
51873 0 : PyErr_SetString( PyExc_RuntimeError,
51874 : "Object given is not a Python function" );
51875 0 : SWIG_fail;
51876 : }
51877 0 : psProgressInfo->psPyCallback = obj9;
51878 0 : arg11 = PyProgressProxy;
51879 : }
51880 :
51881 : }
51882 :
51883 : }
51884 : }
51885 3 : if (obj10) {
51886 0 : {
51887 : /* %typemap(in) ( void* callback_data=NULL) */
51888 0 : psProgressInfo->psPyCallbackData = obj10 ;
51889 : }
51890 : }
51891 3 : {
51892 3 : if (!arg1) {
51893 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
51894 : }
51895 : }
51896 3 : {
51897 3 : if (!arg8) {
51898 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
51899 : }
51900 : }
51901 3 : {
51902 3 : const int bLocalUseExceptions = GetUseExceptions();
51903 3 : if ( bLocalUseExceptions ) {
51904 3 : pushErrorHandler();
51905 : }
51906 3 : {
51907 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
51908 3 : result = (int)ContourGenerate(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
51909 3 : SWIG_PYTHON_THREAD_END_ALLOW;
51910 : }
51911 3 : if ( bLocalUseExceptions ) {
51912 3 : popErrorHandler();
51913 : }
51914 : #ifndef SED_HACKS
51915 : if ( bLocalUseExceptions ) {
51916 : CPLErr eclass = CPLGetLastErrorType();
51917 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
51918 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
51919 : }
51920 : }
51921 : #endif
51922 : }
51923 3 : resultobj = SWIG_From_int(static_cast< int >(result));
51924 3 : {
51925 : /* %typemap(freearg) (int nList, double* pList) */
51926 3 : free(arg5);
51927 : }
51928 3 : {
51929 : /* %typemap(freearg) ( void* callback_data=NULL) */
51930 :
51931 3 : CPLFree(psProgressInfo);
51932 :
51933 : }
51934 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
51935 : return resultobj;
51936 0 : fail:
51937 0 : {
51938 : /* %typemap(freearg) (int nList, double* pList) */
51939 0 : free(arg5);
51940 : }
51941 0 : {
51942 : /* %typemap(freearg) ( void* callback_data=NULL) */
51943 :
51944 0 : CPLFree(psProgressInfo);
51945 :
51946 : }
51947 : return NULL;
51948 : }
51949 :
51950 :
51951 25 : SWIGINTERN PyObject *_wrap_ContourGenerateEx(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51952 25 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
51953 25 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
51954 25 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
51955 25 : char **arg3 = (char **) NULL ;
51956 25 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
51957 25 : void *arg5 = (void *) NULL ;
51958 25 : void *argp1 = 0 ;
51959 25 : int res1 = 0 ;
51960 25 : void *argp2 = 0 ;
51961 25 : int res2 = 0 ;
51962 25 : PyObject * obj0 = 0 ;
51963 25 : PyObject * obj1 = 0 ;
51964 25 : PyObject * obj2 = 0 ;
51965 25 : PyObject * obj3 = 0 ;
51966 25 : PyObject * obj4 = 0 ;
51967 25 : char * kwnames[] = {
51968 : (char *)"srcBand", (char *)"dstLayer", (char *)"options", (char *)"callback", (char *)"callback_data", NULL
51969 : };
51970 25 : int result;
51971 :
51972 : /* %typemap(arginit) ( const char* callback_data=NULL) */
51973 25 : PyProgressData *psProgressInfo;
51974 25 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
51975 25 : psProgressInfo->nLastReported = -1;
51976 25 : psProgressInfo->psPyCallback = NULL;
51977 25 : psProgressInfo->psPyCallbackData = NULL;
51978 25 : arg5 = psProgressInfo;
51979 25 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:ContourGenerateEx", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
51980 25 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
51981 25 : if (!SWIG_IsOK(res1)) {
51982 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContourGenerateEx" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
51983 : }
51984 25 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
51985 25 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_OGRLayerShadow, 0 | 0 );
51986 25 : if (!SWIG_IsOK(res2)) {
51987 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ContourGenerateEx" "', argument " "2"" of type '" "OGRLayerShadow *""'");
51988 : }
51989 25 : arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
51990 25 : if (obj2) {
51991 25 : {
51992 : /* %typemap(in) char **dict */
51993 25 : arg3 = NULL;
51994 25 : if ( PySequence_Check( obj2 ) ) {
51995 25 : int bErr = FALSE;
51996 25 : arg3 = CSLFromPySequence(obj2, &bErr);
51997 25 : if ( bErr )
51998 : {
51999 0 : SWIG_fail;
52000 : }
52001 : }
52002 0 : else if ( PyMapping_Check( obj2 ) ) {
52003 0 : int bErr = FALSE;
52004 0 : arg3 = CSLFromPyMapping(obj2, &bErr);
52005 0 : if ( bErr )
52006 : {
52007 0 : SWIG_fail;
52008 : }
52009 : }
52010 : else {
52011 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
52012 0 : SWIG_fail;
52013 : }
52014 : }
52015 : }
52016 25 : if (obj3) {
52017 0 : {
52018 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
52019 : /* callback_func typemap */
52020 :
52021 : /* In some cases 0 is passed instead of None. */
52022 : /* See https://github.com/OSGeo/gdal/pull/219 */
52023 0 : if ( PyLong_Check(obj3) || PyInt_Check(obj3) )
52024 : {
52025 0 : if( PyLong_AsLong(obj3) == 0 )
52026 : {
52027 0 : obj3 = Py_None;
52028 : }
52029 : }
52030 :
52031 0 : if (obj3 && obj3 != Py_None ) {
52032 0 : void* cbfunction = NULL;
52033 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj3,
52034 : (void**)&cbfunction,
52035 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
52036 : SWIG_POINTER_EXCEPTION | 0 ));
52037 :
52038 0 : if ( cbfunction == GDALTermProgress ) {
52039 : arg4 = GDALTermProgress;
52040 : } else {
52041 0 : if (!PyCallable_Check(obj3)) {
52042 0 : PyErr_SetString( PyExc_RuntimeError,
52043 : "Object given is not a Python function" );
52044 0 : SWIG_fail;
52045 : }
52046 0 : psProgressInfo->psPyCallback = obj3;
52047 0 : arg4 = PyProgressProxy;
52048 : }
52049 :
52050 : }
52051 :
52052 : }
52053 : }
52054 25 : if (obj4) {
52055 0 : {
52056 : /* %typemap(in) ( void* callback_data=NULL) */
52057 0 : psProgressInfo->psPyCallbackData = obj4 ;
52058 : }
52059 : }
52060 25 : {
52061 25 : if (!arg1) {
52062 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
52063 : }
52064 : }
52065 25 : {
52066 25 : if (!arg2) {
52067 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
52068 : }
52069 : }
52070 25 : {
52071 25 : const int bLocalUseExceptions = GetUseExceptions();
52072 25 : if ( bLocalUseExceptions ) {
52073 25 : pushErrorHandler();
52074 : }
52075 25 : {
52076 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
52077 25 : result = (int)ContourGenerateEx(arg1,arg2,arg3,arg4,arg5);
52078 25 : SWIG_PYTHON_THREAD_END_ALLOW;
52079 : }
52080 25 : if ( bLocalUseExceptions ) {
52081 25 : popErrorHandler();
52082 : }
52083 : #ifndef SED_HACKS
52084 : if ( bLocalUseExceptions ) {
52085 : CPLErr eclass = CPLGetLastErrorType();
52086 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
52087 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
52088 : }
52089 : }
52090 : #endif
52091 : }
52092 25 : resultobj = SWIG_From_int(static_cast< int >(result));
52093 25 : {
52094 : /* %typemap(freearg) char **dict */
52095 25 : CSLDestroy( arg3 );
52096 : }
52097 25 : {
52098 : /* %typemap(freearg) ( void* callback_data=NULL) */
52099 :
52100 25 : CPLFree(psProgressInfo);
52101 :
52102 : }
52103 37 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
52104 : return resultobj;
52105 0 : fail:
52106 0 : {
52107 : /* %typemap(freearg) char **dict */
52108 0 : CSLDestroy( arg3 );
52109 : }
52110 0 : {
52111 : /* %typemap(freearg) ( void* callback_data=NULL) */
52112 :
52113 0 : CPLFree(psProgressInfo);
52114 :
52115 : }
52116 : return NULL;
52117 : }
52118 :
52119 :
52120 0 : SWIGINTERN PyObject *_wrap_ViewshedGenerate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52121 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
52122 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
52123 0 : char *arg2 = (char *) 0 ;
52124 0 : char *arg3 = (char *) 0 ;
52125 0 : char **arg4 = (char **) 0 ;
52126 0 : double arg5 ;
52127 0 : double arg6 ;
52128 0 : double arg7 ;
52129 0 : double arg8 ;
52130 0 : double arg9 ;
52131 0 : double arg10 ;
52132 0 : double arg11 ;
52133 0 : double arg12 ;
52134 0 : double arg13 ;
52135 0 : GDALViewshedMode arg14 ;
52136 0 : double arg15 ;
52137 0 : GDALProgressFunc arg16 = (GDALProgressFunc) NULL ;
52138 0 : void *arg17 = (void *) NULL ;
52139 0 : GDALViewshedOutputType arg18 = (GDALViewshedOutputType) GVOT_NORMAL ;
52140 0 : char **arg19 = (char **) NULL ;
52141 0 : void *argp1 = 0 ;
52142 0 : int res1 = 0 ;
52143 0 : int res2 ;
52144 0 : char *buf2 = 0 ;
52145 0 : int alloc2 = 0 ;
52146 0 : int res3 ;
52147 0 : char *buf3 = 0 ;
52148 0 : int alloc3 = 0 ;
52149 0 : double val5 ;
52150 0 : int ecode5 = 0 ;
52151 0 : double val6 ;
52152 0 : int ecode6 = 0 ;
52153 0 : double val7 ;
52154 0 : int ecode7 = 0 ;
52155 0 : double val8 ;
52156 0 : int ecode8 = 0 ;
52157 0 : double val9 ;
52158 0 : int ecode9 = 0 ;
52159 0 : double val10 ;
52160 0 : int ecode10 = 0 ;
52161 0 : double val11 ;
52162 0 : int ecode11 = 0 ;
52163 0 : double val12 ;
52164 0 : int ecode12 = 0 ;
52165 0 : double val13 ;
52166 0 : int ecode13 = 0 ;
52167 0 : int val14 ;
52168 0 : int ecode14 = 0 ;
52169 0 : double val15 ;
52170 0 : int ecode15 = 0 ;
52171 0 : int val18 ;
52172 0 : int ecode18 = 0 ;
52173 0 : PyObject * obj0 = 0 ;
52174 0 : PyObject * obj1 = 0 ;
52175 0 : PyObject * obj2 = 0 ;
52176 0 : PyObject * obj3 = 0 ;
52177 0 : PyObject * obj4 = 0 ;
52178 0 : PyObject * obj5 = 0 ;
52179 0 : PyObject * obj6 = 0 ;
52180 0 : PyObject * obj7 = 0 ;
52181 0 : PyObject * obj8 = 0 ;
52182 0 : PyObject * obj9 = 0 ;
52183 0 : PyObject * obj10 = 0 ;
52184 0 : PyObject * obj11 = 0 ;
52185 0 : PyObject * obj12 = 0 ;
52186 0 : PyObject * obj13 = 0 ;
52187 0 : PyObject * obj14 = 0 ;
52188 0 : PyObject * obj15 = 0 ;
52189 0 : PyObject * obj16 = 0 ;
52190 0 : PyObject * obj17 = 0 ;
52191 0 : PyObject * obj18 = 0 ;
52192 0 : char * kwnames[] = {
52193 : (char *)"srcBand", (char *)"driverName", (char *)"targetRasterName", (char *)"creationOptions", (char *)"observerX", (char *)"observerY", (char *)"observerHeight", (char *)"targetHeight", (char *)"visibleVal", (char *)"invisibleVal", (char *)"outOfRangeVal", (char *)"noDataVal", (char *)"dfCurvCoeff", (char *)"mode", (char *)"maxDistance", (char *)"callback", (char *)"callback_data", (char *)"heightMode", (char *)"options", NULL
52194 : };
52195 0 : GDALDatasetShadow *result = 0 ;
52196 :
52197 : /* %typemap(arginit) ( const char* callback_data=NULL) */
52198 0 : PyProgressData *psProgressInfo;
52199 0 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
52200 0 : psProgressInfo->nLastReported = -1;
52201 0 : psProgressInfo->psPyCallback = NULL;
52202 0 : psProgressInfo->psPyCallbackData = NULL;
52203 0 : arg17 = psProgressInfo;
52204 0 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOOOOOO|OOOO:ViewshedGenerate", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15, &obj16, &obj17, &obj18)) SWIG_fail;
52205 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
52206 0 : if (!SWIG_IsOK(res1)) {
52207 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewshedGenerate" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
52208 : }
52209 0 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
52210 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
52211 0 : if (!SWIG_IsOK(res2)) {
52212 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewshedGenerate" "', argument " "2"" of type '" "char const *""'");
52213 : }
52214 0 : arg2 = reinterpret_cast< char * >(buf2);
52215 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
52216 0 : if (!SWIG_IsOK(res3)) {
52217 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewshedGenerate" "', argument " "3"" of type '" "char const *""'");
52218 : }
52219 0 : arg3 = reinterpret_cast< char * >(buf3);
52220 0 : {
52221 : /* %typemap(in) char **dict */
52222 0 : arg4 = NULL;
52223 0 : if ( PySequence_Check( obj3 ) ) {
52224 0 : int bErr = FALSE;
52225 0 : arg4 = CSLFromPySequence(obj3, &bErr);
52226 0 : if ( bErr )
52227 : {
52228 0 : SWIG_fail;
52229 : }
52230 : }
52231 0 : else if ( PyMapping_Check( obj3 ) ) {
52232 0 : int bErr = FALSE;
52233 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
52234 0 : if ( bErr )
52235 : {
52236 0 : SWIG_fail;
52237 : }
52238 : }
52239 : else {
52240 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
52241 0 : SWIG_fail;
52242 : }
52243 : }
52244 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
52245 0 : if (!SWIG_IsOK(ecode5)) {
52246 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ViewshedGenerate" "', argument " "5"" of type '" "double""'");
52247 : }
52248 0 : arg5 = static_cast< double >(val5);
52249 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
52250 0 : if (!SWIG_IsOK(ecode6)) {
52251 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ViewshedGenerate" "', argument " "6"" of type '" "double""'");
52252 : }
52253 0 : arg6 = static_cast< double >(val6);
52254 0 : ecode7 = SWIG_AsVal_double(obj6, &val7);
52255 0 : if (!SWIG_IsOK(ecode7)) {
52256 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ViewshedGenerate" "', argument " "7"" of type '" "double""'");
52257 : }
52258 0 : arg7 = static_cast< double >(val7);
52259 0 : ecode8 = SWIG_AsVal_double(obj7, &val8);
52260 0 : if (!SWIG_IsOK(ecode8)) {
52261 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ViewshedGenerate" "', argument " "8"" of type '" "double""'");
52262 : }
52263 0 : arg8 = static_cast< double >(val8);
52264 0 : ecode9 = SWIG_AsVal_double(obj8, &val9);
52265 0 : if (!SWIG_IsOK(ecode9)) {
52266 0 : SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ViewshedGenerate" "', argument " "9"" of type '" "double""'");
52267 : }
52268 0 : arg9 = static_cast< double >(val9);
52269 0 : ecode10 = SWIG_AsVal_double(obj9, &val10);
52270 0 : if (!SWIG_IsOK(ecode10)) {
52271 0 : SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ViewshedGenerate" "', argument " "10"" of type '" "double""'");
52272 : }
52273 0 : arg10 = static_cast< double >(val10);
52274 0 : ecode11 = SWIG_AsVal_double(obj10, &val11);
52275 0 : if (!SWIG_IsOK(ecode11)) {
52276 0 : SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ViewshedGenerate" "', argument " "11"" of type '" "double""'");
52277 : }
52278 0 : arg11 = static_cast< double >(val11);
52279 0 : ecode12 = SWIG_AsVal_double(obj11, &val12);
52280 0 : if (!SWIG_IsOK(ecode12)) {
52281 0 : SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ViewshedGenerate" "', argument " "12"" of type '" "double""'");
52282 : }
52283 0 : arg12 = static_cast< double >(val12);
52284 0 : ecode13 = SWIG_AsVal_double(obj12, &val13);
52285 0 : if (!SWIG_IsOK(ecode13)) {
52286 0 : SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ViewshedGenerate" "', argument " "13"" of type '" "double""'");
52287 : }
52288 0 : arg13 = static_cast< double >(val13);
52289 0 : ecode14 = SWIG_AsVal_int(obj13, &val14);
52290 0 : if (!SWIG_IsOK(ecode14)) {
52291 0 : SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ViewshedGenerate" "', argument " "14"" of type '" "GDALViewshedMode""'");
52292 : }
52293 0 : arg14 = static_cast< GDALViewshedMode >(val14);
52294 0 : ecode15 = SWIG_AsVal_double(obj14, &val15);
52295 0 : if (!SWIG_IsOK(ecode15)) {
52296 0 : SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ViewshedGenerate" "', argument " "15"" of type '" "double""'");
52297 : }
52298 0 : arg15 = static_cast< double >(val15);
52299 0 : if (obj15) {
52300 0 : {
52301 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
52302 : /* callback_func typemap */
52303 :
52304 : /* In some cases 0 is passed instead of None. */
52305 : /* See https://github.com/OSGeo/gdal/pull/219 */
52306 0 : if ( PyLong_Check(obj15) || PyInt_Check(obj15) )
52307 : {
52308 0 : if( PyLong_AsLong(obj15) == 0 )
52309 : {
52310 0 : obj15 = Py_None;
52311 : }
52312 : }
52313 :
52314 0 : if (obj15 && obj15 != Py_None ) {
52315 0 : void* cbfunction = NULL;
52316 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj15,
52317 : (void**)&cbfunction,
52318 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
52319 : SWIG_POINTER_EXCEPTION | 0 ));
52320 :
52321 0 : if ( cbfunction == GDALTermProgress ) {
52322 : arg16 = GDALTermProgress;
52323 : } else {
52324 0 : if (!PyCallable_Check(obj15)) {
52325 0 : PyErr_SetString( PyExc_RuntimeError,
52326 : "Object given is not a Python function" );
52327 0 : SWIG_fail;
52328 : }
52329 0 : psProgressInfo->psPyCallback = obj15;
52330 0 : arg16 = PyProgressProxy;
52331 : }
52332 :
52333 : }
52334 :
52335 : }
52336 : }
52337 0 : if (obj16) {
52338 0 : {
52339 : /* %typemap(in) ( void* callback_data=NULL) */
52340 0 : psProgressInfo->psPyCallbackData = obj16 ;
52341 : }
52342 : }
52343 0 : if (obj17) {
52344 0 : ecode18 = SWIG_AsVal_int(obj17, &val18);
52345 0 : if (!SWIG_IsOK(ecode18)) {
52346 0 : SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "ViewshedGenerate" "', argument " "18"" of type '" "GDALViewshedOutputType""'");
52347 : }
52348 0 : arg18 = static_cast< GDALViewshedOutputType >(val18);
52349 : }
52350 0 : if (obj18) {
52351 0 : {
52352 : /* %typemap(in) char **dict */
52353 0 : arg19 = NULL;
52354 0 : if ( PySequence_Check( obj18 ) ) {
52355 0 : int bErr = FALSE;
52356 0 : arg19 = CSLFromPySequence(obj18, &bErr);
52357 0 : if ( bErr )
52358 : {
52359 0 : SWIG_fail;
52360 : }
52361 : }
52362 0 : else if ( PyMapping_Check( obj18 ) ) {
52363 0 : int bErr = FALSE;
52364 0 : arg19 = CSLFromPyMapping(obj18, &bErr);
52365 0 : if ( bErr )
52366 : {
52367 0 : SWIG_fail;
52368 : }
52369 : }
52370 : else {
52371 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
52372 0 : SWIG_fail;
52373 : }
52374 : }
52375 : }
52376 0 : {
52377 0 : if (!arg1) {
52378 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
52379 : }
52380 : }
52381 0 : {
52382 0 : const int bLocalUseExceptions = GetUseExceptions();
52383 0 : if ( bLocalUseExceptions ) {
52384 0 : pushErrorHandler();
52385 : }
52386 0 : {
52387 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
52388 0 : result = (GDALDatasetShadow *)ViewshedGenerate(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
52389 0 : SWIG_PYTHON_THREAD_END_ALLOW;
52390 : }
52391 0 : if ( bLocalUseExceptions ) {
52392 0 : popErrorHandler();
52393 : }
52394 : #ifndef SED_HACKS
52395 : if ( bLocalUseExceptions ) {
52396 : CPLErr eclass = CPLGetLastErrorType();
52397 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
52398 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
52399 : }
52400 : }
52401 : #endif
52402 : }
52403 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
52404 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
52405 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
52406 0 : {
52407 : /* %typemap(freearg) char **dict */
52408 0 : CSLDestroy( arg4 );
52409 : }
52410 0 : {
52411 : /* %typemap(freearg) ( void* callback_data=NULL) */
52412 :
52413 0 : CPLFree(psProgressInfo);
52414 :
52415 : }
52416 0 : {
52417 : /* %typemap(freearg) char **dict */
52418 0 : CSLDestroy( arg19 );
52419 : }
52420 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
52421 : return resultobj;
52422 0 : fail:
52423 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
52424 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
52425 0 : {
52426 : /* %typemap(freearg) char **dict */
52427 0 : CSLDestroy( arg4 );
52428 : }
52429 0 : {
52430 : /* %typemap(freearg) ( void* callback_data=NULL) */
52431 :
52432 0 : CPLFree(psProgressInfo);
52433 :
52434 : }
52435 0 : {
52436 : /* %typemap(freearg) char **dict */
52437 0 : CSLDestroy( arg19 );
52438 : }
52439 : return NULL;
52440 : }
52441 :
52442 :
52443 6 : SWIGINTERN PyObject *_wrap_IsLineOfSightVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52444 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
52445 6 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
52446 6 : int arg2 ;
52447 6 : int arg3 ;
52448 6 : double arg4 ;
52449 6 : int arg5 ;
52450 6 : int arg6 ;
52451 6 : double arg7 ;
52452 6 : bool *arg8 = (bool *) 0 ;
52453 6 : int *arg9 = (int *) 0 ;
52454 6 : int *arg10 = (int *) 0 ;
52455 6 : char **arg11 = (char **) NULL ;
52456 6 : void *argp1 = 0 ;
52457 6 : int res1 = 0 ;
52458 6 : int val2 ;
52459 6 : int ecode2 = 0 ;
52460 6 : int val3 ;
52461 6 : int ecode3 = 0 ;
52462 6 : double val4 ;
52463 6 : int ecode4 = 0 ;
52464 6 : int val5 ;
52465 6 : int ecode5 = 0 ;
52466 6 : int val6 ;
52467 6 : int ecode6 = 0 ;
52468 6 : double val7 ;
52469 6 : int ecode7 = 0 ;
52470 6 : bool visible8 = 0 ;
52471 6 : int nxintersection8 = 0 ;
52472 6 : int nyintersection8 = 0 ;
52473 6 : PyObject * obj0 = 0 ;
52474 6 : PyObject * obj1 = 0 ;
52475 6 : PyObject * obj2 = 0 ;
52476 6 : PyObject * obj3 = 0 ;
52477 6 : PyObject * obj4 = 0 ;
52478 6 : PyObject * obj5 = 0 ;
52479 6 : PyObject * obj6 = 0 ;
52480 6 : PyObject * obj7 = 0 ;
52481 6 : char * kwnames[] = {
52482 : (char *)"band", (char *)"xA", (char *)"yA", (char *)"zA", (char *)"xB", (char *)"yB", (char *)"zB", (char *)"options", NULL
52483 : };
52484 :
52485 6 : {
52486 : /* %typemap(in) (bool *pbVisible, int *pnXIntersection, int *pnYIntersection) */
52487 6 : arg8 = &visible8;
52488 6 : arg9 = &nxintersection8;
52489 6 : arg10 = &nyintersection8;
52490 : }
52491 6 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO|O:IsLineOfSightVisible", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
52492 6 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
52493 6 : if (!SWIG_IsOK(res1)) {
52494 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsLineOfSightVisible" "', argument " "1"" of type '" "GDALRasterBandShadow *""'");
52495 : }
52496 6 : arg1 = reinterpret_cast< GDALRasterBandShadow * >(argp1);
52497 6 : ecode2 = SWIG_AsVal_int(obj1, &val2);
52498 6 : if (!SWIG_IsOK(ecode2)) {
52499 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IsLineOfSightVisible" "', argument " "2"" of type '" "int""'");
52500 : }
52501 6 : arg2 = static_cast< int >(val2);
52502 6 : ecode3 = SWIG_AsVal_int(obj2, &val3);
52503 6 : if (!SWIG_IsOK(ecode3)) {
52504 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IsLineOfSightVisible" "', argument " "3"" of type '" "int""'");
52505 : }
52506 6 : arg3 = static_cast< int >(val3);
52507 6 : ecode4 = SWIG_AsVal_double(obj3, &val4);
52508 6 : if (!SWIG_IsOK(ecode4)) {
52509 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IsLineOfSightVisible" "', argument " "4"" of type '" "double""'");
52510 : }
52511 6 : arg4 = static_cast< double >(val4);
52512 6 : ecode5 = SWIG_AsVal_int(obj4, &val5);
52513 6 : if (!SWIG_IsOK(ecode5)) {
52514 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IsLineOfSightVisible" "', argument " "5"" of type '" "int""'");
52515 : }
52516 6 : arg5 = static_cast< int >(val5);
52517 6 : ecode6 = SWIG_AsVal_int(obj5, &val6);
52518 6 : if (!SWIG_IsOK(ecode6)) {
52519 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IsLineOfSightVisible" "', argument " "6"" of type '" "int""'");
52520 : }
52521 6 : arg6 = static_cast< int >(val6);
52522 6 : ecode7 = SWIG_AsVal_double(obj6, &val7);
52523 6 : if (!SWIG_IsOK(ecode7)) {
52524 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "IsLineOfSightVisible" "', argument " "7"" of type '" "double""'");
52525 : }
52526 6 : arg7 = static_cast< double >(val7);
52527 6 : if (obj7) {
52528 0 : {
52529 : /* %typemap(in) char **dict */
52530 0 : arg11 = NULL;
52531 0 : if ( PySequence_Check( obj7 ) ) {
52532 0 : int bErr = FALSE;
52533 0 : arg11 = CSLFromPySequence(obj7, &bErr);
52534 0 : if ( bErr )
52535 : {
52536 0 : SWIG_fail;
52537 : }
52538 : }
52539 0 : else if ( PyMapping_Check( obj7 ) ) {
52540 0 : int bErr = FALSE;
52541 0 : arg11 = CSLFromPyMapping(obj7, &bErr);
52542 0 : if ( bErr )
52543 : {
52544 0 : SWIG_fail;
52545 : }
52546 : }
52547 : else {
52548 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
52549 0 : SWIG_fail;
52550 : }
52551 : }
52552 : }
52553 6 : {
52554 6 : if (!arg1) {
52555 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
52556 : }
52557 : }
52558 5 : {
52559 5 : const int bLocalUseExceptions = GetUseExceptions();
52560 5 : if ( bLocalUseExceptions ) {
52561 5 : pushErrorHandler();
52562 : }
52563 5 : {
52564 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
52565 5 : IsLineOfSightVisible(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
52566 5 : SWIG_PYTHON_THREAD_END_ALLOW;
52567 : }
52568 5 : if ( bLocalUseExceptions ) {
52569 5 : popErrorHandler();
52570 : }
52571 : #ifndef SED_HACKS
52572 : if ( bLocalUseExceptions ) {
52573 : CPLErr eclass = CPLGetLastErrorType();
52574 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
52575 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
52576 : }
52577 : }
52578 : #endif
52579 : }
52580 5 : resultobj = SWIG_Py_Void();
52581 5 : {
52582 : /* %typemap(argout) (bool *pbVisible, int *pnXIntersection, int *pnYIntersection) */
52583 5 : PyObject *r = PyTuple_New( 3 );
52584 5 : PyTuple_SetItem( r, 0, PyBool_FromLong(*arg8) );
52585 5 : PyTuple_SetItem( r, 1, PyLong_FromLong(*arg9) );
52586 5 : PyTuple_SetItem( r, 2, PyLong_FromLong(*arg10) );
52587 : #if SWIG_VERSION >= 0x040300
52588 : resultobj = SWIG_Python_AppendOutput(resultobj,r,$isvoid);
52589 : #else
52590 5 : resultobj = SWIG_Python_AppendOutput(resultobj,r);
52591 : #endif
52592 : }
52593 5 : {
52594 : /* %typemap(freearg) char **dict */
52595 5 : CSLDestroy( arg11 );
52596 : }
52597 8 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
52598 : return resultobj;
52599 1 : fail:
52600 1 : {
52601 : /* %typemap(freearg) char **dict */
52602 1 : CSLDestroy( arg11 );
52603 : }
52604 : return NULL;
52605 : }
52606 :
52607 :
52608 24 : SWIGINTERN PyObject *_wrap_AutoCreateWarpedVRT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52609 24 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
52610 24 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
52611 24 : char *arg2 = (char *) 0 ;
52612 24 : char *arg3 = (char *) 0 ;
52613 24 : GDALResampleAlg arg4 = (GDALResampleAlg) GRA_NearestNeighbour ;
52614 24 : double arg5 = (double) 0.0 ;
52615 24 : void *argp1 = 0 ;
52616 24 : int res1 = 0 ;
52617 24 : int res2 ;
52618 24 : char *buf2 = 0 ;
52619 24 : int alloc2 = 0 ;
52620 24 : int res3 ;
52621 24 : char *buf3 = 0 ;
52622 24 : int alloc3 = 0 ;
52623 24 : int val4 ;
52624 24 : int ecode4 = 0 ;
52625 24 : double val5 ;
52626 24 : int ecode5 = 0 ;
52627 24 : PyObject *swig_obj[5] ;
52628 24 : GDALDatasetShadow *result = 0 ;
52629 :
52630 24 : if (!SWIG_Python_UnpackTuple(args, "AutoCreateWarpedVRT", 1, 5, swig_obj)) SWIG_fail;
52631 24 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
52632 24 : if (!SWIG_IsOK(res1)) {
52633 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AutoCreateWarpedVRT" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
52634 : }
52635 24 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
52636 24 : if (swig_obj[1]) {
52637 9 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
52638 9 : if (!SWIG_IsOK(res2)) {
52639 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AutoCreateWarpedVRT" "', argument " "2"" of type '" "char const *""'");
52640 : }
52641 9 : arg2 = reinterpret_cast< char * >(buf2);
52642 : }
52643 24 : if (swig_obj[2]) {
52644 9 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
52645 9 : if (!SWIG_IsOK(res3)) {
52646 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AutoCreateWarpedVRT" "', argument " "3"" of type '" "char const *""'");
52647 : }
52648 9 : arg3 = reinterpret_cast< char * >(buf3);
52649 : }
52650 24 : if (swig_obj[3]) {
52651 3 : ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
52652 3 : if (!SWIG_IsOK(ecode4)) {
52653 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AutoCreateWarpedVRT" "', argument " "4"" of type '" "GDALResampleAlg""'");
52654 : }
52655 3 : arg4 = static_cast< GDALResampleAlg >(val4);
52656 : }
52657 24 : if (swig_obj[4]) {
52658 3 : ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
52659 3 : if (!SWIG_IsOK(ecode5)) {
52660 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "AutoCreateWarpedVRT" "', argument " "5"" of type '" "double""'");
52661 : }
52662 3 : arg5 = static_cast< double >(val5);
52663 : }
52664 24 : {
52665 24 : if (!arg1) {
52666 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
52667 : }
52668 : }
52669 24 : {
52670 24 : const int bLocalUseExceptions = GetUseExceptions();
52671 24 : if ( bLocalUseExceptions ) {
52672 24 : pushErrorHandler();
52673 : }
52674 24 : {
52675 24 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
52676 24 : result = (GDALDatasetShadow *)AutoCreateWarpedVRT(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
52677 24 : SWIG_PYTHON_THREAD_END_ALLOW;
52678 : }
52679 24 : if ( bLocalUseExceptions ) {
52680 24 : popErrorHandler();
52681 : }
52682 : #ifndef SED_HACKS
52683 : if ( bLocalUseExceptions ) {
52684 : CPLErr eclass = CPLGetLastErrorType();
52685 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
52686 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
52687 : }
52688 : }
52689 : #endif
52690 : }
52691 24 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
52692 24 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
52693 24 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
52694 26 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
52695 : return resultobj;
52696 0 : fail:
52697 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
52698 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
52699 : return NULL;
52700 : }
52701 :
52702 :
52703 8 : SWIGINTERN PyObject *_wrap_CreatePansharpenedVRT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52704 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
52705 8 : char *arg1 = (char *) 0 ;
52706 8 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
52707 8 : int arg3 ;
52708 8 : GDALRasterBandShadow **arg4 = (GDALRasterBandShadow **) 0 ;
52709 8 : int res1 ;
52710 8 : char *buf1 = 0 ;
52711 8 : int alloc1 = 0 ;
52712 8 : void *argp2 = 0 ;
52713 8 : int res2 = 0 ;
52714 8 : PyObject *swig_obj[3] ;
52715 8 : GDALDatasetShadow *result = 0 ;
52716 :
52717 8 : if (!SWIG_Python_UnpackTuple(args, "CreatePansharpenedVRT", 3, 3, swig_obj)) SWIG_fail;
52718 8 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
52719 8 : if (!SWIG_IsOK(res1)) {
52720 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreatePansharpenedVRT" "', argument " "1"" of type '" "char const *""'");
52721 : }
52722 8 : arg1 = reinterpret_cast< char * >(buf1);
52723 8 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
52724 8 : if (!SWIG_IsOK(res2)) {
52725 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreatePansharpenedVRT" "', argument " "2"" of type '" "GDALRasterBandShadow *""'");
52726 : }
52727 8 : arg2 = reinterpret_cast< GDALRasterBandShadow * >(argp2);
52728 8 : {
52729 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALRasterBandShadow *optional_##GDALRasterBandShadow)*/
52730 8 : if ( !PySequence_Check(swig_obj[2]) ) {
52731 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
52732 0 : SWIG_fail;
52733 : }
52734 8 : Py_ssize_t size = PySequence_Size(swig_obj[2]);
52735 8 : if( size > (Py_ssize_t)INT_MAX ) {
52736 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
52737 0 : SWIG_fail;
52738 : }
52739 8 : if( (size_t)size > SIZE_MAX / sizeof(GDALRasterBandShadow*) ) {
52740 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
52741 0 : SWIG_fail;
52742 : }
52743 8 : arg3 = (int)size;
52744 8 : arg4 = (GDALRasterBandShadow**) VSIMalloc(arg3*sizeof(GDALRasterBandShadow*));
52745 8 : if( !arg4) {
52746 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
52747 0 : SWIG_fail;
52748 : }
52749 :
52750 30 : for( int i = 0; i<arg3; i++ ) {
52751 22 : PyObject *o = PySequence_GetItem(swig_obj[2],i);
52752 22 : GDALRasterBandShadow* rawobjectpointer = NULL;
52753 22 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALRasterBandShadow, SWIG_POINTER_EXCEPTION | 0 ));
52754 22 : if (!rawobjectpointer) {
52755 0 : Py_DECREF(o);
52756 0 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALRasterBandShadow");
52757 0 : SWIG_fail;
52758 : }
52759 22 : arg4[i] = rawobjectpointer;
52760 22 : Py_DECREF(o);
52761 :
52762 : }
52763 : }
52764 8 : {
52765 8 : if (!arg2) {
52766 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
52767 : }
52768 : }
52769 8 : {
52770 8 : const int bLocalUseExceptions = GetUseExceptions();
52771 8 : if ( bLocalUseExceptions ) {
52772 2 : pushErrorHandler();
52773 : }
52774 8 : {
52775 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
52776 8 : result = (GDALDatasetShadow *)CreatePansharpenedVRT((char const *)arg1,arg2,arg3,arg4);
52777 8 : SWIG_PYTHON_THREAD_END_ALLOW;
52778 : }
52779 8 : if ( bLocalUseExceptions ) {
52780 2 : popErrorHandler();
52781 : }
52782 : #ifndef SED_HACKS
52783 : if ( bLocalUseExceptions ) {
52784 : CPLErr eclass = CPLGetLastErrorType();
52785 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
52786 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
52787 : }
52788 : }
52789 : #endif
52790 : }
52791 8 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
52792 8 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
52793 8 : {
52794 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALRasterBandShadow **poObjects)*/
52795 8 : CPLFree( arg4 );
52796 : }
52797 8 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
52798 : return resultobj;
52799 0 : fail:
52800 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
52801 0 : {
52802 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALRasterBandShadow **poObjects)*/
52803 0 : CPLFree( arg4 );
52804 : }
52805 : return NULL;
52806 : }
52807 :
52808 :
52809 1 : SWIGINTERN PyObject *_wrap_GetTranformerOptionList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52810 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
52811 1 : char *result = 0 ;
52812 :
52813 1 : if (!SWIG_Python_UnpackTuple(args, "GetTranformerOptionList", 0, 0, 0)) SWIG_fail;
52814 1 : {
52815 1 : const int bLocalUseExceptions = GetUseExceptions();
52816 1 : if ( bLocalUseExceptions ) {
52817 1 : pushErrorHandler();
52818 : }
52819 1 : {
52820 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
52821 1 : result = (char *)GDALGetGenImgProjTranformerOptionList();
52822 1 : SWIG_PYTHON_THREAD_END_ALLOW;
52823 : }
52824 1 : if ( bLocalUseExceptions ) {
52825 1 : popErrorHandler();
52826 : }
52827 : #ifndef SED_HACKS
52828 : if ( bLocalUseExceptions ) {
52829 : CPLErr eclass = CPLGetLastErrorType();
52830 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
52831 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
52832 : }
52833 : }
52834 : #endif
52835 : }
52836 1 : resultobj = SWIG_FromCharPtr((const char *)result);
52837 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
52838 : return resultobj;
52839 0 : fail:
52840 0 : return NULL;
52841 : }
52842 :
52843 :
52844 71 : SWIGINTERN PyObject *_wrap_delete_GDALTransformerInfoShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52845 71 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
52846 71 : GDALTransformerInfoShadow *arg1 = (GDALTransformerInfoShadow *) 0 ;
52847 71 : void *argp1 = 0 ;
52848 71 : int res1 = 0 ;
52849 71 : PyObject *swig_obj[1] ;
52850 :
52851 71 : if (!args) SWIG_fail;
52852 71 : swig_obj[0] = args;
52853 71 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALTransformerInfoShadow, SWIG_POINTER_DISOWN | 0 );
52854 71 : if (!SWIG_IsOK(res1)) {
52855 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALTransformerInfoShadow" "', argument " "1"" of type '" "GDALTransformerInfoShadow *""'");
52856 : }
52857 71 : arg1 = reinterpret_cast< GDALTransformerInfoShadow * >(argp1);
52858 71 : {
52859 71 : const int bLocalUseExceptions = GetUseExceptions();
52860 71 : if ( bLocalUseExceptions ) {
52861 69 : pushErrorHandler();
52862 : }
52863 71 : {
52864 71 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
52865 71 : delete_GDALTransformerInfoShadow(arg1);
52866 71 : SWIG_PYTHON_THREAD_END_ALLOW;
52867 : }
52868 71 : if ( bLocalUseExceptions ) {
52869 69 : popErrorHandler();
52870 : }
52871 : #ifndef SED_HACKS
52872 : if ( bLocalUseExceptions ) {
52873 : CPLErr eclass = CPLGetLastErrorType();
52874 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
52875 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
52876 : }
52877 : }
52878 : #endif
52879 : }
52880 71 : resultobj = SWIG_Py_Void();
52881 71 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
52882 : return resultobj;
52883 : fail:
52884 : return NULL;
52885 : }
52886 :
52887 :
52888 : SWIGINTERN PyObject *_wrap_GDALTransformerInfoShadow_TransformPoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
52889 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
52890 : GDALTransformerInfoShadow *arg1 = (GDALTransformerInfoShadow *) 0 ;
52891 : int arg2 ;
52892 : double *arg3 ;
52893 : void *argp1 = 0 ;
52894 : int res1 = 0 ;
52895 : int val2 ;
52896 : int ecode2 = 0 ;
52897 : double argin3[3] ;
52898 : int result;
52899 :
52900 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52901 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALTransformerInfoShadow, 0 | 0 );
52902 : if (!SWIG_IsOK(res1)) {
52903 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDALTransformerInfoShadow_TransformPoint" "', argument " "1"" of type '" "GDALTransformerInfoShadow *""'");
52904 : }
52905 : arg1 = reinterpret_cast< GDALTransformerInfoShadow * >(argp1);
52906 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
52907 : if (!SWIG_IsOK(ecode2)) {
52908 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GDALTransformerInfoShadow_TransformPoint" "', argument " "2"" of type '" "int""'");
52909 : }
52910 : arg2 = static_cast< int >(val2);
52911 : {
52912 : /* %typemap(in) (double argin3[ANY]) */
52913 : arg3 = argin3;
52914 : if (! PySequence_Check(swig_obj[2]) ) {
52915 : PyErr_SetString(PyExc_TypeError, "not a sequence");
52916 : SWIG_fail;
52917 : }
52918 : Py_ssize_t seq_size = PySequence_Size(swig_obj[2]);
52919 : if ( seq_size != 3 ) {
52920 : PyErr_SetString(PyExc_TypeError, "sequence must have length ##size");
52921 : SWIG_fail;
52922 : }
52923 : for (unsigned int i=0; i<3; i++) {
52924 : PyObject *o = PySequence_GetItem(swig_obj[2],i);
52925 : double val;
52926 : if ( !PyArg_Parse(o, "d", &val ) ) {
52927 : PyErr_SetString(PyExc_TypeError, "not a number");
52928 : Py_DECREF(o);
52929 : SWIG_fail;
52930 : }
52931 : arg3[i] = val;
52932 : Py_DECREF(o);
52933 : }
52934 : }
52935 : {
52936 : const int bLocalUseExceptions = GetUseExceptions();
52937 : if ( bLocalUseExceptions ) {
52938 : pushErrorHandler();
52939 : }
52940 : {
52941 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
52942 : result = (int)GDALTransformerInfoShadow_TransformPoint__SWIG_0(arg1,arg2,arg3);
52943 : SWIG_PYTHON_THREAD_END_ALLOW;
52944 : }
52945 : if ( bLocalUseExceptions ) {
52946 : popErrorHandler();
52947 : }
52948 : #ifndef SED_HACKS
52949 : if ( bLocalUseExceptions ) {
52950 : CPLErr eclass = CPLGetLastErrorType();
52951 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
52952 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
52953 : }
52954 : }
52955 : #endif
52956 : }
52957 : resultobj = SWIG_From_int(static_cast< int >(result));
52958 : {
52959 : /* %typemap(argout) (double argout[ANY]) */
52960 : PyObject *out = CreateTupleFromDoubleArray( arg3, 3 );
52961 : #if SWIG_VERSION >= 0x040300
52962 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
52963 : #else
52964 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
52965 : #endif
52966 : }
52967 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
52968 : return resultobj;
52969 : fail:
52970 : return NULL;
52971 : }
52972 :
52973 :
52974 : SWIGINTERN PyObject *_wrap_GDALTransformerInfoShadow_TransformPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
52975 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
52976 : GDALTransformerInfoShadow *arg1 = (GDALTransformerInfoShadow *) 0 ;
52977 : double *arg2 ;
52978 : int arg3 ;
52979 : double arg4 ;
52980 : double arg5 ;
52981 : double arg6 = (double) 0.0 ;
52982 : void *argp1 = 0 ;
52983 : int res1 = 0 ;
52984 : double argout2[3] ;
52985 : int val3 ;
52986 : int ecode3 = 0 ;
52987 : double val4 ;
52988 : int ecode4 = 0 ;
52989 : double val5 ;
52990 : int ecode5 = 0 ;
52991 : double val6 ;
52992 : int ecode6 = 0 ;
52993 : int result;
52994 :
52995 : {
52996 : /* %typemap(in,numinputs=0) (double argout2[ANY]) */
52997 : memset(argout2, 0, sizeof(argout2));
52998 : arg2 = argout2;
52999 : }
53000 : if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
53001 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALTransformerInfoShadow, 0 | 0 );
53002 : if (!SWIG_IsOK(res1)) {
53003 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDALTransformerInfoShadow_TransformPoint" "', argument " "1"" of type '" "GDALTransformerInfoShadow *""'");
53004 : }
53005 : arg1 = reinterpret_cast< GDALTransformerInfoShadow * >(argp1);
53006 : ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
53007 : if (!SWIG_IsOK(ecode3)) {
53008 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GDALTransformerInfoShadow_TransformPoint" "', argument " "3"" of type '" "int""'");
53009 : }
53010 : arg3 = static_cast< int >(val3);
53011 : ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
53012 : if (!SWIG_IsOK(ecode4)) {
53013 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GDALTransformerInfoShadow_TransformPoint" "', argument " "4"" of type '" "double""'");
53014 : }
53015 : arg4 = static_cast< double >(val4);
53016 : ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
53017 : if (!SWIG_IsOK(ecode5)) {
53018 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GDALTransformerInfoShadow_TransformPoint" "', argument " "5"" of type '" "double""'");
53019 : }
53020 : arg5 = static_cast< double >(val5);
53021 : if (swig_obj[4]) {
53022 : ecode6 = SWIG_AsVal_double(swig_obj[4], &val6);
53023 : if (!SWIG_IsOK(ecode6)) {
53024 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GDALTransformerInfoShadow_TransformPoint" "', argument " "6"" of type '" "double""'");
53025 : }
53026 : arg6 = static_cast< double >(val6);
53027 : }
53028 : {
53029 : const int bLocalUseExceptions = GetUseExceptions();
53030 : if ( bLocalUseExceptions ) {
53031 : pushErrorHandler();
53032 : }
53033 : {
53034 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53035 : result = (int)GDALTransformerInfoShadow_TransformPoint__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
53036 : SWIG_PYTHON_THREAD_END_ALLOW;
53037 : }
53038 : if ( bLocalUseExceptions ) {
53039 : popErrorHandler();
53040 : }
53041 : #ifndef SED_HACKS
53042 : if ( bLocalUseExceptions ) {
53043 : CPLErr eclass = CPLGetLastErrorType();
53044 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
53045 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
53046 : }
53047 : }
53048 : #endif
53049 : }
53050 : resultobj = SWIG_From_int(static_cast< int >(result));
53051 : {
53052 : /* %typemap(argout) (double argout[ANY]) */
53053 : PyObject *out = CreateTupleFromDoubleArray( arg2, 3 );
53054 : #if SWIG_VERSION >= 0x040300
53055 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
53056 : #else
53057 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
53058 : #endif
53059 : }
53060 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53061 : return resultobj;
53062 : fail:
53063 : return NULL;
53064 : }
53065 :
53066 :
53067 8677 : SWIGINTERN PyObject *_wrap_GDALTransformerInfoShadow_TransformPoint(PyObject *self, PyObject *args) {
53068 8677 : Py_ssize_t argc;
53069 8677 : PyObject *argv[6] = {
53070 : 0
53071 : };
53072 :
53073 8677 : if (!(argc = SWIG_Python_UnpackTuple(args, "GDALTransformerInfoShadow_TransformPoint", 0, 5, argv))) SWIG_fail;
53074 8677 : --argc;
53075 8677 : if (argc == 3) {
53076 0 : int _v;
53077 0 : void *vptr = 0;
53078 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GDALTransformerInfoShadow, 0);
53079 0 : _v = SWIG_CheckState(res);
53080 0 : if (_v) {
53081 0 : {
53082 0 : int res = SWIG_AsVal_int(argv[1], NULL);
53083 0 : _v = SWIG_CheckState(res);
53084 : }
53085 0 : if (_v) {
53086 0 : void *vptr = 0;
53087 0 : int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
53088 0 : _v = SWIG_CheckState(res);
53089 0 : if (_v) {
53090 0 : return _wrap_GDALTransformerInfoShadow_TransformPoint__SWIG_0(self, argc, argv);
53091 : }
53092 : }
53093 : }
53094 : }
53095 8677 : if ((argc >= 4) && (argc <= 5)) {
53096 8677 : int _v;
53097 8677 : void *vptr = 0;
53098 8677 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GDALTransformerInfoShadow, 0);
53099 8677 : _v = SWIG_CheckState(res);
53100 8677 : if (_v) {
53101 8677 : {
53102 8677 : int res = SWIG_AsVal_int(argv[1], NULL);
53103 8677 : _v = SWIG_CheckState(res);
53104 : }
53105 8677 : if (_v) {
53106 8677 : {
53107 8677 : int res = SWIG_AsVal_double(argv[2], NULL);
53108 8677 : _v = SWIG_CheckState(res);
53109 : }
53110 8677 : if (_v) {
53111 8677 : {
53112 8677 : int res = SWIG_AsVal_double(argv[3], NULL);
53113 8677 : _v = SWIG_CheckState(res);
53114 : }
53115 8677 : if (_v) {
53116 8677 : if (argc <= 4) {
53117 8677 : return _wrap_GDALTransformerInfoShadow_TransformPoint__SWIG_1(self, argc, argv);
53118 : }
53119 40 : {
53120 40 : int res = SWIG_AsVal_double(argv[4], NULL);
53121 40 : _v = SWIG_CheckState(res);
53122 : }
53123 40 : if (_v) {
53124 40 : return _wrap_GDALTransformerInfoShadow_TransformPoint__SWIG_1(self, argc, argv);
53125 : }
53126 : }
53127 : }
53128 : }
53129 : }
53130 : }
53131 :
53132 0 : fail:
53133 0 : SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GDALTransformerInfoShadow_TransformPoint'.\n"
53134 : " Possible C/C++ prototypes are:\n"
53135 : " GDALTransformerInfoShadow::TransformPoint(int,double [3])\n"
53136 : " GDALTransformerInfoShadow::TransformPoint(double [3],int,double,double,double)\n");
53137 : return 0;
53138 : }
53139 :
53140 :
53141 4 : SWIGINTERN PyObject *_wrap_GDALTransformerInfoShadow_TransformPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53142 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53143 4 : GDALTransformerInfoShadow *arg1 = (GDALTransformerInfoShadow *) 0 ;
53144 4 : int arg2 ;
53145 4 : int arg3 ;
53146 4 : double *arg4 = (double *) 0 ;
53147 4 : double *arg5 = (double *) 0 ;
53148 4 : double *arg6 = (double *) 0 ;
53149 4 : int *arg7 = (int *) 0 ;
53150 4 : void *argp1 = 0 ;
53151 4 : int res1 = 0 ;
53152 4 : int val2 ;
53153 4 : int ecode2 = 0 ;
53154 4 : PyObject *swig_obj[3] ;
53155 4 : int result;
53156 :
53157 4 : if (!SWIG_Python_UnpackTuple(args, "GDALTransformerInfoShadow_TransformPoints", 3, 3, swig_obj)) SWIG_fail;
53158 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALTransformerInfoShadow, 0 | 0 );
53159 4 : if (!SWIG_IsOK(res1)) {
53160 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDALTransformerInfoShadow_TransformPoints" "', argument " "1"" of type '" "GDALTransformerInfoShadow *""'");
53161 : }
53162 4 : arg1 = reinterpret_cast< GDALTransformerInfoShadow * >(argp1);
53163 4 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
53164 4 : if (!SWIG_IsOK(ecode2)) {
53165 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GDALTransformerInfoShadow_TransformPoints" "', argument " "2"" of type '" "int""'");
53166 : }
53167 4 : arg2 = static_cast< int >(val2);
53168 4 : {
53169 : /* typemap(in,numinputs=1) (int nCount, double *x, double *y, double *z, int* panSuccess) */
53170 4 : if ( !PySequence_Check(swig_obj[2]) ) {
53171 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
53172 0 : SWIG_fail;
53173 : }
53174 :
53175 4 : Py_ssize_t size = PySequence_Size(swig_obj[2]);
53176 4 : if( size != (int)size ) {
53177 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
53178 0 : SWIG_fail;
53179 : }
53180 4 : arg3 = (int)size;
53181 4 : arg4 = (double*) VSIMalloc(arg3*sizeof(double));
53182 4 : arg5 = (double*) VSIMalloc(arg3*sizeof(double));
53183 4 : arg6 = (double*) VSIMalloc(arg3*sizeof(double));
53184 4 : arg7 = (int*) VSIMalloc(arg3*sizeof(int));
53185 :
53186 4 : if (arg4 == NULL || arg5 == NULL || arg6 == NULL || arg7 == NULL)
53187 : {
53188 0 : PyErr_SetString( PyExc_RuntimeError, "Out of memory" );
53189 0 : SWIG_fail;
53190 : }
53191 :
53192 4 : if (!DecomposeSequenceOfCoordinates(swig_obj[2],arg3,arg4,arg5,arg6)) {
53193 0 : SWIG_fail;
53194 : }
53195 : }
53196 4 : {
53197 4 : const int bLocalUseExceptions = GetUseExceptions();
53198 4 : if ( bLocalUseExceptions ) {
53199 4 : pushErrorHandler();
53200 : }
53201 4 : {
53202 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53203 4 : result = (int)GDALTransformerInfoShadow_TransformPoints(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
53204 4 : SWIG_PYTHON_THREAD_END_ALLOW;
53205 : }
53206 4 : if ( bLocalUseExceptions ) {
53207 4 : popErrorHandler();
53208 : }
53209 : #ifndef SED_HACKS
53210 : if ( bLocalUseExceptions ) {
53211 : CPLErr eclass = CPLGetLastErrorType();
53212 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
53213 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
53214 : }
53215 : }
53216 : #endif
53217 : }
53218 4 : resultobj = SWIG_From_int(static_cast< int >(result));
53219 4 : {
53220 : /* %typemap(argout) (int nCount, double *x, double *y, double *z, int* panSuccess) */
53221 4 : Py_DECREF(resultobj);
53222 4 : PyObject *xyz = PyList_New( arg3 );
53223 4 : if( !xyz ) {
53224 0 : SWIG_fail;
53225 : }
53226 4 : PyObject *success = PyList_New( arg3 );
53227 4 : if( !success ) {
53228 0 : Py_DECREF(xyz);
53229 0 : SWIG_fail;
53230 : }
53231 35 : for( int i=0; i< arg3; i++ ) {
53232 31 : PyObject *tuple = PyTuple_New( 3 );
53233 31 : PyTuple_SetItem( tuple, 0, PyFloat_FromDouble( (arg4)[i] ) );
53234 31 : PyTuple_SetItem( tuple, 1, PyFloat_FromDouble( (arg5)[i] ) );
53235 31 : PyTuple_SetItem( tuple, 2, PyFloat_FromDouble( (arg6)[i] ) );
53236 31 : PyList_SetItem( xyz, i, tuple );
53237 31 : PyList_SetItem( success, i, Py_BuildValue( "i", (arg7)[i]) );
53238 : }
53239 4 : resultobj = PyTuple_New( 2 );
53240 4 : PyTuple_SetItem( resultobj, 0, xyz );
53241 4 : PyTuple_SetItem( resultobj, 1, success );
53242 : }
53243 4 : {
53244 : /* %typemap(freearg) (int nCount, double *x, double *y, double *z, int* panSuccess) */
53245 4 : VSIFree(arg4);
53246 4 : VSIFree(arg5);
53247 4 : VSIFree(arg6);
53248 4 : VSIFree(arg7);
53249 : }
53250 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53251 : return resultobj;
53252 0 : fail:
53253 0 : {
53254 : /* %typemap(freearg) (int nCount, double *x, double *y, double *z, int* panSuccess) */
53255 0 : VSIFree(arg4);
53256 0 : VSIFree(arg5);
53257 0 : VSIFree(arg6);
53258 0 : VSIFree(arg7);
53259 : }
53260 : return NULL;
53261 : }
53262 :
53263 :
53264 1 : SWIGINTERN PyObject *_wrap_GDALTransformerInfoShadow_TransformGeolocations(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53265 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53266 1 : GDALTransformerInfoShadow *arg1 = (GDALTransformerInfoShadow *) 0 ;
53267 1 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
53268 1 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
53269 1 : GDALRasterBandShadow *arg4 = (GDALRasterBandShadow *) 0 ;
53270 1 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
53271 1 : void *arg6 = (void *) NULL ;
53272 1 : char **arg7 = (char **) NULL ;
53273 1 : void *argp1 = 0 ;
53274 1 : int res1 = 0 ;
53275 1 : void *argp2 = 0 ;
53276 1 : int res2 = 0 ;
53277 1 : void *argp3 = 0 ;
53278 1 : int res3 = 0 ;
53279 1 : void *argp4 = 0 ;
53280 1 : int res4 = 0 ;
53281 1 : PyObject * obj0 = 0 ;
53282 1 : PyObject * obj1 = 0 ;
53283 1 : PyObject * obj2 = 0 ;
53284 1 : PyObject * obj3 = 0 ;
53285 1 : PyObject * obj4 = 0 ;
53286 1 : PyObject * obj5 = 0 ;
53287 1 : PyObject * obj6 = 0 ;
53288 1 : char * kwnames[] = {
53289 : (char *)"self", (char *)"xBand", (char *)"yBand", (char *)"zBand", (char *)"callback", (char *)"callback_data", (char *)"options", NULL
53290 : };
53291 1 : int result;
53292 :
53293 : /* %typemap(arginit) ( const char* callback_data=NULL) */
53294 1 : PyProgressData *psProgressInfo;
53295 1 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
53296 1 : psProgressInfo->nLastReported = -1;
53297 1 : psProgressInfo->psPyCallback = NULL;
53298 1 : psProgressInfo->psPyCallbackData = NULL;
53299 1 : arg6 = psProgressInfo;
53300 1 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOO:GDALTransformerInfoShadow_TransformGeolocations", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
53301 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALTransformerInfoShadow, 0 | 0 );
53302 1 : if (!SWIG_IsOK(res1)) {
53303 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDALTransformerInfoShadow_TransformGeolocations" "', argument " "1"" of type '" "GDALTransformerInfoShadow *""'");
53304 : }
53305 1 : arg1 = reinterpret_cast< GDALTransformerInfoShadow * >(argp1);
53306 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
53307 1 : if (!SWIG_IsOK(res2)) {
53308 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GDALTransformerInfoShadow_TransformGeolocations" "', argument " "2"" of type '" "GDALRasterBandShadow *""'");
53309 : }
53310 1 : arg2 = reinterpret_cast< GDALRasterBandShadow * >(argp2);
53311 1 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
53312 1 : if (!SWIG_IsOK(res3)) {
53313 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GDALTransformerInfoShadow_TransformGeolocations" "', argument " "3"" of type '" "GDALRasterBandShadow *""'");
53314 : }
53315 1 : arg3 = reinterpret_cast< GDALRasterBandShadow * >(argp3);
53316 1 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_GDALRasterBandShadow, 0 | 0 );
53317 1 : if (!SWIG_IsOK(res4)) {
53318 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GDALTransformerInfoShadow_TransformGeolocations" "', argument " "4"" of type '" "GDALRasterBandShadow *""'");
53319 : }
53320 1 : arg4 = reinterpret_cast< GDALRasterBandShadow * >(argp4);
53321 1 : if (obj4) {
53322 0 : {
53323 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
53324 : /* callback_func typemap */
53325 :
53326 : /* In some cases 0 is passed instead of None. */
53327 : /* See https://github.com/OSGeo/gdal/pull/219 */
53328 0 : if ( PyLong_Check(obj4) || PyInt_Check(obj4) )
53329 : {
53330 0 : if( PyLong_AsLong(obj4) == 0 )
53331 : {
53332 0 : obj4 = Py_None;
53333 : }
53334 : }
53335 :
53336 0 : if (obj4 && obj4 != Py_None ) {
53337 0 : void* cbfunction = NULL;
53338 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( obj4,
53339 : (void**)&cbfunction,
53340 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
53341 : SWIG_POINTER_EXCEPTION | 0 ));
53342 :
53343 0 : if ( cbfunction == GDALTermProgress ) {
53344 : arg5 = GDALTermProgress;
53345 : } else {
53346 0 : if (!PyCallable_Check(obj4)) {
53347 0 : PyErr_SetString( PyExc_RuntimeError,
53348 : "Object given is not a Python function" );
53349 0 : SWIG_fail;
53350 : }
53351 0 : psProgressInfo->psPyCallback = obj4;
53352 0 : arg5 = PyProgressProxy;
53353 : }
53354 :
53355 : }
53356 :
53357 : }
53358 : }
53359 1 : if (obj5) {
53360 0 : {
53361 : /* %typemap(in) ( void* callback_data=NULL) */
53362 0 : psProgressInfo->psPyCallbackData = obj5 ;
53363 : }
53364 : }
53365 1 : if (obj6) {
53366 0 : {
53367 : /* %typemap(in) char **dict */
53368 0 : arg7 = NULL;
53369 0 : if ( PySequence_Check( obj6 ) ) {
53370 0 : int bErr = FALSE;
53371 0 : arg7 = CSLFromPySequence(obj6, &bErr);
53372 0 : if ( bErr )
53373 : {
53374 0 : SWIG_fail;
53375 : }
53376 : }
53377 0 : else if ( PyMapping_Check( obj6 ) ) {
53378 0 : int bErr = FALSE;
53379 0 : arg7 = CSLFromPyMapping(obj6, &bErr);
53380 0 : if ( bErr )
53381 : {
53382 0 : SWIG_fail;
53383 : }
53384 : }
53385 : else {
53386 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
53387 0 : SWIG_fail;
53388 : }
53389 : }
53390 : }
53391 1 : {
53392 1 : if (!arg2) {
53393 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
53394 : }
53395 : }
53396 1 : {
53397 1 : if (!arg3) {
53398 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
53399 : }
53400 : }
53401 1 : {
53402 1 : if (!arg4) {
53403 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
53404 : }
53405 : }
53406 1 : {
53407 1 : const int bLocalUseExceptions = GetUseExceptions();
53408 1 : if ( bLocalUseExceptions ) {
53409 1 : pushErrorHandler();
53410 : }
53411 1 : {
53412 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53413 1 : result = (int)GDALTransformerInfoShadow_TransformGeolocations(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
53414 1 : SWIG_PYTHON_THREAD_END_ALLOW;
53415 : }
53416 1 : if ( bLocalUseExceptions ) {
53417 1 : popErrorHandler();
53418 : }
53419 : #ifndef SED_HACKS
53420 : if ( bLocalUseExceptions ) {
53421 : CPLErr eclass = CPLGetLastErrorType();
53422 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
53423 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
53424 : }
53425 : }
53426 : #endif
53427 : }
53428 1 : resultobj = SWIG_From_int(static_cast< int >(result));
53429 1 : {
53430 : /* %typemap(freearg) ( void* callback_data=NULL) */
53431 :
53432 1 : CPLFree(psProgressInfo);
53433 :
53434 : }
53435 1 : {
53436 : /* %typemap(freearg) char **dict */
53437 1 : CSLDestroy( arg7 );
53438 : }
53439 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53440 : return resultobj;
53441 0 : fail:
53442 0 : {
53443 : /* %typemap(freearg) ( void* callback_data=NULL) */
53444 :
53445 0 : CPLFree(psProgressInfo);
53446 :
53447 : }
53448 0 : {
53449 : /* %typemap(freearg) char **dict */
53450 0 : CSLDestroy( arg7 );
53451 : }
53452 : return NULL;
53453 : }
53454 :
53455 :
53456 277 : SWIGINTERN PyObject *GDALTransformerInfoShadow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53457 277 : PyObject *obj;
53458 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
53459 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALTransformerInfoShadow, SWIG_NewClientData(obj));
53460 277 : return SWIG_Py_Void();
53461 : }
53462 :
53463 79 : SWIGINTERN PyObject *_wrap_Transformer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53464 79 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53465 79 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
53466 79 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
53467 79 : char **arg3 = (char **) 0 ;
53468 79 : void *argp1 = 0 ;
53469 79 : int res1 = 0 ;
53470 79 : void *argp2 = 0 ;
53471 79 : int res2 = 0 ;
53472 79 : PyObject *swig_obj[3] ;
53473 79 : GDALTransformerInfoShadow *result = 0 ;
53474 :
53475 79 : if (!SWIG_Python_UnpackTuple(args, "Transformer", 3, 3, swig_obj)) SWIG_fail;
53476 79 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
53477 79 : if (!SWIG_IsOK(res1)) {
53478 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transformer" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
53479 : }
53480 79 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
53481 79 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
53482 79 : if (!SWIG_IsOK(res2)) {
53483 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transformer" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
53484 : }
53485 79 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
53486 79 : {
53487 : /* %typemap(in) char **dict */
53488 79 : arg3 = NULL;
53489 79 : if ( PySequence_Check( swig_obj[2] ) ) {
53490 79 : int bErr = FALSE;
53491 79 : arg3 = CSLFromPySequence(swig_obj[2], &bErr);
53492 79 : if ( bErr )
53493 : {
53494 0 : SWIG_fail;
53495 : }
53496 : }
53497 0 : else if ( PyMapping_Check( swig_obj[2] ) ) {
53498 0 : int bErr = FALSE;
53499 0 : arg3 = CSLFromPyMapping(swig_obj[2], &bErr);
53500 0 : if ( bErr )
53501 : {
53502 0 : SWIG_fail;
53503 : }
53504 : }
53505 : else {
53506 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
53507 0 : SWIG_fail;
53508 : }
53509 : }
53510 79 : {
53511 79 : const int bLocalUseExceptions = GetUseExceptions();
53512 79 : if ( bLocalUseExceptions ) {
53513 76 : pushErrorHandler();
53514 : }
53515 79 : {
53516 79 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53517 79 : result = (GDALTransformerInfoShadow *)Transformer(arg1,arg2,arg3);
53518 79 : SWIG_PYTHON_THREAD_END_ALLOW;
53519 : }
53520 79 : if ( bLocalUseExceptions ) {
53521 76 : popErrorHandler();
53522 : }
53523 : #ifndef SED_HACKS
53524 : if ( bLocalUseExceptions ) {
53525 : CPLErr eclass = CPLGetLastErrorType();
53526 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
53527 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
53528 : }
53529 : }
53530 : #endif
53531 : }
53532 79 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALTransformerInfoShadow, SWIG_POINTER_OWN | 0 );
53533 79 : {
53534 : /* %typemap(freearg) char **dict */
53535 79 : CSLDestroy( arg3 );
53536 : }
53537 91 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53538 : return resultobj;
53539 0 : fail:
53540 0 : {
53541 : /* %typemap(freearg) char **dict */
53542 0 : CSLDestroy( arg3 );
53543 : }
53544 : return NULL;
53545 : }
53546 :
53547 :
53548 1 : SWIGINTERN PyObject *_wrap_WarpGetOptionList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53549 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53550 1 : char *result = 0 ;
53551 :
53552 1 : if (!SWIG_Python_UnpackTuple(args, "WarpGetOptionList", 0, 0, 0)) SWIG_fail;
53553 1 : {
53554 1 : const int bLocalUseExceptions = GetUseExceptions();
53555 1 : if ( bLocalUseExceptions ) {
53556 1 : pushErrorHandler();
53557 : }
53558 1 : {
53559 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53560 1 : result = (char *)GDALWarpGetOptionList();
53561 1 : SWIG_PYTHON_THREAD_END_ALLOW;
53562 : }
53563 1 : if ( bLocalUseExceptions ) {
53564 1 : popErrorHandler();
53565 : }
53566 : #ifndef SED_HACKS
53567 : if ( bLocalUseExceptions ) {
53568 : CPLErr eclass = CPLGetLastErrorType();
53569 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
53570 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
53571 : }
53572 : }
53573 : #endif
53574 : }
53575 1 : resultobj = SWIG_FromCharPtr((const char *)result);
53576 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53577 : return resultobj;
53578 0 : fail:
53579 0 : return NULL;
53580 : }
53581 :
53582 :
53583 2 : SWIGINTERN PyObject *_wrap_SuggestedWarpOutputRes_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53584 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53585 2 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
53586 2 : void *argp1 = 0 ;
53587 2 : int res1 = 0 ;
53588 2 : PyObject *swig_obj[1] ;
53589 2 : int result;
53590 :
53591 2 : if (!args) SWIG_fail;
53592 2 : swig_obj[0] = args;
53593 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SuggestedWarpOutputRes, 0 | 0 );
53594 2 : if (!SWIG_IsOK(res1)) {
53595 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuggestedWarpOutputRes_width_get" "', argument " "1"" of type '" "SuggestedWarpOutputRes *""'");
53596 : }
53597 2 : arg1 = reinterpret_cast< SuggestedWarpOutputRes * >(argp1);
53598 2 : {
53599 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53600 2 : result = (int) ((arg1)->width);
53601 2 : SWIG_PYTHON_THREAD_END_ALLOW;
53602 : }
53603 2 : resultobj = SWIG_From_int(static_cast< int >(result));
53604 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53605 : return resultobj;
53606 : fail:
53607 : return NULL;
53608 : }
53609 :
53610 :
53611 2 : SWIGINTERN PyObject *_wrap_SuggestedWarpOutputRes_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53612 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53613 2 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
53614 2 : void *argp1 = 0 ;
53615 2 : int res1 = 0 ;
53616 2 : PyObject *swig_obj[1] ;
53617 2 : int result;
53618 :
53619 2 : if (!args) SWIG_fail;
53620 2 : swig_obj[0] = args;
53621 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SuggestedWarpOutputRes, 0 | 0 );
53622 2 : if (!SWIG_IsOK(res1)) {
53623 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuggestedWarpOutputRes_height_get" "', argument " "1"" of type '" "SuggestedWarpOutputRes *""'");
53624 : }
53625 2 : arg1 = reinterpret_cast< SuggestedWarpOutputRes * >(argp1);
53626 2 : {
53627 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53628 2 : result = (int) ((arg1)->height);
53629 2 : SWIG_PYTHON_THREAD_END_ALLOW;
53630 : }
53631 2 : resultobj = SWIG_From_int(static_cast< int >(result));
53632 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53633 : return resultobj;
53634 : fail:
53635 : return NULL;
53636 : }
53637 :
53638 :
53639 3 : SWIGINTERN PyObject *_wrap_SuggestedWarpOutputRes_xmin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53640 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53641 3 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
53642 3 : void *argp1 = 0 ;
53643 3 : int res1 = 0 ;
53644 3 : PyObject *swig_obj[1] ;
53645 3 : double result;
53646 :
53647 3 : if (!args) SWIG_fail;
53648 3 : swig_obj[0] = args;
53649 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SuggestedWarpOutputRes, 0 | 0 );
53650 3 : if (!SWIG_IsOK(res1)) {
53651 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuggestedWarpOutputRes_xmin_get" "', argument " "1"" of type '" "SuggestedWarpOutputRes *""'");
53652 : }
53653 3 : arg1 = reinterpret_cast< SuggestedWarpOutputRes * >(argp1);
53654 3 : {
53655 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53656 3 : result = (double) ((arg1)->xmin);
53657 3 : SWIG_PYTHON_THREAD_END_ALLOW;
53658 : }
53659 3 : resultobj = SWIG_From_double(static_cast< double >(result));
53660 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53661 : return resultobj;
53662 : fail:
53663 : return NULL;
53664 : }
53665 :
53666 :
53667 3 : SWIGINTERN PyObject *_wrap_SuggestedWarpOutputRes_ymin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53668 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53669 3 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
53670 3 : void *argp1 = 0 ;
53671 3 : int res1 = 0 ;
53672 3 : PyObject *swig_obj[1] ;
53673 3 : double result;
53674 :
53675 3 : if (!args) SWIG_fail;
53676 3 : swig_obj[0] = args;
53677 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SuggestedWarpOutputRes, 0 | 0 );
53678 3 : if (!SWIG_IsOK(res1)) {
53679 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuggestedWarpOutputRes_ymin_get" "', argument " "1"" of type '" "SuggestedWarpOutputRes *""'");
53680 : }
53681 3 : arg1 = reinterpret_cast< SuggestedWarpOutputRes * >(argp1);
53682 3 : {
53683 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53684 3 : result = (double) ((arg1)->ymin);
53685 3 : SWIG_PYTHON_THREAD_END_ALLOW;
53686 : }
53687 3 : resultobj = SWIG_From_double(static_cast< double >(result));
53688 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53689 : return resultobj;
53690 : fail:
53691 : return NULL;
53692 : }
53693 :
53694 :
53695 3 : SWIGINTERN PyObject *_wrap_SuggestedWarpOutputRes_xmax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53696 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53697 3 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
53698 3 : void *argp1 = 0 ;
53699 3 : int res1 = 0 ;
53700 3 : PyObject *swig_obj[1] ;
53701 3 : double result;
53702 :
53703 3 : if (!args) SWIG_fail;
53704 3 : swig_obj[0] = args;
53705 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SuggestedWarpOutputRes, 0 | 0 );
53706 3 : if (!SWIG_IsOK(res1)) {
53707 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuggestedWarpOutputRes_xmax_get" "', argument " "1"" of type '" "SuggestedWarpOutputRes *""'");
53708 : }
53709 3 : arg1 = reinterpret_cast< SuggestedWarpOutputRes * >(argp1);
53710 3 : {
53711 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53712 3 : result = (double) ((arg1)->xmax);
53713 3 : SWIG_PYTHON_THREAD_END_ALLOW;
53714 : }
53715 3 : resultobj = SWIG_From_double(static_cast< double >(result));
53716 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53717 : return resultobj;
53718 : fail:
53719 : return NULL;
53720 : }
53721 :
53722 :
53723 3 : SWIGINTERN PyObject *_wrap_SuggestedWarpOutputRes_ymax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53724 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53725 3 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
53726 3 : void *argp1 = 0 ;
53727 3 : int res1 = 0 ;
53728 3 : PyObject *swig_obj[1] ;
53729 3 : double result;
53730 :
53731 3 : if (!args) SWIG_fail;
53732 3 : swig_obj[0] = args;
53733 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SuggestedWarpOutputRes, 0 | 0 );
53734 3 : if (!SWIG_IsOK(res1)) {
53735 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuggestedWarpOutputRes_ymax_get" "', argument " "1"" of type '" "SuggestedWarpOutputRes *""'");
53736 : }
53737 3 : arg1 = reinterpret_cast< SuggestedWarpOutputRes * >(argp1);
53738 3 : {
53739 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53740 3 : result = (double) ((arg1)->ymax);
53741 3 : SWIG_PYTHON_THREAD_END_ALLOW;
53742 : }
53743 3 : resultobj = SWIG_From_double(static_cast< double >(result));
53744 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53745 : return resultobj;
53746 : fail:
53747 : return NULL;
53748 : }
53749 :
53750 :
53751 3 : SWIGINTERN PyObject *_wrap_delete_SuggestedWarpOutputRes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53752 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53753 3 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
53754 3 : void *argp1 = 0 ;
53755 3 : int res1 = 0 ;
53756 3 : PyObject *swig_obj[1] ;
53757 :
53758 3 : if (!args) SWIG_fail;
53759 3 : swig_obj[0] = args;
53760 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SuggestedWarpOutputRes, SWIG_POINTER_DISOWN | 0 );
53761 3 : if (!SWIG_IsOK(res1)) {
53762 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SuggestedWarpOutputRes" "', argument " "1"" of type '" "SuggestedWarpOutputRes *""'");
53763 : }
53764 3 : arg1 = reinterpret_cast< SuggestedWarpOutputRes * >(argp1);
53765 3 : {
53766 3 : const int bLocalUseExceptions = GetUseExceptions();
53767 3 : if ( bLocalUseExceptions ) {
53768 3 : pushErrorHandler();
53769 : }
53770 3 : {
53771 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53772 3 : delete_SuggestedWarpOutputRes(arg1);
53773 3 : SWIG_PYTHON_THREAD_END_ALLOW;
53774 : }
53775 3 : if ( bLocalUseExceptions ) {
53776 3 : popErrorHandler();
53777 : }
53778 : #ifndef SED_HACKS
53779 : if ( bLocalUseExceptions ) {
53780 : CPLErr eclass = CPLGetLastErrorType();
53781 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
53782 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
53783 : }
53784 : }
53785 : #endif
53786 : }
53787 3 : resultobj = SWIG_Py_Void();
53788 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53789 : return resultobj;
53790 : fail:
53791 : return NULL;
53792 : }
53793 :
53794 :
53795 2 : SWIGINTERN PyObject *_wrap_SuggestedWarpOutputRes_GetGeotransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53796 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53797 2 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
53798 2 : double *arg2 ;
53799 2 : void *argp1 = 0 ;
53800 2 : int res1 = 0 ;
53801 2 : double argout2[6] ;
53802 2 : PyObject *swig_obj[1] ;
53803 :
53804 2 : {
53805 : /* %typemap(in,numinputs=0) (double argout2[ANY]) */
53806 2 : memset(argout2, 0, sizeof(argout2));
53807 2 : arg2 = argout2;
53808 : }
53809 2 : if (!args) SWIG_fail;
53810 2 : swig_obj[0] = args;
53811 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SuggestedWarpOutputRes, 0 | 0 );
53812 2 : if (!SWIG_IsOK(res1)) {
53813 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuggestedWarpOutputRes_GetGeotransform" "', argument " "1"" of type '" "SuggestedWarpOutputRes *""'");
53814 : }
53815 2 : arg1 = reinterpret_cast< SuggestedWarpOutputRes * >(argp1);
53816 2 : {
53817 2 : const int bLocalUseExceptions = GetUseExceptions();
53818 2 : if ( bLocalUseExceptions ) {
53819 2 : pushErrorHandler();
53820 : }
53821 2 : {
53822 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53823 2 : SuggestedWarpOutputRes_GetGeotransform(arg1,arg2);
53824 2 : SWIG_PYTHON_THREAD_END_ALLOW;
53825 : }
53826 2 : if ( bLocalUseExceptions ) {
53827 2 : popErrorHandler();
53828 : }
53829 : #ifndef SED_HACKS
53830 : if ( bLocalUseExceptions ) {
53831 : CPLErr eclass = CPLGetLastErrorType();
53832 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
53833 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
53834 : }
53835 : }
53836 : #endif
53837 : }
53838 2 : resultobj = SWIG_Py_Void();
53839 2 : {
53840 : /* %typemap(argout) (double argout[ANY]) */
53841 2 : PyObject *out = CreateTupleFromDoubleArray( arg2, 6 );
53842 : #if SWIG_VERSION >= 0x040300
53843 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
53844 : #else
53845 2 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
53846 : #endif
53847 : }
53848 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53849 : return resultobj;
53850 : fail:
53851 : return NULL;
53852 : }
53853 :
53854 :
53855 277 : SWIGINTERN PyObject *SuggestedWarpOutputRes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53856 277 : PyObject *obj;
53857 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
53858 277 : SWIG_TypeNewClientData(SWIGTYPE_p_SuggestedWarpOutputRes, SWIG_NewClientData(obj));
53859 277 : return SWIG_Py_Void();
53860 : }
53861 :
53862 1 : SWIGINTERN PyObject *_wrap_SuggestedWarpOutputFromTransformer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53863 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53864 1 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
53865 1 : GDALTransformerInfoShadow *arg2 = (GDALTransformerInfoShadow *) 0 ;
53866 1 : void *argp1 = 0 ;
53867 1 : int res1 = 0 ;
53868 1 : void *argp2 = 0 ;
53869 1 : int res2 = 0 ;
53870 1 : PyObject *swig_obj[2] ;
53871 1 : SuggestedWarpOutputRes *result = 0 ;
53872 :
53873 1 : if (!SWIG_Python_UnpackTuple(args, "SuggestedWarpOutputFromTransformer", 2, 2, swig_obj)) SWIG_fail;
53874 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
53875 1 : if (!SWIG_IsOK(res1)) {
53876 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuggestedWarpOutputFromTransformer" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
53877 : }
53878 1 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
53879 1 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALTransformerInfoShadow, 0 | 0 );
53880 1 : if (!SWIG_IsOK(res2)) {
53881 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SuggestedWarpOutputFromTransformer" "', argument " "2"" of type '" "GDALTransformerInfoShadow *""'");
53882 : }
53883 1 : arg2 = reinterpret_cast< GDALTransformerInfoShadow * >(argp2);
53884 1 : {
53885 1 : const int bLocalUseExceptions = GetUseExceptions();
53886 1 : if ( bLocalUseExceptions ) {
53887 1 : pushErrorHandler();
53888 : }
53889 1 : {
53890 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53891 1 : result = (SuggestedWarpOutputRes *)SuggestedWarpOutputFromTransformer(arg1,arg2);
53892 1 : SWIG_PYTHON_THREAD_END_ALLOW;
53893 : }
53894 1 : if ( bLocalUseExceptions ) {
53895 1 : popErrorHandler();
53896 : }
53897 : #ifndef SED_HACKS
53898 : if ( bLocalUseExceptions ) {
53899 : CPLErr eclass = CPLGetLastErrorType();
53900 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
53901 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
53902 : }
53903 : }
53904 : #endif
53905 : }
53906 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SuggestedWarpOutputRes, SWIG_POINTER_OWN | 0 );
53907 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53908 : return resultobj;
53909 : fail:
53910 : return NULL;
53911 : }
53912 :
53913 :
53914 3 : SWIGINTERN PyObject *_wrap_SuggestedWarpOutputFromOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53915 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53916 3 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
53917 3 : char **arg2 = (char **) 0 ;
53918 3 : void *argp1 = 0 ;
53919 3 : int res1 = 0 ;
53920 3 : PyObject *swig_obj[2] ;
53921 3 : SuggestedWarpOutputRes *result = 0 ;
53922 :
53923 3 : if (!SWIG_Python_UnpackTuple(args, "SuggestedWarpOutputFromOptions", 2, 2, swig_obj)) SWIG_fail;
53924 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
53925 3 : if (!SWIG_IsOK(res1)) {
53926 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuggestedWarpOutputFromOptions" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
53927 : }
53928 3 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
53929 3 : {
53930 : /* %typemap(in) char **dict */
53931 3 : arg2 = NULL;
53932 3 : if ( PySequence_Check( swig_obj[1] ) ) {
53933 2 : int bErr = FALSE;
53934 2 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
53935 2 : if ( bErr )
53936 : {
53937 0 : SWIG_fail;
53938 : }
53939 : }
53940 1 : else if ( PyMapping_Check( swig_obj[1] ) ) {
53941 1 : int bErr = FALSE;
53942 1 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
53943 1 : if ( bErr )
53944 : {
53945 0 : SWIG_fail;
53946 : }
53947 : }
53948 : else {
53949 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
53950 0 : SWIG_fail;
53951 : }
53952 : }
53953 3 : {
53954 3 : if (!arg1) {
53955 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
53956 : }
53957 : }
53958 2 : {
53959 2 : const int bLocalUseExceptions = GetUseExceptions();
53960 2 : if ( bLocalUseExceptions ) {
53961 2 : pushErrorHandler();
53962 : }
53963 2 : {
53964 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
53965 2 : result = (SuggestedWarpOutputRes *)SuggestedWarpOutputFromOptions(arg1,arg2);
53966 2 : SWIG_PYTHON_THREAD_END_ALLOW;
53967 : }
53968 2 : if ( bLocalUseExceptions ) {
53969 2 : popErrorHandler();
53970 : }
53971 : #ifndef SED_HACKS
53972 : if ( bLocalUseExceptions ) {
53973 : CPLErr eclass = CPLGetLastErrorType();
53974 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
53975 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
53976 : }
53977 : }
53978 : #endif
53979 : }
53980 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SuggestedWarpOutputRes, SWIG_POINTER_OWN | 0 );
53981 2 : {
53982 : /* %typemap(freearg) char **dict */
53983 2 : CSLDestroy( arg2 );
53984 : }
53985 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
53986 : return resultobj;
53987 1 : fail:
53988 1 : {
53989 : /* %typemap(freearg) char **dict */
53990 1 : CSLDestroy( arg2 );
53991 : }
53992 : return NULL;
53993 : }
53994 :
53995 :
53996 23 : SWIGINTERN PyObject *_wrap__ApplyVerticalShiftGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53997 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
53998 23 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
53999 23 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
54000 23 : bool arg3 = (bool) false ;
54001 23 : double arg4 = (double) 1.0 ;
54002 23 : double arg5 = (double) 1.0 ;
54003 23 : char **arg6 = (char **) NULL ;
54004 23 : void *argp1 = 0 ;
54005 23 : int res1 = 0 ;
54006 23 : void *argp2 = 0 ;
54007 23 : int res2 = 0 ;
54008 23 : bool val3 ;
54009 23 : int ecode3 = 0 ;
54010 23 : double val4 ;
54011 23 : int ecode4 = 0 ;
54012 23 : double val5 ;
54013 23 : int ecode5 = 0 ;
54014 23 : PyObject * obj0 = 0 ;
54015 23 : PyObject * obj1 = 0 ;
54016 23 : PyObject * obj2 = 0 ;
54017 23 : PyObject * obj3 = 0 ;
54018 23 : PyObject * obj4 = 0 ;
54019 23 : PyObject * obj5 = 0 ;
54020 23 : char * kwnames[] = {
54021 : (char *)"src_ds", (char *)"grid_ds", (char *)"inverse", (char *)"srcUnitToMeter", (char *)"dstUnitToMeter", (char *)"options", NULL
54022 : };
54023 23 : GDALDatasetShadow *result = 0 ;
54024 :
54025 23 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOOO:_ApplyVerticalShiftGrid", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
54026 23 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
54027 23 : if (!SWIG_IsOK(res1)) {
54028 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ApplyVerticalShiftGrid" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
54029 : }
54030 23 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
54031 23 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
54032 23 : if (!SWIG_IsOK(res2)) {
54033 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_ApplyVerticalShiftGrid" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
54034 : }
54035 23 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
54036 23 : if (obj2) {
54037 1 : ecode3 = SWIG_AsVal_bool(obj2, &val3);
54038 1 : if (!SWIG_IsOK(ecode3)) {
54039 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_ApplyVerticalShiftGrid" "', argument " "3"" of type '" "bool""'");
54040 : }
54041 : arg3 = static_cast< bool >(val3);
54042 : }
54043 23 : if (obj3) {
54044 1 : ecode4 = SWIG_AsVal_double(obj3, &val4);
54045 1 : if (!SWIG_IsOK(ecode4)) {
54046 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "_ApplyVerticalShiftGrid" "', argument " "4"" of type '" "double""'");
54047 : }
54048 1 : arg4 = static_cast< double >(val4);
54049 : }
54050 23 : if (obj4) {
54051 1 : ecode5 = SWIG_AsVal_double(obj4, &val5);
54052 1 : if (!SWIG_IsOK(ecode5)) {
54053 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "_ApplyVerticalShiftGrid" "', argument " "5"" of type '" "double""'");
54054 : }
54055 1 : arg5 = static_cast< double >(val5);
54056 : }
54057 23 : if (obj5) {
54058 11 : {
54059 : /* %typemap(in) char **dict */
54060 11 : arg6 = NULL;
54061 11 : if ( PySequence_Check( obj5 ) ) {
54062 11 : int bErr = FALSE;
54063 11 : arg6 = CSLFromPySequence(obj5, &bErr);
54064 11 : if ( bErr )
54065 : {
54066 0 : SWIG_fail;
54067 : }
54068 : }
54069 0 : else if ( PyMapping_Check( obj5 ) ) {
54070 0 : int bErr = FALSE;
54071 0 : arg6 = CSLFromPyMapping(obj5, &bErr);
54072 0 : if ( bErr )
54073 : {
54074 0 : SWIG_fail;
54075 : }
54076 : }
54077 : else {
54078 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
54079 0 : SWIG_fail;
54080 : }
54081 : }
54082 : }
54083 23 : {
54084 23 : if (!arg1) {
54085 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
54086 : }
54087 : }
54088 23 : {
54089 23 : if (!arg2) {
54090 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
54091 : }
54092 : }
54093 23 : {
54094 23 : const int bLocalUseExceptions = GetUseExceptions();
54095 23 : if ( bLocalUseExceptions ) {
54096 12 : pushErrorHandler();
54097 : }
54098 23 : {
54099 23 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54100 23 : result = (GDALDatasetShadow *)ApplyVerticalShiftGrid(arg1,arg2,arg3,arg4,arg5,arg6);
54101 23 : SWIG_PYTHON_THREAD_END_ALLOW;
54102 : }
54103 23 : if ( bLocalUseExceptions ) {
54104 12 : popErrorHandler();
54105 : }
54106 : #ifndef SED_HACKS
54107 : if ( bLocalUseExceptions ) {
54108 : CPLErr eclass = CPLGetLastErrorType();
54109 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54110 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54111 : }
54112 : }
54113 : #endif
54114 : }
54115 23 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
54116 23 : {
54117 : /* %typemap(freearg) char **dict */
54118 23 : CSLDestroy( arg6 );
54119 : }
54120 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54121 : return resultobj;
54122 0 : fail:
54123 0 : {
54124 : /* %typemap(freearg) char **dict */
54125 0 : CSLDestroy( arg6 );
54126 : }
54127 : return NULL;
54128 : }
54129 :
54130 :
54131 2121 : SWIGINTERN PyObject *_wrap_GetGlobalAlgorithmRegistry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54132 2121 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54133 2121 : GDALAlgorithmRegistryHS *result = 0 ;
54134 :
54135 2121 : if (!SWIG_Python_UnpackTuple(args, "GetGlobalAlgorithmRegistry", 0, 0, 0)) SWIG_fail;
54136 2121 : {
54137 2121 : const int bLocalUseExceptions = GetUseExceptions();
54138 2121 : if ( bLocalUseExceptions ) {
54139 2120 : pushErrorHandler();
54140 : }
54141 2121 : {
54142 2121 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54143 2121 : result = (GDALAlgorithmRegistryHS *)GDALGetGlobalAlgorithmRegistry();
54144 2121 : SWIG_PYTHON_THREAD_END_ALLOW;
54145 : }
54146 2121 : if ( bLocalUseExceptions ) {
54147 2120 : popErrorHandler();
54148 : }
54149 : #ifndef SED_HACKS
54150 : if ( bLocalUseExceptions ) {
54151 : CPLErr eclass = CPLGetLastErrorType();
54152 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54153 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54154 : }
54155 : }
54156 : #endif
54157 : }
54158 2121 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALAlgorithmRegistryHS, SWIG_POINTER_OWN | 0 );
54159 2121 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54160 : return resultobj;
54161 0 : fail:
54162 0 : return NULL;
54163 : }
54164 :
54165 :
54166 0 : SWIGINTERN PyObject *_wrap_AlgorithmArgTypeIsList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54167 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54168 0 : GDALAlgorithmArgType arg1 ;
54169 0 : int val1 ;
54170 0 : int ecode1 = 0 ;
54171 0 : PyObject *swig_obj[1] ;
54172 0 : bool result;
54173 :
54174 0 : if (!args) SWIG_fail;
54175 0 : swig_obj[0] = args;
54176 0 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
54177 0 : if (!SWIG_IsOK(ecode1)) {
54178 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AlgorithmArgTypeIsList" "', argument " "1"" of type '" "GDALAlgorithmArgType""'");
54179 : }
54180 0 : arg1 = static_cast< GDALAlgorithmArgType >(val1);
54181 0 : {
54182 0 : const int bLocalUseExceptions = GetUseExceptions();
54183 0 : if ( bLocalUseExceptions ) {
54184 0 : pushErrorHandler();
54185 : }
54186 0 : {
54187 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54188 0 : result = (bool)GDALAlgorithmArgTypeIsList(arg1);
54189 0 : SWIG_PYTHON_THREAD_END_ALLOW;
54190 : }
54191 0 : if ( bLocalUseExceptions ) {
54192 0 : popErrorHandler();
54193 : }
54194 : #ifndef SED_HACKS
54195 : if ( bLocalUseExceptions ) {
54196 : CPLErr eclass = CPLGetLastErrorType();
54197 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54198 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54199 : }
54200 : }
54201 : #endif
54202 : }
54203 0 : resultobj = SWIG_From_bool(static_cast< bool >(result));
54204 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54205 : return resultobj;
54206 : fail:
54207 : return NULL;
54208 : }
54209 :
54210 :
54211 0 : SWIGINTERN PyObject *_wrap_AlgorithmArgTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54212 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54213 0 : GDALAlgorithmArgType arg1 ;
54214 0 : int val1 ;
54215 0 : int ecode1 = 0 ;
54216 0 : PyObject *swig_obj[1] ;
54217 0 : char *result = 0 ;
54218 :
54219 0 : if (!args) SWIG_fail;
54220 0 : swig_obj[0] = args;
54221 0 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
54222 0 : if (!SWIG_IsOK(ecode1)) {
54223 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AlgorithmArgTypeName" "', argument " "1"" of type '" "GDALAlgorithmArgType""'");
54224 : }
54225 0 : arg1 = static_cast< GDALAlgorithmArgType >(val1);
54226 0 : {
54227 0 : const int bLocalUseExceptions = GetUseExceptions();
54228 0 : if ( bLocalUseExceptions ) {
54229 0 : pushErrorHandler();
54230 : }
54231 0 : {
54232 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54233 0 : result = (char *)GDALAlgorithmArgTypeName(arg1);
54234 0 : SWIG_PYTHON_THREAD_END_ALLOW;
54235 : }
54236 0 : if ( bLocalUseExceptions ) {
54237 0 : popErrorHandler();
54238 : }
54239 : #ifndef SED_HACKS
54240 : if ( bLocalUseExceptions ) {
54241 : CPLErr eclass = CPLGetLastErrorType();
54242 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54243 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54244 : }
54245 : }
54246 : #endif
54247 : }
54248 0 : resultobj = SWIG_FromCharPtr((const char *)result);
54249 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54250 : return resultobj;
54251 : fail:
54252 : return NULL;
54253 : }
54254 :
54255 :
54256 14330 : SWIGINTERN PyObject *_wrap_delete_AlgorithmArg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54257 14330 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54258 14330 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54259 14330 : void *argp1 = 0 ;
54260 14330 : int res1 = 0 ;
54261 14330 : PyObject *swig_obj[1] ;
54262 :
54263 14330 : if (!args) SWIG_fail;
54264 14330 : swig_obj[0] = args;
54265 14330 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, SWIG_POINTER_DISOWN | 0 );
54266 14330 : if (!SWIG_IsOK(res1)) {
54267 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AlgorithmArg" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54268 : }
54269 14330 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54270 14330 : {
54271 14330 : const int bLocalUseExceptions = GetUseExceptions();
54272 14330 : if ( bLocalUseExceptions ) {
54273 14327 : pushErrorHandler();
54274 : }
54275 14330 : {
54276 14330 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54277 14330 : delete_GDALAlgorithmArgHS(arg1);
54278 14330 : SWIG_PYTHON_THREAD_END_ALLOW;
54279 : }
54280 14330 : if ( bLocalUseExceptions ) {
54281 14327 : popErrorHandler();
54282 : }
54283 : #ifndef SED_HACKS
54284 : if ( bLocalUseExceptions ) {
54285 : CPLErr eclass = CPLGetLastErrorType();
54286 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54287 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54288 : }
54289 : }
54290 : #endif
54291 : }
54292 14330 : resultobj = SWIG_Py_Void();
54293 14330 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54294 : return resultobj;
54295 : fail:
54296 : return NULL;
54297 : }
54298 :
54299 :
54300 480 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54301 480 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54302 480 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54303 480 : void *argp1 = 0 ;
54304 480 : int res1 = 0 ;
54305 480 : PyObject *swig_obj[1] ;
54306 480 : char *result = 0 ;
54307 :
54308 480 : if (!args) SWIG_fail;
54309 480 : swig_obj[0] = args;
54310 480 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54311 480 : if (!SWIG_IsOK(res1)) {
54312 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetName" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54313 : }
54314 480 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54315 480 : {
54316 480 : const int bLocalUseExceptions = GetUseExceptions();
54317 480 : if ( bLocalUseExceptions ) {
54318 480 : pushErrorHandler();
54319 : }
54320 480 : {
54321 480 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54322 480 : result = (char *)GDALAlgorithmArgHS_GetName(arg1);
54323 480 : SWIG_PYTHON_THREAD_END_ALLOW;
54324 : }
54325 480 : if ( bLocalUseExceptions ) {
54326 480 : popErrorHandler();
54327 : }
54328 : #ifndef SED_HACKS
54329 : if ( bLocalUseExceptions ) {
54330 : CPLErr eclass = CPLGetLastErrorType();
54331 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54332 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54333 : }
54334 : }
54335 : #endif
54336 : }
54337 480 : resultobj = SWIG_FromCharPtr((const char *)result);
54338 480 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54339 : return resultobj;
54340 : fail:
54341 : return NULL;
54342 : }
54343 :
54344 :
54345 8438 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54346 8438 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54347 8438 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54348 8438 : void *argp1 = 0 ;
54349 8438 : int res1 = 0 ;
54350 8438 : PyObject *swig_obj[1] ;
54351 8438 : GDALAlgorithmArgType result;
54352 :
54353 8438 : if (!args) SWIG_fail;
54354 8438 : swig_obj[0] = args;
54355 8438 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54356 8438 : if (!SWIG_IsOK(res1)) {
54357 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetType" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54358 : }
54359 8438 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54360 8438 : {
54361 8438 : const int bLocalUseExceptions = GetUseExceptions();
54362 8438 : if ( bLocalUseExceptions ) {
54363 8435 : pushErrorHandler();
54364 : }
54365 8438 : {
54366 8438 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54367 8438 : result = (GDALAlgorithmArgType)GDALAlgorithmArgHS_GetType(arg1);
54368 8438 : SWIG_PYTHON_THREAD_END_ALLOW;
54369 : }
54370 8438 : if ( bLocalUseExceptions ) {
54371 8435 : popErrorHandler();
54372 : }
54373 : #ifndef SED_HACKS
54374 : if ( bLocalUseExceptions ) {
54375 : CPLErr eclass = CPLGetLastErrorType();
54376 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54377 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54378 : }
54379 : }
54380 : #endif
54381 : }
54382 8438 : resultobj = SWIG_From_int(static_cast< int >(result));
54383 8438 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54384 : return resultobj;
54385 : fail:
54386 : return NULL;
54387 : }
54388 :
54389 :
54390 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54391 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54392 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54393 1 : void *argp1 = 0 ;
54394 1 : int res1 = 0 ;
54395 1 : PyObject *swig_obj[1] ;
54396 1 : char *result = 0 ;
54397 :
54398 1 : if (!args) SWIG_fail;
54399 1 : swig_obj[0] = args;
54400 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54401 1 : if (!SWIG_IsOK(res1)) {
54402 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetDescription" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54403 : }
54404 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54405 1 : {
54406 1 : const int bLocalUseExceptions = GetUseExceptions();
54407 1 : if ( bLocalUseExceptions ) {
54408 1 : pushErrorHandler();
54409 : }
54410 1 : {
54411 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54412 1 : result = (char *)GDALAlgorithmArgHS_GetDescription(arg1);
54413 1 : SWIG_PYTHON_THREAD_END_ALLOW;
54414 : }
54415 1 : if ( bLocalUseExceptions ) {
54416 1 : popErrorHandler();
54417 : }
54418 : #ifndef SED_HACKS
54419 : if ( bLocalUseExceptions ) {
54420 : CPLErr eclass = CPLGetLastErrorType();
54421 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54422 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54423 : }
54424 : }
54425 : #endif
54426 : }
54427 1 : resultobj = SWIG_FromCharPtr((const char *)result);
54428 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54429 : return resultobj;
54430 : fail:
54431 : return NULL;
54432 : }
54433 :
54434 :
54435 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54436 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54437 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54438 1 : void *argp1 = 0 ;
54439 1 : int res1 = 0 ;
54440 1 : PyObject *swig_obj[1] ;
54441 1 : char *result = 0 ;
54442 :
54443 1 : if (!args) SWIG_fail;
54444 1 : swig_obj[0] = args;
54445 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54446 1 : if (!SWIG_IsOK(res1)) {
54447 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetShortName" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54448 : }
54449 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54450 1 : {
54451 1 : const int bLocalUseExceptions = GetUseExceptions();
54452 1 : if ( bLocalUseExceptions ) {
54453 1 : pushErrorHandler();
54454 : }
54455 1 : {
54456 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54457 1 : result = (char *)GDALAlgorithmArgHS_GetShortName(arg1);
54458 1 : SWIG_PYTHON_THREAD_END_ALLOW;
54459 : }
54460 1 : if ( bLocalUseExceptions ) {
54461 1 : popErrorHandler();
54462 : }
54463 : #ifndef SED_HACKS
54464 : if ( bLocalUseExceptions ) {
54465 : CPLErr eclass = CPLGetLastErrorType();
54466 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54467 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54468 : }
54469 : }
54470 : #endif
54471 : }
54472 1 : resultobj = SWIG_FromCharPtr((const char *)result);
54473 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54474 : return resultobj;
54475 : fail:
54476 : return NULL;
54477 : }
54478 :
54479 :
54480 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetAliases(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54481 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54482 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54483 1 : void *argp1 = 0 ;
54484 1 : int res1 = 0 ;
54485 1 : PyObject *swig_obj[1] ;
54486 1 : char **result = 0 ;
54487 :
54488 1 : if (!args) SWIG_fail;
54489 1 : swig_obj[0] = args;
54490 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54491 1 : if (!SWIG_IsOK(res1)) {
54492 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetAliases" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54493 : }
54494 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54495 1 : {
54496 1 : const int bLocalUseExceptions = GetUseExceptions();
54497 1 : if ( bLocalUseExceptions ) {
54498 1 : pushErrorHandler();
54499 : }
54500 1 : {
54501 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54502 1 : result = (char **)GDALAlgorithmArgHS_GetAliases(arg1);
54503 1 : SWIG_PYTHON_THREAD_END_ALLOW;
54504 : }
54505 1 : if ( bLocalUseExceptions ) {
54506 1 : popErrorHandler();
54507 : }
54508 : #ifndef SED_HACKS
54509 : if ( bLocalUseExceptions ) {
54510 : CPLErr eclass = CPLGetLastErrorType();
54511 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54512 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54513 : }
54514 : }
54515 : #endif
54516 : }
54517 1 : {
54518 : /* %typemap(out) char **CSL -> ( string ) */
54519 1 : bool bErr = false;
54520 1 : resultobj = CSLToList(result, &bErr);
54521 1 : CSLDestroy(result);
54522 1 : if( bErr ) {
54523 0 : SWIG_fail;
54524 : }
54525 : }
54526 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54527 : return resultobj;
54528 : fail:
54529 : return NULL;
54530 : }
54531 :
54532 :
54533 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetMetaVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54534 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54535 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54536 1 : void *argp1 = 0 ;
54537 1 : int res1 = 0 ;
54538 1 : PyObject *swig_obj[1] ;
54539 1 : char *result = 0 ;
54540 :
54541 1 : if (!args) SWIG_fail;
54542 1 : swig_obj[0] = args;
54543 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54544 1 : if (!SWIG_IsOK(res1)) {
54545 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetMetaVar" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54546 : }
54547 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54548 1 : {
54549 1 : const int bLocalUseExceptions = GetUseExceptions();
54550 1 : if ( bLocalUseExceptions ) {
54551 1 : pushErrorHandler();
54552 : }
54553 1 : {
54554 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54555 1 : result = (char *)GDALAlgorithmArgHS_GetMetaVar(arg1);
54556 1 : SWIG_PYTHON_THREAD_END_ALLOW;
54557 : }
54558 1 : if ( bLocalUseExceptions ) {
54559 1 : popErrorHandler();
54560 : }
54561 : #ifndef SED_HACKS
54562 : if ( bLocalUseExceptions ) {
54563 : CPLErr eclass = CPLGetLastErrorType();
54564 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54565 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54566 : }
54567 : }
54568 : #endif
54569 : }
54570 1 : resultobj = SWIG_FromCharPtr((const char *)result);
54571 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54572 : return resultobj;
54573 : fail:
54574 : return NULL;
54575 : }
54576 :
54577 :
54578 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetCategory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54579 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54580 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54581 1 : void *argp1 = 0 ;
54582 1 : int res1 = 0 ;
54583 1 : PyObject *swig_obj[1] ;
54584 1 : char *result = 0 ;
54585 :
54586 1 : if (!args) SWIG_fail;
54587 1 : swig_obj[0] = args;
54588 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54589 1 : if (!SWIG_IsOK(res1)) {
54590 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetCategory" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54591 : }
54592 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54593 1 : {
54594 1 : const int bLocalUseExceptions = GetUseExceptions();
54595 1 : if ( bLocalUseExceptions ) {
54596 1 : pushErrorHandler();
54597 : }
54598 1 : {
54599 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54600 1 : result = (char *)GDALAlgorithmArgHS_GetCategory(arg1);
54601 1 : SWIG_PYTHON_THREAD_END_ALLOW;
54602 : }
54603 1 : if ( bLocalUseExceptions ) {
54604 1 : popErrorHandler();
54605 : }
54606 : #ifndef SED_HACKS
54607 : if ( bLocalUseExceptions ) {
54608 : CPLErr eclass = CPLGetLastErrorType();
54609 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54610 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54611 : }
54612 : }
54613 : #endif
54614 : }
54615 1 : resultobj = SWIG_FromCharPtr((const char *)result);
54616 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54617 : return resultobj;
54618 : fail:
54619 : return NULL;
54620 : }
54621 :
54622 :
54623 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_IsPositional(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54624 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54625 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54626 1 : void *argp1 = 0 ;
54627 1 : int res1 = 0 ;
54628 1 : PyObject *swig_obj[1] ;
54629 1 : bool result;
54630 :
54631 1 : if (!args) SWIG_fail;
54632 1 : swig_obj[0] = args;
54633 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54634 1 : if (!SWIG_IsOK(res1)) {
54635 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_IsPositional" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54636 : }
54637 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54638 1 : {
54639 1 : const int bLocalUseExceptions = GetUseExceptions();
54640 1 : if ( bLocalUseExceptions ) {
54641 1 : pushErrorHandler();
54642 : }
54643 1 : {
54644 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54645 1 : result = (bool)GDALAlgorithmArgHS_IsPositional(arg1);
54646 1 : SWIG_PYTHON_THREAD_END_ALLOW;
54647 : }
54648 1 : if ( bLocalUseExceptions ) {
54649 1 : popErrorHandler();
54650 : }
54651 : #ifndef SED_HACKS
54652 : if ( bLocalUseExceptions ) {
54653 : CPLErr eclass = CPLGetLastErrorType();
54654 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54655 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54656 : }
54657 : }
54658 : #endif
54659 : }
54660 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
54661 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54662 : return resultobj;
54663 : fail:
54664 : return NULL;
54665 : }
54666 :
54667 :
54668 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_IsRequired(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54669 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54670 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54671 1 : void *argp1 = 0 ;
54672 1 : int res1 = 0 ;
54673 1 : PyObject *swig_obj[1] ;
54674 1 : bool result;
54675 :
54676 1 : if (!args) SWIG_fail;
54677 1 : swig_obj[0] = args;
54678 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54679 1 : if (!SWIG_IsOK(res1)) {
54680 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_IsRequired" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54681 : }
54682 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54683 1 : {
54684 1 : const int bLocalUseExceptions = GetUseExceptions();
54685 1 : if ( bLocalUseExceptions ) {
54686 1 : pushErrorHandler();
54687 : }
54688 1 : {
54689 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54690 1 : result = (bool)GDALAlgorithmArgHS_IsRequired(arg1);
54691 1 : SWIG_PYTHON_THREAD_END_ALLOW;
54692 : }
54693 1 : if ( bLocalUseExceptions ) {
54694 1 : popErrorHandler();
54695 : }
54696 : #ifndef SED_HACKS
54697 : if ( bLocalUseExceptions ) {
54698 : CPLErr eclass = CPLGetLastErrorType();
54699 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54700 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54701 : }
54702 : }
54703 : #endif
54704 : }
54705 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
54706 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54707 : return resultobj;
54708 : fail:
54709 : return NULL;
54710 : }
54711 :
54712 :
54713 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetMinCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54714 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54715 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54716 1 : void *argp1 = 0 ;
54717 1 : int res1 = 0 ;
54718 1 : PyObject *swig_obj[1] ;
54719 1 : int result;
54720 :
54721 1 : if (!args) SWIG_fail;
54722 1 : swig_obj[0] = args;
54723 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54724 1 : if (!SWIG_IsOK(res1)) {
54725 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetMinCount" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54726 : }
54727 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54728 1 : {
54729 1 : const int bLocalUseExceptions = GetUseExceptions();
54730 1 : if ( bLocalUseExceptions ) {
54731 1 : pushErrorHandler();
54732 : }
54733 1 : {
54734 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54735 1 : result = (int)GDALAlgorithmArgHS_GetMinCount(arg1);
54736 1 : SWIG_PYTHON_THREAD_END_ALLOW;
54737 : }
54738 1 : if ( bLocalUseExceptions ) {
54739 1 : popErrorHandler();
54740 : }
54741 : #ifndef SED_HACKS
54742 : if ( bLocalUseExceptions ) {
54743 : CPLErr eclass = CPLGetLastErrorType();
54744 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54745 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54746 : }
54747 : }
54748 : #endif
54749 : }
54750 1 : resultobj = SWIG_From_int(static_cast< int >(result));
54751 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54752 : return resultobj;
54753 : fail:
54754 : return NULL;
54755 : }
54756 :
54757 :
54758 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetMaxCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54759 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54760 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54761 1 : void *argp1 = 0 ;
54762 1 : int res1 = 0 ;
54763 1 : PyObject *swig_obj[1] ;
54764 1 : int result;
54765 :
54766 1 : if (!args) SWIG_fail;
54767 1 : swig_obj[0] = args;
54768 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54769 1 : if (!SWIG_IsOK(res1)) {
54770 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetMaxCount" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54771 : }
54772 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54773 1 : {
54774 1 : const int bLocalUseExceptions = GetUseExceptions();
54775 1 : if ( bLocalUseExceptions ) {
54776 1 : pushErrorHandler();
54777 : }
54778 1 : {
54779 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54780 1 : result = (int)GDALAlgorithmArgHS_GetMaxCount(arg1);
54781 1 : SWIG_PYTHON_THREAD_END_ALLOW;
54782 : }
54783 1 : if ( bLocalUseExceptions ) {
54784 1 : popErrorHandler();
54785 : }
54786 : #ifndef SED_HACKS
54787 : if ( bLocalUseExceptions ) {
54788 : CPLErr eclass = CPLGetLastErrorType();
54789 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54790 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54791 : }
54792 : }
54793 : #endif
54794 : }
54795 1 : resultobj = SWIG_From_int(static_cast< int >(result));
54796 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54797 : return resultobj;
54798 : fail:
54799 : return NULL;
54800 : }
54801 :
54802 :
54803 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetPackedValuesAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54804 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54805 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54806 1 : void *argp1 = 0 ;
54807 1 : int res1 = 0 ;
54808 1 : PyObject *swig_obj[1] ;
54809 1 : bool result;
54810 :
54811 1 : if (!args) SWIG_fail;
54812 1 : swig_obj[0] = args;
54813 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54814 1 : if (!SWIG_IsOK(res1)) {
54815 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetPackedValuesAllowed" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54816 : }
54817 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54818 1 : {
54819 1 : const int bLocalUseExceptions = GetUseExceptions();
54820 1 : if ( bLocalUseExceptions ) {
54821 1 : pushErrorHandler();
54822 : }
54823 1 : {
54824 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54825 1 : result = (bool)GDALAlgorithmArgHS_GetPackedValuesAllowed(arg1);
54826 1 : SWIG_PYTHON_THREAD_END_ALLOW;
54827 : }
54828 1 : if ( bLocalUseExceptions ) {
54829 1 : popErrorHandler();
54830 : }
54831 : #ifndef SED_HACKS
54832 : if ( bLocalUseExceptions ) {
54833 : CPLErr eclass = CPLGetLastErrorType();
54834 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54835 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54836 : }
54837 : }
54838 : #endif
54839 : }
54840 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
54841 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54842 : return resultobj;
54843 : fail:
54844 : return NULL;
54845 : }
54846 :
54847 :
54848 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetRepeatedArgAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54849 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54850 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54851 1 : void *argp1 = 0 ;
54852 1 : int res1 = 0 ;
54853 1 : PyObject *swig_obj[1] ;
54854 1 : bool result;
54855 :
54856 1 : if (!args) SWIG_fail;
54857 1 : swig_obj[0] = args;
54858 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54859 1 : if (!SWIG_IsOK(res1)) {
54860 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetRepeatedArgAllowed" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54861 : }
54862 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54863 1 : {
54864 1 : const int bLocalUseExceptions = GetUseExceptions();
54865 1 : if ( bLocalUseExceptions ) {
54866 1 : pushErrorHandler();
54867 : }
54868 1 : {
54869 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54870 1 : result = (bool)GDALAlgorithmArgHS_GetRepeatedArgAllowed(arg1);
54871 1 : SWIG_PYTHON_THREAD_END_ALLOW;
54872 : }
54873 1 : if ( bLocalUseExceptions ) {
54874 1 : popErrorHandler();
54875 : }
54876 : #ifndef SED_HACKS
54877 : if ( bLocalUseExceptions ) {
54878 : CPLErr eclass = CPLGetLastErrorType();
54879 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54880 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54881 : }
54882 : }
54883 : #endif
54884 : }
54885 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
54886 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54887 : return resultobj;
54888 : fail:
54889 : return NULL;
54890 : }
54891 :
54892 :
54893 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetChoices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54894 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54895 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54896 1 : void *argp1 = 0 ;
54897 1 : int res1 = 0 ;
54898 1 : PyObject *swig_obj[1] ;
54899 1 : char **result = 0 ;
54900 :
54901 1 : if (!args) SWIG_fail;
54902 1 : swig_obj[0] = args;
54903 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54904 1 : if (!SWIG_IsOK(res1)) {
54905 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetChoices" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54906 : }
54907 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54908 1 : {
54909 1 : const int bLocalUseExceptions = GetUseExceptions();
54910 1 : if ( bLocalUseExceptions ) {
54911 1 : pushErrorHandler();
54912 : }
54913 1 : {
54914 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54915 1 : result = (char **)GDALAlgorithmArgHS_GetChoices(arg1);
54916 1 : SWIG_PYTHON_THREAD_END_ALLOW;
54917 : }
54918 1 : if ( bLocalUseExceptions ) {
54919 1 : popErrorHandler();
54920 : }
54921 : #ifndef SED_HACKS
54922 : if ( bLocalUseExceptions ) {
54923 : CPLErr eclass = CPLGetLastErrorType();
54924 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54925 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54926 : }
54927 : }
54928 : #endif
54929 : }
54930 1 : {
54931 : /* %typemap(out) char **CSL -> ( string ) */
54932 1 : bool bErr = false;
54933 1 : resultobj = CSLToList(result, &bErr);
54934 1 : CSLDestroy(result);
54935 1 : if( bErr ) {
54936 0 : SWIG_fail;
54937 : }
54938 : }
54939 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
54940 : return resultobj;
54941 : fail:
54942 : return NULL;
54943 : }
54944 :
54945 :
54946 28 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetMetadataItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54947 28 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
54948 28 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
54949 28 : char *arg2 = (char *) 0 ;
54950 28 : void *argp1 = 0 ;
54951 28 : int res1 = 0 ;
54952 28 : int res2 ;
54953 28 : char *buf2 = 0 ;
54954 28 : int alloc2 = 0 ;
54955 28 : PyObject *swig_obj[2] ;
54956 28 : char **result = 0 ;
54957 :
54958 28 : if (!SWIG_Python_UnpackTuple(args, "AlgorithmArg_GetMetadataItem", 2, 2, swig_obj)) SWIG_fail;
54959 28 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
54960 28 : if (!SWIG_IsOK(res1)) {
54961 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetMetadataItem" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
54962 : }
54963 28 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
54964 28 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
54965 28 : if (!SWIG_IsOK(res2)) {
54966 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlgorithmArg_GetMetadataItem" "', argument " "2"" of type '" "char const *""'");
54967 : }
54968 28 : arg2 = reinterpret_cast< char * >(buf2);
54969 28 : {
54970 28 : const int bLocalUseExceptions = GetUseExceptions();
54971 28 : if ( bLocalUseExceptions ) {
54972 28 : pushErrorHandler();
54973 : }
54974 28 : {
54975 28 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
54976 28 : result = (char **)GDALAlgorithmArgHS_GetMetadataItem(arg1,(char const *)arg2);
54977 28 : SWIG_PYTHON_THREAD_END_ALLOW;
54978 : }
54979 28 : if ( bLocalUseExceptions ) {
54980 28 : popErrorHandler();
54981 : }
54982 : #ifndef SED_HACKS
54983 : if ( bLocalUseExceptions ) {
54984 : CPLErr eclass = CPLGetLastErrorType();
54985 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
54986 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
54987 : }
54988 : }
54989 : #endif
54990 : }
54991 28 : {
54992 : /* %typemap(out) char **CSL -> ( string ) */
54993 28 : bool bErr = false;
54994 28 : resultobj = CSLToList(result, &bErr);
54995 28 : CSLDestroy(result);
54996 28 : if( bErr ) {
54997 0 : SWIG_fail;
54998 : }
54999 : }
55000 28 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
55001 28 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55002 : return resultobj;
55003 0 : fail:
55004 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
55005 : return NULL;
55006 : }
55007 :
55008 :
55009 321 : SWIGINTERN PyObject *_wrap_AlgorithmArg_IsExplicitlySet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55010 321 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55011 321 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55012 321 : void *argp1 = 0 ;
55013 321 : int res1 = 0 ;
55014 321 : PyObject *swig_obj[1] ;
55015 321 : bool result;
55016 :
55017 321 : if (!args) SWIG_fail;
55018 321 : swig_obj[0] = args;
55019 321 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55020 321 : if (!SWIG_IsOK(res1)) {
55021 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_IsExplicitlySet" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55022 : }
55023 321 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55024 321 : {
55025 321 : const int bLocalUseExceptions = GetUseExceptions();
55026 321 : if ( bLocalUseExceptions ) {
55027 321 : pushErrorHandler();
55028 : }
55029 321 : {
55030 321 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55031 321 : result = (bool)GDALAlgorithmArgHS_IsExplicitlySet(arg1);
55032 321 : SWIG_PYTHON_THREAD_END_ALLOW;
55033 : }
55034 321 : if ( bLocalUseExceptions ) {
55035 321 : popErrorHandler();
55036 : }
55037 : #ifndef SED_HACKS
55038 : if ( bLocalUseExceptions ) {
55039 : CPLErr eclass = CPLGetLastErrorType();
55040 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55041 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55042 : }
55043 : }
55044 : #endif
55045 : }
55046 321 : resultobj = SWIG_From_bool(static_cast< bool >(result));
55047 321 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55048 : return resultobj;
55049 : fail:
55050 : return NULL;
55051 : }
55052 :
55053 :
55054 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_HasDefaultValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55055 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55056 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55057 1 : void *argp1 = 0 ;
55058 1 : int res1 = 0 ;
55059 1 : PyObject *swig_obj[1] ;
55060 1 : bool result;
55061 :
55062 1 : if (!args) SWIG_fail;
55063 1 : swig_obj[0] = args;
55064 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55065 1 : if (!SWIG_IsOK(res1)) {
55066 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_HasDefaultValue" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55067 : }
55068 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55069 1 : {
55070 1 : const int bLocalUseExceptions = GetUseExceptions();
55071 1 : if ( bLocalUseExceptions ) {
55072 1 : pushErrorHandler();
55073 : }
55074 1 : {
55075 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55076 1 : result = (bool)GDALAlgorithmArgHS_HasDefaultValue(arg1);
55077 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55078 : }
55079 1 : if ( bLocalUseExceptions ) {
55080 1 : popErrorHandler();
55081 : }
55082 : #ifndef SED_HACKS
55083 : if ( bLocalUseExceptions ) {
55084 : CPLErr eclass = CPLGetLastErrorType();
55085 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55086 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55087 : }
55088 : }
55089 : #endif
55090 : }
55091 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
55092 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55093 : return resultobj;
55094 : fail:
55095 : return NULL;
55096 : }
55097 :
55098 :
55099 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetDefaultAsBoolean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55100 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55101 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55102 1 : void *argp1 = 0 ;
55103 1 : int res1 = 0 ;
55104 1 : PyObject *swig_obj[1] ;
55105 1 : bool result;
55106 :
55107 1 : if (!args) SWIG_fail;
55108 1 : swig_obj[0] = args;
55109 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55110 1 : if (!SWIG_IsOK(res1)) {
55111 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetDefaultAsBoolean" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55112 : }
55113 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55114 1 : {
55115 1 : const int bLocalUseExceptions = GetUseExceptions();
55116 1 : if ( bLocalUseExceptions ) {
55117 1 : pushErrorHandler();
55118 : }
55119 1 : {
55120 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55121 1 : result = (bool)GDALAlgorithmArgHS_GetDefaultAsBoolean(arg1);
55122 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55123 : }
55124 1 : if ( bLocalUseExceptions ) {
55125 1 : popErrorHandler();
55126 : }
55127 : #ifndef SED_HACKS
55128 : if ( bLocalUseExceptions ) {
55129 : CPLErr eclass = CPLGetLastErrorType();
55130 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55131 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55132 : }
55133 : }
55134 : #endif
55135 : }
55136 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
55137 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55138 : return resultobj;
55139 : fail:
55140 : return NULL;
55141 : }
55142 :
55143 :
55144 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetDefaultAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55145 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55146 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55147 1 : void *argp1 = 0 ;
55148 1 : int res1 = 0 ;
55149 1 : PyObject *swig_obj[1] ;
55150 1 : char *result = 0 ;
55151 :
55152 1 : if (!args) SWIG_fail;
55153 1 : swig_obj[0] = args;
55154 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55155 1 : if (!SWIG_IsOK(res1)) {
55156 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetDefaultAsString" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55157 : }
55158 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55159 1 : {
55160 1 : const int bLocalUseExceptions = GetUseExceptions();
55161 1 : if ( bLocalUseExceptions ) {
55162 1 : pushErrorHandler();
55163 : }
55164 1 : {
55165 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55166 1 : result = (char *)GDALAlgorithmArgHS_GetDefaultAsString(arg1);
55167 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55168 : }
55169 1 : if ( bLocalUseExceptions ) {
55170 1 : popErrorHandler();
55171 : }
55172 : #ifndef SED_HACKS
55173 : if ( bLocalUseExceptions ) {
55174 : CPLErr eclass = CPLGetLastErrorType();
55175 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55176 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55177 : }
55178 : }
55179 : #endif
55180 : }
55181 1 : resultobj = SWIG_FromCharPtr((const char *)result);
55182 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55183 : return resultobj;
55184 : fail:
55185 : return NULL;
55186 : }
55187 :
55188 :
55189 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetDefaultAsInteger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55190 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55191 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55192 1 : void *argp1 = 0 ;
55193 1 : int res1 = 0 ;
55194 1 : PyObject *swig_obj[1] ;
55195 1 : int result;
55196 :
55197 1 : if (!args) SWIG_fail;
55198 1 : swig_obj[0] = args;
55199 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55200 1 : if (!SWIG_IsOK(res1)) {
55201 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetDefaultAsInteger" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55202 : }
55203 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55204 1 : {
55205 1 : const int bLocalUseExceptions = GetUseExceptions();
55206 1 : if ( bLocalUseExceptions ) {
55207 1 : pushErrorHandler();
55208 : }
55209 1 : {
55210 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55211 1 : result = (int)GDALAlgorithmArgHS_GetDefaultAsInteger(arg1);
55212 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55213 : }
55214 1 : if ( bLocalUseExceptions ) {
55215 1 : popErrorHandler();
55216 : }
55217 : #ifndef SED_HACKS
55218 : if ( bLocalUseExceptions ) {
55219 : CPLErr eclass = CPLGetLastErrorType();
55220 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55221 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55222 : }
55223 : }
55224 : #endif
55225 : }
55226 1 : resultobj = SWIG_From_int(static_cast< int >(result));
55227 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55228 : return resultobj;
55229 : fail:
55230 : return NULL;
55231 : }
55232 :
55233 :
55234 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetDefaultAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55235 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55236 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55237 1 : void *argp1 = 0 ;
55238 1 : int res1 = 0 ;
55239 1 : PyObject *swig_obj[1] ;
55240 1 : double result;
55241 :
55242 1 : if (!args) SWIG_fail;
55243 1 : swig_obj[0] = args;
55244 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55245 1 : if (!SWIG_IsOK(res1)) {
55246 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetDefaultAsDouble" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55247 : }
55248 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55249 1 : {
55250 1 : const int bLocalUseExceptions = GetUseExceptions();
55251 1 : if ( bLocalUseExceptions ) {
55252 1 : pushErrorHandler();
55253 : }
55254 1 : {
55255 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55256 1 : result = (double)GDALAlgorithmArgHS_GetDefaultAsDouble(arg1);
55257 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55258 : }
55259 1 : if ( bLocalUseExceptions ) {
55260 1 : popErrorHandler();
55261 : }
55262 : #ifndef SED_HACKS
55263 : if ( bLocalUseExceptions ) {
55264 : CPLErr eclass = CPLGetLastErrorType();
55265 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55266 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55267 : }
55268 : }
55269 : #endif
55270 : }
55271 1 : resultobj = SWIG_From_double(static_cast< double >(result));
55272 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55273 : return resultobj;
55274 : fail:
55275 : return NULL;
55276 : }
55277 :
55278 :
55279 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetDefaultAsStringList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55280 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55281 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55282 1 : void *argp1 = 0 ;
55283 1 : int res1 = 0 ;
55284 1 : PyObject *swig_obj[1] ;
55285 1 : char **result = 0 ;
55286 :
55287 1 : if (!args) SWIG_fail;
55288 1 : swig_obj[0] = args;
55289 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55290 1 : if (!SWIG_IsOK(res1)) {
55291 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetDefaultAsStringList" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55292 : }
55293 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55294 1 : {
55295 1 : const int bLocalUseExceptions = GetUseExceptions();
55296 1 : if ( bLocalUseExceptions ) {
55297 1 : pushErrorHandler();
55298 : }
55299 1 : {
55300 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55301 1 : result = (char **)GDALAlgorithmArgHS_GetDefaultAsStringList(arg1);
55302 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55303 : }
55304 1 : if ( bLocalUseExceptions ) {
55305 1 : popErrorHandler();
55306 : }
55307 : #ifndef SED_HACKS
55308 : if ( bLocalUseExceptions ) {
55309 : CPLErr eclass = CPLGetLastErrorType();
55310 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55311 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55312 : }
55313 : }
55314 : #endif
55315 : }
55316 1 : {
55317 : /* %typemap(out) char **CSL -> ( string ) */
55318 1 : bool bErr = false;
55319 1 : resultobj = CSLToList(result, &bErr);
55320 1 : CSLDestroy(result);
55321 1 : if( bErr ) {
55322 0 : SWIG_fail;
55323 : }
55324 : }
55325 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55326 : return resultobj;
55327 : fail:
55328 : return NULL;
55329 : }
55330 :
55331 :
55332 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetDefaultAsIntegerList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55333 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55334 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55335 1 : int *arg2 = (int *) 0 ;
55336 1 : int **arg3 = (int **) 0 ;
55337 1 : void *argp1 = 0 ;
55338 1 : int res1 = 0 ;
55339 1 : int nLen2 = 0 ;
55340 1 : int *pList2 = NULL ;
55341 1 : PyObject *swig_obj[1] ;
55342 :
55343 1 : {
55344 : /* %typemap(in,numinputs=0) (int *nLen2, const int **pList2) (int nLen2, int *pList2) */
55345 1 : arg2 = &nLen2;
55346 1 : arg3 = &pList2;
55347 : }
55348 1 : if (!args) SWIG_fail;
55349 1 : swig_obj[0] = args;
55350 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55351 1 : if (!SWIG_IsOK(res1)) {
55352 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetDefaultAsIntegerList" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55353 : }
55354 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55355 1 : {
55356 1 : const int bLocalUseExceptions = GetUseExceptions();
55357 1 : if ( bLocalUseExceptions ) {
55358 1 : pushErrorHandler();
55359 : }
55360 1 : {
55361 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55362 1 : GDALAlgorithmArgHS_GetDefaultAsIntegerList(arg1,arg2,(int const **)arg3);
55363 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55364 : }
55365 1 : if ( bLocalUseExceptions ) {
55366 1 : popErrorHandler();
55367 : }
55368 : #ifndef SED_HACKS
55369 : if ( bLocalUseExceptions ) {
55370 : CPLErr eclass = CPLGetLastErrorType();
55371 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55372 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55373 : }
55374 : }
55375 : #endif
55376 : }
55377 1 : resultobj = SWIG_Py_Void();
55378 1 : {
55379 : /* %typemap(argout) (int *nLen, const int **pList ) */
55380 1 : Py_DECREF(resultobj);
55381 1 : PyObject *out = PyList_New( *arg2 );
55382 1 : if( !out ) {
55383 0 : SWIG_fail;
55384 : }
55385 1 : for( int i=0; i<*arg2; i++ ) {
55386 0 : PyObject *val = PyInt_FromLong( (*arg3)[i] );
55387 0 : PyList_SetItem( out, i, val );
55388 : }
55389 1 : resultobj = out;
55390 : }
55391 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55392 : return resultobj;
55393 : fail:
55394 : return NULL;
55395 : }
55396 :
55397 :
55398 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetDefaultAsDoubleList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55399 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55400 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55401 1 : int *arg2 = (int *) 0 ;
55402 1 : double **arg3 = (double **) 0 ;
55403 1 : void *argp1 = 0 ;
55404 1 : int res1 = 0 ;
55405 1 : int nLen2 = 0 ;
55406 1 : double *pList2 = NULL ;
55407 1 : PyObject *swig_obj[1] ;
55408 :
55409 1 : {
55410 : /* %typemap(in,numinputs=0) (int *nLen2, const double **pList2) (int nLen2, double *pList2) */
55411 1 : arg2 = &nLen2;
55412 1 : arg3 = &pList2;
55413 : }
55414 1 : if (!args) SWIG_fail;
55415 1 : swig_obj[0] = args;
55416 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55417 1 : if (!SWIG_IsOK(res1)) {
55418 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetDefaultAsDoubleList" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55419 : }
55420 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55421 1 : {
55422 1 : const int bLocalUseExceptions = GetUseExceptions();
55423 1 : if ( bLocalUseExceptions ) {
55424 1 : pushErrorHandler();
55425 : }
55426 1 : {
55427 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55428 1 : GDALAlgorithmArgHS_GetDefaultAsDoubleList(arg1,arg2,(double const **)arg3);
55429 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55430 : }
55431 1 : if ( bLocalUseExceptions ) {
55432 1 : popErrorHandler();
55433 : }
55434 : #ifndef SED_HACKS
55435 : if ( bLocalUseExceptions ) {
55436 : CPLErr eclass = CPLGetLastErrorType();
55437 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55438 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55439 : }
55440 : }
55441 : #endif
55442 : }
55443 1 : resultobj = SWIG_Py_Void();
55444 1 : {
55445 : /* %typemap(argout) (int *nLen, const double **pList ) */
55446 1 : Py_DECREF(resultobj);
55447 1 : PyObject *out = PyList_New( *arg2 );
55448 1 : if( !out ) {
55449 0 : SWIG_fail;
55450 : }
55451 1 : for( int i=0; i<*arg2; i++ ) {
55452 0 : PyObject *val = PyFloat_FromDouble( (*arg3)[i] );
55453 0 : PyList_SetItem( out, i, val );
55454 : }
55455 1 : resultobj = out;
55456 : }
55457 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55458 : return resultobj;
55459 : fail:
55460 : return NULL;
55461 : }
55462 :
55463 :
55464 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_IsHidden(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55465 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55466 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55467 1 : void *argp1 = 0 ;
55468 1 : int res1 = 0 ;
55469 1 : PyObject *swig_obj[1] ;
55470 1 : bool result;
55471 :
55472 1 : if (!args) SWIG_fail;
55473 1 : swig_obj[0] = args;
55474 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55475 1 : if (!SWIG_IsOK(res1)) {
55476 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_IsHidden" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55477 : }
55478 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55479 1 : {
55480 1 : const int bLocalUseExceptions = GetUseExceptions();
55481 1 : if ( bLocalUseExceptions ) {
55482 1 : pushErrorHandler();
55483 : }
55484 1 : {
55485 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55486 1 : result = (bool)GDALAlgorithmArgHS_IsHidden(arg1);
55487 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55488 : }
55489 1 : if ( bLocalUseExceptions ) {
55490 1 : popErrorHandler();
55491 : }
55492 : #ifndef SED_HACKS
55493 : if ( bLocalUseExceptions ) {
55494 : CPLErr eclass = CPLGetLastErrorType();
55495 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55496 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55497 : }
55498 : }
55499 : #endif
55500 : }
55501 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
55502 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55503 : return resultobj;
55504 : fail:
55505 : return NULL;
55506 : }
55507 :
55508 :
55509 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_IsHiddenForCLI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55510 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55511 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55512 1 : void *argp1 = 0 ;
55513 1 : int res1 = 0 ;
55514 1 : PyObject *swig_obj[1] ;
55515 1 : bool result;
55516 :
55517 1 : if (!args) SWIG_fail;
55518 1 : swig_obj[0] = args;
55519 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55520 1 : if (!SWIG_IsOK(res1)) {
55521 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_IsHiddenForCLI" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55522 : }
55523 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55524 1 : {
55525 1 : const int bLocalUseExceptions = GetUseExceptions();
55526 1 : if ( bLocalUseExceptions ) {
55527 1 : pushErrorHandler();
55528 : }
55529 1 : {
55530 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55531 1 : result = (bool)GDALAlgorithmArgHS_IsHiddenForCLI(arg1);
55532 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55533 : }
55534 1 : if ( bLocalUseExceptions ) {
55535 1 : popErrorHandler();
55536 : }
55537 : #ifndef SED_HACKS
55538 : if ( bLocalUseExceptions ) {
55539 : CPLErr eclass = CPLGetLastErrorType();
55540 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55541 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55542 : }
55543 : }
55544 : #endif
55545 : }
55546 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
55547 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55548 : return resultobj;
55549 : fail:
55550 : return NULL;
55551 : }
55552 :
55553 :
55554 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_IsHiddenForAPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55555 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55556 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55557 1 : void *argp1 = 0 ;
55558 1 : int res1 = 0 ;
55559 1 : PyObject *swig_obj[1] ;
55560 1 : bool result;
55561 :
55562 1 : if (!args) SWIG_fail;
55563 1 : swig_obj[0] = args;
55564 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55565 1 : if (!SWIG_IsOK(res1)) {
55566 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_IsHiddenForAPI" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55567 : }
55568 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55569 1 : {
55570 1 : const int bLocalUseExceptions = GetUseExceptions();
55571 1 : if ( bLocalUseExceptions ) {
55572 1 : pushErrorHandler();
55573 : }
55574 1 : {
55575 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55576 1 : result = (bool)GDALAlgorithmArgHS_IsHiddenForAPI(arg1);
55577 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55578 : }
55579 1 : if ( bLocalUseExceptions ) {
55580 1 : popErrorHandler();
55581 : }
55582 : #ifndef SED_HACKS
55583 : if ( bLocalUseExceptions ) {
55584 : CPLErr eclass = CPLGetLastErrorType();
55585 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55586 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55587 : }
55588 : }
55589 : #endif
55590 : }
55591 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
55592 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55593 : return resultobj;
55594 : fail:
55595 : return NULL;
55596 : }
55597 :
55598 :
55599 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_IsInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55600 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55601 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55602 1 : void *argp1 = 0 ;
55603 1 : int res1 = 0 ;
55604 1 : PyObject *swig_obj[1] ;
55605 1 : bool result;
55606 :
55607 1 : if (!args) SWIG_fail;
55608 1 : swig_obj[0] = args;
55609 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55610 1 : if (!SWIG_IsOK(res1)) {
55611 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_IsInput" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55612 : }
55613 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55614 1 : {
55615 1 : const int bLocalUseExceptions = GetUseExceptions();
55616 1 : if ( bLocalUseExceptions ) {
55617 1 : pushErrorHandler();
55618 : }
55619 1 : {
55620 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55621 1 : result = (bool)GDALAlgorithmArgHS_IsInput(arg1);
55622 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55623 : }
55624 1 : if ( bLocalUseExceptions ) {
55625 1 : popErrorHandler();
55626 : }
55627 : #ifndef SED_HACKS
55628 : if ( bLocalUseExceptions ) {
55629 : CPLErr eclass = CPLGetLastErrorType();
55630 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55631 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55632 : }
55633 : }
55634 : #endif
55635 : }
55636 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
55637 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55638 : return resultobj;
55639 : fail:
55640 : return NULL;
55641 : }
55642 :
55643 :
55644 6728 : SWIGINTERN PyObject *_wrap_AlgorithmArg_IsOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55645 6728 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55646 6728 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55647 6728 : void *argp1 = 0 ;
55648 6728 : int res1 = 0 ;
55649 6728 : PyObject *swig_obj[1] ;
55650 6728 : bool result;
55651 :
55652 6728 : if (!args) SWIG_fail;
55653 6728 : swig_obj[0] = args;
55654 6728 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55655 6728 : if (!SWIG_IsOK(res1)) {
55656 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_IsOutput" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55657 : }
55658 6728 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55659 6728 : {
55660 6728 : const int bLocalUseExceptions = GetUseExceptions();
55661 6728 : if ( bLocalUseExceptions ) {
55662 6728 : pushErrorHandler();
55663 : }
55664 6728 : {
55665 6728 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55666 6728 : result = (bool)GDALAlgorithmArgHS_IsOutput(arg1);
55667 6728 : SWIG_PYTHON_THREAD_END_ALLOW;
55668 : }
55669 6728 : if ( bLocalUseExceptions ) {
55670 6728 : popErrorHandler();
55671 : }
55672 : #ifndef SED_HACKS
55673 : if ( bLocalUseExceptions ) {
55674 : CPLErr eclass = CPLGetLastErrorType();
55675 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55676 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55677 : }
55678 : }
55679 : #endif
55680 : }
55681 6728 : resultobj = SWIG_From_bool(static_cast< bool >(result));
55682 6728 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55683 : return resultobj;
55684 : fail:
55685 : return NULL;
55686 : }
55687 :
55688 :
55689 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetDatasetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55690 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55691 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55692 1 : void *argp1 = 0 ;
55693 1 : int res1 = 0 ;
55694 1 : PyObject *swig_obj[1] ;
55695 1 : int result;
55696 :
55697 1 : if (!args) SWIG_fail;
55698 1 : swig_obj[0] = args;
55699 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55700 1 : if (!SWIG_IsOK(res1)) {
55701 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetDatasetType" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55702 : }
55703 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55704 1 : {
55705 1 : const int bLocalUseExceptions = GetUseExceptions();
55706 1 : if ( bLocalUseExceptions ) {
55707 1 : pushErrorHandler();
55708 : }
55709 1 : {
55710 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55711 1 : result = (int)GDALAlgorithmArgHS_GetDatasetType(arg1);
55712 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55713 : }
55714 1 : if ( bLocalUseExceptions ) {
55715 1 : popErrorHandler();
55716 : }
55717 : #ifndef SED_HACKS
55718 : if ( bLocalUseExceptions ) {
55719 : CPLErr eclass = CPLGetLastErrorType();
55720 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55721 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55722 : }
55723 : }
55724 : #endif
55725 : }
55726 1 : resultobj = SWIG_From_int(static_cast< int >(result));
55727 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55728 : return resultobj;
55729 : fail:
55730 : return NULL;
55731 : }
55732 :
55733 :
55734 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetDatasetInputFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55735 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55736 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55737 1 : void *argp1 = 0 ;
55738 1 : int res1 = 0 ;
55739 1 : PyObject *swig_obj[1] ;
55740 1 : int result;
55741 :
55742 1 : if (!args) SWIG_fail;
55743 1 : swig_obj[0] = args;
55744 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55745 1 : if (!SWIG_IsOK(res1)) {
55746 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetDatasetInputFlags" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55747 : }
55748 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55749 1 : {
55750 1 : const int bLocalUseExceptions = GetUseExceptions();
55751 1 : if ( bLocalUseExceptions ) {
55752 1 : pushErrorHandler();
55753 : }
55754 1 : {
55755 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55756 1 : result = (int)GDALAlgorithmArgHS_GetDatasetInputFlags(arg1);
55757 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55758 : }
55759 1 : if ( bLocalUseExceptions ) {
55760 1 : popErrorHandler();
55761 : }
55762 : #ifndef SED_HACKS
55763 : if ( bLocalUseExceptions ) {
55764 : CPLErr eclass = CPLGetLastErrorType();
55765 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55766 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55767 : }
55768 : }
55769 : #endif
55770 : }
55771 1 : resultobj = SWIG_From_int(static_cast< int >(result));
55772 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55773 : return resultobj;
55774 : fail:
55775 : return NULL;
55776 : }
55777 :
55778 :
55779 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetDatasetOutputFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55780 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55781 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55782 1 : void *argp1 = 0 ;
55783 1 : int res1 = 0 ;
55784 1 : PyObject *swig_obj[1] ;
55785 1 : int result;
55786 :
55787 1 : if (!args) SWIG_fail;
55788 1 : swig_obj[0] = args;
55789 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55790 1 : if (!SWIG_IsOK(res1)) {
55791 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetDatasetOutputFlags" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55792 : }
55793 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55794 1 : {
55795 1 : const int bLocalUseExceptions = GetUseExceptions();
55796 1 : if ( bLocalUseExceptions ) {
55797 1 : pushErrorHandler();
55798 : }
55799 1 : {
55800 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55801 1 : result = (int)GDALAlgorithmArgHS_GetDatasetOutputFlags(arg1);
55802 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55803 : }
55804 1 : if ( bLocalUseExceptions ) {
55805 1 : popErrorHandler();
55806 : }
55807 : #ifndef SED_HACKS
55808 : if ( bLocalUseExceptions ) {
55809 : CPLErr eclass = CPLGetLastErrorType();
55810 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55811 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55812 : }
55813 : }
55814 : #endif
55815 : }
55816 1 : resultobj = SWIG_From_int(static_cast< int >(result));
55817 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55818 : return resultobj;
55819 : fail:
55820 : return NULL;
55821 : }
55822 :
55823 :
55824 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetMutualExclusionGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55825 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55826 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55827 1 : void *argp1 = 0 ;
55828 1 : int res1 = 0 ;
55829 1 : PyObject *swig_obj[1] ;
55830 1 : char *result = 0 ;
55831 :
55832 1 : if (!args) SWIG_fail;
55833 1 : swig_obj[0] = args;
55834 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55835 1 : if (!SWIG_IsOK(res1)) {
55836 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetMutualExclusionGroup" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55837 : }
55838 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55839 1 : {
55840 1 : const int bLocalUseExceptions = GetUseExceptions();
55841 1 : if ( bLocalUseExceptions ) {
55842 1 : pushErrorHandler();
55843 : }
55844 1 : {
55845 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55846 1 : result = (char *)GDALAlgorithmArgHS_GetMutualExclusionGroup(arg1);
55847 1 : SWIG_PYTHON_THREAD_END_ALLOW;
55848 : }
55849 1 : if ( bLocalUseExceptions ) {
55850 1 : popErrorHandler();
55851 : }
55852 : #ifndef SED_HACKS
55853 : if ( bLocalUseExceptions ) {
55854 : CPLErr eclass = CPLGetLastErrorType();
55855 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55856 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55857 : }
55858 : }
55859 : #endif
55860 : }
55861 1 : resultobj = SWIG_FromCharPtr((const char *)result);
55862 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55863 : return resultobj;
55864 : fail:
55865 : return NULL;
55866 : }
55867 :
55868 :
55869 7 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetAsBoolean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55870 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55871 7 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55872 7 : void *argp1 = 0 ;
55873 7 : int res1 = 0 ;
55874 7 : PyObject *swig_obj[1] ;
55875 7 : bool result;
55876 :
55877 7 : if (!args) SWIG_fail;
55878 7 : swig_obj[0] = args;
55879 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55880 7 : if (!SWIG_IsOK(res1)) {
55881 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetAsBoolean" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55882 : }
55883 7 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55884 7 : {
55885 7 : const int bLocalUseExceptions = GetUseExceptions();
55886 7 : if ( bLocalUseExceptions ) {
55887 7 : pushErrorHandler();
55888 : }
55889 7 : {
55890 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55891 7 : result = (bool)GDALAlgorithmArgHS_GetAsBoolean(arg1);
55892 7 : SWIG_PYTHON_THREAD_END_ALLOW;
55893 : }
55894 7 : if ( bLocalUseExceptions ) {
55895 7 : popErrorHandler();
55896 : }
55897 : #ifndef SED_HACKS
55898 : if ( bLocalUseExceptions ) {
55899 : CPLErr eclass = CPLGetLastErrorType();
55900 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55901 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55902 : }
55903 : }
55904 : #endif
55905 : }
55906 7 : resultobj = SWIG_From_bool(static_cast< bool >(result));
55907 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55908 : return resultobj;
55909 : fail:
55910 : return NULL;
55911 : }
55912 :
55913 :
55914 292 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55915 292 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55916 292 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55917 292 : void *argp1 = 0 ;
55918 292 : int res1 = 0 ;
55919 292 : PyObject *swig_obj[1] ;
55920 292 : char *result = 0 ;
55921 :
55922 292 : if (!args) SWIG_fail;
55923 292 : swig_obj[0] = args;
55924 292 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55925 292 : if (!SWIG_IsOK(res1)) {
55926 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetAsString" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55927 : }
55928 292 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55929 292 : {
55930 292 : const int bLocalUseExceptions = GetUseExceptions();
55931 292 : if ( bLocalUseExceptions ) {
55932 292 : pushErrorHandler();
55933 : }
55934 292 : {
55935 292 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55936 292 : result = (char *)GDALAlgorithmArgHS_GetAsString(arg1);
55937 292 : SWIG_PYTHON_THREAD_END_ALLOW;
55938 : }
55939 292 : if ( bLocalUseExceptions ) {
55940 292 : popErrorHandler();
55941 : }
55942 : #ifndef SED_HACKS
55943 : if ( bLocalUseExceptions ) {
55944 : CPLErr eclass = CPLGetLastErrorType();
55945 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55946 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55947 : }
55948 : }
55949 : #endif
55950 : }
55951 292 : resultobj = SWIG_FromCharPtr((const char *)result);
55952 294 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55953 : return resultobj;
55954 : fail:
55955 : return NULL;
55956 : }
55957 :
55958 :
55959 7 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetAsInteger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55960 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
55961 7 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
55962 7 : void *argp1 = 0 ;
55963 7 : int res1 = 0 ;
55964 7 : PyObject *swig_obj[1] ;
55965 7 : int result;
55966 :
55967 7 : if (!args) SWIG_fail;
55968 7 : swig_obj[0] = args;
55969 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
55970 7 : if (!SWIG_IsOK(res1)) {
55971 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetAsInteger" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
55972 : }
55973 7 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
55974 7 : {
55975 7 : const int bLocalUseExceptions = GetUseExceptions();
55976 7 : if ( bLocalUseExceptions ) {
55977 7 : pushErrorHandler();
55978 : }
55979 7 : {
55980 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
55981 7 : result = (int)GDALAlgorithmArgHS_GetAsInteger(arg1);
55982 7 : SWIG_PYTHON_THREAD_END_ALLOW;
55983 : }
55984 7 : if ( bLocalUseExceptions ) {
55985 7 : popErrorHandler();
55986 : }
55987 : #ifndef SED_HACKS
55988 : if ( bLocalUseExceptions ) {
55989 : CPLErr eclass = CPLGetLastErrorType();
55990 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
55991 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
55992 : }
55993 : }
55994 : #endif
55995 : }
55996 7 : resultobj = SWIG_From_int(static_cast< int >(result));
55997 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
55998 : return resultobj;
55999 : fail:
56000 : return NULL;
56001 : }
56002 :
56003 :
56004 7 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56005 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56006 7 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56007 7 : void *argp1 = 0 ;
56008 7 : int res1 = 0 ;
56009 7 : PyObject *swig_obj[1] ;
56010 7 : double result;
56011 :
56012 7 : if (!args) SWIG_fail;
56013 7 : swig_obj[0] = args;
56014 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56015 7 : if (!SWIG_IsOK(res1)) {
56016 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetAsDouble" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56017 : }
56018 7 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56019 7 : {
56020 7 : const int bLocalUseExceptions = GetUseExceptions();
56021 7 : if ( bLocalUseExceptions ) {
56022 7 : pushErrorHandler();
56023 : }
56024 7 : {
56025 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56026 7 : result = (double)GDALAlgorithmArgHS_GetAsDouble(arg1);
56027 7 : SWIG_PYTHON_THREAD_END_ALLOW;
56028 : }
56029 7 : if ( bLocalUseExceptions ) {
56030 7 : popErrorHandler();
56031 : }
56032 : #ifndef SED_HACKS
56033 : if ( bLocalUseExceptions ) {
56034 : CPLErr eclass = CPLGetLastErrorType();
56035 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56036 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56037 : }
56038 : }
56039 : #endif
56040 : }
56041 7 : resultobj = SWIG_From_double(static_cast< double >(result));
56042 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56043 : return resultobj;
56044 : fail:
56045 : return NULL;
56046 : }
56047 :
56048 :
56049 2314 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetAsDatasetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56050 2314 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56051 2314 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56052 2314 : void *argp1 = 0 ;
56053 2314 : int res1 = 0 ;
56054 2314 : PyObject *swig_obj[1] ;
56055 2314 : GDALArgDatasetValueHS *result = 0 ;
56056 :
56057 2314 : if (!args) SWIG_fail;
56058 2314 : swig_obj[0] = args;
56059 2314 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56060 2314 : if (!SWIG_IsOK(res1)) {
56061 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetAsDatasetValue" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56062 : }
56063 2314 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56064 2314 : {
56065 2314 : const int bLocalUseExceptions = GetUseExceptions();
56066 2314 : if ( bLocalUseExceptions ) {
56067 2312 : pushErrorHandler();
56068 : }
56069 2314 : {
56070 2314 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56071 2314 : result = (GDALArgDatasetValueHS *)GDALAlgorithmArgHS_GetAsDatasetValue(arg1);
56072 2314 : SWIG_PYTHON_THREAD_END_ALLOW;
56073 : }
56074 2314 : if ( bLocalUseExceptions ) {
56075 2312 : popErrorHandler();
56076 : }
56077 : #ifndef SED_HACKS
56078 : if ( bLocalUseExceptions ) {
56079 : CPLErr eclass = CPLGetLastErrorType();
56080 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56081 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56082 : }
56083 : }
56084 : #endif
56085 : }
56086 2314 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALArgDatasetValueHS, SWIG_POINTER_OWN | 0 );
56087 2316 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56088 : return resultobj;
56089 : fail:
56090 : return NULL;
56091 : }
56092 :
56093 :
56094 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetAsStringList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56095 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56096 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56097 1 : void *argp1 = 0 ;
56098 1 : int res1 = 0 ;
56099 1 : PyObject *swig_obj[1] ;
56100 1 : char **result = 0 ;
56101 :
56102 1 : if (!args) SWIG_fail;
56103 1 : swig_obj[0] = args;
56104 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56105 1 : if (!SWIG_IsOK(res1)) {
56106 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetAsStringList" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56107 : }
56108 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56109 1 : {
56110 1 : const int bLocalUseExceptions = GetUseExceptions();
56111 1 : if ( bLocalUseExceptions ) {
56112 1 : pushErrorHandler();
56113 : }
56114 1 : {
56115 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56116 1 : result = (char **)GDALAlgorithmArgHS_GetAsStringList(arg1);
56117 1 : SWIG_PYTHON_THREAD_END_ALLOW;
56118 : }
56119 1 : if ( bLocalUseExceptions ) {
56120 1 : popErrorHandler();
56121 : }
56122 : #ifndef SED_HACKS
56123 : if ( bLocalUseExceptions ) {
56124 : CPLErr eclass = CPLGetLastErrorType();
56125 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56126 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56127 : }
56128 : }
56129 : #endif
56130 : }
56131 1 : {
56132 : /* %typemap(out) char **CSL -> ( string ) */
56133 1 : bool bErr = false;
56134 1 : resultobj = CSLToList(result, &bErr);
56135 1 : CSLDestroy(result);
56136 1 : if( bErr ) {
56137 0 : SWIG_fail;
56138 : }
56139 : }
56140 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56141 : return resultobj;
56142 : fail:
56143 : return NULL;
56144 : }
56145 :
56146 :
56147 7 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetAsIntegerList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56148 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56149 7 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56150 7 : int *arg2 = (int *) 0 ;
56151 7 : int **arg3 = (int **) 0 ;
56152 7 : void *argp1 = 0 ;
56153 7 : int res1 = 0 ;
56154 7 : int nLen2 = 0 ;
56155 7 : int *pList2 = NULL ;
56156 7 : PyObject *swig_obj[1] ;
56157 :
56158 7 : {
56159 : /* %typemap(in,numinputs=0) (int *nLen2, const int **pList2) (int nLen2, int *pList2) */
56160 7 : arg2 = &nLen2;
56161 7 : arg3 = &pList2;
56162 : }
56163 7 : if (!args) SWIG_fail;
56164 7 : swig_obj[0] = args;
56165 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56166 7 : if (!SWIG_IsOK(res1)) {
56167 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetAsIntegerList" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56168 : }
56169 7 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56170 7 : {
56171 7 : const int bLocalUseExceptions = GetUseExceptions();
56172 7 : if ( bLocalUseExceptions ) {
56173 7 : pushErrorHandler();
56174 : }
56175 7 : {
56176 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56177 7 : GDALAlgorithmArgHS_GetAsIntegerList(arg1,arg2,(int const **)arg3);
56178 7 : SWIG_PYTHON_THREAD_END_ALLOW;
56179 : }
56180 7 : if ( bLocalUseExceptions ) {
56181 7 : popErrorHandler();
56182 : }
56183 : #ifndef SED_HACKS
56184 : if ( bLocalUseExceptions ) {
56185 : CPLErr eclass = CPLGetLastErrorType();
56186 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56187 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56188 : }
56189 : }
56190 : #endif
56191 : }
56192 7 : resultobj = SWIG_Py_Void();
56193 7 : {
56194 : /* %typemap(argout) (int *nLen, const int **pList ) */
56195 7 : Py_DECREF(resultobj);
56196 7 : PyObject *out = PyList_New( *arg2 );
56197 7 : if( !out ) {
56198 0 : SWIG_fail;
56199 : }
56200 16 : for( int i=0; i<*arg2; i++ ) {
56201 9 : PyObject *val = PyInt_FromLong( (*arg3)[i] );
56202 9 : PyList_SetItem( out, i, val );
56203 : }
56204 7 : resultobj = out;
56205 : }
56206 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56207 : return resultobj;
56208 : fail:
56209 : return NULL;
56210 : }
56211 :
56212 :
56213 7 : SWIGINTERN PyObject *_wrap_AlgorithmArg_GetAsDoubleList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56214 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56215 7 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56216 7 : int *arg2 = (int *) 0 ;
56217 7 : double **arg3 = (double **) 0 ;
56218 7 : void *argp1 = 0 ;
56219 7 : int res1 = 0 ;
56220 7 : int nLen2 = 0 ;
56221 7 : double *pList2 = NULL ;
56222 7 : PyObject *swig_obj[1] ;
56223 :
56224 7 : {
56225 : /* %typemap(in,numinputs=0) (int *nLen2, const double **pList2) (int nLen2, double *pList2) */
56226 7 : arg2 = &nLen2;
56227 7 : arg3 = &pList2;
56228 : }
56229 7 : if (!args) SWIG_fail;
56230 7 : swig_obj[0] = args;
56231 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56232 7 : if (!SWIG_IsOK(res1)) {
56233 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_GetAsDoubleList" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56234 : }
56235 7 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56236 7 : {
56237 7 : const int bLocalUseExceptions = GetUseExceptions();
56238 7 : if ( bLocalUseExceptions ) {
56239 7 : pushErrorHandler();
56240 : }
56241 7 : {
56242 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56243 7 : GDALAlgorithmArgHS_GetAsDoubleList(arg1,arg2,(double const **)arg3);
56244 7 : SWIG_PYTHON_THREAD_END_ALLOW;
56245 : }
56246 7 : if ( bLocalUseExceptions ) {
56247 7 : popErrorHandler();
56248 : }
56249 : #ifndef SED_HACKS
56250 : if ( bLocalUseExceptions ) {
56251 : CPLErr eclass = CPLGetLastErrorType();
56252 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56253 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56254 : }
56255 : }
56256 : #endif
56257 : }
56258 7 : resultobj = SWIG_Py_Void();
56259 7 : {
56260 : /* %typemap(argout) (int *nLen, const double **pList ) */
56261 7 : Py_DECREF(resultobj);
56262 7 : PyObject *out = PyList_New( *arg2 );
56263 7 : if( !out ) {
56264 0 : SWIG_fail;
56265 : }
56266 16 : for( int i=0; i<*arg2; i++ ) {
56267 9 : PyObject *val = PyFloat_FromDouble( (*arg3)[i] );
56268 9 : PyList_SetItem( out, i, val );
56269 : }
56270 7 : resultobj = out;
56271 : }
56272 9 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56273 : return resultobj;
56274 : fail:
56275 : return NULL;
56276 : }
56277 :
56278 :
56279 516 : SWIGINTERN PyObject *_wrap_AlgorithmArg_SetAsBoolean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56280 516 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56281 516 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56282 516 : bool arg2 ;
56283 516 : void *argp1 = 0 ;
56284 516 : int res1 = 0 ;
56285 516 : bool val2 ;
56286 516 : int ecode2 = 0 ;
56287 516 : PyObject *swig_obj[2] ;
56288 516 : bool result;
56289 :
56290 516 : if (!SWIG_Python_UnpackTuple(args, "AlgorithmArg_SetAsBoolean", 2, 2, swig_obj)) SWIG_fail;
56291 516 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56292 516 : if (!SWIG_IsOK(res1)) {
56293 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_SetAsBoolean" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56294 : }
56295 516 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56296 516 : ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
56297 515 : if (!SWIG_IsOK(ecode2)) {
56298 1 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlgorithmArg_SetAsBoolean" "', argument " "2"" of type '" "bool""'");
56299 : }
56300 515 : arg2 = static_cast< bool >(val2);
56301 515 : {
56302 515 : const int bLocalUseExceptions = GetUseExceptions();
56303 515 : if ( bLocalUseExceptions ) {
56304 515 : pushErrorHandler();
56305 : }
56306 515 : {
56307 515 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56308 515 : result = (bool)GDALAlgorithmArgHS_SetAsBoolean(arg1,arg2);
56309 515 : SWIG_PYTHON_THREAD_END_ALLOW;
56310 : }
56311 515 : if ( bLocalUseExceptions ) {
56312 515 : popErrorHandler();
56313 : }
56314 : #ifndef SED_HACKS
56315 : if ( bLocalUseExceptions ) {
56316 : CPLErr eclass = CPLGetLastErrorType();
56317 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56318 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56319 : }
56320 : }
56321 : #endif
56322 : }
56323 515 : resultobj = SWIG_From_bool(static_cast< bool >(result));
56324 516 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56325 : return resultobj;
56326 : fail:
56327 : return NULL;
56328 : }
56329 :
56330 :
56331 2030 : SWIGINTERN PyObject *_wrap_AlgorithmArg_SetAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56332 2030 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56333 2030 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56334 2030 : char *arg2 = (char *) 0 ;
56335 2030 : void *argp1 = 0 ;
56336 2030 : int res1 = 0 ;
56337 2030 : int res2 ;
56338 2030 : char *buf2 = 0 ;
56339 2030 : int alloc2 = 0 ;
56340 2030 : PyObject *swig_obj[2] ;
56341 2030 : bool result;
56342 :
56343 2030 : if (!SWIG_Python_UnpackTuple(args, "AlgorithmArg_SetAsString", 2, 2, swig_obj)) SWIG_fail;
56344 2030 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56345 2030 : if (!SWIG_IsOK(res1)) {
56346 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_SetAsString" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56347 : }
56348 2030 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56349 2030 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
56350 2030 : if (!SWIG_IsOK(res2)) {
56351 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlgorithmArg_SetAsString" "', argument " "2"" of type '" "char const *""'");
56352 : }
56353 2030 : arg2 = reinterpret_cast< char * >(buf2);
56354 2030 : {
56355 2030 : const int bLocalUseExceptions = GetUseExceptions();
56356 2030 : if ( bLocalUseExceptions ) {
56357 2030 : pushErrorHandler();
56358 : }
56359 2030 : {
56360 2030 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56361 2030 : result = (bool)GDALAlgorithmArgHS_SetAsString(arg1,(char const *)arg2);
56362 2030 : SWIG_PYTHON_THREAD_END_ALLOW;
56363 : }
56364 2030 : if ( bLocalUseExceptions ) {
56365 2030 : popErrorHandler();
56366 : }
56367 : #ifndef SED_HACKS
56368 : if ( bLocalUseExceptions ) {
56369 : CPLErr eclass = CPLGetLastErrorType();
56370 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56371 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56372 : }
56373 : }
56374 : #endif
56375 : }
56376 2030 : resultobj = SWIG_From_bool(static_cast< bool >(result));
56377 2030 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
56378 2096 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56379 : return resultobj;
56380 0 : fail:
56381 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
56382 : return NULL;
56383 : }
56384 :
56385 :
56386 260 : SWIGINTERN PyObject *_wrap_AlgorithmArg_SetAsInteger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56387 260 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56388 260 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56389 260 : int arg2 ;
56390 260 : void *argp1 = 0 ;
56391 260 : int res1 = 0 ;
56392 260 : int val2 ;
56393 260 : int ecode2 = 0 ;
56394 260 : PyObject *swig_obj[2] ;
56395 260 : bool result;
56396 :
56397 260 : if (!SWIG_Python_UnpackTuple(args, "AlgorithmArg_SetAsInteger", 2, 2, swig_obj)) SWIG_fail;
56398 260 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56399 260 : if (!SWIG_IsOK(res1)) {
56400 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_SetAsInteger" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56401 : }
56402 260 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56403 260 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
56404 260 : if (!SWIG_IsOK(ecode2)) {
56405 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlgorithmArg_SetAsInteger" "', argument " "2"" of type '" "int""'");
56406 : }
56407 260 : arg2 = static_cast< int >(val2);
56408 260 : {
56409 260 : const int bLocalUseExceptions = GetUseExceptions();
56410 260 : if ( bLocalUseExceptions ) {
56411 260 : pushErrorHandler();
56412 : }
56413 260 : {
56414 260 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56415 260 : result = (bool)GDALAlgorithmArgHS_SetAsInteger(arg1,arg2);
56416 260 : SWIG_PYTHON_THREAD_END_ALLOW;
56417 : }
56418 260 : if ( bLocalUseExceptions ) {
56419 260 : popErrorHandler();
56420 : }
56421 : #ifndef SED_HACKS
56422 : if ( bLocalUseExceptions ) {
56423 : CPLErr eclass = CPLGetLastErrorType();
56424 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56425 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56426 : }
56427 : }
56428 : #endif
56429 : }
56430 260 : resultobj = SWIG_From_bool(static_cast< bool >(result));
56431 264 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56432 : return resultobj;
56433 : fail:
56434 : return NULL;
56435 : }
56436 :
56437 :
56438 215 : SWIGINTERN PyObject *_wrap_AlgorithmArg_SetAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56439 215 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56440 215 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56441 215 : double arg2 ;
56442 215 : void *argp1 = 0 ;
56443 215 : int res1 = 0 ;
56444 215 : double val2 ;
56445 215 : int ecode2 = 0 ;
56446 215 : PyObject *swig_obj[2] ;
56447 215 : bool result;
56448 :
56449 215 : if (!SWIG_Python_UnpackTuple(args, "AlgorithmArg_SetAsDouble", 2, 2, swig_obj)) SWIG_fail;
56450 215 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56451 215 : if (!SWIG_IsOK(res1)) {
56452 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_SetAsDouble" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56453 : }
56454 215 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56455 215 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
56456 215 : if (!SWIG_IsOK(ecode2)) {
56457 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlgorithmArg_SetAsDouble" "', argument " "2"" of type '" "double""'");
56458 : }
56459 215 : arg2 = static_cast< double >(val2);
56460 215 : {
56461 215 : const int bLocalUseExceptions = GetUseExceptions();
56462 215 : if ( bLocalUseExceptions ) {
56463 215 : pushErrorHandler();
56464 : }
56465 215 : {
56466 215 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56467 215 : result = (bool)GDALAlgorithmArgHS_SetAsDouble(arg1,arg2);
56468 215 : SWIG_PYTHON_THREAD_END_ALLOW;
56469 : }
56470 215 : if ( bLocalUseExceptions ) {
56471 215 : popErrorHandler();
56472 : }
56473 : #ifndef SED_HACKS
56474 : if ( bLocalUseExceptions ) {
56475 : CPLErr eclass = CPLGetLastErrorType();
56476 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56477 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56478 : }
56479 : }
56480 : #endif
56481 : }
56482 215 : resultobj = SWIG_From_bool(static_cast< bool >(result));
56483 235 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56484 : return resultobj;
56485 : fail:
56486 : return NULL;
56487 : }
56488 :
56489 :
56490 1 : SWIGINTERN PyObject *_wrap_AlgorithmArg_SetAsDatasetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56491 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56492 1 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56493 1 : GDALArgDatasetValueHS *arg2 = (GDALArgDatasetValueHS *) 0 ;
56494 1 : void *argp1 = 0 ;
56495 1 : int res1 = 0 ;
56496 1 : void *argp2 = 0 ;
56497 1 : int res2 = 0 ;
56498 1 : PyObject *swig_obj[2] ;
56499 1 : bool result;
56500 :
56501 1 : if (!SWIG_Python_UnpackTuple(args, "AlgorithmArg_SetAsDatasetValue", 2, 2, swig_obj)) SWIG_fail;
56502 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56503 1 : if (!SWIG_IsOK(res1)) {
56504 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_SetAsDatasetValue" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56505 : }
56506 1 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56507 1 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALArgDatasetValueHS, 0 | 0 );
56508 1 : if (!SWIG_IsOK(res2)) {
56509 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlgorithmArg_SetAsDatasetValue" "', argument " "2"" of type '" "GDALArgDatasetValueHS *""'");
56510 : }
56511 1 : arg2 = reinterpret_cast< GDALArgDatasetValueHS * >(argp2);
56512 1 : {
56513 1 : const int bLocalUseExceptions = GetUseExceptions();
56514 1 : if ( bLocalUseExceptions ) {
56515 1 : pushErrorHandler();
56516 : }
56517 1 : {
56518 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56519 1 : result = (bool)GDALAlgorithmArgHS_SetAsDatasetValue(arg1,arg2);
56520 1 : SWIG_PYTHON_THREAD_END_ALLOW;
56521 : }
56522 1 : if ( bLocalUseExceptions ) {
56523 1 : popErrorHandler();
56524 : }
56525 : #ifndef SED_HACKS
56526 : if ( bLocalUseExceptions ) {
56527 : CPLErr eclass = CPLGetLastErrorType();
56528 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56529 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56530 : }
56531 : }
56532 : #endif
56533 : }
56534 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
56535 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56536 : return resultobj;
56537 : fail:
56538 : return NULL;
56539 : }
56540 :
56541 :
56542 533 : SWIGINTERN PyObject *_wrap_AlgorithmArg_SetAsStringList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56543 533 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56544 533 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56545 533 : char **arg2 = (char **) 0 ;
56546 533 : void *argp1 = 0 ;
56547 533 : int res1 = 0 ;
56548 533 : PyObject *swig_obj[2] ;
56549 533 : bool result;
56550 :
56551 533 : if (!SWIG_Python_UnpackTuple(args, "AlgorithmArg_SetAsStringList", 2, 2, swig_obj)) SWIG_fail;
56552 533 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56553 533 : if (!SWIG_IsOK(res1)) {
56554 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_SetAsStringList" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56555 : }
56556 533 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56557 533 : {
56558 : /* %typemap(in) char **dict */
56559 533 : arg2 = NULL;
56560 533 : if ( PySequence_Check( swig_obj[1] ) ) {
56561 533 : int bErr = FALSE;
56562 533 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
56563 533 : if ( bErr )
56564 : {
56565 0 : SWIG_fail;
56566 : }
56567 : }
56568 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
56569 0 : int bErr = FALSE;
56570 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
56571 0 : if ( bErr )
56572 : {
56573 0 : SWIG_fail;
56574 : }
56575 : }
56576 : else {
56577 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
56578 0 : SWIG_fail;
56579 : }
56580 : }
56581 533 : {
56582 533 : const int bLocalUseExceptions = GetUseExceptions();
56583 533 : if ( bLocalUseExceptions ) {
56584 532 : pushErrorHandler();
56585 : }
56586 533 : {
56587 533 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56588 533 : result = (bool)GDALAlgorithmArgHS_SetAsStringList(arg1,arg2);
56589 533 : SWIG_PYTHON_THREAD_END_ALLOW;
56590 : }
56591 533 : if ( bLocalUseExceptions ) {
56592 532 : popErrorHandler();
56593 : }
56594 : #ifndef SED_HACKS
56595 : if ( bLocalUseExceptions ) {
56596 : CPLErr eclass = CPLGetLastErrorType();
56597 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56598 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56599 : }
56600 : }
56601 : #endif
56602 : }
56603 533 : resultobj = SWIG_From_bool(static_cast< bool >(result));
56604 533 : {
56605 : /* %typemap(freearg) char **dict */
56606 533 : CSLDestroy( arg2 );
56607 : }
56608 565 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56609 : return resultobj;
56610 0 : fail:
56611 0 : {
56612 : /* %typemap(freearg) char **dict */
56613 0 : CSLDestroy( arg2 );
56614 : }
56615 : return NULL;
56616 : }
56617 :
56618 :
56619 86 : SWIGINTERN PyObject *_wrap_AlgorithmArg_SetAsIntegerList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56620 86 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56621 86 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56622 86 : int arg2 ;
56623 86 : int *arg3 = (int *) 0 ;
56624 86 : void *argp1 = 0 ;
56625 86 : int res1 = 0 ;
56626 86 : PyObject *swig_obj[2] ;
56627 86 : bool result;
56628 :
56629 86 : if (!SWIG_Python_UnpackTuple(args, "AlgorithmArg_SetAsIntegerList", 2, 2, swig_obj)) SWIG_fail;
56630 86 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56631 86 : if (!SWIG_IsOK(res1)) {
56632 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_SetAsIntegerList" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56633 : }
56634 86 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56635 86 : {
56636 : /* %typemap(in,numinputs=1) (int nList, int* pList)*/
56637 86 : arg3 = CreateCIntListFromSequence(swig_obj[1], &arg2);
56638 86 : if( arg2 < 0 ) {
56639 2 : SWIG_fail;
56640 : }
56641 : }
56642 84 : {
56643 84 : const int bLocalUseExceptions = GetUseExceptions();
56644 84 : if ( bLocalUseExceptions ) {
56645 84 : pushErrorHandler();
56646 : }
56647 84 : {
56648 84 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56649 84 : result = (bool)GDALAlgorithmArgHS_SetAsIntegerList(arg1,arg2,arg3);
56650 84 : SWIG_PYTHON_THREAD_END_ALLOW;
56651 : }
56652 84 : if ( bLocalUseExceptions ) {
56653 84 : popErrorHandler();
56654 : }
56655 : #ifndef SED_HACKS
56656 : if ( bLocalUseExceptions ) {
56657 : CPLErr eclass = CPLGetLastErrorType();
56658 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56659 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56660 : }
56661 : }
56662 : #endif
56663 : }
56664 84 : resultobj = SWIG_From_bool(static_cast< bool >(result));
56665 84 : {
56666 : /* %typemap(freearg) (int nList, int* pList) */
56667 84 : free(arg3);
56668 : }
56669 92 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56670 : return resultobj;
56671 2 : fail:
56672 2 : {
56673 : /* %typemap(freearg) (int nList, int* pList) */
56674 2 : free(arg3);
56675 : }
56676 2 : return NULL;
56677 : }
56678 :
56679 :
56680 128 : SWIGINTERN PyObject *_wrap_AlgorithmArg_SetAsDoubleList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56681 128 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56682 128 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56683 128 : int arg2 ;
56684 128 : double *arg3 = (double *) 0 ;
56685 128 : void *argp1 = 0 ;
56686 128 : int res1 = 0 ;
56687 128 : PyObject *swig_obj[2] ;
56688 128 : bool result;
56689 :
56690 128 : if (!SWIG_Python_UnpackTuple(args, "AlgorithmArg_SetAsDoubleList", 2, 2, swig_obj)) SWIG_fail;
56691 128 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56692 128 : if (!SWIG_IsOK(res1)) {
56693 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_SetAsDoubleList" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56694 : }
56695 128 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56696 128 : {
56697 : /* %typemap(in,numinputs=1) (int nList, double* pList)*/
56698 128 : arg3 = CreateCDoubleListFromSequence(swig_obj[1], &arg2);
56699 128 : if( arg2 < 0 ) {
56700 2 : SWIG_fail;
56701 : }
56702 : }
56703 126 : {
56704 126 : const int bLocalUseExceptions = GetUseExceptions();
56705 126 : if ( bLocalUseExceptions ) {
56706 126 : pushErrorHandler();
56707 : }
56708 126 : {
56709 126 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56710 126 : result = (bool)GDALAlgorithmArgHS_SetAsDoubleList(arg1,arg2,arg3);
56711 126 : SWIG_PYTHON_THREAD_END_ALLOW;
56712 : }
56713 126 : if ( bLocalUseExceptions ) {
56714 126 : popErrorHandler();
56715 : }
56716 : #ifndef SED_HACKS
56717 : if ( bLocalUseExceptions ) {
56718 : CPLErr eclass = CPLGetLastErrorType();
56719 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56720 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56721 : }
56722 : }
56723 : #endif
56724 : }
56725 126 : resultobj = SWIG_From_bool(static_cast< bool >(result));
56726 126 : {
56727 : /* %typemap(freearg) (int nList, double* pList) */
56728 126 : free(arg3);
56729 : }
56730 132 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56731 : return resultobj;
56732 2 : fail:
56733 2 : {
56734 : /* %typemap(freearg) (int nList, double* pList) */
56735 2 : free(arg3);
56736 : }
56737 2 : return NULL;
56738 : }
56739 :
56740 :
56741 0 : SWIGINTERN PyObject *_wrap_AlgorithmArg_SetDataset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56742 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56743 0 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56744 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
56745 0 : void *argp1 = 0 ;
56746 0 : int res1 = 0 ;
56747 0 : void *argp2 = 0 ;
56748 0 : int res2 = 0 ;
56749 0 : PyObject *swig_obj[2] ;
56750 0 : bool result;
56751 :
56752 0 : if (!SWIG_Python_UnpackTuple(args, "AlgorithmArg_SetDataset", 2, 2, swig_obj)) SWIG_fail;
56753 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56754 0 : if (!SWIG_IsOK(res1)) {
56755 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_SetDataset" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56756 : }
56757 0 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56758 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
56759 0 : if (!SWIG_IsOK(res2)) {
56760 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlgorithmArg_SetDataset" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
56761 : }
56762 0 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
56763 0 : {
56764 0 : const int bLocalUseExceptions = GetUseExceptions();
56765 0 : if ( bLocalUseExceptions ) {
56766 0 : pushErrorHandler();
56767 : }
56768 0 : {
56769 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56770 0 : result = (bool)GDALAlgorithmArgHS_SetDataset(arg1,arg2);
56771 0 : SWIG_PYTHON_THREAD_END_ALLOW;
56772 : }
56773 0 : if ( bLocalUseExceptions ) {
56774 0 : popErrorHandler();
56775 : }
56776 : #ifndef SED_HACKS
56777 : if ( bLocalUseExceptions ) {
56778 : CPLErr eclass = CPLGetLastErrorType();
56779 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56780 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56781 : }
56782 : }
56783 : #endif
56784 : }
56785 0 : resultobj = SWIG_From_bool(static_cast< bool >(result));
56786 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56787 : return resultobj;
56788 : fail:
56789 : return NULL;
56790 : }
56791 :
56792 :
56793 929 : SWIGINTERN PyObject *_wrap_AlgorithmArg_SetDatasets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56794 929 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56795 929 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56796 929 : int arg2 ;
56797 929 : GDALDatasetShadow **arg3 = (GDALDatasetShadow **) 0 ;
56798 929 : void *argp1 = 0 ;
56799 929 : int res1 = 0 ;
56800 929 : PyObject *swig_obj[2] ;
56801 929 : bool result;
56802 :
56803 929 : if (!SWIG_Python_UnpackTuple(args, "AlgorithmArg_SetDatasets", 2, 2, swig_obj)) SWIG_fail;
56804 929 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56805 929 : if (!SWIG_IsOK(res1)) {
56806 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_SetDatasets" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56807 : }
56808 929 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56809 929 : {
56810 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALDatasetShadow *optional_##GDALDatasetShadow)*/
56811 929 : if ( !PySequence_Check(swig_obj[1]) ) {
56812 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
56813 0 : SWIG_fail;
56814 : }
56815 929 : Py_ssize_t size = PySequence_Size(swig_obj[1]);
56816 929 : if( size > (Py_ssize_t)INT_MAX ) {
56817 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
56818 0 : SWIG_fail;
56819 : }
56820 929 : if( (size_t)size > SIZE_MAX / sizeof(GDALDatasetShadow*) ) {
56821 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
56822 0 : SWIG_fail;
56823 : }
56824 929 : arg2 = (int)size;
56825 929 : arg3 = (GDALDatasetShadow**) VSIMalloc(arg2*sizeof(GDALDatasetShadow*));
56826 929 : if( !arg3) {
56827 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
56828 0 : SWIG_fail;
56829 : }
56830 :
56831 1883 : for( int i = 0; i<arg2; i++ ) {
56832 954 : PyObject *o = PySequence_GetItem(swig_obj[1],i);
56833 954 : GDALDatasetShadow* rawobjectpointer = NULL;
56834 954 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_EXCEPTION | 0 ));
56835 954 : if (!rawobjectpointer) {
56836 0 : Py_DECREF(o);
56837 0 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALDatasetShadow");
56838 0 : SWIG_fail;
56839 : }
56840 954 : arg3[i] = rawobjectpointer;
56841 954 : Py_DECREF(o);
56842 :
56843 : }
56844 : }
56845 929 : {
56846 929 : const int bLocalUseExceptions = GetUseExceptions();
56847 929 : if ( bLocalUseExceptions ) {
56848 929 : pushErrorHandler();
56849 : }
56850 929 : {
56851 929 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56852 929 : result = (bool)GDALAlgorithmArgHS_SetDatasets(arg1,arg2,arg3);
56853 929 : SWIG_PYTHON_THREAD_END_ALLOW;
56854 : }
56855 929 : if ( bLocalUseExceptions ) {
56856 929 : popErrorHandler();
56857 : }
56858 : #ifndef SED_HACKS
56859 : if ( bLocalUseExceptions ) {
56860 : CPLErr eclass = CPLGetLastErrorType();
56861 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56862 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56863 : }
56864 : }
56865 : #endif
56866 : }
56867 929 : resultobj = SWIG_From_bool(static_cast< bool >(result));
56868 929 : {
56869 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects)*/
56870 929 : CPLFree( arg3 );
56871 : }
56872 931 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56873 : return resultobj;
56874 0 : fail:
56875 0 : {
56876 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects)*/
56877 0 : CPLFree( arg3 );
56878 : }
56879 : return NULL;
56880 : }
56881 :
56882 :
56883 530 : SWIGINTERN PyObject *_wrap_AlgorithmArg_SetDatasetNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56884 530 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56885 530 : GDALAlgorithmArgHS *arg1 = (GDALAlgorithmArgHS *) 0 ;
56886 530 : char **arg2 = (char **) 0 ;
56887 530 : void *argp1 = 0 ;
56888 530 : int res1 = 0 ;
56889 530 : PyObject *swig_obj[2] ;
56890 530 : bool result;
56891 :
56892 530 : if (!SWIG_Python_UnpackTuple(args, "AlgorithmArg_SetDatasetNames", 2, 2, swig_obj)) SWIG_fail;
56893 530 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmArgHS, 0 | 0 );
56894 530 : if (!SWIG_IsOK(res1)) {
56895 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmArg_SetDatasetNames" "', argument " "1"" of type '" "GDALAlgorithmArgHS *""'");
56896 : }
56897 530 : arg1 = reinterpret_cast< GDALAlgorithmArgHS * >(argp1);
56898 530 : {
56899 : /* %typemap(in) char **dict */
56900 530 : arg2 = NULL;
56901 530 : if ( PySequence_Check( swig_obj[1] ) ) {
56902 530 : int bErr = FALSE;
56903 530 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
56904 530 : if ( bErr )
56905 : {
56906 0 : SWIG_fail;
56907 : }
56908 : }
56909 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
56910 0 : int bErr = FALSE;
56911 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
56912 0 : if ( bErr )
56913 : {
56914 0 : SWIG_fail;
56915 : }
56916 : }
56917 : else {
56918 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
56919 0 : SWIG_fail;
56920 : }
56921 : }
56922 530 : {
56923 530 : const int bLocalUseExceptions = GetUseExceptions();
56924 530 : if ( bLocalUseExceptions ) {
56925 530 : pushErrorHandler();
56926 : }
56927 530 : {
56928 530 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56929 530 : result = (bool)GDALAlgorithmArgHS_SetDatasetNames(arg1,arg2);
56930 530 : SWIG_PYTHON_THREAD_END_ALLOW;
56931 : }
56932 530 : if ( bLocalUseExceptions ) {
56933 530 : popErrorHandler();
56934 : }
56935 : #ifndef SED_HACKS
56936 : if ( bLocalUseExceptions ) {
56937 : CPLErr eclass = CPLGetLastErrorType();
56938 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56939 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56940 : }
56941 : }
56942 : #endif
56943 : }
56944 530 : resultobj = SWIG_From_bool(static_cast< bool >(result));
56945 530 : {
56946 : /* %typemap(freearg) char **dict */
56947 530 : CSLDestroy( arg2 );
56948 : }
56949 530 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
56950 : return resultobj;
56951 0 : fail:
56952 0 : {
56953 : /* %typemap(freearg) char **dict */
56954 0 : CSLDestroy( arg2 );
56955 : }
56956 : return NULL;
56957 : }
56958 :
56959 :
56960 277 : SWIGINTERN PyObject *AlgorithmArg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56961 277 : PyObject *obj;
56962 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
56963 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALAlgorithmArgHS, SWIG_NewClientData(obj));
56964 277 : return SWIG_Py_Void();
56965 : }
56966 :
56967 5113 : SWIGINTERN PyObject *_wrap_delete_Algorithm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56968 5113 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
56969 5113 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
56970 5113 : void *argp1 = 0 ;
56971 5113 : int res1 = 0 ;
56972 5113 : PyObject *swig_obj[1] ;
56973 :
56974 5113 : if (!args) SWIG_fail;
56975 5113 : swig_obj[0] = args;
56976 5113 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, SWIG_POINTER_DISOWN | 0 );
56977 5113 : if (!SWIG_IsOK(res1)) {
56978 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Algorithm" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
56979 : }
56980 5113 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
56981 5113 : {
56982 5113 : const int bLocalUseExceptions = GetUseExceptions();
56983 5113 : if ( bLocalUseExceptions ) {
56984 5111 : pushErrorHandler();
56985 : }
56986 5113 : {
56987 5113 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
56988 5113 : delete_GDALAlgorithmHS(arg1);
56989 5113 : SWIG_PYTHON_THREAD_END_ALLOW;
56990 : }
56991 5113 : if ( bLocalUseExceptions ) {
56992 5111 : popErrorHandler();
56993 : }
56994 : #ifndef SED_HACKS
56995 : if ( bLocalUseExceptions ) {
56996 : CPLErr eclass = CPLGetLastErrorType();
56997 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
56998 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
56999 : }
57000 : }
57001 : #endif
57002 : }
57003 5113 : resultobj = SWIG_Py_Void();
57004 5113 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57005 : return resultobj;
57006 : fail:
57007 : return NULL;
57008 : }
57009 :
57010 :
57011 32 : SWIGINTERN PyObject *_wrap_Algorithm_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57012 32 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57013 32 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57014 32 : void *argp1 = 0 ;
57015 32 : int res1 = 0 ;
57016 32 : PyObject *swig_obj[1] ;
57017 32 : char *result = 0 ;
57018 :
57019 32 : if (!args) SWIG_fail;
57020 32 : swig_obj[0] = args;
57021 32 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57022 32 : if (!SWIG_IsOK(res1)) {
57023 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_GetName" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57024 : }
57025 32 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57026 32 : {
57027 32 : const int bLocalUseExceptions = GetUseExceptions();
57028 32 : if ( bLocalUseExceptions ) {
57029 32 : pushErrorHandler();
57030 : }
57031 32 : {
57032 32 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57033 32 : result = (char *)GDALAlgorithmHS_GetName(arg1);
57034 32 : SWIG_PYTHON_THREAD_END_ALLOW;
57035 : }
57036 32 : if ( bLocalUseExceptions ) {
57037 32 : popErrorHandler();
57038 : }
57039 : #ifndef SED_HACKS
57040 : if ( bLocalUseExceptions ) {
57041 : CPLErr eclass = CPLGetLastErrorType();
57042 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57043 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57044 : }
57045 : }
57046 : #endif
57047 : }
57048 32 : resultobj = SWIG_FromCharPtr((const char *)result);
57049 32 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57050 : return resultobj;
57051 : fail:
57052 : return NULL;
57053 : }
57054 :
57055 :
57056 1 : SWIGINTERN PyObject *_wrap_Algorithm_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57057 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57058 1 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57059 1 : void *argp1 = 0 ;
57060 1 : int res1 = 0 ;
57061 1 : PyObject *swig_obj[1] ;
57062 1 : char *result = 0 ;
57063 :
57064 1 : if (!args) SWIG_fail;
57065 1 : swig_obj[0] = args;
57066 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57067 1 : if (!SWIG_IsOK(res1)) {
57068 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_GetDescription" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57069 : }
57070 1 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57071 1 : {
57072 1 : const int bLocalUseExceptions = GetUseExceptions();
57073 1 : if ( bLocalUseExceptions ) {
57074 1 : pushErrorHandler();
57075 : }
57076 1 : {
57077 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57078 1 : result = (char *)GDALAlgorithmHS_GetDescription(arg1);
57079 1 : SWIG_PYTHON_THREAD_END_ALLOW;
57080 : }
57081 1 : if ( bLocalUseExceptions ) {
57082 1 : popErrorHandler();
57083 : }
57084 : #ifndef SED_HACKS
57085 : if ( bLocalUseExceptions ) {
57086 : CPLErr eclass = CPLGetLastErrorType();
57087 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57088 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57089 : }
57090 : }
57091 : #endif
57092 : }
57093 1 : resultobj = SWIG_FromCharPtr((const char *)result);
57094 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57095 : return resultobj;
57096 : fail:
57097 : return NULL;
57098 : }
57099 :
57100 :
57101 1 : SWIGINTERN PyObject *_wrap_Algorithm_GetLongDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57102 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57103 1 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57104 1 : void *argp1 = 0 ;
57105 1 : int res1 = 0 ;
57106 1 : PyObject *swig_obj[1] ;
57107 1 : char *result = 0 ;
57108 :
57109 1 : if (!args) SWIG_fail;
57110 1 : swig_obj[0] = args;
57111 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57112 1 : if (!SWIG_IsOK(res1)) {
57113 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_GetLongDescription" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57114 : }
57115 1 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57116 1 : {
57117 1 : const int bLocalUseExceptions = GetUseExceptions();
57118 1 : if ( bLocalUseExceptions ) {
57119 1 : pushErrorHandler();
57120 : }
57121 1 : {
57122 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57123 1 : result = (char *)GDALAlgorithmHS_GetLongDescription(arg1);
57124 1 : SWIG_PYTHON_THREAD_END_ALLOW;
57125 : }
57126 1 : if ( bLocalUseExceptions ) {
57127 1 : popErrorHandler();
57128 : }
57129 : #ifndef SED_HACKS
57130 : if ( bLocalUseExceptions ) {
57131 : CPLErr eclass = CPLGetLastErrorType();
57132 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57133 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57134 : }
57135 : }
57136 : #endif
57137 : }
57138 1 : resultobj = SWIG_FromCharPtr((const char *)result);
57139 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57140 : return resultobj;
57141 : fail:
57142 : return NULL;
57143 : }
57144 :
57145 :
57146 1 : SWIGINTERN PyObject *_wrap_Algorithm_GetHelpFullURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57147 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57148 1 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57149 1 : void *argp1 = 0 ;
57150 1 : int res1 = 0 ;
57151 1 : PyObject *swig_obj[1] ;
57152 1 : char *result = 0 ;
57153 :
57154 1 : if (!args) SWIG_fail;
57155 1 : swig_obj[0] = args;
57156 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57157 1 : if (!SWIG_IsOK(res1)) {
57158 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_GetHelpFullURL" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57159 : }
57160 1 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57161 1 : {
57162 1 : const int bLocalUseExceptions = GetUseExceptions();
57163 1 : if ( bLocalUseExceptions ) {
57164 1 : pushErrorHandler();
57165 : }
57166 1 : {
57167 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57168 1 : result = (char *)GDALAlgorithmHS_GetHelpFullURL(arg1);
57169 1 : SWIG_PYTHON_THREAD_END_ALLOW;
57170 : }
57171 1 : if ( bLocalUseExceptions ) {
57172 1 : popErrorHandler();
57173 : }
57174 : #ifndef SED_HACKS
57175 : if ( bLocalUseExceptions ) {
57176 : CPLErr eclass = CPLGetLastErrorType();
57177 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57178 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57179 : }
57180 : }
57181 : #endif
57182 : }
57183 1 : resultobj = SWIG_FromCharPtr((const char *)result);
57184 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57185 : return resultobj;
57186 : fail:
57187 : return NULL;
57188 : }
57189 :
57190 :
57191 2642 : SWIGINTERN PyObject *_wrap_Algorithm_HasSubAlgorithms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57192 2642 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57193 2642 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57194 2642 : void *argp1 = 0 ;
57195 2642 : int res1 = 0 ;
57196 2642 : PyObject *swig_obj[1] ;
57197 2642 : bool result;
57198 :
57199 2642 : if (!args) SWIG_fail;
57200 2642 : swig_obj[0] = args;
57201 2642 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57202 2642 : if (!SWIG_IsOK(res1)) {
57203 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_HasSubAlgorithms" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57204 : }
57205 2642 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57206 2642 : {
57207 2642 : const int bLocalUseExceptions = GetUseExceptions();
57208 2642 : if ( bLocalUseExceptions ) {
57209 2641 : pushErrorHandler();
57210 : }
57211 2642 : {
57212 2642 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57213 2642 : result = (bool)GDALAlgorithmHS_HasSubAlgorithms(arg1);
57214 2642 : SWIG_PYTHON_THREAD_END_ALLOW;
57215 : }
57216 2642 : if ( bLocalUseExceptions ) {
57217 2641 : popErrorHandler();
57218 : }
57219 : #ifndef SED_HACKS
57220 : if ( bLocalUseExceptions ) {
57221 : CPLErr eclass = CPLGetLastErrorType();
57222 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57223 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57224 : }
57225 : }
57226 : #endif
57227 : }
57228 2642 : resultobj = SWIG_From_bool(static_cast< bool >(result));
57229 2642 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57230 : return resultobj;
57231 : fail:
57232 : return NULL;
57233 : }
57234 :
57235 :
57236 6 : SWIGINTERN PyObject *_wrap_Algorithm_GetSubAlgorithmNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57237 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57238 6 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57239 6 : void *argp1 = 0 ;
57240 6 : int res1 = 0 ;
57241 6 : PyObject *swig_obj[1] ;
57242 6 : char **result = 0 ;
57243 :
57244 6 : if (!args) SWIG_fail;
57245 6 : swig_obj[0] = args;
57246 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57247 6 : if (!SWIG_IsOK(res1)) {
57248 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_GetSubAlgorithmNames" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57249 : }
57250 6 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57251 6 : {
57252 6 : const int bLocalUseExceptions = GetUseExceptions();
57253 6 : if ( bLocalUseExceptions ) {
57254 6 : pushErrorHandler();
57255 : }
57256 6 : {
57257 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57258 6 : result = (char **)GDALAlgorithmHS_GetSubAlgorithmNames(arg1);
57259 6 : SWIG_PYTHON_THREAD_END_ALLOW;
57260 : }
57261 6 : if ( bLocalUseExceptions ) {
57262 6 : popErrorHandler();
57263 : }
57264 : #ifndef SED_HACKS
57265 : if ( bLocalUseExceptions ) {
57266 : CPLErr eclass = CPLGetLastErrorType();
57267 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57268 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57269 : }
57270 : }
57271 : #endif
57272 : }
57273 6 : {
57274 : /* %typemap(out) char **CSL -> ( string ) */
57275 6 : bool bErr = false;
57276 6 : resultobj = CSLToList(result, &bErr);
57277 6 : CSLDestroy(result);
57278 6 : if( bErr ) {
57279 0 : SWIG_fail;
57280 : }
57281 : }
57282 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57283 : return resultobj;
57284 : fail:
57285 : return NULL;
57286 : }
57287 :
57288 :
57289 2218 : SWIGINTERN PyObject *_wrap_Algorithm_InstantiateSubAlgorithm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57290 2218 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57291 2218 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57292 2218 : char *arg2 = (char *) 0 ;
57293 2218 : void *argp1 = 0 ;
57294 2218 : int res1 = 0 ;
57295 2218 : int res2 ;
57296 2218 : char *buf2 = 0 ;
57297 2218 : int alloc2 = 0 ;
57298 2218 : PyObject *swig_obj[2] ;
57299 2218 : GDALAlgorithmHS *result = 0 ;
57300 :
57301 2218 : if (!SWIG_Python_UnpackTuple(args, "Algorithm_InstantiateSubAlgorithm", 2, 2, swig_obj)) SWIG_fail;
57302 2218 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57303 2218 : if (!SWIG_IsOK(res1)) {
57304 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_InstantiateSubAlgorithm" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57305 : }
57306 2218 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57307 2218 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
57308 2218 : if (!SWIG_IsOK(res2)) {
57309 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Algorithm_InstantiateSubAlgorithm" "', argument " "2"" of type '" "char const *""'");
57310 : }
57311 2218 : arg2 = reinterpret_cast< char * >(buf2);
57312 2218 : {
57313 2218 : if (!arg2) {
57314 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
57315 : }
57316 : }
57317 2217 : {
57318 2217 : const int bLocalUseExceptions = GetUseExceptions();
57319 2217 : if ( bLocalUseExceptions ) {
57320 2216 : pushErrorHandler();
57321 : }
57322 2217 : {
57323 2217 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57324 2217 : result = (GDALAlgorithmHS *)GDALAlgorithmHS_InstantiateSubAlgorithm(arg1,(char const *)arg2);
57325 2217 : SWIG_PYTHON_THREAD_END_ALLOW;
57326 : }
57327 2217 : if ( bLocalUseExceptions ) {
57328 2216 : popErrorHandler();
57329 : }
57330 : #ifndef SED_HACKS
57331 : if ( bLocalUseExceptions ) {
57332 : CPLErr eclass = CPLGetLastErrorType();
57333 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57334 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57335 : }
57336 : }
57337 : #endif
57338 : }
57339 2217 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALAlgorithmHS, SWIG_POINTER_OWN | 0 );
57340 2217 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
57341 2218 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57342 : return resultobj;
57343 1 : fail:
57344 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
57345 : return NULL;
57346 : }
57347 :
57348 :
57349 85 : SWIGINTERN PyObject *_wrap_Algorithm_ParseCommandLineArguments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57350 85 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57351 85 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57352 85 : char **arg2 = (char **) 0 ;
57353 85 : void *argp1 = 0 ;
57354 85 : int res1 = 0 ;
57355 85 : PyObject *swig_obj[2] ;
57356 85 : bool result;
57357 :
57358 85 : if (!SWIG_Python_UnpackTuple(args, "Algorithm_ParseCommandLineArguments", 2, 2, swig_obj)) SWIG_fail;
57359 85 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57360 85 : if (!SWIG_IsOK(res1)) {
57361 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_ParseCommandLineArguments" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57362 : }
57363 85 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57364 85 : {
57365 : /* %typemap(in) char **dict */
57366 85 : arg2 = NULL;
57367 85 : if ( PySequence_Check( swig_obj[1] ) ) {
57368 85 : int bErr = FALSE;
57369 85 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
57370 85 : if ( bErr )
57371 : {
57372 0 : SWIG_fail;
57373 : }
57374 : }
57375 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
57376 0 : int bErr = FALSE;
57377 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
57378 0 : if ( bErr )
57379 : {
57380 0 : SWIG_fail;
57381 : }
57382 : }
57383 : else {
57384 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
57385 0 : SWIG_fail;
57386 : }
57387 : }
57388 85 : {
57389 85 : const int bLocalUseExceptions = GetUseExceptions();
57390 85 : if ( bLocalUseExceptions ) {
57391 85 : pushErrorHandler();
57392 : }
57393 85 : {
57394 85 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57395 85 : result = (bool)GDALAlgorithmHS_ParseCommandLineArguments(arg1,arg2);
57396 85 : SWIG_PYTHON_THREAD_END_ALLOW;
57397 : }
57398 85 : if ( bLocalUseExceptions ) {
57399 85 : popErrorHandler();
57400 : }
57401 : #ifndef SED_HACKS
57402 : if ( bLocalUseExceptions ) {
57403 : CPLErr eclass = CPLGetLastErrorType();
57404 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57405 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57406 : }
57407 : }
57408 : #endif
57409 : }
57410 85 : resultobj = SWIG_From_bool(static_cast< bool >(result));
57411 85 : {
57412 : /* %typemap(freearg) char **dict */
57413 85 : CSLDestroy( arg2 );
57414 : }
57415 97 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57416 : return resultobj;
57417 0 : fail:
57418 0 : {
57419 : /* %typemap(freearg) char **dict */
57420 0 : CSLDestroy( arg2 );
57421 : }
57422 : return NULL;
57423 : }
57424 :
57425 :
57426 791 : SWIGINTERN PyObject *_wrap_Algorithm_GetActualAlgorithm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57427 791 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57428 791 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57429 791 : void *argp1 = 0 ;
57430 791 : int res1 = 0 ;
57431 791 : PyObject *swig_obj[1] ;
57432 791 : GDALAlgorithmHS *result = 0 ;
57433 :
57434 791 : if (!args) SWIG_fail;
57435 791 : swig_obj[0] = args;
57436 791 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57437 791 : if (!SWIG_IsOK(res1)) {
57438 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_GetActualAlgorithm" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57439 : }
57440 791 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57441 791 : {
57442 791 : const int bLocalUseExceptions = GetUseExceptions();
57443 791 : if ( bLocalUseExceptions ) {
57444 791 : pushErrorHandler();
57445 : }
57446 791 : {
57447 791 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57448 791 : result = (GDALAlgorithmHS *)GDALAlgorithmHS_GetActualAlgorithm(arg1);
57449 791 : SWIG_PYTHON_THREAD_END_ALLOW;
57450 : }
57451 791 : if ( bLocalUseExceptions ) {
57452 791 : popErrorHandler();
57453 : }
57454 : #ifndef SED_HACKS
57455 : if ( bLocalUseExceptions ) {
57456 : CPLErr eclass = CPLGetLastErrorType();
57457 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57458 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57459 : }
57460 : }
57461 : #endif
57462 : }
57463 791 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALAlgorithmHS, SWIG_POINTER_OWN | 0 );
57464 791 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57465 : return resultobj;
57466 : fail:
57467 : return NULL;
57468 : }
57469 :
57470 :
57471 1802 : SWIGINTERN PyObject *_wrap_Algorithm_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57472 1802 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57473 1802 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57474 1802 : GDALProgressFunc arg2 = (GDALProgressFunc) NULL ;
57475 1802 : void *arg3 = (void *) NULL ;
57476 1802 : void *argp1 = 0 ;
57477 1802 : int res1 = 0 ;
57478 1802 : PyObject *swig_obj[3] ;
57479 1802 : bool result;
57480 :
57481 : /* %typemap(arginit) ( const char* callback_data=NULL) */
57482 1802 : PyProgressData *psProgressInfo;
57483 1802 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
57484 1802 : psProgressInfo->nLastReported = -1;
57485 1802 : psProgressInfo->psPyCallback = NULL;
57486 1802 : psProgressInfo->psPyCallbackData = NULL;
57487 1802 : arg3 = psProgressInfo;
57488 1802 : if (!SWIG_Python_UnpackTuple(args, "Algorithm_Run", 1, 3, swig_obj)) SWIG_fail;
57489 1802 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57490 1802 : if (!SWIG_IsOK(res1)) {
57491 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_Run" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57492 : }
57493 1802 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57494 1802 : if (swig_obj[1]) {
57495 616 : {
57496 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
57497 : /* callback_func typemap */
57498 :
57499 : /* In some cases 0 is passed instead of None. */
57500 : /* See https://github.com/OSGeo/gdal/pull/219 */
57501 616 : if ( PyLong_Check(swig_obj[1]) || PyInt_Check(swig_obj[1]) )
57502 : {
57503 0 : if( PyLong_AsLong(swig_obj[1]) == 0 )
57504 : {
57505 0 : swig_obj[1] = Py_None;
57506 : }
57507 : }
57508 :
57509 616 : if (swig_obj[1] && swig_obj[1] != Py_None ) {
57510 66 : void* cbfunction = NULL;
57511 66 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[1],
57512 : (void**)&cbfunction,
57513 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
57514 : SWIG_POINTER_EXCEPTION | 0 ));
57515 :
57516 66 : if ( cbfunction == GDALTermProgress ) {
57517 : arg2 = GDALTermProgress;
57518 : } else {
57519 66 : if (!PyCallable_Check(swig_obj[1])) {
57520 0 : PyErr_SetString( PyExc_RuntimeError,
57521 : "Object given is not a Python function" );
57522 0 : SWIG_fail;
57523 : }
57524 66 : psProgressInfo->psPyCallback = swig_obj[1];
57525 66 : arg2 = PyProgressProxy;
57526 : }
57527 :
57528 : }
57529 :
57530 : }
57531 : }
57532 1802 : if (swig_obj[2]) {
57533 0 : {
57534 : /* %typemap(in) ( void* callback_data=NULL) */
57535 0 : psProgressInfo->psPyCallbackData = swig_obj[2] ;
57536 : }
57537 : }
57538 1802 : {
57539 1802 : const int bLocalUseExceptions = GetUseExceptions();
57540 1802 : if ( bLocalUseExceptions ) {
57541 1799 : pushErrorHandler();
57542 : }
57543 1802 : {
57544 1802 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57545 1802 : result = (bool)GDALAlgorithmHS_Run(arg1,arg2,arg3);
57546 1802 : SWIG_PYTHON_THREAD_END_ALLOW;
57547 : }
57548 1802 : if ( bLocalUseExceptions ) {
57549 1799 : popErrorHandler();
57550 : }
57551 : #ifndef SED_HACKS
57552 : if ( bLocalUseExceptions ) {
57553 : CPLErr eclass = CPLGetLastErrorType();
57554 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57555 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57556 : }
57557 : }
57558 : #endif
57559 : }
57560 1802 : resultobj = SWIG_From_bool(static_cast< bool >(result));
57561 1802 : {
57562 : /* %typemap(freearg) ( void* callback_data=NULL) */
57563 :
57564 1802 : CPLFree(psProgressInfo);
57565 :
57566 : }
57567 2720 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57568 : return resultobj;
57569 0 : fail:
57570 0 : {
57571 : /* %typemap(freearg) ( void* callback_data=NULL) */
57572 :
57573 0 : CPLFree(psProgressInfo);
57574 :
57575 : }
57576 : return NULL;
57577 : }
57578 :
57579 :
57580 477 : SWIGINTERN PyObject *_wrap_Algorithm_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57581 477 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57582 477 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57583 477 : void *argp1 = 0 ;
57584 477 : int res1 = 0 ;
57585 477 : PyObject *swig_obj[1] ;
57586 477 : bool result;
57587 :
57588 477 : if (!args) SWIG_fail;
57589 477 : swig_obj[0] = args;
57590 477 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57591 477 : if (!SWIG_IsOK(res1)) {
57592 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_Finalize" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57593 : }
57594 477 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57595 477 : {
57596 477 : const int bLocalUseExceptions = GetUseExceptions();
57597 477 : if ( bLocalUseExceptions ) {
57598 477 : pushErrorHandler();
57599 : }
57600 477 : {
57601 477 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57602 477 : result = (bool)GDALAlgorithmHS_Finalize(arg1);
57603 477 : SWIG_PYTHON_THREAD_END_ALLOW;
57604 : }
57605 477 : if ( bLocalUseExceptions ) {
57606 477 : popErrorHandler();
57607 : }
57608 : #ifndef SED_HACKS
57609 : if ( bLocalUseExceptions ) {
57610 : CPLErr eclass = CPLGetLastErrorType();
57611 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57612 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57613 : }
57614 : }
57615 : #endif
57616 : }
57617 477 : resultobj = SWIG_From_bool(static_cast< bool >(result));
57618 477 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57619 : return resultobj;
57620 : fail:
57621 : return NULL;
57622 : }
57623 :
57624 :
57625 253 : SWIGINTERN PyObject *_wrap_Algorithm_ParseRunAndFinalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57626 253 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57627 253 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57628 253 : char **arg2 = (char **) 0 ;
57629 253 : GDALProgressFunc arg3 = (GDALProgressFunc) NULL ;
57630 253 : void *arg4 = (void *) NULL ;
57631 253 : void *argp1 = 0 ;
57632 253 : int res1 = 0 ;
57633 253 : PyObject *swig_obj[4] ;
57634 253 : bool result;
57635 :
57636 : /* %typemap(arginit) ( const char* callback_data=NULL) */
57637 253 : PyProgressData *psProgressInfo;
57638 253 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
57639 253 : psProgressInfo->nLastReported = -1;
57640 253 : psProgressInfo->psPyCallback = NULL;
57641 253 : psProgressInfo->psPyCallbackData = NULL;
57642 253 : arg4 = psProgressInfo;
57643 253 : if (!SWIG_Python_UnpackTuple(args, "Algorithm_ParseRunAndFinalize", 2, 4, swig_obj)) SWIG_fail;
57644 253 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57645 253 : if (!SWIG_IsOK(res1)) {
57646 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_ParseRunAndFinalize" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57647 : }
57648 253 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57649 253 : {
57650 : /* %typemap(in) char **dict */
57651 253 : arg2 = NULL;
57652 253 : if ( PySequence_Check( swig_obj[1] ) ) {
57653 253 : int bErr = FALSE;
57654 253 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
57655 253 : if ( bErr )
57656 : {
57657 0 : SWIG_fail;
57658 : }
57659 : }
57660 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
57661 0 : int bErr = FALSE;
57662 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
57663 0 : if ( bErr )
57664 : {
57665 0 : SWIG_fail;
57666 : }
57667 : }
57668 : else {
57669 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
57670 0 : SWIG_fail;
57671 : }
57672 : }
57673 253 : if (swig_obj[2]) {
57674 12 : {
57675 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
57676 : /* callback_func typemap */
57677 :
57678 : /* In some cases 0 is passed instead of None. */
57679 : /* See https://github.com/OSGeo/gdal/pull/219 */
57680 12 : if ( PyLong_Check(swig_obj[2]) || PyInt_Check(swig_obj[2]) )
57681 : {
57682 0 : if( PyLong_AsLong(swig_obj[2]) == 0 )
57683 : {
57684 0 : swig_obj[2] = Py_None;
57685 : }
57686 : }
57687 :
57688 12 : if (swig_obj[2] && swig_obj[2] != Py_None ) {
57689 12 : void* cbfunction = NULL;
57690 12 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[2],
57691 : (void**)&cbfunction,
57692 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
57693 : SWIG_POINTER_EXCEPTION | 0 ));
57694 :
57695 12 : if ( cbfunction == GDALTermProgress ) {
57696 : arg3 = GDALTermProgress;
57697 : } else {
57698 12 : if (!PyCallable_Check(swig_obj[2])) {
57699 0 : PyErr_SetString( PyExc_RuntimeError,
57700 : "Object given is not a Python function" );
57701 0 : SWIG_fail;
57702 : }
57703 12 : psProgressInfo->psPyCallback = swig_obj[2];
57704 12 : arg3 = PyProgressProxy;
57705 : }
57706 :
57707 : }
57708 :
57709 : }
57710 : }
57711 253 : if (swig_obj[3]) {
57712 0 : {
57713 : /* %typemap(in) ( void* callback_data=NULL) */
57714 0 : psProgressInfo->psPyCallbackData = swig_obj[3] ;
57715 : }
57716 : }
57717 253 : {
57718 253 : const int bLocalUseExceptions = GetUseExceptions();
57719 253 : if ( bLocalUseExceptions ) {
57720 253 : pushErrorHandler();
57721 : }
57722 253 : {
57723 253 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57724 253 : result = (bool)GDALAlgorithmHS_ParseRunAndFinalize(arg1,arg2,arg3,arg4);
57725 253 : SWIG_PYTHON_THREAD_END_ALLOW;
57726 : }
57727 253 : if ( bLocalUseExceptions ) {
57728 253 : popErrorHandler();
57729 : }
57730 : #ifndef SED_HACKS
57731 : if ( bLocalUseExceptions ) {
57732 : CPLErr eclass = CPLGetLastErrorType();
57733 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57734 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57735 : }
57736 : }
57737 : #endif
57738 : }
57739 253 : resultobj = SWIG_From_bool(static_cast< bool >(result));
57740 253 : {
57741 : /* %typemap(freearg) char **dict */
57742 253 : CSLDestroy( arg2 );
57743 : }
57744 253 : {
57745 : /* %typemap(freearg) ( void* callback_data=NULL) */
57746 :
57747 253 : CPLFree(psProgressInfo);
57748 :
57749 : }
57750 415 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57751 : return resultobj;
57752 0 : fail:
57753 0 : {
57754 : /* %typemap(freearg) char **dict */
57755 0 : CSLDestroy( arg2 );
57756 : }
57757 0 : {
57758 : /* %typemap(freearg) ( void* callback_data=NULL) */
57759 :
57760 0 : CPLFree(psProgressInfo);
57761 :
57762 : }
57763 : return NULL;
57764 : }
57765 :
57766 :
57767 3 : SWIGINTERN PyObject *_wrap_Algorithm_GetUsageAsJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57768 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57769 3 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57770 3 : void *argp1 = 0 ;
57771 3 : int res1 = 0 ;
57772 3 : PyObject *swig_obj[1] ;
57773 3 : retStringAndCPLFree *result = 0 ;
57774 :
57775 3 : if (!args) SWIG_fail;
57776 3 : swig_obj[0] = args;
57777 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57778 3 : if (!SWIG_IsOK(res1)) {
57779 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_GetUsageAsJSON" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57780 : }
57781 3 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57782 3 : {
57783 3 : const int bLocalUseExceptions = GetUseExceptions();
57784 3 : if ( bLocalUseExceptions ) {
57785 3 : pushErrorHandler();
57786 : }
57787 3 : {
57788 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57789 3 : result = (retStringAndCPLFree *)GDALAlgorithmHS_GetUsageAsJSON(arg1);
57790 3 : SWIG_PYTHON_THREAD_END_ALLOW;
57791 : }
57792 3 : if ( bLocalUseExceptions ) {
57793 3 : popErrorHandler();
57794 : }
57795 : #ifndef SED_HACKS
57796 : if ( bLocalUseExceptions ) {
57797 : CPLErr eclass = CPLGetLastErrorType();
57798 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57799 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57800 : }
57801 : }
57802 : #endif
57803 : }
57804 3 : {
57805 : /* %typemap(out) (retStringAndCPLFree*) */
57806 3 : Py_XDECREF(resultobj);
57807 3 : if(result)
57808 : {
57809 3 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
57810 3 : CPLFree(result);
57811 : }
57812 : else
57813 : {
57814 0 : resultobj = Py_None;
57815 0 : Py_INCREF(resultobj);
57816 : }
57817 : }
57818 3 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57819 : return resultobj;
57820 : fail:
57821 : return NULL;
57822 : }
57823 :
57824 :
57825 281 : SWIGINTERN PyObject *_wrap_Algorithm_GetArgNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57826 281 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57827 281 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57828 281 : void *argp1 = 0 ;
57829 281 : int res1 = 0 ;
57830 281 : PyObject *swig_obj[1] ;
57831 281 : char **result = 0 ;
57832 :
57833 281 : if (!args) SWIG_fail;
57834 281 : swig_obj[0] = args;
57835 281 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57836 281 : if (!SWIG_IsOK(res1)) {
57837 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_GetArgNames" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57838 : }
57839 281 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57840 281 : {
57841 281 : const int bLocalUseExceptions = GetUseExceptions();
57842 281 : if ( bLocalUseExceptions ) {
57843 281 : pushErrorHandler();
57844 : }
57845 281 : {
57846 281 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57847 281 : result = (char **)GDALAlgorithmHS_GetArgNames(arg1);
57848 281 : SWIG_PYTHON_THREAD_END_ALLOW;
57849 : }
57850 281 : if ( bLocalUseExceptions ) {
57851 281 : popErrorHandler();
57852 : }
57853 : #ifndef SED_HACKS
57854 : if ( bLocalUseExceptions ) {
57855 : CPLErr eclass = CPLGetLastErrorType();
57856 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57857 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57858 : }
57859 : }
57860 : #endif
57861 : }
57862 281 : {
57863 : /* %typemap(out) char **CSL -> ( string ) */
57864 281 : bool bErr = false;
57865 281 : resultobj = CSLToList(result, &bErr);
57866 281 : CSLDestroy(result);
57867 281 : if( bErr ) {
57868 0 : SWIG_fail;
57869 : }
57870 : }
57871 281 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57872 : return resultobj;
57873 : fail:
57874 : return NULL;
57875 : }
57876 :
57877 :
57878 7525 : SWIGINTERN PyObject *_wrap_Algorithm_GetArg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57879 7525 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57880 7525 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57881 7525 : char *arg2 = (char *) 0 ;
57882 7525 : void *argp1 = 0 ;
57883 7525 : int res1 = 0 ;
57884 7525 : int res2 ;
57885 7525 : char *buf2 = 0 ;
57886 7525 : int alloc2 = 0 ;
57887 7525 : PyObject *swig_obj[2] ;
57888 7525 : GDALAlgorithmArgHS *result = 0 ;
57889 :
57890 7525 : if (!SWIG_Python_UnpackTuple(args, "Algorithm_GetArg", 2, 2, swig_obj)) SWIG_fail;
57891 7525 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57892 7525 : if (!SWIG_IsOK(res1)) {
57893 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_GetArg" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57894 : }
57895 7525 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57896 7525 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
57897 7525 : if (!SWIG_IsOK(res2)) {
57898 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Algorithm_GetArg" "', argument " "2"" of type '" "char const *""'");
57899 : }
57900 7525 : arg2 = reinterpret_cast< char * >(buf2);
57901 7525 : {
57902 7525 : if (!arg2) {
57903 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
57904 : }
57905 : }
57906 7524 : {
57907 7524 : const int bLocalUseExceptions = GetUseExceptions();
57908 7524 : if ( bLocalUseExceptions ) {
57909 7524 : pushErrorHandler();
57910 : }
57911 7524 : {
57912 7524 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57913 7524 : result = (GDALAlgorithmArgHS *)GDALAlgorithmHS_GetArg(arg1,(char const *)arg2);
57914 7524 : SWIG_PYTHON_THREAD_END_ALLOW;
57915 : }
57916 7524 : if ( bLocalUseExceptions ) {
57917 7524 : popErrorHandler();
57918 : }
57919 : #ifndef SED_HACKS
57920 : if ( bLocalUseExceptions ) {
57921 : CPLErr eclass = CPLGetLastErrorType();
57922 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57923 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57924 : }
57925 : }
57926 : #endif
57927 : }
57928 7524 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALAlgorithmArgHS, SWIG_POINTER_OWN | 0 );
57929 7524 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
57930 7525 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57931 : return resultobj;
57932 1 : fail:
57933 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
57934 : return NULL;
57935 : }
57936 :
57937 :
57938 6809 : SWIGINTERN PyObject *_wrap_Algorithm_GetArgNonConst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57939 6809 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
57940 6809 : GDALAlgorithmHS *arg1 = (GDALAlgorithmHS *) 0 ;
57941 6809 : char *arg2 = (char *) 0 ;
57942 6809 : void *argp1 = 0 ;
57943 6809 : int res1 = 0 ;
57944 6809 : int res2 ;
57945 6809 : char *buf2 = 0 ;
57946 6809 : int alloc2 = 0 ;
57947 6809 : PyObject *swig_obj[2] ;
57948 6809 : GDALAlgorithmArgHS *result = 0 ;
57949 :
57950 6809 : if (!SWIG_Python_UnpackTuple(args, "Algorithm_GetArgNonConst", 2, 2, swig_obj)) SWIG_fail;
57951 6809 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmHS, 0 | 0 );
57952 6809 : if (!SWIG_IsOK(res1)) {
57953 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Algorithm_GetArgNonConst" "', argument " "1"" of type '" "GDALAlgorithmHS *""'");
57954 : }
57955 6809 : arg1 = reinterpret_cast< GDALAlgorithmHS * >(argp1);
57956 6809 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
57957 6809 : if (!SWIG_IsOK(res2)) {
57958 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Algorithm_GetArgNonConst" "', argument " "2"" of type '" "char const *""'");
57959 : }
57960 6809 : arg2 = reinterpret_cast< char * >(buf2);
57961 6809 : {
57962 6809 : if (!arg2) {
57963 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
57964 : }
57965 : }
57966 6809 : {
57967 6809 : const int bLocalUseExceptions = GetUseExceptions();
57968 6809 : if ( bLocalUseExceptions ) {
57969 6806 : pushErrorHandler();
57970 : }
57971 6809 : {
57972 6809 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
57973 6809 : result = (GDALAlgorithmArgHS *)GDALAlgorithmHS_GetArgNonConst(arg1,(char const *)arg2);
57974 6809 : SWIG_PYTHON_THREAD_END_ALLOW;
57975 : }
57976 6809 : if ( bLocalUseExceptions ) {
57977 6806 : popErrorHandler();
57978 : }
57979 : #ifndef SED_HACKS
57980 : if ( bLocalUseExceptions ) {
57981 : CPLErr eclass = CPLGetLastErrorType();
57982 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
57983 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
57984 : }
57985 : }
57986 : #endif
57987 : }
57988 6809 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALAlgorithmArgHS, SWIG_POINTER_OWN | 0 );
57989 6809 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
57990 6809 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
57991 : return resultobj;
57992 0 : fail:
57993 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
57994 : return NULL;
57995 : }
57996 :
57997 :
57998 277 : SWIGINTERN PyObject *Algorithm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57999 277 : PyObject *obj;
58000 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
58001 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALAlgorithmHS, SWIG_NewClientData(obj));
58002 277 : return SWIG_Py_Void();
58003 : }
58004 :
58005 2121 : SWIGINTERN PyObject *_wrap_delete_AlgorithmRegistry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58006 2121 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58007 2121 : GDALAlgorithmRegistryHS *arg1 = (GDALAlgorithmRegistryHS *) 0 ;
58008 2121 : void *argp1 = 0 ;
58009 2121 : int res1 = 0 ;
58010 2121 : PyObject *swig_obj[1] ;
58011 :
58012 2121 : if (!args) SWIG_fail;
58013 2121 : swig_obj[0] = args;
58014 2121 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmRegistryHS, SWIG_POINTER_DISOWN | 0 );
58015 2121 : if (!SWIG_IsOK(res1)) {
58016 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AlgorithmRegistry" "', argument " "1"" of type '" "GDALAlgorithmRegistryHS *""'");
58017 : }
58018 2121 : arg1 = reinterpret_cast< GDALAlgorithmRegistryHS * >(argp1);
58019 2121 : {
58020 2121 : const int bLocalUseExceptions = GetUseExceptions();
58021 2121 : if ( bLocalUseExceptions ) {
58022 2120 : pushErrorHandler();
58023 : }
58024 2121 : {
58025 2121 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58026 2121 : delete_GDALAlgorithmRegistryHS(arg1);
58027 2121 : SWIG_PYTHON_THREAD_END_ALLOW;
58028 : }
58029 2121 : if ( bLocalUseExceptions ) {
58030 2120 : popErrorHandler();
58031 : }
58032 : #ifndef SED_HACKS
58033 : if ( bLocalUseExceptions ) {
58034 : CPLErr eclass = CPLGetLastErrorType();
58035 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58036 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58037 : }
58038 : }
58039 : #endif
58040 : }
58041 2121 : resultobj = SWIG_Py_Void();
58042 2121 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58043 : return resultobj;
58044 : fail:
58045 : return NULL;
58046 : }
58047 :
58048 :
58049 1 : SWIGINTERN PyObject *_wrap_AlgorithmRegistry_GetAlgNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58050 1 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58051 1 : GDALAlgorithmRegistryHS *arg1 = (GDALAlgorithmRegistryHS *) 0 ;
58052 1 : void *argp1 = 0 ;
58053 1 : int res1 = 0 ;
58054 1 : PyObject *swig_obj[1] ;
58055 1 : char **result = 0 ;
58056 :
58057 1 : if (!args) SWIG_fail;
58058 1 : swig_obj[0] = args;
58059 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmRegistryHS, 0 | 0 );
58060 1 : if (!SWIG_IsOK(res1)) {
58061 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmRegistry_GetAlgNames" "', argument " "1"" of type '" "GDALAlgorithmRegistryHS *""'");
58062 : }
58063 1 : arg1 = reinterpret_cast< GDALAlgorithmRegistryHS * >(argp1);
58064 1 : {
58065 1 : const int bLocalUseExceptions = GetUseExceptions();
58066 1 : if ( bLocalUseExceptions ) {
58067 1 : pushErrorHandler();
58068 : }
58069 1 : {
58070 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58071 1 : result = (char **)GDALAlgorithmRegistryHS_GetAlgNames(arg1);
58072 1 : SWIG_PYTHON_THREAD_END_ALLOW;
58073 : }
58074 1 : if ( bLocalUseExceptions ) {
58075 1 : popErrorHandler();
58076 : }
58077 : #ifndef SED_HACKS
58078 : if ( bLocalUseExceptions ) {
58079 : CPLErr eclass = CPLGetLastErrorType();
58080 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58081 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58082 : }
58083 : }
58084 : #endif
58085 : }
58086 1 : {
58087 : /* %typemap(out) char **CSL -> ( string ) */
58088 1 : bool bErr = false;
58089 1 : resultobj = CSLToList(result, &bErr);
58090 1 : CSLDestroy(result);
58091 1 : if( bErr ) {
58092 0 : SWIG_fail;
58093 : }
58094 : }
58095 1 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58096 : return resultobj;
58097 : fail:
58098 : return NULL;
58099 : }
58100 :
58101 :
58102 2123 : SWIGINTERN PyObject *_wrap_AlgorithmRegistry_InstantiateAlg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58103 2123 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58104 2123 : GDALAlgorithmRegistryHS *arg1 = (GDALAlgorithmRegistryHS *) 0 ;
58105 2123 : char *arg2 = (char *) 0 ;
58106 2123 : void *argp1 = 0 ;
58107 2123 : int res1 = 0 ;
58108 2123 : int res2 ;
58109 2123 : char *buf2 = 0 ;
58110 2123 : int alloc2 = 0 ;
58111 2123 : PyObject *swig_obj[2] ;
58112 2123 : GDALAlgorithmHS *result = 0 ;
58113 :
58114 2123 : if (!SWIG_Python_UnpackTuple(args, "AlgorithmRegistry_InstantiateAlg", 2, 2, swig_obj)) SWIG_fail;
58115 2123 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALAlgorithmRegistryHS, 0 | 0 );
58116 2123 : if (!SWIG_IsOK(res1)) {
58117 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgorithmRegistry_InstantiateAlg" "', argument " "1"" of type '" "GDALAlgorithmRegistryHS *""'");
58118 : }
58119 2123 : arg1 = reinterpret_cast< GDALAlgorithmRegistryHS * >(argp1);
58120 2123 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
58121 2123 : if (!SWIG_IsOK(res2)) {
58122 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlgorithmRegistry_InstantiateAlg" "', argument " "2"" of type '" "char const *""'");
58123 : }
58124 2123 : arg2 = reinterpret_cast< char * >(buf2);
58125 2123 : {
58126 2123 : if (!arg2) {
58127 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
58128 : }
58129 : }
58130 2122 : {
58131 2122 : const int bLocalUseExceptions = GetUseExceptions();
58132 2122 : if ( bLocalUseExceptions ) {
58133 2121 : pushErrorHandler();
58134 : }
58135 2122 : {
58136 2122 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58137 2122 : result = (GDALAlgorithmHS *)GDALAlgorithmRegistryHS_InstantiateAlg(arg1,(char const *)arg2);
58138 2122 : SWIG_PYTHON_THREAD_END_ALLOW;
58139 : }
58140 2122 : if ( bLocalUseExceptions ) {
58141 2121 : popErrorHandler();
58142 : }
58143 : #ifndef SED_HACKS
58144 : if ( bLocalUseExceptions ) {
58145 : CPLErr eclass = CPLGetLastErrorType();
58146 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58147 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58148 : }
58149 : }
58150 : #endif
58151 : }
58152 2122 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALAlgorithmHS, SWIG_POINTER_OWN | 0 );
58153 2122 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
58154 2123 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58155 : return resultobj;
58156 1 : fail:
58157 1 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
58158 : return NULL;
58159 : }
58160 :
58161 :
58162 277 : SWIGINTERN PyObject *AlgorithmRegistry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58163 277 : PyObject *obj;
58164 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
58165 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALAlgorithmRegistryHS, SWIG_NewClientData(obj));
58166 277 : return SWIG_Py_Void();
58167 : }
58168 :
58169 2313 : SWIGINTERN PyObject *_wrap_delete_ArgDatasetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58170 2313 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58171 2313 : GDALArgDatasetValueHS *arg1 = (GDALArgDatasetValueHS *) 0 ;
58172 2313 : void *argp1 = 0 ;
58173 2313 : int res1 = 0 ;
58174 2313 : PyObject *swig_obj[1] ;
58175 :
58176 2313 : if (!args) SWIG_fail;
58177 2313 : swig_obj[0] = args;
58178 2313 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALArgDatasetValueHS, SWIG_POINTER_DISOWN | 0 );
58179 2313 : if (!SWIG_IsOK(res1)) {
58180 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArgDatasetValue" "', argument " "1"" of type '" "GDALArgDatasetValueHS *""'");
58181 : }
58182 2313 : arg1 = reinterpret_cast< GDALArgDatasetValueHS * >(argp1);
58183 2313 : {
58184 2313 : const int bLocalUseExceptions = GetUseExceptions();
58185 2313 : if ( bLocalUseExceptions ) {
58186 2311 : pushErrorHandler();
58187 : }
58188 2313 : {
58189 2313 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58190 2313 : delete_GDALArgDatasetValueHS(arg1);
58191 2313 : SWIG_PYTHON_THREAD_END_ALLOW;
58192 : }
58193 2313 : if ( bLocalUseExceptions ) {
58194 2311 : popErrorHandler();
58195 : }
58196 : #ifndef SED_HACKS
58197 : if ( bLocalUseExceptions ) {
58198 : CPLErr eclass = CPLGetLastErrorType();
58199 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58200 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58201 : }
58202 : }
58203 : #endif
58204 : }
58205 2313 : resultobj = SWIG_Py_Void();
58206 2313 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58207 : return resultobj;
58208 : fail:
58209 : return NULL;
58210 : }
58211 :
58212 :
58213 2 : SWIGINTERN PyObject *_wrap_ArgDatasetValue_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58214 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58215 2 : GDALArgDatasetValueHS *arg1 = (GDALArgDatasetValueHS *) 0 ;
58216 2 : void *argp1 = 0 ;
58217 2 : int res1 = 0 ;
58218 2 : PyObject *swig_obj[1] ;
58219 2 : char *result = 0 ;
58220 :
58221 2 : if (!args) SWIG_fail;
58222 2 : swig_obj[0] = args;
58223 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALArgDatasetValueHS, 0 | 0 );
58224 2 : if (!SWIG_IsOK(res1)) {
58225 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArgDatasetValue_GetName" "', argument " "1"" of type '" "GDALArgDatasetValueHS *""'");
58226 : }
58227 2 : arg1 = reinterpret_cast< GDALArgDatasetValueHS * >(argp1);
58228 2 : {
58229 2 : const int bLocalUseExceptions = GetUseExceptions();
58230 2 : if ( bLocalUseExceptions ) {
58231 2 : pushErrorHandler();
58232 : }
58233 2 : {
58234 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58235 2 : result = (char *)GDALArgDatasetValueHS_GetName(arg1);
58236 2 : SWIG_PYTHON_THREAD_END_ALLOW;
58237 : }
58238 2 : if ( bLocalUseExceptions ) {
58239 2 : popErrorHandler();
58240 : }
58241 : #ifndef SED_HACKS
58242 : if ( bLocalUseExceptions ) {
58243 : CPLErr eclass = CPLGetLastErrorType();
58244 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58245 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58246 : }
58247 : }
58248 : #endif
58249 : }
58250 2 : resultobj = SWIG_FromCharPtr((const char *)result);
58251 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58252 : return resultobj;
58253 : fail:
58254 : return NULL;
58255 : }
58256 :
58257 :
58258 745 : SWIGINTERN PyObject *_wrap_ArgDatasetValue_GetDataset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58259 745 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58260 745 : GDALArgDatasetValueHS *arg1 = (GDALArgDatasetValueHS *) 0 ;
58261 745 : void *argp1 = 0 ;
58262 745 : int res1 = 0 ;
58263 745 : PyObject *swig_obj[1] ;
58264 745 : GDALDatasetShadow *result = 0 ;
58265 :
58266 745 : if (!args) SWIG_fail;
58267 745 : swig_obj[0] = args;
58268 745 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALArgDatasetValueHS, 0 | 0 );
58269 745 : if (!SWIG_IsOK(res1)) {
58270 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArgDatasetValue_GetDataset" "', argument " "1"" of type '" "GDALArgDatasetValueHS *""'");
58271 : }
58272 745 : arg1 = reinterpret_cast< GDALArgDatasetValueHS * >(argp1);
58273 745 : {
58274 745 : const int bLocalUseExceptions = GetUseExceptions();
58275 745 : if ( bLocalUseExceptions ) {
58276 745 : pushErrorHandler();
58277 : }
58278 745 : {
58279 745 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58280 745 : result = (GDALDatasetShadow *)GDALArgDatasetValueHS_GetDataset(arg1);
58281 745 : SWIG_PYTHON_THREAD_END_ALLOW;
58282 : }
58283 745 : if ( bLocalUseExceptions ) {
58284 745 : popErrorHandler();
58285 : }
58286 : #ifndef SED_HACKS
58287 : if ( bLocalUseExceptions ) {
58288 : CPLErr eclass = CPLGetLastErrorType();
58289 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58290 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58291 : }
58292 : }
58293 : #endif
58294 : }
58295 745 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
58296 745 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58297 : return resultobj;
58298 : fail:
58299 : return NULL;
58300 : }
58301 :
58302 :
58303 1032 : SWIGINTERN PyObject *_wrap_ArgDatasetValue_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58304 1032 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58305 1032 : GDALArgDatasetValueHS *arg1 = (GDALArgDatasetValueHS *) 0 ;
58306 1032 : char *arg2 = (char *) 0 ;
58307 1032 : void *argp1 = 0 ;
58308 1032 : int res1 = 0 ;
58309 1032 : int res2 ;
58310 1032 : char *buf2 = 0 ;
58311 1032 : int alloc2 = 0 ;
58312 1032 : PyObject *swig_obj[2] ;
58313 :
58314 1032 : if (!SWIG_Python_UnpackTuple(args, "ArgDatasetValue_SetName", 2, 2, swig_obj)) SWIG_fail;
58315 1032 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALArgDatasetValueHS, 0 | 0 );
58316 1032 : if (!SWIG_IsOK(res1)) {
58317 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArgDatasetValue_SetName" "', argument " "1"" of type '" "GDALArgDatasetValueHS *""'");
58318 : }
58319 1032 : arg1 = reinterpret_cast< GDALArgDatasetValueHS * >(argp1);
58320 1032 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
58321 1032 : if (!SWIG_IsOK(res2)) {
58322 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArgDatasetValue_SetName" "', argument " "2"" of type '" "char const *""'");
58323 : }
58324 1032 : arg2 = reinterpret_cast< char * >(buf2);
58325 1032 : {
58326 1032 : if (!arg2) {
58327 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
58328 : }
58329 : }
58330 1032 : {
58331 1032 : const int bLocalUseExceptions = GetUseExceptions();
58332 1032 : if ( bLocalUseExceptions ) {
58333 1030 : pushErrorHandler();
58334 : }
58335 1032 : {
58336 1032 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58337 1032 : GDALArgDatasetValueHS_SetName(arg1,(char const *)arg2);
58338 1032 : SWIG_PYTHON_THREAD_END_ALLOW;
58339 : }
58340 1032 : if ( bLocalUseExceptions ) {
58341 1030 : popErrorHandler();
58342 : }
58343 : #ifndef SED_HACKS
58344 : if ( bLocalUseExceptions ) {
58345 : CPLErr eclass = CPLGetLastErrorType();
58346 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58347 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58348 : }
58349 : }
58350 : #endif
58351 : }
58352 1032 : resultobj = SWIG_Py_Void();
58353 1032 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
58354 1032 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58355 : return resultobj;
58356 0 : fail:
58357 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
58358 : return NULL;
58359 : }
58360 :
58361 :
58362 529 : SWIGINTERN PyObject *_wrap_ArgDatasetValue_SetDataset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58363 529 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58364 529 : GDALArgDatasetValueHS *arg1 = (GDALArgDatasetValueHS *) 0 ;
58365 529 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
58366 529 : void *argp1 = 0 ;
58367 529 : int res1 = 0 ;
58368 529 : void *argp2 = 0 ;
58369 529 : int res2 = 0 ;
58370 529 : PyObject *swig_obj[2] ;
58371 :
58372 529 : if (!SWIG_Python_UnpackTuple(args, "ArgDatasetValue_SetDataset", 2, 2, swig_obj)) SWIG_fail;
58373 529 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALArgDatasetValueHS, 0 | 0 );
58374 529 : if (!SWIG_IsOK(res1)) {
58375 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArgDatasetValue_SetDataset" "', argument " "1"" of type '" "GDALArgDatasetValueHS *""'");
58376 : }
58377 529 : arg1 = reinterpret_cast< GDALArgDatasetValueHS * >(argp1);
58378 529 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
58379 529 : if (!SWIG_IsOK(res2)) {
58380 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArgDatasetValue_SetDataset" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
58381 : }
58382 529 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
58383 529 : {
58384 529 : const int bLocalUseExceptions = GetUseExceptions();
58385 529 : if ( bLocalUseExceptions ) {
58386 529 : pushErrorHandler();
58387 : }
58388 529 : {
58389 529 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58390 529 : GDALArgDatasetValueHS_SetDataset(arg1,arg2);
58391 529 : SWIG_PYTHON_THREAD_END_ALLOW;
58392 : }
58393 529 : if ( bLocalUseExceptions ) {
58394 529 : popErrorHandler();
58395 : }
58396 : #ifndef SED_HACKS
58397 : if ( bLocalUseExceptions ) {
58398 : CPLErr eclass = CPLGetLastErrorType();
58399 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58400 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58401 : }
58402 : }
58403 : #endif
58404 : }
58405 529 : resultobj = SWIG_Py_Void();
58406 529 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58407 : return resultobj;
58408 : fail:
58409 : return NULL;
58410 : }
58411 :
58412 :
58413 277 : SWIGINTERN PyObject *ArgDatasetValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58414 277 : PyObject *obj;
58415 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
58416 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALArgDatasetValueHS, SWIG_NewClientData(obj));
58417 277 : return SWIG_Py_Void();
58418 : }
58419 :
58420 425 : SWIGINTERN PyObject *_wrap_ApplyGeoTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58421 425 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58422 425 : double *arg1 ;
58423 425 : double arg2 ;
58424 425 : double arg3 ;
58425 425 : double *arg4 = (double *) 0 ;
58426 425 : double *arg5 = (double *) 0 ;
58427 425 : double argin1[6] ;
58428 425 : double val2 ;
58429 425 : int ecode2 = 0 ;
58430 425 : double val3 ;
58431 425 : int ecode3 = 0 ;
58432 425 : double temp4 ;
58433 425 : int res4 = SWIG_TMPOBJ ;
58434 425 : double temp5 ;
58435 425 : int res5 = SWIG_TMPOBJ ;
58436 425 : PyObject *swig_obj[3] ;
58437 :
58438 425 : arg4 = &temp4;
58439 425 : arg5 = &temp5;
58440 425 : if (!SWIG_Python_UnpackTuple(args, "ApplyGeoTransform", 3, 3, swig_obj)) SWIG_fail;
58441 425 : {
58442 : /* %typemap(in) (double argin1[ANY]) */
58443 425 : arg1 = argin1;
58444 425 : if (! PySequence_Check(swig_obj[0]) ) {
58445 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
58446 0 : SWIG_fail;
58447 : }
58448 425 : Py_ssize_t seq_size = PySequence_Size(swig_obj[0]);
58449 425 : if ( seq_size != 6 ) {
58450 0 : PyErr_SetString(PyExc_TypeError, "sequence must have length ##size");
58451 0 : SWIG_fail;
58452 : }
58453 2975 : for (unsigned int i=0; i<6; i++) {
58454 2550 : PyObject *o = PySequence_GetItem(swig_obj[0],i);
58455 2550 : double val;
58456 2550 : if ( !PyArg_Parse(o, "d", &val ) ) {
58457 0 : PyErr_SetString(PyExc_TypeError, "not a number");
58458 0 : Py_DECREF(o);
58459 0 : SWIG_fail;
58460 : }
58461 2550 : arg1[i] = val;
58462 2550 : Py_DECREF(o);
58463 : }
58464 : }
58465 425 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
58466 425 : if (!SWIG_IsOK(ecode2)) {
58467 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ApplyGeoTransform" "', argument " "2"" of type '" "double""'");
58468 : }
58469 425 : arg2 = static_cast< double >(val2);
58470 425 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
58471 425 : if (!SWIG_IsOK(ecode3)) {
58472 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ApplyGeoTransform" "', argument " "3"" of type '" "double""'");
58473 : }
58474 425 : arg3 = static_cast< double >(val3);
58475 425 : {
58476 425 : const int bLocalUseExceptions = GetUseExceptions();
58477 425 : if ( bLocalUseExceptions ) {
58478 24 : pushErrorHandler();
58479 : }
58480 425 : {
58481 425 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58482 425 : GDALApplyGeoTransform(arg1,arg2,arg3,arg4,arg5);
58483 425 : SWIG_PYTHON_THREAD_END_ALLOW;
58484 : }
58485 425 : if ( bLocalUseExceptions ) {
58486 24 : popErrorHandler();
58487 : }
58488 : #ifndef SED_HACKS
58489 : if ( bLocalUseExceptions ) {
58490 : CPLErr eclass = CPLGetLastErrorType();
58491 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58492 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58493 : }
58494 : }
58495 : #endif
58496 : }
58497 425 : resultobj = SWIG_Py_Void();
58498 425 : if (ReturnSame(SWIG_IsTmpObj(res4))) {
58499 425 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
58500 : } else {
58501 0 : int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
58502 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
58503 : }
58504 425 : if (ReturnSame(SWIG_IsTmpObj(res5))) {
58505 425 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
58506 : } else {
58507 0 : int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
58508 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
58509 : }
58510 425 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58511 : return resultobj;
58512 : fail:
58513 : return NULL;
58514 : }
58515 :
58516 :
58517 41 : SWIGINTERN PyObject *_wrap_InvGeoTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58518 41 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58519 41 : double *arg1 ;
58520 41 : double *arg2 ;
58521 41 : double argin1[6] ;
58522 41 : double argout2[6] ;
58523 41 : PyObject *swig_obj[1] ;
58524 41 : RETURN_NONE result;
58525 :
58526 41 : {
58527 : /* %typemap(in,numinputs=0) (double argout2[ANY]) */
58528 41 : memset(argout2, 0, sizeof(argout2));
58529 41 : arg2 = argout2;
58530 : }
58531 41 : if (!args) SWIG_fail;
58532 41 : swig_obj[0] = args;
58533 41 : {
58534 : /* %typemap(in) (double argin1[ANY]) */
58535 41 : arg1 = argin1;
58536 41 : if (! PySequence_Check(swig_obj[0]) ) {
58537 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
58538 0 : SWIG_fail;
58539 : }
58540 41 : Py_ssize_t seq_size = PySequence_Size(swig_obj[0]);
58541 41 : if ( seq_size != 6 ) {
58542 0 : PyErr_SetString(PyExc_TypeError, "sequence must have length ##size");
58543 0 : SWIG_fail;
58544 : }
58545 287 : for (unsigned int i=0; i<6; i++) {
58546 246 : PyObject *o = PySequence_GetItem(swig_obj[0],i);
58547 246 : double val;
58548 246 : if ( !PyArg_Parse(o, "d", &val ) ) {
58549 0 : PyErr_SetString(PyExc_TypeError, "not a number");
58550 0 : Py_DECREF(o);
58551 0 : SWIG_fail;
58552 : }
58553 246 : arg1[i] = val;
58554 246 : Py_DECREF(o);
58555 : }
58556 : }
58557 41 : {
58558 41 : const int bLocalUseExceptions = GetUseExceptions();
58559 41 : if ( bLocalUseExceptions ) {
58560 33 : pushErrorHandler();
58561 : }
58562 41 : {
58563 41 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58564 41 : result = (RETURN_NONE)GDALInvGeoTransform(arg1,arg2);
58565 41 : SWIG_PYTHON_THREAD_END_ALLOW;
58566 : }
58567 41 : if ( bLocalUseExceptions ) {
58568 33 : popErrorHandler();
58569 : }
58570 : #ifndef SED_HACKS
58571 : if ( bLocalUseExceptions ) {
58572 : CPLErr eclass = CPLGetLastErrorType();
58573 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58574 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58575 : }
58576 : }
58577 : #endif
58578 : }
58579 : /*%typemap(out) IF_FALSE_RETURN_NONE */
58580 41 : {
58581 : /* %typemap(argout) (double argout[ANY]) */
58582 41 : PyObject *out = CreateTupleFromDoubleArray( arg2, 6 );
58583 : #if SWIG_VERSION >= 0x040300
58584 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
58585 : #else
58586 41 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
58587 : #endif
58588 : }
58589 41 : {
58590 : /* %typemap(ret) IF_FALSE_RETURN_NONE */
58591 41 : if (result == 0 ) {
58592 3 : Py_XDECREF( resultobj );
58593 3 : resultobj = Py_None;
58594 3 : Py_INCREF(resultobj);
58595 : }
58596 41 : if (resultobj == 0) {
58597 0 : resultobj = Py_None;
58598 0 : Py_INCREF(resultobj);
58599 : }
58600 : }
58601 41 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58602 : return resultobj;
58603 : fail:
58604 : return NULL;
58605 : }
58606 :
58607 :
58608 10 : SWIGINTERN PyObject *_wrap_ApplyHomography(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58609 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58610 10 : double *arg1 ;
58611 10 : double arg2 ;
58612 10 : double arg3 ;
58613 10 : double *arg4 = (double *) 0 ;
58614 10 : double *arg5 = (double *) 0 ;
58615 10 : double argin1[9] ;
58616 10 : double val2 ;
58617 10 : int ecode2 = 0 ;
58618 10 : double val3 ;
58619 10 : int ecode3 = 0 ;
58620 10 : double temp4 ;
58621 10 : int res4 = SWIG_TMPOBJ ;
58622 10 : double temp5 ;
58623 10 : int res5 = SWIG_TMPOBJ ;
58624 10 : PyObject *swig_obj[3] ;
58625 10 : int result;
58626 :
58627 10 : arg4 = &temp4;
58628 10 : arg5 = &temp5;
58629 10 : if (!SWIG_Python_UnpackTuple(args, "ApplyHomography", 3, 3, swig_obj)) SWIG_fail;
58630 10 : {
58631 : /* %typemap(in) (double argin1[ANY]) */
58632 10 : arg1 = argin1;
58633 10 : if (! PySequence_Check(swig_obj[0]) ) {
58634 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
58635 0 : SWIG_fail;
58636 : }
58637 10 : Py_ssize_t seq_size = PySequence_Size(swig_obj[0]);
58638 10 : if ( seq_size != 9 ) {
58639 0 : PyErr_SetString(PyExc_TypeError, "sequence must have length ##size");
58640 0 : SWIG_fail;
58641 : }
58642 100 : for (unsigned int i=0; i<9; i++) {
58643 90 : PyObject *o = PySequence_GetItem(swig_obj[0],i);
58644 90 : double val;
58645 90 : if ( !PyArg_Parse(o, "d", &val ) ) {
58646 0 : PyErr_SetString(PyExc_TypeError, "not a number");
58647 0 : Py_DECREF(o);
58648 0 : SWIG_fail;
58649 : }
58650 90 : arg1[i] = val;
58651 90 : Py_DECREF(o);
58652 : }
58653 : }
58654 10 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
58655 10 : if (!SWIG_IsOK(ecode2)) {
58656 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ApplyHomography" "', argument " "2"" of type '" "double""'");
58657 : }
58658 10 : arg2 = static_cast< double >(val2);
58659 10 : ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
58660 10 : if (!SWIG_IsOK(ecode3)) {
58661 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ApplyHomography" "', argument " "3"" of type '" "double""'");
58662 : }
58663 10 : arg3 = static_cast< double >(val3);
58664 10 : {
58665 10 : const int bLocalUseExceptions = GetUseExceptions();
58666 10 : if ( bLocalUseExceptions ) {
58667 10 : pushErrorHandler();
58668 : }
58669 10 : {
58670 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58671 10 : result = (int)GDALApplyHomography(arg1,arg2,arg3,arg4,arg5);
58672 10 : SWIG_PYTHON_THREAD_END_ALLOW;
58673 : }
58674 10 : if ( bLocalUseExceptions ) {
58675 10 : popErrorHandler();
58676 : }
58677 : #ifndef SED_HACKS
58678 : if ( bLocalUseExceptions ) {
58679 : CPLErr eclass = CPLGetLastErrorType();
58680 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58681 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58682 : }
58683 : }
58684 : #endif
58685 : }
58686 10 : resultobj = SWIG_From_int(static_cast< int >(result));
58687 10 : if (ReturnSame(SWIG_IsTmpObj(res4))) {
58688 10 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
58689 : } else {
58690 0 : int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
58691 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
58692 : }
58693 10 : if (ReturnSame(SWIG_IsTmpObj(res5))) {
58694 10 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
58695 : } else {
58696 0 : int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
58697 0 : resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
58698 : }
58699 10 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58700 : return resultobj;
58701 : fail:
58702 : return NULL;
58703 : }
58704 :
58705 :
58706 7 : SWIGINTERN PyObject *_wrap_InvHomography(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58707 7 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58708 7 : double *arg1 ;
58709 7 : double *arg2 ;
58710 7 : double argin1[9] ;
58711 7 : double argout2[9] ;
58712 7 : PyObject *swig_obj[1] ;
58713 7 : RETURN_NONE result;
58714 :
58715 7 : {
58716 : /* %typemap(in,numinputs=0) (double argout2[ANY]) */
58717 7 : memset(argout2, 0, sizeof(argout2));
58718 7 : arg2 = argout2;
58719 : }
58720 7 : if (!args) SWIG_fail;
58721 7 : swig_obj[0] = args;
58722 7 : {
58723 : /* %typemap(in) (double argin1[ANY]) */
58724 7 : arg1 = argin1;
58725 7 : if (! PySequence_Check(swig_obj[0]) ) {
58726 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
58727 0 : SWIG_fail;
58728 : }
58729 7 : Py_ssize_t seq_size = PySequence_Size(swig_obj[0]);
58730 7 : if ( seq_size != 9 ) {
58731 0 : PyErr_SetString(PyExc_TypeError, "sequence must have length ##size");
58732 0 : SWIG_fail;
58733 : }
58734 70 : for (unsigned int i=0; i<9; i++) {
58735 63 : PyObject *o = PySequence_GetItem(swig_obj[0],i);
58736 63 : double val;
58737 63 : if ( !PyArg_Parse(o, "d", &val ) ) {
58738 0 : PyErr_SetString(PyExc_TypeError, "not a number");
58739 0 : Py_DECREF(o);
58740 0 : SWIG_fail;
58741 : }
58742 63 : arg1[i] = val;
58743 63 : Py_DECREF(o);
58744 : }
58745 : }
58746 7 : {
58747 7 : const int bLocalUseExceptions = GetUseExceptions();
58748 7 : if ( bLocalUseExceptions ) {
58749 7 : pushErrorHandler();
58750 : }
58751 7 : {
58752 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58753 7 : result = (RETURN_NONE)GDALInvHomography(arg1,arg2);
58754 7 : SWIG_PYTHON_THREAD_END_ALLOW;
58755 : }
58756 7 : if ( bLocalUseExceptions ) {
58757 7 : popErrorHandler();
58758 : }
58759 : #ifndef SED_HACKS
58760 : if ( bLocalUseExceptions ) {
58761 : CPLErr eclass = CPLGetLastErrorType();
58762 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58763 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58764 : }
58765 : }
58766 : #endif
58767 : }
58768 : /*%typemap(out) IF_FALSE_RETURN_NONE */
58769 7 : {
58770 : /* %typemap(argout) (double argout[ANY]) */
58771 7 : PyObject *out = CreateTupleFromDoubleArray( arg2, 9 );
58772 : #if SWIG_VERSION >= 0x040300
58773 : resultobj = SWIG_Python_AppendOutput(resultobj,out,$isvoid);
58774 : #else
58775 7 : resultobj = SWIG_Python_AppendOutput(resultobj,out);
58776 : #endif
58777 : }
58778 7 : {
58779 : /* %typemap(ret) IF_FALSE_RETURN_NONE */
58780 7 : if (result == 0 ) {
58781 3 : Py_XDECREF( resultobj );
58782 3 : resultobj = Py_None;
58783 3 : Py_INCREF(resultobj);
58784 : }
58785 7 : if (resultobj == 0) {
58786 0 : resultobj = Py_None;
58787 0 : Py_INCREF(resultobj);
58788 : }
58789 : }
58790 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58791 : return resultobj;
58792 : fail:
58793 : return NULL;
58794 : }
58795 :
58796 :
58797 1313 : SWIGINTERN PyObject *_wrap_VersionInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58798 1313 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58799 1313 : char *arg1 = (char *) "VERSION_NUM" ;
58800 1313 : int res1 ;
58801 1313 : char *buf1 = 0 ;
58802 1313 : int alloc1 = 0 ;
58803 1313 : PyObject *swig_obj[1] ;
58804 1313 : char *result = 0 ;
58805 :
58806 1313 : if (!SWIG_Python_UnpackTuple(args, "VersionInfo", 0, 1, swig_obj)) SWIG_fail;
58807 1313 : if (swig_obj[0]) {
58808 1313 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
58809 1313 : if (!SWIG_IsOK(res1)) {
58810 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VersionInfo" "', argument " "1"" of type '" "char const *""'");
58811 : }
58812 1313 : arg1 = reinterpret_cast< char * >(buf1);
58813 : }
58814 1313 : {
58815 1313 : const int bLocalUseExceptions = GetUseExceptions();
58816 1313 : if ( bLocalUseExceptions ) {
58817 745 : pushErrorHandler();
58818 : }
58819 1313 : {
58820 1313 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58821 1313 : result = (char *)GDALVersionInfo((char const *)arg1);
58822 1313 : SWIG_PYTHON_THREAD_END_ALLOW;
58823 : }
58824 1313 : if ( bLocalUseExceptions ) {
58825 745 : popErrorHandler();
58826 : }
58827 : #ifndef SED_HACKS
58828 : if ( bLocalUseExceptions ) {
58829 : CPLErr eclass = CPLGetLastErrorType();
58830 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58831 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58832 : }
58833 : }
58834 : #endif
58835 : }
58836 1313 : resultobj = SWIG_FromCharPtr((const char *)result);
58837 1313 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
58838 1313 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58839 : return resultobj;
58840 0 : fail:
58841 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
58842 : return NULL;
58843 : }
58844 :
58845 :
58846 274 : SWIGINTERN PyObject *_wrap_AllRegister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58847 274 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58848 :
58849 274 : if (!SWIG_Python_UnpackTuple(args, "AllRegister", 0, 0, 0)) SWIG_fail;
58850 274 : {
58851 274 : const int bLocalUseExceptions = GetUseExceptions();
58852 274 : if ( bLocalUseExceptions ) {
58853 225 : pushErrorHandler();
58854 : }
58855 274 : {
58856 274 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58857 274 : GDALAllRegister();
58858 274 : SWIG_PYTHON_THREAD_END_ALLOW;
58859 : }
58860 274 : if ( bLocalUseExceptions ) {
58861 225 : popErrorHandler();
58862 : }
58863 : #ifndef SED_HACKS
58864 : if ( bLocalUseExceptions ) {
58865 : CPLErr eclass = CPLGetLastErrorType();
58866 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58867 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58868 : }
58869 : }
58870 : #endif
58871 : }
58872 274 : resultobj = SWIG_Py_Void();
58873 274 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58874 : return resultobj;
58875 0 : fail:
58876 0 : return NULL;
58877 : }
58878 :
58879 :
58880 0 : SWIGINTERN PyObject *_wrap_GDALDestroyDriverManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58881 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58882 :
58883 0 : if (!SWIG_Python_UnpackTuple(args, "GDALDestroyDriverManager", 0, 0, 0)) SWIG_fail;
58884 0 : {
58885 0 : const int bLocalUseExceptions = GetUseExceptions();
58886 0 : if ( bLocalUseExceptions ) {
58887 0 : pushErrorHandler();
58888 : }
58889 0 : {
58890 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58891 0 : GDALDestroyDriverManager();
58892 0 : SWIG_PYTHON_THREAD_END_ALLOW;
58893 : }
58894 0 : if ( bLocalUseExceptions ) {
58895 0 : popErrorHandler();
58896 : }
58897 : #ifndef SED_HACKS
58898 : if ( bLocalUseExceptions ) {
58899 : CPLErr eclass = CPLGetLastErrorType();
58900 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58901 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58902 : }
58903 : }
58904 : #endif
58905 : }
58906 0 : resultobj = SWIG_Py_Void();
58907 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58908 : return resultobj;
58909 0 : fail:
58910 0 : return NULL;
58911 : }
58912 :
58913 :
58914 56 : SWIGINTERN PyObject *_wrap_GetCacheMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58915 56 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58916 56 : GIntBig result;
58917 :
58918 56 : if (!SWIG_Python_UnpackTuple(args, "GetCacheMax", 0, 0, 0)) SWIG_fail;
58919 56 : {
58920 56 : const int bLocalUseExceptions = GetUseExceptions();
58921 56 : if ( bLocalUseExceptions ) {
58922 26 : pushErrorHandler();
58923 : }
58924 56 : {
58925 56 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58926 56 : result = wrapper_GDALGetCacheMax();
58927 56 : SWIG_PYTHON_THREAD_END_ALLOW;
58928 : }
58929 56 : if ( bLocalUseExceptions ) {
58930 26 : popErrorHandler();
58931 : }
58932 : #ifndef SED_HACKS
58933 : if ( bLocalUseExceptions ) {
58934 : CPLErr eclass = CPLGetLastErrorType();
58935 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58936 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58937 : }
58938 : }
58939 : #endif
58940 : }
58941 56 : {
58942 56 : resultobj = PyLong_FromLongLong(result);
58943 : }
58944 56 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58945 : return resultobj;
58946 0 : fail:
58947 0 : return NULL;
58948 : }
58949 :
58950 :
58951 2 : SWIGINTERN PyObject *_wrap_GetCacheUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58952 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58953 2 : GIntBig result;
58954 :
58955 2 : if (!SWIG_Python_UnpackTuple(args, "GetCacheUsed", 0, 0, 0)) SWIG_fail;
58956 2 : {
58957 2 : const int bLocalUseExceptions = GetUseExceptions();
58958 2 : if ( bLocalUseExceptions ) {
58959 0 : pushErrorHandler();
58960 : }
58961 2 : {
58962 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
58963 2 : result = wrapper_GDALGetCacheUsed();
58964 2 : SWIG_PYTHON_THREAD_END_ALLOW;
58965 : }
58966 2 : if ( bLocalUseExceptions ) {
58967 0 : popErrorHandler();
58968 : }
58969 : #ifndef SED_HACKS
58970 : if ( bLocalUseExceptions ) {
58971 : CPLErr eclass = CPLGetLastErrorType();
58972 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
58973 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
58974 : }
58975 : }
58976 : #endif
58977 : }
58978 2 : {
58979 2 : resultobj = PyLong_FromLongLong(result);
58980 : }
58981 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
58982 : return resultobj;
58983 0 : fail:
58984 0 : return NULL;
58985 : }
58986 :
58987 :
58988 76 : SWIGINTERN PyObject *_wrap_SetCacheMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58989 76 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
58990 76 : GIntBig arg1 ;
58991 76 : PyObject *swig_obj[1] ;
58992 :
58993 76 : if (!args) SWIG_fail;
58994 76 : swig_obj[0] = args;
58995 76 : {
58996 76 : arg1 = (GIntBig)PyLong_AsLongLong(swig_obj[0]);
58997 : }
58998 76 : {
58999 76 : const int bLocalUseExceptions = GetUseExceptions();
59000 76 : if ( bLocalUseExceptions ) {
59001 20 : pushErrorHandler();
59002 : }
59003 76 : {
59004 76 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59005 76 : wrapper_GDALSetCacheMax(arg1);
59006 76 : SWIG_PYTHON_THREAD_END_ALLOW;
59007 : }
59008 76 : if ( bLocalUseExceptions ) {
59009 20 : popErrorHandler();
59010 : }
59011 : #ifndef SED_HACKS
59012 : if ( bLocalUseExceptions ) {
59013 : CPLErr eclass = CPLGetLastErrorType();
59014 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59015 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59016 : }
59017 : }
59018 : #endif
59019 : }
59020 76 : resultobj = SWIG_Py_Void();
59021 76 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59022 : return resultobj;
59023 0 : fail:
59024 0 : return NULL;
59025 : }
59026 :
59027 :
59028 43 : SWIGINTERN PyObject *_wrap_GetDataTypeSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59029 43 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59030 43 : GDALDataType arg1 ;
59031 43 : PyObject *swig_obj[1] ;
59032 43 : int result;
59033 :
59034 43 : if (!args) SWIG_fail;
59035 43 : swig_obj[0] = args;
59036 43 : {
59037 : // %typemap(in) GDALDataType
59038 43 : int val = 0;
59039 43 : int ecode = SWIG_AsVal_int(swig_obj[0], &val);
59040 43 : if (!SWIG_IsOK(ecode)) {
59041 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
59042 : }
59043 43 : if( val < GDT_Unknown || val >= GDT_TypeCount )
59044 : {
59045 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
59046 : }
59047 43 : arg1 = static_cast<GDALDataType>(val);
59048 : }
59049 43 : {
59050 43 : const int bLocalUseExceptions = GetUseExceptions();
59051 43 : if ( bLocalUseExceptions ) {
59052 21 : pushErrorHandler();
59053 : }
59054 43 : {
59055 43 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59056 43 : result = (int)wrapper_GDALGetDataTypeSizeBits(arg1);
59057 43 : SWIG_PYTHON_THREAD_END_ALLOW;
59058 : }
59059 43 : if ( bLocalUseExceptions ) {
59060 21 : popErrorHandler();
59061 : }
59062 : #ifndef SED_HACKS
59063 : if ( bLocalUseExceptions ) {
59064 : CPLErr eclass = CPLGetLastErrorType();
59065 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59066 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59067 : }
59068 : }
59069 : #endif
59070 : }
59071 43 : resultobj = SWIG_From_int(static_cast< int >(result));
59072 43 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59073 : return resultobj;
59074 : fail:
59075 : return NULL;
59076 : }
59077 :
59078 :
59079 0 : SWIGINTERN PyObject *_wrap_GetDataTypeSizeBits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59080 0 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59081 0 : GDALDataType arg1 ;
59082 0 : PyObject *swig_obj[1] ;
59083 0 : int result;
59084 :
59085 0 : if (!args) SWIG_fail;
59086 0 : swig_obj[0] = args;
59087 0 : {
59088 : // %typemap(in) GDALDataType
59089 0 : int val = 0;
59090 0 : int ecode = SWIG_AsVal_int(swig_obj[0], &val);
59091 0 : if (!SWIG_IsOK(ecode)) {
59092 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
59093 : }
59094 0 : if( val < GDT_Unknown || val >= GDT_TypeCount )
59095 : {
59096 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
59097 : }
59098 0 : arg1 = static_cast<GDALDataType>(val);
59099 : }
59100 0 : {
59101 0 : const int bLocalUseExceptions = GetUseExceptions();
59102 0 : if ( bLocalUseExceptions ) {
59103 0 : pushErrorHandler();
59104 : }
59105 0 : {
59106 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59107 0 : result = (int)GDALGetDataTypeSizeBits(arg1);
59108 0 : SWIG_PYTHON_THREAD_END_ALLOW;
59109 : }
59110 0 : if ( bLocalUseExceptions ) {
59111 0 : popErrorHandler();
59112 : }
59113 : #ifndef SED_HACKS
59114 : if ( bLocalUseExceptions ) {
59115 : CPLErr eclass = CPLGetLastErrorType();
59116 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59117 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59118 : }
59119 : }
59120 : #endif
59121 : }
59122 0 : resultobj = SWIG_From_int(static_cast< int >(result));
59123 0 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59124 : return resultobj;
59125 : fail:
59126 : return NULL;
59127 : }
59128 :
59129 :
59130 24 : SWIGINTERN PyObject *_wrap_GetDataTypeSizeBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59131 24 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59132 24 : GDALDataType arg1 ;
59133 24 : PyObject *swig_obj[1] ;
59134 24 : int result;
59135 :
59136 24 : if (!args) SWIG_fail;
59137 24 : swig_obj[0] = args;
59138 24 : {
59139 : // %typemap(in) GDALDataType
59140 24 : int val = 0;
59141 24 : int ecode = SWIG_AsVal_int(swig_obj[0], &val);
59142 24 : if (!SWIG_IsOK(ecode)) {
59143 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
59144 : }
59145 24 : if( val < GDT_Unknown || val >= GDT_TypeCount )
59146 : {
59147 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
59148 : }
59149 24 : arg1 = static_cast<GDALDataType>(val);
59150 : }
59151 24 : {
59152 24 : const int bLocalUseExceptions = GetUseExceptions();
59153 24 : if ( bLocalUseExceptions ) {
59154 24 : pushErrorHandler();
59155 : }
59156 24 : {
59157 24 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59158 24 : result = (int)GDALGetDataTypeSizeBytes(arg1);
59159 24 : SWIG_PYTHON_THREAD_END_ALLOW;
59160 : }
59161 24 : if ( bLocalUseExceptions ) {
59162 24 : popErrorHandler();
59163 : }
59164 : #ifndef SED_HACKS
59165 : if ( bLocalUseExceptions ) {
59166 : CPLErr eclass = CPLGetLastErrorType();
59167 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59168 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59169 : }
59170 : }
59171 : #endif
59172 : }
59173 24 : resultobj = SWIG_From_int(static_cast< int >(result));
59174 24 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59175 : return resultobj;
59176 : fail:
59177 : return NULL;
59178 : }
59179 :
59180 :
59181 217 : SWIGINTERN PyObject *_wrap_DataTypeIsComplex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59182 217 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59183 217 : GDALDataType arg1 ;
59184 217 : PyObject *swig_obj[1] ;
59185 217 : int result;
59186 :
59187 217 : if (!args) SWIG_fail;
59188 217 : swig_obj[0] = args;
59189 217 : {
59190 : // %typemap(in) GDALDataType
59191 217 : int val = 0;
59192 217 : int ecode = SWIG_AsVal_int(swig_obj[0], &val);
59193 217 : if (!SWIG_IsOK(ecode)) {
59194 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
59195 : }
59196 217 : if( val < GDT_Unknown || val >= GDT_TypeCount )
59197 : {
59198 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
59199 : }
59200 217 : arg1 = static_cast<GDALDataType>(val);
59201 : }
59202 217 : {
59203 217 : const int bLocalUseExceptions = GetUseExceptions();
59204 217 : if ( bLocalUseExceptions ) {
59205 159 : pushErrorHandler();
59206 : }
59207 217 : {
59208 217 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59209 217 : result = (int)GDALDataTypeIsComplex(arg1);
59210 217 : SWIG_PYTHON_THREAD_END_ALLOW;
59211 : }
59212 217 : if ( bLocalUseExceptions ) {
59213 159 : popErrorHandler();
59214 : }
59215 : #ifndef SED_HACKS
59216 : if ( bLocalUseExceptions ) {
59217 : CPLErr eclass = CPLGetLastErrorType();
59218 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59219 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59220 : }
59221 : }
59222 : #endif
59223 : }
59224 217 : resultobj = SWIG_From_int(static_cast< int >(result));
59225 217 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59226 : return resultobj;
59227 : fail:
59228 : return NULL;
59229 : }
59230 :
59231 :
59232 3871 : SWIGINTERN PyObject *_wrap_GetDataTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59233 3871 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59234 3871 : GDALDataType arg1 ;
59235 3871 : PyObject *swig_obj[1] ;
59236 3871 : char *result = 0 ;
59237 :
59238 3871 : if (!args) SWIG_fail;
59239 3871 : swig_obj[0] = args;
59240 3871 : {
59241 : // %typemap(in) GDALDataType
59242 3871 : int val = 0;
59243 3871 : int ecode = SWIG_AsVal_int(swig_obj[0], &val);
59244 3871 : if (!SWIG_IsOK(ecode)) {
59245 1 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
59246 : }
59247 3870 : if( val < GDT_Unknown || val >= GDT_TypeCount )
59248 : {
59249 2 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
59250 : }
59251 3868 : arg1 = static_cast<GDALDataType>(val);
59252 : }
59253 3868 : {
59254 3868 : const int bLocalUseExceptions = GetUseExceptions();
59255 3868 : if ( bLocalUseExceptions ) {
59256 275 : pushErrorHandler();
59257 : }
59258 3868 : {
59259 3868 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59260 3868 : result = (char *)GDALGetDataTypeName(arg1);
59261 3868 : SWIG_PYTHON_THREAD_END_ALLOW;
59262 : }
59263 3868 : if ( bLocalUseExceptions ) {
59264 275 : popErrorHandler();
59265 : }
59266 : #ifndef SED_HACKS
59267 : if ( bLocalUseExceptions ) {
59268 : CPLErr eclass = CPLGetLastErrorType();
59269 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59270 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59271 : }
59272 : }
59273 : #endif
59274 : }
59275 3868 : resultobj = SWIG_FromCharPtr((const char *)result);
59276 3871 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59277 : return resultobj;
59278 : fail:
59279 : return NULL;
59280 : }
59281 :
59282 :
59283 995 : SWIGINTERN PyObject *_wrap_GetDataTypeByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59284 995 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59285 995 : char *arg1 = (char *) 0 ;
59286 995 : int res1 ;
59287 995 : char *buf1 = 0 ;
59288 995 : int alloc1 = 0 ;
59289 995 : PyObject *swig_obj[1] ;
59290 995 : GDALDataType result;
59291 :
59292 995 : if (!args) SWIG_fail;
59293 995 : swig_obj[0] = args;
59294 995 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
59295 995 : if (!SWIG_IsOK(res1)) {
59296 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDataTypeByName" "', argument " "1"" of type '" "char const *""'");
59297 : }
59298 995 : arg1 = reinterpret_cast< char * >(buf1);
59299 995 : {
59300 995 : const int bLocalUseExceptions = GetUseExceptions();
59301 995 : if ( bLocalUseExceptions ) {
59302 89 : pushErrorHandler();
59303 : }
59304 995 : {
59305 995 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59306 995 : result = (GDALDataType)GDALGetDataTypeByName((char const *)arg1);
59307 995 : SWIG_PYTHON_THREAD_END_ALLOW;
59308 : }
59309 995 : if ( bLocalUseExceptions ) {
59310 89 : popErrorHandler();
59311 : }
59312 : #ifndef SED_HACKS
59313 : if ( bLocalUseExceptions ) {
59314 : CPLErr eclass = CPLGetLastErrorType();
59315 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59316 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59317 : }
59318 : }
59319 : #endif
59320 : }
59321 995 : resultobj = SWIG_From_int(static_cast< int >(result));
59322 995 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
59323 995 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59324 : return resultobj;
59325 0 : fail:
59326 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
59327 : return NULL;
59328 : }
59329 :
59330 :
59331 65 : SWIGINTERN PyObject *_wrap_DataTypeUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59332 65 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59333 65 : GDALDataType arg1 ;
59334 65 : GDALDataType arg2 ;
59335 65 : PyObject *swig_obj[2] ;
59336 65 : GDALDataType result;
59337 :
59338 65 : if (!SWIG_Python_UnpackTuple(args, "DataTypeUnion", 2, 2, swig_obj)) SWIG_fail;
59339 65 : {
59340 : // %typemap(in) GDALDataType
59341 65 : int val = 0;
59342 65 : int ecode = SWIG_AsVal_int(swig_obj[0], &val);
59343 65 : if (!SWIG_IsOK(ecode)) {
59344 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
59345 : }
59346 65 : if( val < GDT_Unknown || val >= GDT_TypeCount )
59347 : {
59348 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
59349 : }
59350 65 : arg1 = static_cast<GDALDataType>(val);
59351 : }
59352 65 : {
59353 : // %typemap(in) GDALDataType
59354 65 : int val = 0;
59355 65 : int ecode = SWIG_AsVal_int(swig_obj[1], &val);
59356 65 : if (!SWIG_IsOK(ecode)) {
59357 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
59358 : }
59359 65 : if( val < GDT_Unknown || val >= GDT_TypeCount )
59360 : {
59361 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
59362 : }
59363 65 : arg2 = static_cast<GDALDataType>(val);
59364 : }
59365 65 : {
59366 65 : const int bLocalUseExceptions = GetUseExceptions();
59367 65 : if ( bLocalUseExceptions ) {
59368 64 : pushErrorHandler();
59369 : }
59370 65 : {
59371 65 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59372 65 : result = (GDALDataType)GDALDataTypeUnion(arg1,arg2);
59373 65 : SWIG_PYTHON_THREAD_END_ALLOW;
59374 : }
59375 65 : if ( bLocalUseExceptions ) {
59376 64 : popErrorHandler();
59377 : }
59378 : #ifndef SED_HACKS
59379 : if ( bLocalUseExceptions ) {
59380 : CPLErr eclass = CPLGetLastErrorType();
59381 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59382 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59383 : }
59384 : }
59385 : #endif
59386 : }
59387 65 : resultobj = SWIG_From_int(static_cast< int >(result));
59388 65 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59389 : return resultobj;
59390 : fail:
59391 : return NULL;
59392 : }
59393 :
59394 :
59395 8 : SWIGINTERN PyObject *_wrap_DataTypeUnionWithValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59396 8 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59397 8 : GDALDataType arg1 ;
59398 8 : double arg2 ;
59399 8 : bool arg3 ;
59400 8 : double val2 ;
59401 8 : int ecode2 = 0 ;
59402 8 : bool val3 ;
59403 8 : int ecode3 = 0 ;
59404 8 : PyObject *swig_obj[3] ;
59405 8 : GDALDataType result;
59406 :
59407 8 : if (!SWIG_Python_UnpackTuple(args, "DataTypeUnionWithValue", 3, 3, swig_obj)) SWIG_fail;
59408 8 : {
59409 : // %typemap(in) GDALDataType
59410 8 : int val = 0;
59411 8 : int ecode = SWIG_AsVal_int(swig_obj[0], &val);
59412 8 : if (!SWIG_IsOK(ecode)) {
59413 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALDataType");
59414 : }
59415 8 : if( val < GDT_Unknown || val >= GDT_TypeCount )
59416 : {
59417 0 : SWIG_exception_fail(SWIG_ValueError, "Invalid value for GDALDataType");
59418 : }
59419 8 : arg1 = static_cast<GDALDataType>(val);
59420 : }
59421 8 : ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
59422 8 : if (!SWIG_IsOK(ecode2)) {
59423 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataTypeUnionWithValue" "', argument " "2"" of type '" "double""'");
59424 : }
59425 8 : arg2 = static_cast< double >(val2);
59426 8 : ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
59427 8 : if (!SWIG_IsOK(ecode3)) {
59428 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataTypeUnionWithValue" "', argument " "3"" of type '" "bool""'");
59429 : }
59430 8 : arg3 = static_cast< bool >(val3);
59431 8 : {
59432 8 : const int bLocalUseExceptions = GetUseExceptions();
59433 8 : if ( bLocalUseExceptions ) {
59434 8 : pushErrorHandler();
59435 : }
59436 8 : {
59437 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59438 8 : result = (GDALDataType)GDALDataTypeUnionWithValue(arg1,arg2,arg3);
59439 8 : SWIG_PYTHON_THREAD_END_ALLOW;
59440 : }
59441 8 : if ( bLocalUseExceptions ) {
59442 8 : popErrorHandler();
59443 : }
59444 : #ifndef SED_HACKS
59445 : if ( bLocalUseExceptions ) {
59446 : CPLErr eclass = CPLGetLastErrorType();
59447 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59448 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59449 : }
59450 : }
59451 : #endif
59452 : }
59453 8 : resultobj = SWIG_From_int(static_cast< int >(result));
59454 8 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59455 : return resultobj;
59456 : fail:
59457 : return NULL;
59458 : }
59459 :
59460 :
59461 61 : SWIGINTERN PyObject *_wrap_GetColorInterpretationName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59462 61 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59463 61 : GDALColorInterp arg1 ;
59464 61 : int val1 ;
59465 61 : int ecode1 = 0 ;
59466 61 : PyObject *swig_obj[1] ;
59467 61 : char *result = 0 ;
59468 :
59469 61 : if (!args) SWIG_fail;
59470 61 : swig_obj[0] = args;
59471 61 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
59472 61 : if (!SWIG_IsOK(ecode1)) {
59473 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetColorInterpretationName" "', argument " "1"" of type '" "GDALColorInterp""'");
59474 : }
59475 61 : arg1 = static_cast< GDALColorInterp >(val1);
59476 61 : {
59477 61 : const int bLocalUseExceptions = GetUseExceptions();
59478 61 : if ( bLocalUseExceptions ) {
59479 4 : pushErrorHandler();
59480 : }
59481 61 : {
59482 61 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59483 61 : result = (char *)GDALGetColorInterpretationName(arg1);
59484 61 : SWIG_PYTHON_THREAD_END_ALLOW;
59485 : }
59486 61 : if ( bLocalUseExceptions ) {
59487 4 : popErrorHandler();
59488 : }
59489 : #ifndef SED_HACKS
59490 : if ( bLocalUseExceptions ) {
59491 : CPLErr eclass = CPLGetLastErrorType();
59492 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59493 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59494 : }
59495 : }
59496 : #endif
59497 : }
59498 61 : resultobj = SWIG_FromCharPtr((const char *)result);
59499 61 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59500 : return resultobj;
59501 : fail:
59502 : return NULL;
59503 : }
59504 :
59505 :
59506 41 : SWIGINTERN PyObject *_wrap_GetColorInterpretationByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59507 41 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59508 41 : char *arg1 = (char *) 0 ;
59509 41 : int res1 ;
59510 41 : char *buf1 = 0 ;
59511 41 : int alloc1 = 0 ;
59512 41 : PyObject *swig_obj[1] ;
59513 41 : GDALColorInterp result;
59514 :
59515 41 : if (!args) SWIG_fail;
59516 41 : swig_obj[0] = args;
59517 41 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
59518 41 : if (!SWIG_IsOK(res1)) {
59519 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetColorInterpretationByName" "', argument " "1"" of type '" "char const *""'");
59520 : }
59521 41 : arg1 = reinterpret_cast< char * >(buf1);
59522 41 : {
59523 41 : const int bLocalUseExceptions = GetUseExceptions();
59524 41 : if ( bLocalUseExceptions ) {
59525 1 : pushErrorHandler();
59526 : }
59527 41 : {
59528 41 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59529 41 : result = (GDALColorInterp)GDALGetColorInterpretationByName((char const *)arg1);
59530 41 : SWIG_PYTHON_THREAD_END_ALLOW;
59531 : }
59532 41 : if ( bLocalUseExceptions ) {
59533 1 : popErrorHandler();
59534 : }
59535 : #ifndef SED_HACKS
59536 : if ( bLocalUseExceptions ) {
59537 : CPLErr eclass = CPLGetLastErrorType();
59538 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59539 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59540 : }
59541 : }
59542 : #endif
59543 : }
59544 41 : resultobj = SWIG_From_int(static_cast< int >(result));
59545 41 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
59546 41 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59547 : return resultobj;
59548 0 : fail:
59549 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
59550 : return NULL;
59551 : }
59552 :
59553 :
59554 2 : SWIGINTERN PyObject *_wrap_GetPaletteInterpretationName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59555 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59556 2 : GDALPaletteInterp arg1 ;
59557 2 : int val1 ;
59558 2 : int ecode1 = 0 ;
59559 2 : PyObject *swig_obj[1] ;
59560 2 : char *result = 0 ;
59561 :
59562 2 : if (!args) SWIG_fail;
59563 2 : swig_obj[0] = args;
59564 2 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
59565 2 : if (!SWIG_IsOK(ecode1)) {
59566 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetPaletteInterpretationName" "', argument " "1"" of type '" "GDALPaletteInterp""'");
59567 : }
59568 2 : arg1 = static_cast< GDALPaletteInterp >(val1);
59569 2 : {
59570 2 : const int bLocalUseExceptions = GetUseExceptions();
59571 2 : if ( bLocalUseExceptions ) {
59572 0 : pushErrorHandler();
59573 : }
59574 2 : {
59575 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59576 2 : result = (char *)GDALGetPaletteInterpretationName(arg1);
59577 2 : SWIG_PYTHON_THREAD_END_ALLOW;
59578 : }
59579 2 : if ( bLocalUseExceptions ) {
59580 0 : popErrorHandler();
59581 : }
59582 : #ifndef SED_HACKS
59583 : if ( bLocalUseExceptions ) {
59584 : CPLErr eclass = CPLGetLastErrorType();
59585 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59586 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59587 : }
59588 : }
59589 : #endif
59590 : }
59591 2 : resultobj = SWIG_FromCharPtr((const char *)result);
59592 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59593 : return resultobj;
59594 : fail:
59595 : return NULL;
59596 : }
59597 :
59598 :
59599 130 : SWIGINTERN PyObject *_wrap_DecToDMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59600 130 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59601 130 : double arg1 ;
59602 130 : char *arg2 = (char *) 0 ;
59603 130 : int arg3 = (int) 2 ;
59604 130 : double val1 ;
59605 130 : int ecode1 = 0 ;
59606 130 : int res2 ;
59607 130 : char *buf2 = 0 ;
59608 130 : int alloc2 = 0 ;
59609 130 : int val3 ;
59610 130 : int ecode3 = 0 ;
59611 130 : PyObject *swig_obj[3] ;
59612 130 : char *result = 0 ;
59613 :
59614 130 : if (!SWIG_Python_UnpackTuple(args, "DecToDMS", 2, 3, swig_obj)) SWIG_fail;
59615 130 : ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
59616 130 : if (!SWIG_IsOK(ecode1)) {
59617 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DecToDMS" "', argument " "1"" of type '" "double""'");
59618 : }
59619 130 : arg1 = static_cast< double >(val1);
59620 130 : res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
59621 130 : if (!SWIG_IsOK(res2)) {
59622 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DecToDMS" "', argument " "2"" of type '" "char const *""'");
59623 : }
59624 130 : arg2 = reinterpret_cast< char * >(buf2);
59625 130 : if (swig_obj[2]) {
59626 130 : ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
59627 130 : if (!SWIG_IsOK(ecode3)) {
59628 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DecToDMS" "', argument " "3"" of type '" "int""'");
59629 : }
59630 : arg3 = static_cast< int >(val3);
59631 : }
59632 130 : {
59633 130 : const int bLocalUseExceptions = GetUseExceptions();
59634 130 : if ( bLocalUseExceptions ) {
59635 0 : pushErrorHandler();
59636 : }
59637 130 : {
59638 130 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59639 130 : result = (char *)GDALDecToDMS(arg1,(char const *)arg2,arg3);
59640 130 : SWIG_PYTHON_THREAD_END_ALLOW;
59641 : }
59642 130 : if ( bLocalUseExceptions ) {
59643 0 : popErrorHandler();
59644 : }
59645 : #ifndef SED_HACKS
59646 : if ( bLocalUseExceptions ) {
59647 : CPLErr eclass = CPLGetLastErrorType();
59648 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59649 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59650 : }
59651 : }
59652 : #endif
59653 : }
59654 130 : resultobj = SWIG_FromCharPtr((const char *)result);
59655 130 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
59656 130 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59657 : return resultobj;
59658 0 : fail:
59659 0 : if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
59660 : return NULL;
59661 : }
59662 :
59663 :
59664 4 : SWIGINTERN PyObject *_wrap_PackedDMSToDec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59665 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59666 4 : double arg1 ;
59667 4 : double val1 ;
59668 4 : int ecode1 = 0 ;
59669 4 : PyObject *swig_obj[1] ;
59670 4 : double result;
59671 :
59672 4 : if (!args) SWIG_fail;
59673 4 : swig_obj[0] = args;
59674 4 : ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
59675 4 : if (!SWIG_IsOK(ecode1)) {
59676 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PackedDMSToDec" "', argument " "1"" of type '" "double""'");
59677 : }
59678 4 : arg1 = static_cast< double >(val1);
59679 4 : {
59680 4 : const int bLocalUseExceptions = GetUseExceptions();
59681 4 : if ( bLocalUseExceptions ) {
59682 4 : pushErrorHandler();
59683 : }
59684 4 : {
59685 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59686 4 : result = (double)GDALPackedDMSToDec(arg1);
59687 4 : SWIG_PYTHON_THREAD_END_ALLOW;
59688 : }
59689 4 : if ( bLocalUseExceptions ) {
59690 4 : popErrorHandler();
59691 : }
59692 : #ifndef SED_HACKS
59693 : if ( bLocalUseExceptions ) {
59694 : CPLErr eclass = CPLGetLastErrorType();
59695 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59696 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59697 : }
59698 : }
59699 : #endif
59700 : }
59701 4 : resultobj = SWIG_From_double(static_cast< double >(result));
59702 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59703 : return resultobj;
59704 : fail:
59705 : return NULL;
59706 : }
59707 :
59708 :
59709 4 : SWIGINTERN PyObject *_wrap_DecToPackedDMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59710 4 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59711 4 : double arg1 ;
59712 4 : double val1 ;
59713 4 : int ecode1 = 0 ;
59714 4 : PyObject *swig_obj[1] ;
59715 4 : double result;
59716 :
59717 4 : if (!args) SWIG_fail;
59718 4 : swig_obj[0] = args;
59719 4 : ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
59720 4 : if (!SWIG_IsOK(ecode1)) {
59721 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DecToPackedDMS" "', argument " "1"" of type '" "double""'");
59722 : }
59723 4 : arg1 = static_cast< double >(val1);
59724 4 : {
59725 4 : const int bLocalUseExceptions = GetUseExceptions();
59726 4 : if ( bLocalUseExceptions ) {
59727 4 : pushErrorHandler();
59728 : }
59729 4 : {
59730 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59731 4 : result = (double)GDALDecToPackedDMS(arg1);
59732 4 : SWIG_PYTHON_THREAD_END_ALLOW;
59733 : }
59734 4 : if ( bLocalUseExceptions ) {
59735 4 : popErrorHandler();
59736 : }
59737 : #ifndef SED_HACKS
59738 : if ( bLocalUseExceptions ) {
59739 : CPLErr eclass = CPLGetLastErrorType();
59740 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59741 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59742 : }
59743 : }
59744 : #endif
59745 : }
59746 4 : resultobj = SWIG_From_double(static_cast< double >(result));
59747 4 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59748 : return resultobj;
59749 : fail:
59750 : return NULL;
59751 : }
59752 :
59753 :
59754 49 : SWIGINTERN PyObject *_wrap_ParseXMLString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59755 49 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59756 49 : char *arg1 = (char *) 0 ;
59757 49 : int res1 ;
59758 49 : char *buf1 = 0 ;
59759 49 : int alloc1 = 0 ;
59760 49 : PyObject *swig_obj[1] ;
59761 49 : CPLXMLNode *result = 0 ;
59762 :
59763 49 : if (!args) SWIG_fail;
59764 49 : swig_obj[0] = args;
59765 49 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
59766 49 : if (!SWIG_IsOK(res1)) {
59767 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParseXMLString" "', argument " "1"" of type '" "char *""'");
59768 : }
59769 49 : arg1 = reinterpret_cast< char * >(buf1);
59770 49 : {
59771 49 : const int bLocalUseExceptions = GetUseExceptions();
59772 49 : if ( bLocalUseExceptions ) {
59773 24 : pushErrorHandler();
59774 : }
59775 49 : {
59776 49 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59777 49 : result = (CPLXMLNode *)CPLParseXMLString(arg1);
59778 49 : SWIG_PYTHON_THREAD_END_ALLOW;
59779 : }
59780 49 : if ( bLocalUseExceptions ) {
59781 24 : popErrorHandler();
59782 : }
59783 : #ifndef SED_HACKS
59784 : if ( bLocalUseExceptions ) {
59785 : CPLErr eclass = CPLGetLastErrorType();
59786 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59787 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59788 : }
59789 : }
59790 : #endif
59791 : }
59792 49 : {
59793 : /* %typemap(out) (CPLXMLNode*) */
59794 :
59795 49 : CPLXMLNode *psXMLTree = result;
59796 49 : int bFakeRoot = FALSE;
59797 :
59798 49 : if( psXMLTree != NULL && psXMLTree->psNext != NULL )
59799 : {
59800 3 : CPLXMLNode *psFirst = psXMLTree;
59801 :
59802 : /* create a "pseudo" root if we have multiple elements */
59803 3 : psXMLTree = CPLCreateXMLNode( NULL, CXT_Element, "" );
59804 3 : psXMLTree->psChild = psFirst;
59805 3 : bFakeRoot = TRUE;
59806 : }
59807 :
59808 49 : resultobj = XMLTreeToPyList( psXMLTree );
59809 :
59810 49 : if( bFakeRoot )
59811 : {
59812 3 : psXMLTree->psChild = NULL;
59813 3 : CPLDestroyXMLNode( psXMLTree );
59814 : }
59815 : }
59816 49 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
59817 49 : {
59818 : /* %typemap(ret) (CPLXMLNode*) */
59819 49 : if ( result ) CPLDestroyXMLNode( result );
59820 : }
59821 75 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59822 : return resultobj;
59823 0 : fail:
59824 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
59825 : return NULL;
59826 : }
59827 :
59828 :
59829 13 : SWIGINTERN PyObject *_wrap_SerializeXMLTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59830 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59831 13 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
59832 13 : PyObject *swig_obj[1] ;
59833 13 : retStringAndCPLFree *result = 0 ;
59834 :
59835 13 : if (!args) SWIG_fail;
59836 13 : swig_obj[0] = args;
59837 13 : {
59838 : /* %typemap(python,in) (CPLXMLNode* xmlnode ) */
59839 13 : arg1 = PyListToXMLTree( swig_obj[0] );
59840 13 : if ( !arg1 ) SWIG_fail;
59841 : }
59842 13 : {
59843 13 : const int bLocalUseExceptions = GetUseExceptions();
59844 13 : if ( bLocalUseExceptions ) {
59845 3 : pushErrorHandler();
59846 : }
59847 13 : {
59848 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59849 13 : result = (retStringAndCPLFree *)CPLSerializeXMLTree(arg1);
59850 13 : SWIG_PYTHON_THREAD_END_ALLOW;
59851 : }
59852 13 : if ( bLocalUseExceptions ) {
59853 3 : popErrorHandler();
59854 : }
59855 : #ifndef SED_HACKS
59856 : if ( bLocalUseExceptions ) {
59857 : CPLErr eclass = CPLGetLastErrorType();
59858 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59859 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59860 : }
59861 : }
59862 : #endif
59863 : }
59864 13 : {
59865 : /* %typemap(out) (retStringAndCPLFree*) */
59866 13 : Py_XDECREF(resultobj);
59867 13 : if(result)
59868 : {
59869 13 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
59870 13 : CPLFree(result);
59871 : }
59872 : else
59873 : {
59874 0 : resultobj = Py_None;
59875 0 : Py_INCREF(resultobj);
59876 : }
59877 : }
59878 13 : {
59879 : /* %typemap(freearg) (CPLXMLNode *xmlnode) */
59880 13 : CPLDestroyXMLNode( arg1 );
59881 : }
59882 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59883 : return resultobj;
59884 0 : fail:
59885 0 : {
59886 : /* %typemap(freearg) (CPLXMLNode *xmlnode) */
59887 0 : CPLDestroyXMLNode( arg1 );
59888 : }
59889 : return NULL;
59890 : }
59891 :
59892 :
59893 30 : SWIGINTERN PyObject *_wrap_GetJPEG2000Structure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
59894 30 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
59895 30 : char *arg1 = (char *) 0 ;
59896 30 : char **arg2 = (char **) NULL ;
59897 30 : int res1 ;
59898 30 : char *buf1 = 0 ;
59899 30 : int alloc1 = 0 ;
59900 30 : PyObject *swig_obj[2] ;
59901 30 : CPLXMLNode *result = 0 ;
59902 :
59903 30 : if (!SWIG_Python_UnpackTuple(args, "GetJPEG2000Structure", 1, 2, swig_obj)) SWIG_fail;
59904 30 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
59905 30 : if (!SWIG_IsOK(res1)) {
59906 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetJPEG2000Structure" "', argument " "1"" of type '" "char const *""'");
59907 : }
59908 30 : arg1 = reinterpret_cast< char * >(buf1);
59909 30 : if (swig_obj[1]) {
59910 30 : {
59911 : /* %typemap(in) char **dict */
59912 30 : arg2 = NULL;
59913 30 : if ( PySequence_Check( swig_obj[1] ) ) {
59914 30 : int bErr = FALSE;
59915 30 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
59916 30 : if ( bErr )
59917 : {
59918 0 : SWIG_fail;
59919 : }
59920 : }
59921 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
59922 0 : int bErr = FALSE;
59923 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
59924 0 : if ( bErr )
59925 : {
59926 0 : SWIG_fail;
59927 : }
59928 : }
59929 : else {
59930 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
59931 0 : SWIG_fail;
59932 : }
59933 : }
59934 : }
59935 30 : {
59936 30 : const int bLocalUseExceptions = GetUseExceptions();
59937 30 : if ( bLocalUseExceptions ) {
59938 0 : pushErrorHandler();
59939 : }
59940 30 : {
59941 30 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
59942 30 : result = (CPLXMLNode *)GDALGetJPEG2000Structure((char const *)arg1,arg2);
59943 30 : SWIG_PYTHON_THREAD_END_ALLOW;
59944 : }
59945 30 : if ( bLocalUseExceptions ) {
59946 0 : popErrorHandler();
59947 : }
59948 : #ifndef SED_HACKS
59949 : if ( bLocalUseExceptions ) {
59950 : CPLErr eclass = CPLGetLastErrorType();
59951 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
59952 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
59953 : }
59954 : }
59955 : #endif
59956 : }
59957 30 : {
59958 : /* %typemap(out) (CPLXMLNode*) */
59959 :
59960 30 : CPLXMLNode *psXMLTree = result;
59961 30 : int bFakeRoot = FALSE;
59962 :
59963 30 : if( psXMLTree != NULL && psXMLTree->psNext != NULL )
59964 : {
59965 0 : CPLXMLNode *psFirst = psXMLTree;
59966 :
59967 : /* create a "pseudo" root if we have multiple elements */
59968 0 : psXMLTree = CPLCreateXMLNode( NULL, CXT_Element, "" );
59969 0 : psXMLTree->psChild = psFirst;
59970 0 : bFakeRoot = TRUE;
59971 : }
59972 :
59973 30 : resultobj = XMLTreeToPyList( psXMLTree );
59974 :
59975 30 : if( bFakeRoot )
59976 : {
59977 0 : psXMLTree->psChild = NULL;
59978 0 : CPLDestroyXMLNode( psXMLTree );
59979 : }
59980 : }
59981 30 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
59982 30 : {
59983 : /* %typemap(freearg) char **dict */
59984 30 : CSLDestroy( arg2 );
59985 : }
59986 30 : {
59987 : /* %typemap(ret) (CPLXMLNode*) */
59988 30 : if ( result ) CPLDestroyXMLNode( result );
59989 : }
59990 30 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
59991 : return resultobj;
59992 0 : fail:
59993 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
59994 0 : {
59995 : /* %typemap(freearg) char **dict */
59996 0 : CSLDestroy( arg2 );
59997 : }
59998 : return NULL;
59999 : }
60000 :
60001 :
60002 9 : SWIGINTERN PyObject *_wrap_GetJPEG2000StructureAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
60003 9 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
60004 9 : char *arg1 = (char *) 0 ;
60005 9 : char **arg2 = (char **) NULL ;
60006 9 : int res1 ;
60007 9 : char *buf1 = 0 ;
60008 9 : int alloc1 = 0 ;
60009 9 : PyObject *swig_obj[2] ;
60010 9 : retStringAndCPLFree *result = 0 ;
60011 :
60012 9 : if (!SWIG_Python_UnpackTuple(args, "GetJPEG2000StructureAsString", 1, 2, swig_obj)) SWIG_fail;
60013 9 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
60014 9 : if (!SWIG_IsOK(res1)) {
60015 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetJPEG2000StructureAsString" "', argument " "1"" of type '" "char const *""'");
60016 : }
60017 9 : arg1 = reinterpret_cast< char * >(buf1);
60018 9 : if (swig_obj[1]) {
60019 9 : {
60020 : /* %typemap(in) char **dict */
60021 9 : arg2 = NULL;
60022 9 : if ( PySequence_Check( swig_obj[1] ) ) {
60023 9 : int bErr = FALSE;
60024 9 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
60025 9 : if ( bErr )
60026 : {
60027 0 : SWIG_fail;
60028 : }
60029 : }
60030 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
60031 0 : int bErr = FALSE;
60032 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
60033 0 : if ( bErr )
60034 : {
60035 0 : SWIG_fail;
60036 : }
60037 : }
60038 : else {
60039 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
60040 0 : SWIG_fail;
60041 : }
60042 : }
60043 : }
60044 9 : {
60045 9 : const int bLocalUseExceptions = GetUseExceptions();
60046 9 : if ( bLocalUseExceptions ) {
60047 5 : pushErrorHandler();
60048 : }
60049 9 : {
60050 9 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
60051 9 : result = (retStringAndCPLFree *)GetJPEG2000StructureAsString((char const *)arg1,arg2);
60052 9 : SWIG_PYTHON_THREAD_END_ALLOW;
60053 : }
60054 9 : if ( bLocalUseExceptions ) {
60055 5 : popErrorHandler();
60056 : }
60057 : #ifndef SED_HACKS
60058 : if ( bLocalUseExceptions ) {
60059 : CPLErr eclass = CPLGetLastErrorType();
60060 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
60061 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
60062 : }
60063 : }
60064 : #endif
60065 : }
60066 9 : {
60067 : /* %typemap(out) (retStringAndCPLFree*) */
60068 9 : Py_XDECREF(resultobj);
60069 9 : if(result)
60070 : {
60071 9 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
60072 9 : CPLFree(result);
60073 : }
60074 : else
60075 : {
60076 0 : resultobj = Py_None;
60077 0 : Py_INCREF(resultobj);
60078 : }
60079 : }
60080 9 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
60081 9 : {
60082 : /* %typemap(freearg) char **dict */
60083 9 : CSLDestroy( arg2 );
60084 : }
60085 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
60086 : return resultobj;
60087 0 : fail:
60088 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
60089 0 : {
60090 : /* %typemap(freearg) char **dict */
60091 0 : CSLDestroy( arg2 );
60092 : }
60093 : return NULL;
60094 : }
60095 :
60096 :
60097 6 : SWIGINTERN PyObject *_wrap_HasTriangulation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
60098 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
60099 6 : int result;
60100 :
60101 6 : if (!SWIG_Python_UnpackTuple(args, "HasTriangulation", 0, 0, 0)) SWIG_fail;
60102 6 : {
60103 6 : const int bLocalUseExceptions = GetUseExceptions();
60104 6 : if ( bLocalUseExceptions ) {
60105 6 : pushErrorHandler();
60106 : }
60107 6 : {
60108 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
60109 6 : result = (int)GDALHasTriangulation();
60110 6 : SWIG_PYTHON_THREAD_END_ALLOW;
60111 : }
60112 6 : if ( bLocalUseExceptions ) {
60113 6 : popErrorHandler();
60114 : }
60115 : #ifndef SED_HACKS
60116 : if ( bLocalUseExceptions ) {
60117 : CPLErr eclass = CPLGetLastErrorType();
60118 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
60119 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
60120 : }
60121 : }
60122 : #endif
60123 : }
60124 6 : resultobj = SWIG_From_int(static_cast< int >(result));
60125 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
60126 : return resultobj;
60127 0 : fail:
60128 0 : return NULL;
60129 : }
60130 :
60131 :
60132 373 : SWIGINTERN PyObject *_wrap_GetDriverCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
60133 373 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
60134 373 : int result;
60135 :
60136 373 : if (!SWIG_Python_UnpackTuple(args, "GetDriverCount", 0, 0, 0)) SWIG_fail;
60137 373 : {
60138 373 : const int bLocalUseExceptions = GetUseExceptions();
60139 373 : if ( bLocalUseExceptions ) {
60140 303 : pushErrorHandler();
60141 : }
60142 373 : {
60143 373 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
60144 373 : result = (int)GetDriverCount();
60145 373 : SWIG_PYTHON_THREAD_END_ALLOW;
60146 : }
60147 373 : if ( bLocalUseExceptions ) {
60148 303 : popErrorHandler();
60149 : }
60150 : #ifndef SED_HACKS
60151 : if ( bLocalUseExceptions ) {
60152 : CPLErr eclass = CPLGetLastErrorType();
60153 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
60154 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
60155 : }
60156 : }
60157 : #endif
60158 : }
60159 373 : resultobj = SWIG_From_int(static_cast< int >(result));
60160 373 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
60161 : return resultobj;
60162 0 : fail:
60163 0 : return NULL;
60164 : }
60165 :
60166 :
60167 16285 : SWIGINTERN PyObject *_wrap_GetDriverByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
60168 16285 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
60169 16285 : char *arg1 = (char *) 0 ;
60170 16285 : int res1 ;
60171 16285 : char *buf1 = 0 ;
60172 16285 : int alloc1 = 0 ;
60173 16285 : PyObject *swig_obj[1] ;
60174 16285 : GDALDriverShadow *result = 0 ;
60175 :
60176 16285 : if (!args) SWIG_fail;
60177 16285 : swig_obj[0] = args;
60178 16285 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
60179 16285 : if (!SWIG_IsOK(res1)) {
60180 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDriverByName" "', argument " "1"" of type '" "char const *""'");
60181 : }
60182 16285 : arg1 = reinterpret_cast< char * >(buf1);
60183 16285 : {
60184 16285 : if (!arg1) {
60185 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
60186 : }
60187 : }
60188 16285 : {
60189 16285 : const int bLocalUseExceptions = GetUseExceptions();
60190 16285 : if ( bLocalUseExceptions ) {
60191 10226 : pushErrorHandler();
60192 : }
60193 16285 : {
60194 16285 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
60195 16285 : result = (GDALDriverShadow *)GetDriverByName((char const *)arg1);
60196 16285 : SWIG_PYTHON_THREAD_END_ALLOW;
60197 : }
60198 16285 : if ( bLocalUseExceptions ) {
60199 10226 : popErrorHandler();
60200 : }
60201 : #ifndef SED_HACKS
60202 : if ( bLocalUseExceptions ) {
60203 : CPLErr eclass = CPLGetLastErrorType();
60204 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
60205 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
60206 : }
60207 : }
60208 : #endif
60209 : }
60210 16285 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
60211 16285 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
60212 16285 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
60213 : return resultobj;
60214 0 : fail:
60215 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
60216 : return NULL;
60217 : }
60218 :
60219 :
60220 82228 : SWIGINTERN PyObject *_wrap_GetDriver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
60221 82228 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
60222 82228 : int arg1 ;
60223 82228 : int val1 ;
60224 82228 : int ecode1 = 0 ;
60225 82228 : PyObject *swig_obj[1] ;
60226 82228 : GDALDriverShadow *result = 0 ;
60227 :
60228 82228 : if (!args) SWIG_fail;
60229 82228 : swig_obj[0] = args;
60230 82228 : ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
60231 82228 : if (!SWIG_IsOK(ecode1)) {
60232 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetDriver" "', argument " "1"" of type '" "int""'");
60233 : }
60234 82228 : arg1 = static_cast< int >(val1);
60235 82228 : {
60236 82228 : const int bLocalUseExceptions = GetUseExceptions();
60237 82228 : if ( bLocalUseExceptions ) {
60238 67621 : pushErrorHandler();
60239 : }
60240 82228 : {
60241 82228 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
60242 82228 : result = (GDALDriverShadow *)GetDriver(arg1);
60243 82228 : SWIG_PYTHON_THREAD_END_ALLOW;
60244 : }
60245 82228 : if ( bLocalUseExceptions ) {
60246 67621 : popErrorHandler();
60247 : }
60248 : #ifndef SED_HACKS
60249 : if ( bLocalUseExceptions ) {
60250 : CPLErr eclass = CPLGetLastErrorType();
60251 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
60252 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
60253 : }
60254 : }
60255 : #endif
60256 : }
60257 82228 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
60258 82228 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
60259 : return resultobj;
60260 : fail:
60261 : return NULL;
60262 : }
60263 :
60264 :
60265 23473 : SWIGINTERN PyObject *_wrap_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
60266 23473 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
60267 23473 : char *arg1 = (char *) 0 ;
60268 23473 : GDALAccess arg2 = (GDALAccess) GA_ReadOnly ;
60269 23473 : int bToFree1 = 0 ;
60270 23473 : PyObject *swig_obj[2] ;
60271 23473 : GDALDatasetShadow *result = 0 ;
60272 :
60273 23473 : if (!SWIG_Python_UnpackTuple(args, "Open", 1, 2, swig_obj)) SWIG_fail;
60274 23473 : {
60275 : /* %typemap(in) (const char *utf8_path) */
60276 23473 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
60277 : {
60278 22590 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
60279 : }
60280 : else
60281 : {
60282 883 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
60283 :
60284 : }
60285 23473 : if (arg1 == NULL)
60286 : {
60287 1 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
60288 1 : SWIG_fail;
60289 : }
60290 : }
60291 23472 : if (swig_obj[1]) {
60292 1517 : {
60293 : // %typemap(in) GDALAccess
60294 1517 : int val = 0;
60295 1517 : int ecode = SWIG_AsVal_int(swig_obj[1], &val);
60296 1517 : if (!SWIG_IsOK(ecode)) {
60297 1 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALAccess");
60298 : }
60299 1516 : if( val != GA_ReadOnly && val != GA_Update )
60300 : {
60301 1 : SWIG_exception_fail(SWIG_ValueError, "invalid value for GDALAccess");
60302 : }
60303 : arg2 = static_cast<GDALAccess>(val);
60304 : }
60305 : }
60306 23470 : {
60307 23470 : if (!arg1) {
60308 23470 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
60309 : }
60310 : }
60311 23470 : {
60312 23470 : const int bLocalUseExceptions = GetUseExceptions();
60313 23470 : if ( bLocalUseExceptions ) {
60314 11660 : pushErrorHandler();
60315 : }
60316 23470 : {
60317 23470 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
60318 23470 : result = (GDALDatasetShadow *)Open((char const *)arg1,arg2);
60319 23470 : SWIG_PYTHON_THREAD_END_ALLOW;
60320 : }
60321 23470 : if ( bLocalUseExceptions ) {
60322 11660 : popErrorHandler();
60323 : }
60324 : #ifndef SED_HACKS
60325 : if( result == NULL && bLocalUseExceptions ) {
60326 : CPLErr eclass = CPLGetLastErrorType();
60327 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
60328 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
60329 : }
60330 : }
60331 : #endif
60332 23470 : if( result != NULL && bLocalUseExceptions ) {
60333 : #ifdef SED_HACKS
60334 11368 : bLocalUseExceptionsCode = FALSE;
60335 : #endif
60336 : }
60337 : }
60338 23470 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
60339 23470 : {
60340 : /* %typemap(freearg) (const char *utf8_path) */
60341 23470 : GDALPythonFreeCStr(arg1, bToFree1);
60342 : }
60343 24052 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
60344 : return resultobj;
60345 3 : fail:
60346 3 : {
60347 : /* %typemap(freearg) (const char *utf8_path) */
60348 23475 : GDALPythonFreeCStr(arg1, bToFree1);
60349 : }
60350 : return NULL;
60351 : }
60352 :
60353 :
60354 6658 : SWIGINTERN PyObject *_wrap_OpenEx(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
60355 6658 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
60356 6658 : char *arg1 = (char *) 0 ;
60357 6658 : unsigned int arg2 = (unsigned int) 0 ;
60358 6658 : char **arg3 = (char **) NULL ;
60359 6658 : char **arg4 = (char **) NULL ;
60360 6658 : char **arg5 = (char **) NULL ;
60361 6658 : int bToFree1 = 0 ;
60362 6658 : unsigned int val2 ;
60363 6658 : int ecode2 = 0 ;
60364 6658 : PyObject * obj0 = 0 ;
60365 6658 : PyObject * obj1 = 0 ;
60366 6658 : PyObject * obj2 = 0 ;
60367 6658 : PyObject * obj3 = 0 ;
60368 6658 : PyObject * obj4 = 0 ;
60369 6658 : char * kwnames[] = {
60370 : (char *)"utf8_path", (char *)"nOpenFlags", (char *)"allowed_drivers", (char *)"open_options", (char *)"sibling_files", NULL
60371 : };
60372 6658 : GDALDatasetShadow *result = 0 ;
60373 :
60374 6658 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOO:OpenEx", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
60375 6658 : {
60376 : /* %typemap(in) (const char *utf8_path) */
60377 6658 : if (PyUnicode_Check(obj0) || PyBytes_Check(obj0))
60378 : {
60379 5880 : arg1 = GDALPythonObjectToCStr( obj0, &bToFree1 );
60380 : }
60381 : else
60382 : {
60383 778 : arg1 = GDALPythonPathToCStr(obj0, &bToFree1);
60384 :
60385 : }
60386 6658 : if (arg1 == NULL)
60387 : {
60388 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
60389 0 : SWIG_fail;
60390 : }
60391 : }
60392 6658 : if (obj1) {
60393 3936 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
60394 3936 : if (!SWIG_IsOK(ecode2)) {
60395 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OpenEx" "', argument " "2"" of type '" "unsigned int""'");
60396 : }
60397 : arg2 = static_cast< unsigned int >(val2);
60398 : }
60399 6658 : if (obj2) {
60400 2003 : {
60401 : /* %typemap(in) char **dict */
60402 2003 : arg3 = NULL;
60403 2003 : if ( PySequence_Check( obj2 ) ) {
60404 2003 : int bErr = FALSE;
60405 2003 : arg3 = CSLFromPySequence(obj2, &bErr);
60406 2003 : if ( bErr )
60407 : {
60408 0 : SWIG_fail;
60409 : }
60410 : }
60411 0 : else if ( PyMapping_Check( obj2 ) ) {
60412 0 : int bErr = FALSE;
60413 0 : arg3 = CSLFromPyMapping(obj2, &bErr);
60414 0 : if ( bErr )
60415 : {
60416 0 : SWIG_fail;
60417 : }
60418 : }
60419 : else {
60420 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
60421 0 : SWIG_fail;
60422 : }
60423 : }
60424 : }
60425 6658 : if (obj3) {
60426 2610 : {
60427 : /* %typemap(in) char **dict */
60428 2610 : arg4 = NULL;
60429 2610 : if ( PySequence_Check( obj3 ) ) {
60430 2425 : int bErr = FALSE;
60431 2425 : arg4 = CSLFromPySequence(obj3, &bErr);
60432 2425 : if ( bErr )
60433 : {
60434 0 : SWIG_fail;
60435 : }
60436 : }
60437 185 : else if ( PyMapping_Check( obj3 ) ) {
60438 185 : int bErr = FALSE;
60439 185 : arg4 = CSLFromPyMapping(obj3, &bErr);
60440 185 : if ( bErr )
60441 : {
60442 0 : SWIG_fail;
60443 : }
60444 : }
60445 : else {
60446 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
60447 0 : SWIG_fail;
60448 : }
60449 : }
60450 : }
60451 6658 : if (obj4) {
60452 0 : {
60453 : /* %typemap(in) char **dict */
60454 0 : arg5 = NULL;
60455 0 : if ( PySequence_Check( obj4 ) ) {
60456 0 : int bErr = FALSE;
60457 0 : arg5 = CSLFromPySequence(obj4, &bErr);
60458 0 : if ( bErr )
60459 : {
60460 0 : SWIG_fail;
60461 : }
60462 : }
60463 0 : else if ( PyMapping_Check( obj4 ) ) {
60464 0 : int bErr = FALSE;
60465 0 : arg5 = CSLFromPyMapping(obj4, &bErr);
60466 0 : if ( bErr )
60467 : {
60468 0 : SWIG_fail;
60469 : }
60470 : }
60471 : else {
60472 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
60473 0 : SWIG_fail;
60474 : }
60475 : }
60476 : }
60477 6658 : {
60478 6658 : if (!arg1) {
60479 6658 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
60480 : }
60481 : }
60482 6658 : {
60483 6658 : const int bLocalUseExceptions = GetUseExceptions();
60484 6658 : if ( bLocalUseExceptions ) {
60485 3015 : pushErrorHandler();
60486 : }
60487 6658 : {
60488 6658 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
60489 6658 : result = (GDALDatasetShadow *)OpenEx((char const *)arg1,arg2,arg3,arg4,arg5);
60490 6658 : SWIG_PYTHON_THREAD_END_ALLOW;
60491 : }
60492 6658 : if ( bLocalUseExceptions ) {
60493 3015 : popErrorHandler();
60494 : }
60495 : #ifndef SED_HACKS
60496 : if( result == NULL && bLocalUseExceptions ) {
60497 : CPLErr eclass = CPLGetLastErrorType();
60498 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
60499 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
60500 : }
60501 : }
60502 : #endif
60503 6658 : if( result != NULL && bLocalUseExceptions ) {
60504 : #ifdef SED_HACKS
60505 2631 : bLocalUseExceptionsCode = FALSE;
60506 : #endif
60507 : }
60508 : }
60509 6658 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
60510 6658 : {
60511 : /* %typemap(freearg) (const char *utf8_path) */
60512 6658 : GDALPythonFreeCStr(arg1, bToFree1);
60513 : }
60514 6658 : {
60515 : /* %typemap(freearg) char **dict */
60516 6658 : CSLDestroy( arg3 );
60517 : }
60518 6658 : {
60519 : /* %typemap(freearg) char **dict */
60520 6658 : CSLDestroy( arg4 );
60521 : }
60522 6658 : {
60523 : /* %typemap(freearg) char **dict */
60524 6658 : CSLDestroy( arg5 );
60525 : }
60526 7426 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
60527 : return resultobj;
60528 0 : fail:
60529 0 : {
60530 : /* %typemap(freearg) (const char *utf8_path) */
60531 0 : GDALPythonFreeCStr(arg1, bToFree1);
60532 : }
60533 0 : {
60534 : /* %typemap(freearg) char **dict */
60535 0 : CSLDestroy( arg3 );
60536 : }
60537 0 : {
60538 : /* %typemap(freearg) char **dict */
60539 0 : CSLDestroy( arg4 );
60540 : }
60541 0 : {
60542 : /* %typemap(freearg) char **dict */
60543 0 : CSLDestroy( arg5 );
60544 : }
60545 : return NULL;
60546 : }
60547 :
60548 :
60549 5053 : SWIGINTERN PyObject *_wrap_OpenShared(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
60550 5053 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
60551 5053 : char *arg1 = (char *) 0 ;
60552 5053 : GDALAccess arg2 = (GDALAccess) GA_ReadOnly ;
60553 5053 : int bToFree1 = 0 ;
60554 5053 : PyObject *swig_obj[2] ;
60555 5053 : GDALDatasetShadow *result = 0 ;
60556 :
60557 5053 : if (!SWIG_Python_UnpackTuple(args, "OpenShared", 1, 2, swig_obj)) SWIG_fail;
60558 5053 : {
60559 : /* %typemap(in) (const char *utf8_path) */
60560 5053 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
60561 : {
60562 5053 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
60563 : }
60564 : else
60565 : {
60566 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
60567 :
60568 : }
60569 5053 : if (arg1 == NULL)
60570 : {
60571 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
60572 0 : SWIG_fail;
60573 : }
60574 : }
60575 5053 : if (swig_obj[1]) {
60576 50 : {
60577 : // %typemap(in) GDALAccess
60578 50 : int val = 0;
60579 50 : int ecode = SWIG_AsVal_int(swig_obj[1], &val);
60580 50 : if (!SWIG_IsOK(ecode)) {
60581 0 : SWIG_exception_fail(SWIG_ArgError(ecode), "invalid value for GDALAccess");
60582 : }
60583 50 : if( val != GA_ReadOnly && val != GA_Update )
60584 : {
60585 0 : SWIG_exception_fail(SWIG_ValueError, "invalid value for GDALAccess");
60586 : }
60587 : arg2 = static_cast<GDALAccess>(val);
60588 : }
60589 : }
60590 5053 : {
60591 5053 : if (!arg1) {
60592 5053 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
60593 : }
60594 : }
60595 5053 : {
60596 5053 : const int bLocalUseExceptions = GetUseExceptions();
60597 5053 : if ( bLocalUseExceptions ) {
60598 51 : pushErrorHandler();
60599 : }
60600 5053 : {
60601 5053 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
60602 5053 : result = (GDALDatasetShadow *)OpenShared((char const *)arg1,arg2);
60603 5053 : SWIG_PYTHON_THREAD_END_ALLOW;
60604 : }
60605 5053 : if ( bLocalUseExceptions ) {
60606 51 : popErrorHandler();
60607 : }
60608 : #ifndef SED_HACKS
60609 : if( result == NULL && bLocalUseExceptions ) {
60610 : CPLErr eclass = CPLGetLastErrorType();
60611 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
60612 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
60613 : }
60614 : }
60615 : #endif
60616 5053 : if( result != NULL && bLocalUseExceptions ) {
60617 : #ifdef SED_HACKS
60618 51 : bLocalUseExceptionsCode = FALSE;
60619 : #endif
60620 : }
60621 : }
60622 5053 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
60623 5053 : {
60624 : /* %typemap(freearg) (const char *utf8_path) */
60625 5053 : GDALPythonFreeCStr(arg1, bToFree1);
60626 : }
60627 5053 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
60628 : return resultobj;
60629 0 : fail:
60630 0 : {
60631 : /* %typemap(freearg) (const char *utf8_path) */
60632 5053 : GDALPythonFreeCStr(arg1, bToFree1);
60633 : }
60634 : return NULL;
60635 : }
60636 :
60637 :
60638 11 : SWIGINTERN PyObject *_wrap_IdentifyDriver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
60639 11 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
60640 11 : char *arg1 = (char *) 0 ;
60641 11 : char **arg2 = (char **) NULL ;
60642 11 : int bToFree1 = 0 ;
60643 11 : PyObject *swig_obj[2] ;
60644 11 : GDALDriverShadow *result = 0 ;
60645 :
60646 11 : if (!SWIG_Python_UnpackTuple(args, "IdentifyDriver", 1, 2, swig_obj)) SWIG_fail;
60647 11 : {
60648 : /* %typemap(in) (const char *utf8_path) */
60649 11 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
60650 : {
60651 11 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
60652 : }
60653 : else
60654 : {
60655 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
60656 :
60657 : }
60658 11 : if (arg1 == NULL)
60659 : {
60660 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
60661 0 : SWIG_fail;
60662 : }
60663 : }
60664 11 : if (swig_obj[1]) {
60665 2 : {
60666 : /* %typemap(in) char **dict */
60667 2 : arg2 = NULL;
60668 2 : if ( PySequence_Check( swig_obj[1] ) ) {
60669 2 : int bErr = FALSE;
60670 2 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
60671 2 : if ( bErr )
60672 : {
60673 0 : SWIG_fail;
60674 : }
60675 : }
60676 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
60677 0 : int bErr = FALSE;
60678 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
60679 0 : if ( bErr )
60680 : {
60681 0 : SWIG_fail;
60682 : }
60683 : }
60684 : else {
60685 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
60686 0 : SWIG_fail;
60687 : }
60688 : }
60689 : }
60690 11 : {
60691 11 : if (!arg1) {
60692 11 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
60693 : }
60694 : }
60695 11 : {
60696 11 : const int bLocalUseExceptions = GetUseExceptions();
60697 11 : if ( bLocalUseExceptions ) {
60698 6 : pushErrorHandler();
60699 : }
60700 11 : {
60701 11 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
60702 11 : result = (GDALDriverShadow *)IdentifyDriver((char const *)arg1,arg2);
60703 11 : SWIG_PYTHON_THREAD_END_ALLOW;
60704 : }
60705 11 : if ( bLocalUseExceptions ) {
60706 6 : popErrorHandler();
60707 : }
60708 : #ifndef SED_HACKS
60709 : if ( bLocalUseExceptions ) {
60710 : CPLErr eclass = CPLGetLastErrorType();
60711 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
60712 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
60713 : }
60714 : }
60715 : #endif
60716 : }
60717 11 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
60718 11 : {
60719 : /* %typemap(freearg) (const char *utf8_path) */
60720 11 : GDALPythonFreeCStr(arg1, bToFree1);
60721 : }
60722 11 : {
60723 : /* %typemap(freearg) char **dict */
60724 11 : CSLDestroy( arg2 );
60725 : }
60726 11 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
60727 : return resultobj;
60728 0 : fail:
60729 0 : {
60730 : /* %typemap(freearg) (const char *utf8_path) */
60731 0 : GDALPythonFreeCStr(arg1, bToFree1);
60732 : }
60733 0 : {
60734 : /* %typemap(freearg) char **dict */
60735 0 : CSLDestroy( arg2 );
60736 : }
60737 : return NULL;
60738 : }
60739 :
60740 :
60741 50 : SWIGINTERN PyObject *_wrap_IdentifyDriverEx(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
60742 50 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
60743 50 : char *arg1 = (char *) 0 ;
60744 50 : unsigned int arg2 = (unsigned int) 0 ;
60745 50 : char **arg3 = (char **) NULL ;
60746 50 : char **arg4 = (char **) NULL ;
60747 50 : int bToFree1 = 0 ;
60748 50 : unsigned int val2 ;
60749 50 : int ecode2 = 0 ;
60750 50 : PyObject * obj0 = 0 ;
60751 50 : PyObject * obj1 = 0 ;
60752 50 : PyObject * obj2 = 0 ;
60753 50 : PyObject * obj3 = 0 ;
60754 50 : char * kwnames[] = {
60755 : (char *)"utf8_path", (char *)"nIdentifyFlags", (char *)"allowed_drivers", (char *)"sibling_files", NULL
60756 : };
60757 50 : GDALDriverShadow *result = 0 ;
60758 :
60759 50 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:IdentifyDriverEx", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
60760 50 : {
60761 : /* %typemap(in) (const char *utf8_path) */
60762 50 : if (PyUnicode_Check(obj0) || PyBytes_Check(obj0))
60763 : {
60764 50 : arg1 = GDALPythonObjectToCStr( obj0, &bToFree1 );
60765 : }
60766 : else
60767 : {
60768 0 : arg1 = GDALPythonPathToCStr(obj0, &bToFree1);
60769 :
60770 : }
60771 50 : if (arg1 == NULL)
60772 : {
60773 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
60774 0 : SWIG_fail;
60775 : }
60776 : }
60777 50 : if (obj1) {
60778 3 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
60779 3 : if (!SWIG_IsOK(ecode2)) {
60780 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdentifyDriverEx" "', argument " "2"" of type '" "unsigned int""'");
60781 : }
60782 : arg2 = static_cast< unsigned int >(val2);
60783 : }
60784 50 : if (obj2) {
60785 41 : {
60786 : /* %typemap(in) char **dict */
60787 41 : arg3 = NULL;
60788 41 : if ( PySequence_Check( obj2 ) ) {
60789 41 : int bErr = FALSE;
60790 41 : arg3 = CSLFromPySequence(obj2, &bErr);
60791 41 : if ( bErr )
60792 : {
60793 0 : SWIG_fail;
60794 : }
60795 : }
60796 0 : else if ( PyMapping_Check( obj2 ) ) {
60797 0 : int bErr = FALSE;
60798 0 : arg3 = CSLFromPyMapping(obj2, &bErr);
60799 0 : if ( bErr )
60800 : {
60801 0 : SWIG_fail;
60802 : }
60803 : }
60804 : else {
60805 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
60806 0 : SWIG_fail;
60807 : }
60808 : }
60809 : }
60810 50 : if (obj3) {
60811 2 : {
60812 : /* %typemap(in) char **dict */
60813 2 : arg4 = NULL;
60814 2 : if ( PySequence_Check( obj3 ) ) {
60815 2 : int bErr = FALSE;
60816 2 : arg4 = CSLFromPySequence(obj3, &bErr);
60817 2 : if ( bErr )
60818 : {
60819 0 : SWIG_fail;
60820 : }
60821 : }
60822 0 : else if ( PyMapping_Check( obj3 ) ) {
60823 0 : int bErr = FALSE;
60824 0 : arg4 = CSLFromPyMapping(obj3, &bErr);
60825 0 : if ( bErr )
60826 : {
60827 0 : SWIG_fail;
60828 : }
60829 : }
60830 : else {
60831 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
60832 0 : SWIG_fail;
60833 : }
60834 : }
60835 : }
60836 50 : {
60837 50 : if (!arg1) {
60838 50 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
60839 : }
60840 : }
60841 50 : {
60842 50 : const int bLocalUseExceptions = GetUseExceptions();
60843 50 : if ( bLocalUseExceptions ) {
60844 45 : pushErrorHandler();
60845 : }
60846 50 : {
60847 50 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
60848 50 : result = (GDALDriverShadow *)IdentifyDriverEx((char const *)arg1,arg2,arg3,arg4);
60849 50 : SWIG_PYTHON_THREAD_END_ALLOW;
60850 : }
60851 50 : if ( bLocalUseExceptions ) {
60852 45 : popErrorHandler();
60853 : }
60854 : #ifndef SED_HACKS
60855 : if ( bLocalUseExceptions ) {
60856 : CPLErr eclass = CPLGetLastErrorType();
60857 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
60858 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
60859 : }
60860 : }
60861 : #endif
60862 : }
60863 50 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDriverShadow, 0 | 0 );
60864 50 : {
60865 : /* %typemap(freearg) (const char *utf8_path) */
60866 50 : GDALPythonFreeCStr(arg1, bToFree1);
60867 : }
60868 50 : {
60869 : /* %typemap(freearg) char **dict */
60870 50 : CSLDestroy( arg3 );
60871 : }
60872 50 : {
60873 : /* %typemap(freearg) char **dict */
60874 50 : CSLDestroy( arg4 );
60875 : }
60876 50 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
60877 : return resultobj;
60878 0 : fail:
60879 0 : {
60880 : /* %typemap(freearg) (const char *utf8_path) */
60881 0 : GDALPythonFreeCStr(arg1, bToFree1);
60882 : }
60883 0 : {
60884 : /* %typemap(freearg) char **dict */
60885 0 : CSLDestroy( arg3 );
60886 : }
60887 0 : {
60888 : /* %typemap(freearg) char **dict */
60889 0 : CSLDestroy( arg4 );
60890 : }
60891 : return NULL;
60892 : }
60893 :
60894 :
60895 188 : SWIGINTERN PyObject *_wrap_GeneralCmdLineProcessor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
60896 188 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
60897 188 : char **arg1 = (char **) 0 ;
60898 188 : int arg2 = (int) 0 ;
60899 188 : int val2 ;
60900 188 : int ecode2 = 0 ;
60901 188 : PyObject *swig_obj[2] ;
60902 188 : char **result = 0 ;
60903 :
60904 188 : if (!SWIG_Python_UnpackTuple(args, "GeneralCmdLineProcessor", 1, 2, swig_obj)) SWIG_fail;
60905 188 : {
60906 : /* %typemap(in) char **dict */
60907 188 : arg1 = NULL;
60908 188 : if ( PySequence_Check( swig_obj[0] ) ) {
60909 188 : int bErr = FALSE;
60910 188 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
60911 188 : if ( bErr )
60912 : {
60913 0 : SWIG_fail;
60914 : }
60915 : }
60916 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
60917 0 : int bErr = FALSE;
60918 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
60919 0 : if ( bErr )
60920 : {
60921 0 : SWIG_fail;
60922 : }
60923 : }
60924 : else {
60925 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
60926 0 : SWIG_fail;
60927 : }
60928 : }
60929 188 : if (swig_obj[1]) {
60930 0 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
60931 0 : if (!SWIG_IsOK(ecode2)) {
60932 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeneralCmdLineProcessor" "', argument " "2"" of type '" "int""'");
60933 : }
60934 : arg2 = static_cast< int >(val2);
60935 : }
60936 188 : {
60937 188 : const int bLocalUseExceptions = GetUseExceptions();
60938 188 : if ( bLocalUseExceptions ) {
60939 99 : pushErrorHandler();
60940 : }
60941 188 : {
60942 188 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
60943 188 : result = (char **)GeneralCmdLineProcessor(arg1,arg2);
60944 188 : SWIG_PYTHON_THREAD_END_ALLOW;
60945 : }
60946 188 : if ( bLocalUseExceptions ) {
60947 99 : popErrorHandler();
60948 : }
60949 : #ifndef SED_HACKS
60950 : if ( bLocalUseExceptions ) {
60951 : CPLErr eclass = CPLGetLastErrorType();
60952 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
60953 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
60954 : }
60955 : }
60956 : #endif
60957 : }
60958 188 : {
60959 : /* %typemap(out) char **CSL -> ( string ) */
60960 188 : bool bErr = false;
60961 188 : resultobj = CSLToList(result, &bErr);
60962 188 : CSLDestroy(result);
60963 188 : if( bErr ) {
60964 0 : SWIG_fail;
60965 : }
60966 : }
60967 188 : {
60968 : /* %typemap(freearg) char **dict */
60969 188 : CSLDestroy( arg1 );
60970 : }
60971 188 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
60972 : return resultobj;
60973 0 : fail:
60974 0 : {
60975 : /* %typemap(freearg) char **dict */
60976 0 : CSLDestroy( arg1 );
60977 : }
60978 : return NULL;
60979 : }
60980 :
60981 :
60982 60 : SWIGINTERN PyObject *_wrap_new_GDALInfoOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
60983 60 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
60984 60 : char **arg1 = (char **) 0 ;
60985 60 : PyObject *swig_obj[1] ;
60986 60 : GDALInfoOptions *result = 0 ;
60987 :
60988 60 : if (!args) SWIG_fail;
60989 60 : swig_obj[0] = args;
60990 60 : {
60991 : /* %typemap(in) char **dict */
60992 60 : arg1 = NULL;
60993 60 : if ( PySequence_Check( swig_obj[0] ) ) {
60994 60 : int bErr = FALSE;
60995 60 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
60996 60 : if ( bErr )
60997 : {
60998 0 : SWIG_fail;
60999 : }
61000 : }
61001 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
61002 0 : int bErr = FALSE;
61003 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
61004 0 : if ( bErr )
61005 : {
61006 0 : SWIG_fail;
61007 : }
61008 : }
61009 : else {
61010 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
61011 0 : SWIG_fail;
61012 : }
61013 : }
61014 60 : {
61015 60 : const int bLocalUseExceptions = GetUseExceptions();
61016 60 : if ( bLocalUseExceptions ) {
61017 53 : pushErrorHandler();
61018 : }
61019 60 : {
61020 60 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
61021 60 : result = (GDALInfoOptions *)new_GDALInfoOptions(arg1);
61022 60 : SWIG_PYTHON_THREAD_END_ALLOW;
61023 : }
61024 60 : if ( bLocalUseExceptions ) {
61025 53 : popErrorHandler();
61026 : }
61027 : #ifndef SED_HACKS
61028 : if ( bLocalUseExceptions ) {
61029 : CPLErr eclass = CPLGetLastErrorType();
61030 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
61031 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
61032 : }
61033 : }
61034 : #endif
61035 : }
61036 60 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALInfoOptions, SWIG_POINTER_NEW | 0 );
61037 60 : {
61038 : /* %typemap(freearg) char **dict */
61039 60 : CSLDestroy( arg1 );
61040 : }
61041 60 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
61042 : return resultobj;
61043 0 : fail:
61044 0 : {
61045 : /* %typemap(freearg) char **dict */
61046 0 : CSLDestroy( arg1 );
61047 : }
61048 : return NULL;
61049 : }
61050 :
61051 :
61052 60 : SWIGINTERN PyObject *_wrap_delete_GDALInfoOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61053 60 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
61054 60 : GDALInfoOptions *arg1 = (GDALInfoOptions *) 0 ;
61055 60 : void *argp1 = 0 ;
61056 60 : int res1 = 0 ;
61057 60 : PyObject *swig_obj[1] ;
61058 :
61059 60 : if (!args) SWIG_fail;
61060 60 : swig_obj[0] = args;
61061 60 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALInfoOptions, SWIG_POINTER_DISOWN | 0 );
61062 60 : if (!SWIG_IsOK(res1)) {
61063 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALInfoOptions" "', argument " "1"" of type '" "GDALInfoOptions *""'");
61064 : }
61065 60 : arg1 = reinterpret_cast< GDALInfoOptions * >(argp1);
61066 60 : {
61067 60 : const int bLocalUseExceptions = GetUseExceptions();
61068 60 : if ( bLocalUseExceptions ) {
61069 53 : pushErrorHandler();
61070 : }
61071 60 : {
61072 60 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
61073 60 : delete_GDALInfoOptions(arg1);
61074 60 : SWIG_PYTHON_THREAD_END_ALLOW;
61075 : }
61076 60 : if ( bLocalUseExceptions ) {
61077 53 : popErrorHandler();
61078 : }
61079 : #ifndef SED_HACKS
61080 : if ( bLocalUseExceptions ) {
61081 : CPLErr eclass = CPLGetLastErrorType();
61082 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
61083 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
61084 : }
61085 : }
61086 : #endif
61087 : }
61088 60 : resultobj = SWIG_Py_Void();
61089 60 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
61090 : return resultobj;
61091 : fail:
61092 : return NULL;
61093 : }
61094 :
61095 :
61096 277 : SWIGINTERN PyObject *GDALInfoOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61097 277 : PyObject *obj;
61098 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
61099 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALInfoOptions, SWIG_NewClientData(obj));
61100 277 : return SWIG_Py_Void();
61101 : }
61102 :
61103 60 : SWIGINTERN PyObject *GDALInfoOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61104 60 : return SWIG_Python_InitShadowInstance(args);
61105 : }
61106 :
61107 60 : SWIGINTERN PyObject *_wrap_InfoInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61108 60 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
61109 60 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
61110 60 : GDALInfoOptions *arg2 = (GDALInfoOptions *) 0 ;
61111 60 : void *argp1 = 0 ;
61112 60 : int res1 = 0 ;
61113 60 : void *argp2 = 0 ;
61114 60 : int res2 = 0 ;
61115 60 : PyObject *swig_obj[2] ;
61116 60 : retStringAndCPLFree *result = 0 ;
61117 :
61118 60 : if (!SWIG_Python_UnpackTuple(args, "InfoInternal", 2, 2, swig_obj)) SWIG_fail;
61119 60 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
61120 60 : if (!SWIG_IsOK(res1)) {
61121 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoInternal" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
61122 : }
61123 60 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
61124 60 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALInfoOptions, 0 | 0 );
61125 60 : if (!SWIG_IsOK(res2)) {
61126 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfoInternal" "', argument " "2"" of type '" "GDALInfoOptions *""'");
61127 : }
61128 60 : arg2 = reinterpret_cast< GDALInfoOptions * >(argp2);
61129 60 : {
61130 60 : const int bLocalUseExceptions = GetUseExceptions();
61131 60 : if ( bLocalUseExceptions ) {
61132 53 : pushErrorHandler();
61133 : }
61134 60 : {
61135 60 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
61136 60 : result = (retStringAndCPLFree *)GDALInfo(arg1,arg2);
61137 60 : SWIG_PYTHON_THREAD_END_ALLOW;
61138 : }
61139 60 : if ( bLocalUseExceptions ) {
61140 53 : popErrorHandler();
61141 : }
61142 : #ifndef SED_HACKS
61143 : if ( bLocalUseExceptions ) {
61144 : CPLErr eclass = CPLGetLastErrorType();
61145 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
61146 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
61147 : }
61148 : }
61149 : #endif
61150 : }
61151 60 : {
61152 : /* %typemap(out) (retStringAndCPLFree*) */
61153 60 : Py_XDECREF(resultobj);
61154 60 : if(result)
61155 : {
61156 60 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
61157 60 : CPLFree(result);
61158 : }
61159 : else
61160 : {
61161 0 : resultobj = Py_None;
61162 0 : Py_INCREF(resultobj);
61163 : }
61164 : }
61165 60 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
61166 : return resultobj;
61167 : fail:
61168 : return NULL;
61169 : }
61170 :
61171 :
61172 36 : SWIGINTERN PyObject *_wrap_new_GDALVectorInfoOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61173 36 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
61174 36 : char **arg1 = (char **) 0 ;
61175 36 : PyObject *swig_obj[1] ;
61176 36 : GDALVectorInfoOptions *result = 0 ;
61177 :
61178 36 : if (!args) SWIG_fail;
61179 36 : swig_obj[0] = args;
61180 36 : {
61181 : /* %typemap(in) char **dict */
61182 36 : arg1 = NULL;
61183 36 : if ( PySequence_Check( swig_obj[0] ) ) {
61184 36 : int bErr = FALSE;
61185 36 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
61186 36 : if ( bErr )
61187 : {
61188 0 : SWIG_fail;
61189 : }
61190 : }
61191 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
61192 0 : int bErr = FALSE;
61193 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
61194 0 : if ( bErr )
61195 : {
61196 0 : SWIG_fail;
61197 : }
61198 : }
61199 : else {
61200 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
61201 0 : SWIG_fail;
61202 : }
61203 : }
61204 36 : {
61205 36 : const int bLocalUseExceptions = GetUseExceptions();
61206 36 : if ( bLocalUseExceptions ) {
61207 35 : pushErrorHandler();
61208 : }
61209 36 : {
61210 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
61211 36 : result = (GDALVectorInfoOptions *)new_GDALVectorInfoOptions(arg1);
61212 36 : SWIG_PYTHON_THREAD_END_ALLOW;
61213 : }
61214 36 : if ( bLocalUseExceptions ) {
61215 35 : popErrorHandler();
61216 : }
61217 : #ifndef SED_HACKS
61218 : if ( bLocalUseExceptions ) {
61219 : CPLErr eclass = CPLGetLastErrorType();
61220 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
61221 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
61222 : }
61223 : }
61224 : #endif
61225 : }
61226 36 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALVectorInfoOptions, SWIG_POINTER_NEW | 0 );
61227 36 : {
61228 : /* %typemap(freearg) char **dict */
61229 36 : CSLDestroy( arg1 );
61230 : }
61231 36 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
61232 : return resultobj;
61233 0 : fail:
61234 0 : {
61235 : /* %typemap(freearg) char **dict */
61236 0 : CSLDestroy( arg1 );
61237 : }
61238 : return NULL;
61239 : }
61240 :
61241 :
61242 36 : SWIGINTERN PyObject *_wrap_delete_GDALVectorInfoOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61243 36 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
61244 36 : GDALVectorInfoOptions *arg1 = (GDALVectorInfoOptions *) 0 ;
61245 36 : void *argp1 = 0 ;
61246 36 : int res1 = 0 ;
61247 36 : PyObject *swig_obj[1] ;
61248 :
61249 36 : if (!args) SWIG_fail;
61250 36 : swig_obj[0] = args;
61251 36 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALVectorInfoOptions, SWIG_POINTER_DISOWN | 0 );
61252 36 : if (!SWIG_IsOK(res1)) {
61253 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALVectorInfoOptions" "', argument " "1"" of type '" "GDALVectorInfoOptions *""'");
61254 : }
61255 36 : arg1 = reinterpret_cast< GDALVectorInfoOptions * >(argp1);
61256 36 : {
61257 36 : const int bLocalUseExceptions = GetUseExceptions();
61258 36 : if ( bLocalUseExceptions ) {
61259 35 : pushErrorHandler();
61260 : }
61261 36 : {
61262 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
61263 36 : delete_GDALVectorInfoOptions(arg1);
61264 36 : SWIG_PYTHON_THREAD_END_ALLOW;
61265 : }
61266 36 : if ( bLocalUseExceptions ) {
61267 35 : popErrorHandler();
61268 : }
61269 : #ifndef SED_HACKS
61270 : if ( bLocalUseExceptions ) {
61271 : CPLErr eclass = CPLGetLastErrorType();
61272 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
61273 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
61274 : }
61275 : }
61276 : #endif
61277 : }
61278 36 : resultobj = SWIG_Py_Void();
61279 36 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
61280 : return resultobj;
61281 : fail:
61282 : return NULL;
61283 : }
61284 :
61285 :
61286 277 : SWIGINTERN PyObject *GDALVectorInfoOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61287 277 : PyObject *obj;
61288 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
61289 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALVectorInfoOptions, SWIG_NewClientData(obj));
61290 277 : return SWIG_Py_Void();
61291 : }
61292 :
61293 36 : SWIGINTERN PyObject *GDALVectorInfoOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61294 36 : return SWIG_Python_InitShadowInstance(args);
61295 : }
61296 :
61297 36 : SWIGINTERN PyObject *_wrap_VectorInfoInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61298 36 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
61299 36 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
61300 36 : GDALVectorInfoOptions *arg2 = (GDALVectorInfoOptions *) 0 ;
61301 36 : void *argp1 = 0 ;
61302 36 : int res1 = 0 ;
61303 36 : void *argp2 = 0 ;
61304 36 : int res2 = 0 ;
61305 36 : PyObject *swig_obj[2] ;
61306 36 : retStringAndCPLFree *result = 0 ;
61307 :
61308 36 : if (!SWIG_Python_UnpackTuple(args, "VectorInfoInternal", 2, 2, swig_obj)) SWIG_fail;
61309 36 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
61310 36 : if (!SWIG_IsOK(res1)) {
61311 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInfoInternal" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
61312 : }
61313 36 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
61314 36 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALVectorInfoOptions, 0 | 0 );
61315 36 : if (!SWIG_IsOK(res2)) {
61316 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInfoInternal" "', argument " "2"" of type '" "GDALVectorInfoOptions *""'");
61317 : }
61318 36 : arg2 = reinterpret_cast< GDALVectorInfoOptions * >(argp2);
61319 36 : {
61320 36 : const int bLocalUseExceptions = GetUseExceptions();
61321 36 : if ( bLocalUseExceptions ) {
61322 35 : pushErrorHandler();
61323 : }
61324 36 : {
61325 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
61326 36 : result = (retStringAndCPLFree *)GDALVectorInfo(arg1,arg2);
61327 36 : SWIG_PYTHON_THREAD_END_ALLOW;
61328 : }
61329 36 : if ( bLocalUseExceptions ) {
61330 35 : popErrorHandler();
61331 : }
61332 : #ifndef SED_HACKS
61333 : if ( bLocalUseExceptions ) {
61334 : CPLErr eclass = CPLGetLastErrorType();
61335 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
61336 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
61337 : }
61338 : }
61339 : #endif
61340 : }
61341 36 : {
61342 : /* %typemap(out) (retStringAndCPLFree*) */
61343 36 : Py_XDECREF(resultobj);
61344 36 : if(result)
61345 : {
61346 35 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
61347 35 : CPLFree(result);
61348 : }
61349 : else
61350 : {
61351 1 : resultobj = Py_None;
61352 1 : Py_INCREF(resultobj);
61353 : }
61354 : }
61355 38 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
61356 : return resultobj;
61357 : fail:
61358 : return NULL;
61359 : }
61360 :
61361 :
61362 28 : SWIGINTERN PyObject *_wrap_new_GDALMultiDimInfoOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61363 28 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
61364 28 : char **arg1 = (char **) 0 ;
61365 28 : PyObject *swig_obj[1] ;
61366 28 : GDALMultiDimInfoOptions *result = 0 ;
61367 :
61368 28 : if (!args) SWIG_fail;
61369 28 : swig_obj[0] = args;
61370 28 : {
61371 : /* %typemap(in) char **dict */
61372 28 : arg1 = NULL;
61373 28 : if ( PySequence_Check( swig_obj[0] ) ) {
61374 28 : int bErr = FALSE;
61375 28 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
61376 28 : if ( bErr )
61377 : {
61378 0 : SWIG_fail;
61379 : }
61380 : }
61381 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
61382 0 : int bErr = FALSE;
61383 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
61384 0 : if ( bErr )
61385 : {
61386 0 : SWIG_fail;
61387 : }
61388 : }
61389 : else {
61390 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
61391 0 : SWIG_fail;
61392 : }
61393 : }
61394 28 : {
61395 28 : const int bLocalUseExceptions = GetUseExceptions();
61396 28 : if ( bLocalUseExceptions ) {
61397 22 : pushErrorHandler();
61398 : }
61399 28 : {
61400 28 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
61401 28 : result = (GDALMultiDimInfoOptions *)new_GDALMultiDimInfoOptions(arg1);
61402 28 : SWIG_PYTHON_THREAD_END_ALLOW;
61403 : }
61404 28 : if ( bLocalUseExceptions ) {
61405 22 : popErrorHandler();
61406 : }
61407 : #ifndef SED_HACKS
61408 : if ( bLocalUseExceptions ) {
61409 : CPLErr eclass = CPLGetLastErrorType();
61410 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
61411 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
61412 : }
61413 : }
61414 : #endif
61415 : }
61416 28 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMultiDimInfoOptions, SWIG_POINTER_NEW | 0 );
61417 28 : {
61418 : /* %typemap(freearg) char **dict */
61419 28 : CSLDestroy( arg1 );
61420 : }
61421 28 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
61422 : return resultobj;
61423 0 : fail:
61424 0 : {
61425 : /* %typemap(freearg) char **dict */
61426 0 : CSLDestroy( arg1 );
61427 : }
61428 : return NULL;
61429 : }
61430 :
61431 :
61432 28 : SWIGINTERN PyObject *_wrap_delete_GDALMultiDimInfoOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61433 28 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
61434 28 : GDALMultiDimInfoOptions *arg1 = (GDALMultiDimInfoOptions *) 0 ;
61435 28 : void *argp1 = 0 ;
61436 28 : int res1 = 0 ;
61437 28 : PyObject *swig_obj[1] ;
61438 :
61439 28 : if (!args) SWIG_fail;
61440 28 : swig_obj[0] = args;
61441 28 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMultiDimInfoOptions, SWIG_POINTER_DISOWN | 0 );
61442 28 : if (!SWIG_IsOK(res1)) {
61443 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALMultiDimInfoOptions" "', argument " "1"" of type '" "GDALMultiDimInfoOptions *""'");
61444 : }
61445 28 : arg1 = reinterpret_cast< GDALMultiDimInfoOptions * >(argp1);
61446 28 : {
61447 28 : const int bLocalUseExceptions = GetUseExceptions();
61448 28 : if ( bLocalUseExceptions ) {
61449 22 : pushErrorHandler();
61450 : }
61451 28 : {
61452 28 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
61453 28 : delete_GDALMultiDimInfoOptions(arg1);
61454 28 : SWIG_PYTHON_THREAD_END_ALLOW;
61455 : }
61456 28 : if ( bLocalUseExceptions ) {
61457 22 : popErrorHandler();
61458 : }
61459 : #ifndef SED_HACKS
61460 : if ( bLocalUseExceptions ) {
61461 : CPLErr eclass = CPLGetLastErrorType();
61462 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
61463 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
61464 : }
61465 : }
61466 : #endif
61467 : }
61468 28 : resultobj = SWIG_Py_Void();
61469 28 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
61470 : return resultobj;
61471 : fail:
61472 : return NULL;
61473 : }
61474 :
61475 :
61476 277 : SWIGINTERN PyObject *GDALMultiDimInfoOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61477 277 : PyObject *obj;
61478 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
61479 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALMultiDimInfoOptions, SWIG_NewClientData(obj));
61480 277 : return SWIG_Py_Void();
61481 : }
61482 :
61483 28 : SWIGINTERN PyObject *GDALMultiDimInfoOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61484 28 : return SWIG_Python_InitShadowInstance(args);
61485 : }
61486 :
61487 27 : SWIGINTERN PyObject *_wrap_MultiDimInfoInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61488 27 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
61489 27 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
61490 27 : GDALMultiDimInfoOptions *arg2 = (GDALMultiDimInfoOptions *) 0 ;
61491 27 : void *argp1 = 0 ;
61492 27 : int res1 = 0 ;
61493 27 : void *argp2 = 0 ;
61494 27 : int res2 = 0 ;
61495 27 : PyObject *swig_obj[2] ;
61496 27 : retStringAndCPLFree *result = 0 ;
61497 :
61498 27 : if (!SWIG_Python_UnpackTuple(args, "MultiDimInfoInternal", 2, 2, swig_obj)) SWIG_fail;
61499 27 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
61500 27 : if (!SWIG_IsOK(res1)) {
61501 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiDimInfoInternal" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
61502 : }
61503 27 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
61504 27 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALMultiDimInfoOptions, 0 | 0 );
61505 27 : if (!SWIG_IsOK(res2)) {
61506 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiDimInfoInternal" "', argument " "2"" of type '" "GDALMultiDimInfoOptions *""'");
61507 : }
61508 27 : arg2 = reinterpret_cast< GDALMultiDimInfoOptions * >(argp2);
61509 27 : {
61510 27 : const int bLocalUseExceptions = GetUseExceptions();
61511 27 : if ( bLocalUseExceptions ) {
61512 21 : pushErrorHandler();
61513 : }
61514 27 : {
61515 27 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
61516 27 : result = (retStringAndCPLFree *)GDALMultiDimInfo(arg1,arg2);
61517 27 : SWIG_PYTHON_THREAD_END_ALLOW;
61518 : }
61519 27 : if ( bLocalUseExceptions ) {
61520 21 : popErrorHandler();
61521 : }
61522 : #ifndef SED_HACKS
61523 : if ( bLocalUseExceptions ) {
61524 : CPLErr eclass = CPLGetLastErrorType();
61525 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
61526 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
61527 : }
61528 : }
61529 : #endif
61530 : }
61531 27 : {
61532 : /* %typemap(out) (retStringAndCPLFree*) */
61533 27 : Py_XDECREF(resultobj);
61534 27 : if(result)
61535 : {
61536 26 : resultobj = GDALPythonObjectFromCStr( (const char *)result);
61537 26 : CPLFree(result);
61538 : }
61539 : else
61540 : {
61541 1 : resultobj = Py_None;
61542 1 : Py_INCREF(resultobj);
61543 : }
61544 : }
61545 27 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
61546 : return resultobj;
61547 : fail:
61548 : return NULL;
61549 : }
61550 :
61551 :
61552 2038 : SWIGINTERN PyObject *_wrap_new_GDALTranslateOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61553 2038 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
61554 2038 : char **arg1 = (char **) 0 ;
61555 2038 : PyObject *swig_obj[1] ;
61556 2038 : GDALTranslateOptions *result = 0 ;
61557 :
61558 2038 : if (!args) SWIG_fail;
61559 2038 : swig_obj[0] = args;
61560 2038 : {
61561 : /* %typemap(in) char **dict */
61562 2038 : arg1 = NULL;
61563 2038 : if ( PySequence_Check( swig_obj[0] ) ) {
61564 2038 : int bErr = FALSE;
61565 2038 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
61566 2038 : if ( bErr )
61567 : {
61568 0 : SWIG_fail;
61569 : }
61570 : }
61571 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
61572 0 : int bErr = FALSE;
61573 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
61574 0 : if ( bErr )
61575 : {
61576 0 : SWIG_fail;
61577 : }
61578 : }
61579 : else {
61580 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
61581 0 : SWIG_fail;
61582 : }
61583 : }
61584 2038 : {
61585 2038 : const int bLocalUseExceptions = GetUseExceptions();
61586 2038 : if ( bLocalUseExceptions ) {
61587 906 : pushErrorHandler();
61588 : }
61589 2038 : {
61590 2038 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
61591 2038 : result = (GDALTranslateOptions *)new_GDALTranslateOptions(arg1);
61592 2038 : SWIG_PYTHON_THREAD_END_ALLOW;
61593 : }
61594 2038 : if ( bLocalUseExceptions ) {
61595 906 : popErrorHandler();
61596 : }
61597 : #ifndef SED_HACKS
61598 : if ( bLocalUseExceptions ) {
61599 : CPLErr eclass = CPLGetLastErrorType();
61600 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
61601 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
61602 : }
61603 : }
61604 : #endif
61605 : }
61606 2038 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALTranslateOptions, SWIG_POINTER_NEW | 0 );
61607 2038 : {
61608 : /* %typemap(freearg) char **dict */
61609 2038 : CSLDestroy( arg1 );
61610 : }
61611 2046 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
61612 : return resultobj;
61613 0 : fail:
61614 0 : {
61615 : /* %typemap(freearg) char **dict */
61616 0 : CSLDestroy( arg1 );
61617 : }
61618 : return NULL;
61619 : }
61620 :
61621 :
61622 2034 : SWIGINTERN PyObject *_wrap_delete_GDALTranslateOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61623 2034 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
61624 2034 : GDALTranslateOptions *arg1 = (GDALTranslateOptions *) 0 ;
61625 2034 : void *argp1 = 0 ;
61626 2034 : int res1 = 0 ;
61627 2034 : PyObject *swig_obj[1] ;
61628 :
61629 2034 : if (!args) SWIG_fail;
61630 2034 : swig_obj[0] = args;
61631 2034 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALTranslateOptions, SWIG_POINTER_DISOWN | 0 );
61632 2034 : if (!SWIG_IsOK(res1)) {
61633 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALTranslateOptions" "', argument " "1"" of type '" "GDALTranslateOptions *""'");
61634 : }
61635 2034 : arg1 = reinterpret_cast< GDALTranslateOptions * >(argp1);
61636 2034 : {
61637 2034 : const int bLocalUseExceptions = GetUseExceptions();
61638 2034 : if ( bLocalUseExceptions ) {
61639 902 : pushErrorHandler();
61640 : }
61641 2034 : {
61642 2034 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
61643 2034 : delete_GDALTranslateOptions(arg1);
61644 2034 : SWIG_PYTHON_THREAD_END_ALLOW;
61645 : }
61646 2034 : if ( bLocalUseExceptions ) {
61647 902 : popErrorHandler();
61648 : }
61649 : #ifndef SED_HACKS
61650 : if ( bLocalUseExceptions ) {
61651 : CPLErr eclass = CPLGetLastErrorType();
61652 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
61653 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
61654 : }
61655 : }
61656 : #endif
61657 : }
61658 2034 : resultobj = SWIG_Py_Void();
61659 2034 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
61660 : return resultobj;
61661 : fail:
61662 : return NULL;
61663 : }
61664 :
61665 :
61666 277 : SWIGINTERN PyObject *GDALTranslateOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61667 277 : PyObject *obj;
61668 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
61669 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALTranslateOptions, SWIG_NewClientData(obj));
61670 277 : return SWIG_Py_Void();
61671 : }
61672 :
61673 2034 : SWIGINTERN PyObject *GDALTranslateOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61674 2034 : return SWIG_Python_InitShadowInstance(args);
61675 : }
61676 :
61677 2037 : SWIGINTERN PyObject *_wrap_TranslateInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61678 2037 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
61679 2037 : char *arg1 = (char *) 0 ;
61680 2037 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
61681 2037 : GDALTranslateOptions *arg3 = (GDALTranslateOptions *) 0 ;
61682 2037 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
61683 2037 : void *arg5 = (void *) NULL ;
61684 2037 : int bToFree1 = 0 ;
61685 2037 : void *argp2 = 0 ;
61686 2037 : int res2 = 0 ;
61687 2037 : void *argp3 = 0 ;
61688 2037 : int res3 = 0 ;
61689 2037 : PyObject *swig_obj[5] ;
61690 2037 : GDALDatasetShadow *result = 0 ;
61691 :
61692 : /* %typemap(arginit) ( const char* callback_data=NULL) */
61693 2037 : PyProgressData *psProgressInfo;
61694 2037 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
61695 2037 : psProgressInfo->nLastReported = -1;
61696 2037 : psProgressInfo->psPyCallback = NULL;
61697 2037 : psProgressInfo->psPyCallbackData = NULL;
61698 2037 : arg5 = psProgressInfo;
61699 2037 : if (!SWIG_Python_UnpackTuple(args, "TranslateInternal", 3, 5, swig_obj)) SWIG_fail;
61700 2037 : {
61701 : /* %typemap(in) (const char *utf8_path) */
61702 2037 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
61703 : {
61704 1847 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
61705 : }
61706 : else
61707 : {
61708 190 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
61709 :
61710 : }
61711 2037 : if (arg1 == NULL)
61712 : {
61713 1 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
61714 1 : SWIG_fail;
61715 : }
61716 : }
61717 2036 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
61718 2036 : if (!SWIG_IsOK(res2)) {
61719 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TranslateInternal" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
61720 : }
61721 2036 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
61722 2036 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALTranslateOptions, 0 | 0 );
61723 2036 : if (!SWIG_IsOK(res3)) {
61724 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TranslateInternal" "', argument " "3"" of type '" "GDALTranslateOptions *""'");
61725 : }
61726 2036 : arg3 = reinterpret_cast< GDALTranslateOptions * >(argp3);
61727 2036 : if (swig_obj[3]) {
61728 2035 : {
61729 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
61730 : /* callback_func typemap */
61731 :
61732 : /* In some cases 0 is passed instead of None. */
61733 : /* See https://github.com/OSGeo/gdal/pull/219 */
61734 2035 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
61735 : {
61736 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
61737 : {
61738 0 : swig_obj[3] = Py_None;
61739 : }
61740 : }
61741 :
61742 2035 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
61743 3 : void* cbfunction = NULL;
61744 3 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
61745 : (void**)&cbfunction,
61746 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
61747 : SWIG_POINTER_EXCEPTION | 0 ));
61748 :
61749 3 : if ( cbfunction == GDALTermProgress ) {
61750 : arg4 = GDALTermProgress;
61751 : } else {
61752 3 : if (!PyCallable_Check(swig_obj[3])) {
61753 0 : PyErr_SetString( PyExc_RuntimeError,
61754 : "Object given is not a Python function" );
61755 0 : SWIG_fail;
61756 : }
61757 3 : psProgressInfo->psPyCallback = swig_obj[3];
61758 3 : arg4 = PyProgressProxy;
61759 : }
61760 :
61761 : }
61762 :
61763 : }
61764 : }
61765 2036 : if (swig_obj[4]) {
61766 2034 : {
61767 : /* %typemap(in) ( void* callback_data=NULL) */
61768 2034 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
61769 : }
61770 : }
61771 2036 : {
61772 2036 : if (!arg1) {
61773 2036 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
61774 : }
61775 : }
61776 2036 : {
61777 2036 : if (!arg2) {
61778 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
61779 : }
61780 : }
61781 2036 : {
61782 2036 : const int bLocalUseExceptions = GetUseExceptions();
61783 2036 : if ( bLocalUseExceptions ) {
61784 904 : pushErrorHandler();
61785 : }
61786 2036 : {
61787 2036 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
61788 2036 : result = (GDALDatasetShadow *)wrapper_GDALTranslate((char const *)arg1,arg2,arg3,arg4,arg5);
61789 2036 : SWIG_PYTHON_THREAD_END_ALLOW;
61790 : }
61791 2036 : if ( bLocalUseExceptions ) {
61792 904 : popErrorHandler();
61793 : }
61794 : #ifndef SED_HACKS
61795 : if ( bLocalUseExceptions ) {
61796 : CPLErr eclass = CPLGetLastErrorType();
61797 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
61798 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
61799 : }
61800 : }
61801 : #endif
61802 : }
61803 2036 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
61804 2036 : {
61805 : /* %typemap(freearg) (const char *utf8_path) */
61806 2036 : GDALPythonFreeCStr(arg1, bToFree1);
61807 : }
61808 2036 : {
61809 : /* %typemap(freearg) ( void* callback_data=NULL) */
61810 :
61811 2036 : CPLFree(psProgressInfo);
61812 :
61813 : }
61814 2075 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
61815 : return resultobj;
61816 1 : fail:
61817 1 : {
61818 : /* %typemap(freearg) (const char *utf8_path) */
61819 1 : GDALPythonFreeCStr(arg1, bToFree1);
61820 : }
61821 1 : {
61822 : /* %typemap(freearg) ( void* callback_data=NULL) */
61823 :
61824 1 : CPLFree(psProgressInfo);
61825 :
61826 : }
61827 : return NULL;
61828 : }
61829 :
61830 :
61831 810 : SWIGINTERN PyObject *_wrap_new_GDALWarpAppOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61832 810 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
61833 810 : char **arg1 = (char **) 0 ;
61834 810 : PyObject *swig_obj[1] ;
61835 810 : GDALWarpAppOptions *result = 0 ;
61836 :
61837 810 : if (!args) SWIG_fail;
61838 810 : swig_obj[0] = args;
61839 810 : {
61840 : /* %typemap(in) char **dict */
61841 810 : arg1 = NULL;
61842 810 : if ( PySequence_Check( swig_obj[0] ) ) {
61843 810 : int bErr = FALSE;
61844 810 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
61845 810 : if ( bErr )
61846 : {
61847 0 : SWIG_fail;
61848 : }
61849 : }
61850 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
61851 0 : int bErr = FALSE;
61852 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
61853 0 : if ( bErr )
61854 : {
61855 0 : SWIG_fail;
61856 : }
61857 : }
61858 : else {
61859 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
61860 0 : SWIG_fail;
61861 : }
61862 : }
61863 810 : {
61864 810 : const int bLocalUseExceptions = GetUseExceptions();
61865 810 : if ( bLocalUseExceptions ) {
61866 786 : pushErrorHandler();
61867 : }
61868 810 : {
61869 810 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
61870 810 : result = (GDALWarpAppOptions *)new_GDALWarpAppOptions(arg1);
61871 810 : SWIG_PYTHON_THREAD_END_ALLOW;
61872 : }
61873 810 : if ( bLocalUseExceptions ) {
61874 786 : popErrorHandler();
61875 : }
61876 : #ifndef SED_HACKS
61877 : if ( bLocalUseExceptions ) {
61878 : CPLErr eclass = CPLGetLastErrorType();
61879 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
61880 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
61881 : }
61882 : }
61883 : #endif
61884 : }
61885 810 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALWarpAppOptions, SWIG_POINTER_NEW | 0 );
61886 810 : {
61887 : /* %typemap(freearg) char **dict */
61888 810 : CSLDestroy( arg1 );
61889 : }
61890 814 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
61891 : return resultobj;
61892 0 : fail:
61893 0 : {
61894 : /* %typemap(freearg) char **dict */
61895 0 : CSLDestroy( arg1 );
61896 : }
61897 : return NULL;
61898 : }
61899 :
61900 :
61901 808 : SWIGINTERN PyObject *_wrap_delete_GDALWarpAppOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61902 808 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
61903 808 : GDALWarpAppOptions *arg1 = (GDALWarpAppOptions *) 0 ;
61904 808 : void *argp1 = 0 ;
61905 808 : int res1 = 0 ;
61906 808 : PyObject *swig_obj[1] ;
61907 :
61908 808 : if (!args) SWIG_fail;
61909 808 : swig_obj[0] = args;
61910 808 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALWarpAppOptions, SWIG_POINTER_DISOWN | 0 );
61911 808 : if (!SWIG_IsOK(res1)) {
61912 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALWarpAppOptions" "', argument " "1"" of type '" "GDALWarpAppOptions *""'");
61913 : }
61914 808 : arg1 = reinterpret_cast< GDALWarpAppOptions * >(argp1);
61915 808 : {
61916 808 : const int bLocalUseExceptions = GetUseExceptions();
61917 808 : if ( bLocalUseExceptions ) {
61918 784 : pushErrorHandler();
61919 : }
61920 808 : {
61921 808 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
61922 808 : delete_GDALWarpAppOptions(arg1);
61923 808 : SWIG_PYTHON_THREAD_END_ALLOW;
61924 : }
61925 808 : if ( bLocalUseExceptions ) {
61926 784 : popErrorHandler();
61927 : }
61928 : #ifndef SED_HACKS
61929 : if ( bLocalUseExceptions ) {
61930 : CPLErr eclass = CPLGetLastErrorType();
61931 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
61932 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
61933 : }
61934 : }
61935 : #endif
61936 : }
61937 808 : resultobj = SWIG_Py_Void();
61938 808 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
61939 : return resultobj;
61940 : fail:
61941 : return NULL;
61942 : }
61943 :
61944 :
61945 277 : SWIGINTERN PyObject *GDALWarpAppOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61946 277 : PyObject *obj;
61947 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
61948 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALWarpAppOptions, SWIG_NewClientData(obj));
61949 277 : return SWIG_Py_Void();
61950 : }
61951 :
61952 808 : SWIGINTERN PyObject *GDALWarpAppOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61953 808 : return SWIG_Python_InitShadowInstance(args);
61954 : }
61955 :
61956 87 : SWIGINTERN PyObject *_wrap_wrapper_GDALWarpDestDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
61957 87 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
61958 87 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
61959 87 : int arg2 ;
61960 87 : GDALDatasetShadow **arg3 = (GDALDatasetShadow **) 0 ;
61961 87 : GDALWarpAppOptions *arg4 = (GDALWarpAppOptions *) 0 ;
61962 87 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
61963 87 : void *arg6 = (void *) NULL ;
61964 87 : void *argp1 = 0 ;
61965 87 : int res1 = 0 ;
61966 87 : void *argp4 = 0 ;
61967 87 : int res4 = 0 ;
61968 87 : PyObject *swig_obj[5] ;
61969 87 : int result;
61970 :
61971 : /* %typemap(arginit) ( const char* callback_data=NULL) */
61972 87 : PyProgressData *psProgressInfo;
61973 87 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
61974 87 : psProgressInfo->nLastReported = -1;
61975 87 : psProgressInfo->psPyCallback = NULL;
61976 87 : psProgressInfo->psPyCallbackData = NULL;
61977 87 : arg6 = psProgressInfo;
61978 87 : if (!SWIG_Python_UnpackTuple(args, "wrapper_GDALWarpDestDS", 3, 5, swig_obj)) SWIG_fail;
61979 87 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
61980 87 : if (!SWIG_IsOK(res1)) {
61981 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wrapper_GDALWarpDestDS" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
61982 : }
61983 87 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
61984 87 : {
61985 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALDatasetShadow *optional_##GDALDatasetShadow)*/
61986 87 : if ( !PySequence_Check(swig_obj[1]) ) {
61987 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
61988 0 : SWIG_fail;
61989 : }
61990 87 : Py_ssize_t size = PySequence_Size(swig_obj[1]);
61991 87 : if( size > (Py_ssize_t)INT_MAX ) {
61992 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
61993 0 : SWIG_fail;
61994 : }
61995 87 : if( (size_t)size > SIZE_MAX / sizeof(GDALDatasetShadow*) ) {
61996 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
61997 0 : SWIG_fail;
61998 : }
61999 87 : arg2 = (int)size;
62000 87 : arg3 = (GDALDatasetShadow**) VSIMalloc(arg2*sizeof(GDALDatasetShadow*));
62001 87 : if( !arg3) {
62002 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
62003 0 : SWIG_fail;
62004 : }
62005 :
62006 172 : for( int i = 0; i<arg2; i++ ) {
62007 85 : PyObject *o = PySequence_GetItem(swig_obj[1],i);
62008 85 : GDALDatasetShadow* rawobjectpointer = NULL;
62009 85 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_EXCEPTION | 0 ));
62010 85 : if (!rawobjectpointer) {
62011 0 : Py_DECREF(o);
62012 0 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALDatasetShadow");
62013 0 : SWIG_fail;
62014 : }
62015 85 : arg3[i] = rawobjectpointer;
62016 85 : Py_DECREF(o);
62017 :
62018 : }
62019 : }
62020 87 : res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_GDALWarpAppOptions, 0 | 0 );
62021 87 : if (!SWIG_IsOK(res4)) {
62022 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "wrapper_GDALWarpDestDS" "', argument " "4"" of type '" "GDALWarpAppOptions *""'");
62023 : }
62024 87 : arg4 = reinterpret_cast< GDALWarpAppOptions * >(argp4);
62025 87 : if (swig_obj[3]) {
62026 86 : {
62027 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
62028 : /* callback_func typemap */
62029 :
62030 : /* In some cases 0 is passed instead of None. */
62031 : /* See https://github.com/OSGeo/gdal/pull/219 */
62032 86 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
62033 : {
62034 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
62035 : {
62036 0 : swig_obj[3] = Py_None;
62037 : }
62038 : }
62039 :
62040 86 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
62041 1 : void* cbfunction = NULL;
62042 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
62043 : (void**)&cbfunction,
62044 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
62045 : SWIG_POINTER_EXCEPTION | 0 ));
62046 :
62047 1 : if ( cbfunction == GDALTermProgress ) {
62048 : arg5 = GDALTermProgress;
62049 : } else {
62050 1 : if (!PyCallable_Check(swig_obj[3])) {
62051 0 : PyErr_SetString( PyExc_RuntimeError,
62052 : "Object given is not a Python function" );
62053 0 : SWIG_fail;
62054 : }
62055 1 : psProgressInfo->psPyCallback = swig_obj[3];
62056 1 : arg5 = PyProgressProxy;
62057 : }
62058 :
62059 : }
62060 :
62061 : }
62062 : }
62063 87 : if (swig_obj[4]) {
62064 85 : {
62065 : /* %typemap(in) ( void* callback_data=NULL) */
62066 85 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
62067 : }
62068 : }
62069 87 : {
62070 87 : if (!arg1) {
62071 1 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
62072 : }
62073 : }
62074 86 : {
62075 86 : const int bLocalUseExceptions = GetUseExceptions();
62076 86 : if ( bLocalUseExceptions ) {
62077 86 : pushErrorHandler();
62078 : }
62079 86 : {
62080 86 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
62081 86 : result = (int)wrapper_GDALWarpDestDS(arg1,arg2,arg3,arg4,arg5,arg6);
62082 86 : SWIG_PYTHON_THREAD_END_ALLOW;
62083 : }
62084 86 : if ( bLocalUseExceptions ) {
62085 86 : popErrorHandler();
62086 : }
62087 : #ifndef SED_HACKS
62088 : if ( bLocalUseExceptions ) {
62089 : CPLErr eclass = CPLGetLastErrorType();
62090 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
62091 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
62092 : }
62093 : }
62094 : #endif
62095 : }
62096 86 : resultobj = SWIG_From_int(static_cast< int >(result));
62097 86 : {
62098 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects)*/
62099 86 : CPLFree( arg3 );
62100 : }
62101 86 : {
62102 : /* %typemap(freearg) ( void* callback_data=NULL) */
62103 :
62104 86 : CPLFree(psProgressInfo);
62105 :
62106 : }
62107 91 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
62108 : return resultobj;
62109 1 : fail:
62110 1 : {
62111 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects)*/
62112 1 : CPLFree( arg3 );
62113 : }
62114 1 : {
62115 : /* %typemap(freearg) ( void* callback_data=NULL) */
62116 :
62117 1 : CPLFree(psProgressInfo);
62118 :
62119 : }
62120 : return NULL;
62121 : }
62122 :
62123 :
62124 726 : SWIGINTERN PyObject *_wrap_wrapper_GDALWarpDestName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
62125 726 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
62126 726 : char *arg1 = (char *) 0 ;
62127 726 : int arg2 ;
62128 726 : GDALDatasetShadow **arg3 = (GDALDatasetShadow **) 0 ;
62129 726 : GDALWarpAppOptions *arg4 = (GDALWarpAppOptions *) 0 ;
62130 726 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
62131 726 : void *arg6 = (void *) NULL ;
62132 726 : int bToFree1 = 0 ;
62133 726 : void *argp4 = 0 ;
62134 726 : int res4 = 0 ;
62135 726 : PyObject *swig_obj[5] ;
62136 726 : GDALDatasetShadow *result = 0 ;
62137 :
62138 : /* %typemap(arginit) ( const char* callback_data=NULL) */
62139 726 : PyProgressData *psProgressInfo;
62140 726 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
62141 726 : psProgressInfo->nLastReported = -1;
62142 726 : psProgressInfo->psPyCallback = NULL;
62143 726 : psProgressInfo->psPyCallbackData = NULL;
62144 726 : arg6 = psProgressInfo;
62145 726 : if (!SWIG_Python_UnpackTuple(args, "wrapper_GDALWarpDestName", 3, 5, swig_obj)) SWIG_fail;
62146 726 : {
62147 : /* %typemap(in) (const char *utf8_path) */
62148 726 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
62149 : {
62150 672 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
62151 : }
62152 : else
62153 : {
62154 54 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
62155 :
62156 : }
62157 726 : if (arg1 == NULL)
62158 : {
62159 1 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
62160 1 : SWIG_fail;
62161 : }
62162 : }
62163 725 : {
62164 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALDatasetShadow *optional_##GDALDatasetShadow)*/
62165 725 : if ( !PySequence_Check(swig_obj[1]) ) {
62166 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
62167 0 : SWIG_fail;
62168 : }
62169 725 : Py_ssize_t size = PySequence_Size(swig_obj[1]);
62170 725 : if( size > (Py_ssize_t)INT_MAX ) {
62171 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
62172 0 : SWIG_fail;
62173 : }
62174 725 : if( (size_t)size > SIZE_MAX / sizeof(GDALDatasetShadow*) ) {
62175 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
62176 0 : SWIG_fail;
62177 : }
62178 725 : arg2 = (int)size;
62179 725 : arg3 = (GDALDatasetShadow**) VSIMalloc(arg2*sizeof(GDALDatasetShadow*));
62180 725 : if( !arg3) {
62181 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
62182 0 : SWIG_fail;
62183 : }
62184 :
62185 1468 : for( int i = 0; i<arg2; i++ ) {
62186 743 : PyObject *o = PySequence_GetItem(swig_obj[1],i);
62187 743 : GDALDatasetShadow* rawobjectpointer = NULL;
62188 743 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_EXCEPTION | 0 ));
62189 743 : if (!rawobjectpointer) {
62190 0 : Py_DECREF(o);
62191 0 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALDatasetShadow");
62192 0 : SWIG_fail;
62193 : }
62194 743 : arg3[i] = rawobjectpointer;
62195 743 : Py_DECREF(o);
62196 :
62197 : }
62198 : }
62199 725 : res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_GDALWarpAppOptions, 0 | 0 );
62200 725 : if (!SWIG_IsOK(res4)) {
62201 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "wrapper_GDALWarpDestName" "', argument " "4"" of type '" "GDALWarpAppOptions *""'");
62202 : }
62203 725 : arg4 = reinterpret_cast< GDALWarpAppOptions * >(argp4);
62204 725 : if (swig_obj[3]) {
62205 724 : {
62206 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
62207 : /* callback_func typemap */
62208 :
62209 : /* In some cases 0 is passed instead of None. */
62210 : /* See https://github.com/OSGeo/gdal/pull/219 */
62211 724 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
62212 : {
62213 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
62214 : {
62215 0 : swig_obj[3] = Py_None;
62216 : }
62217 : }
62218 :
62219 724 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
62220 2 : void* cbfunction = NULL;
62221 2 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
62222 : (void**)&cbfunction,
62223 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
62224 : SWIG_POINTER_EXCEPTION | 0 ));
62225 :
62226 2 : if ( cbfunction == GDALTermProgress ) {
62227 : arg5 = GDALTermProgress;
62228 : } else {
62229 2 : if (!PyCallable_Check(swig_obj[3])) {
62230 0 : PyErr_SetString( PyExc_RuntimeError,
62231 : "Object given is not a Python function" );
62232 0 : SWIG_fail;
62233 : }
62234 2 : psProgressInfo->psPyCallback = swig_obj[3];
62235 2 : arg5 = PyProgressProxy;
62236 : }
62237 :
62238 : }
62239 :
62240 : }
62241 : }
62242 725 : if (swig_obj[4]) {
62243 723 : {
62244 : /* %typemap(in) ( void* callback_data=NULL) */
62245 723 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
62246 : }
62247 : }
62248 725 : {
62249 725 : if (!arg1) {
62250 725 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
62251 : }
62252 : }
62253 725 : {
62254 725 : const int bLocalUseExceptions = GetUseExceptions();
62255 725 : if ( bLocalUseExceptions ) {
62256 701 : pushErrorHandler();
62257 : }
62258 725 : {
62259 725 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
62260 725 : result = (GDALDatasetShadow *)wrapper_GDALWarpDestName((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
62261 725 : SWIG_PYTHON_THREAD_END_ALLOW;
62262 : }
62263 725 : if ( bLocalUseExceptions ) {
62264 701 : popErrorHandler();
62265 : }
62266 : #ifndef SED_HACKS
62267 : if ( bLocalUseExceptions ) {
62268 : CPLErr eclass = CPLGetLastErrorType();
62269 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
62270 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
62271 : }
62272 : }
62273 : #endif
62274 : }
62275 725 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
62276 725 : {
62277 : /* %typemap(freearg) (const char *utf8_path) */
62278 725 : GDALPythonFreeCStr(arg1, bToFree1);
62279 : }
62280 725 : {
62281 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects)*/
62282 725 : CPLFree( arg3 );
62283 : }
62284 725 : {
62285 : /* %typemap(freearg) ( void* callback_data=NULL) */
62286 :
62287 725 : CPLFree(psProgressInfo);
62288 :
62289 : }
62290 806 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
62291 : return resultobj;
62292 1 : fail:
62293 1 : {
62294 : /* %typemap(freearg) (const char *utf8_path) */
62295 1 : GDALPythonFreeCStr(arg1, bToFree1);
62296 : }
62297 1 : {
62298 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects)*/
62299 1 : CPLFree( arg3 );
62300 : }
62301 1 : {
62302 : /* %typemap(freearg) ( void* callback_data=NULL) */
62303 :
62304 1 : CPLFree(psProgressInfo);
62305 :
62306 : }
62307 : return NULL;
62308 : }
62309 :
62310 :
62311 656 : SWIGINTERN PyObject *_wrap_new_GDALVectorTranslateOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
62312 656 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
62313 656 : char **arg1 = (char **) 0 ;
62314 656 : PyObject *swig_obj[1] ;
62315 656 : GDALVectorTranslateOptions *result = 0 ;
62316 :
62317 656 : if (!args) SWIG_fail;
62318 656 : swig_obj[0] = args;
62319 656 : {
62320 : /* %typemap(in) char **dict */
62321 656 : arg1 = NULL;
62322 656 : if ( PySequence_Check( swig_obj[0] ) ) {
62323 656 : int bErr = FALSE;
62324 656 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
62325 656 : if ( bErr )
62326 : {
62327 0 : SWIG_fail;
62328 : }
62329 : }
62330 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
62331 0 : int bErr = FALSE;
62332 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
62333 0 : if ( bErr )
62334 : {
62335 0 : SWIG_fail;
62336 : }
62337 : }
62338 : else {
62339 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
62340 0 : SWIG_fail;
62341 : }
62342 : }
62343 656 : {
62344 656 : const int bLocalUseExceptions = GetUseExceptions();
62345 656 : if ( bLocalUseExceptions ) {
62346 505 : pushErrorHandler();
62347 : }
62348 656 : {
62349 656 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
62350 656 : result = (GDALVectorTranslateOptions *)new_GDALVectorTranslateOptions(arg1);
62351 656 : SWIG_PYTHON_THREAD_END_ALLOW;
62352 : }
62353 656 : if ( bLocalUseExceptions ) {
62354 505 : popErrorHandler();
62355 : }
62356 : #ifndef SED_HACKS
62357 : if ( bLocalUseExceptions ) {
62358 : CPLErr eclass = CPLGetLastErrorType();
62359 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
62360 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
62361 : }
62362 : }
62363 : #endif
62364 : }
62365 656 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALVectorTranslateOptions, SWIG_POINTER_NEW | 0 );
62366 656 : {
62367 : /* %typemap(freearg) char **dict */
62368 656 : CSLDestroy( arg1 );
62369 : }
62370 710 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
62371 : return resultobj;
62372 0 : fail:
62373 0 : {
62374 : /* %typemap(freearg) char **dict */
62375 0 : CSLDestroy( arg1 );
62376 : }
62377 : return NULL;
62378 : }
62379 :
62380 :
62381 629 : SWIGINTERN PyObject *_wrap_delete_GDALVectorTranslateOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
62382 629 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
62383 629 : GDALVectorTranslateOptions *arg1 = (GDALVectorTranslateOptions *) 0 ;
62384 629 : void *argp1 = 0 ;
62385 629 : int res1 = 0 ;
62386 629 : PyObject *swig_obj[1] ;
62387 :
62388 629 : if (!args) SWIG_fail;
62389 629 : swig_obj[0] = args;
62390 629 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALVectorTranslateOptions, SWIG_POINTER_DISOWN | 0 );
62391 629 : if (!SWIG_IsOK(res1)) {
62392 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALVectorTranslateOptions" "', argument " "1"" of type '" "GDALVectorTranslateOptions *""'");
62393 : }
62394 629 : arg1 = reinterpret_cast< GDALVectorTranslateOptions * >(argp1);
62395 629 : {
62396 629 : const int bLocalUseExceptions = GetUseExceptions();
62397 629 : if ( bLocalUseExceptions ) {
62398 478 : pushErrorHandler();
62399 : }
62400 629 : {
62401 629 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
62402 629 : delete_GDALVectorTranslateOptions(arg1);
62403 629 : SWIG_PYTHON_THREAD_END_ALLOW;
62404 : }
62405 629 : if ( bLocalUseExceptions ) {
62406 478 : popErrorHandler();
62407 : }
62408 : #ifndef SED_HACKS
62409 : if ( bLocalUseExceptions ) {
62410 : CPLErr eclass = CPLGetLastErrorType();
62411 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
62412 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
62413 : }
62414 : }
62415 : #endif
62416 : }
62417 629 : resultobj = SWIG_Py_Void();
62418 629 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
62419 : return resultobj;
62420 : fail:
62421 : return NULL;
62422 : }
62423 :
62424 :
62425 277 : SWIGINTERN PyObject *GDALVectorTranslateOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
62426 277 : PyObject *obj;
62427 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
62428 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALVectorTranslateOptions, SWIG_NewClientData(obj));
62429 277 : return SWIG_Py_Void();
62430 : }
62431 :
62432 629 : SWIGINTERN PyObject *GDALVectorTranslateOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
62433 629 : return SWIG_Python_InitShadowInstance(args);
62434 : }
62435 :
62436 12 : SWIGINTERN PyObject *_wrap_wrapper_GDALVectorTranslateDestDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
62437 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
62438 12 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
62439 12 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
62440 12 : GDALVectorTranslateOptions *arg3 = (GDALVectorTranslateOptions *) 0 ;
62441 12 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
62442 12 : void *arg5 = (void *) NULL ;
62443 12 : void *argp1 = 0 ;
62444 12 : int res1 = 0 ;
62445 12 : void *argp2 = 0 ;
62446 12 : int res2 = 0 ;
62447 12 : void *argp3 = 0 ;
62448 12 : int res3 = 0 ;
62449 12 : PyObject *swig_obj[5] ;
62450 12 : int result;
62451 :
62452 : /* %typemap(arginit) ( const char* callback_data=NULL) */
62453 12 : PyProgressData *psProgressInfo;
62454 12 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
62455 12 : psProgressInfo->nLastReported = -1;
62456 12 : psProgressInfo->psPyCallback = NULL;
62457 12 : psProgressInfo->psPyCallbackData = NULL;
62458 12 : arg5 = psProgressInfo;
62459 12 : if (!SWIG_Python_UnpackTuple(args, "wrapper_GDALVectorTranslateDestDS", 3, 5, swig_obj)) SWIG_fail;
62460 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
62461 12 : if (!SWIG_IsOK(res1)) {
62462 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wrapper_GDALVectorTranslateDestDS" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
62463 : }
62464 12 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
62465 12 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
62466 12 : if (!SWIG_IsOK(res2)) {
62467 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wrapper_GDALVectorTranslateDestDS" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
62468 : }
62469 12 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
62470 12 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALVectorTranslateOptions, 0 | 0 );
62471 12 : if (!SWIG_IsOK(res3)) {
62472 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wrapper_GDALVectorTranslateDestDS" "', argument " "3"" of type '" "GDALVectorTranslateOptions *""'");
62473 : }
62474 12 : arg3 = reinterpret_cast< GDALVectorTranslateOptions * >(argp3);
62475 12 : if (swig_obj[3]) {
62476 12 : {
62477 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
62478 : /* callback_func typemap */
62479 :
62480 : /* In some cases 0 is passed instead of None. */
62481 : /* See https://github.com/OSGeo/gdal/pull/219 */
62482 12 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
62483 : {
62484 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
62485 : {
62486 0 : swig_obj[3] = Py_None;
62487 : }
62488 : }
62489 :
62490 12 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
62491 0 : void* cbfunction = NULL;
62492 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
62493 : (void**)&cbfunction,
62494 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
62495 : SWIG_POINTER_EXCEPTION | 0 ));
62496 :
62497 0 : if ( cbfunction == GDALTermProgress ) {
62498 : arg4 = GDALTermProgress;
62499 : } else {
62500 0 : if (!PyCallable_Check(swig_obj[3])) {
62501 0 : PyErr_SetString( PyExc_RuntimeError,
62502 : "Object given is not a Python function" );
62503 0 : SWIG_fail;
62504 : }
62505 0 : psProgressInfo->psPyCallback = swig_obj[3];
62506 0 : arg4 = PyProgressProxy;
62507 : }
62508 :
62509 : }
62510 :
62511 : }
62512 : }
62513 12 : if (swig_obj[4]) {
62514 12 : {
62515 : /* %typemap(in) ( void* callback_data=NULL) */
62516 12 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
62517 : }
62518 : }
62519 12 : {
62520 12 : const int bLocalUseExceptions = GetUseExceptions();
62521 12 : if ( bLocalUseExceptions ) {
62522 11 : pushErrorHandler();
62523 : }
62524 12 : {
62525 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
62526 12 : result = (int)wrapper_GDALVectorTranslateDestDS(arg1,arg2,arg3,arg4,arg5);
62527 12 : SWIG_PYTHON_THREAD_END_ALLOW;
62528 : }
62529 12 : if ( bLocalUseExceptions ) {
62530 11 : popErrorHandler();
62531 : }
62532 : #ifndef SED_HACKS
62533 : if ( bLocalUseExceptions ) {
62534 : CPLErr eclass = CPLGetLastErrorType();
62535 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
62536 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
62537 : }
62538 : }
62539 : #endif
62540 : }
62541 12 : resultobj = SWIG_From_int(static_cast< int >(result));
62542 12 : {
62543 : /* %typemap(freearg) ( void* callback_data=NULL) */
62544 :
62545 12 : CPLFree(psProgressInfo);
62546 :
62547 : }
62548 14 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
62549 : return resultobj;
62550 0 : fail:
62551 0 : {
62552 : /* %typemap(freearg) ( void* callback_data=NULL) */
62553 :
62554 0 : CPLFree(psProgressInfo);
62555 :
62556 : }
62557 : return NULL;
62558 : }
62559 :
62560 :
62561 606 : SWIGINTERN PyObject *_wrap_wrapper_GDALVectorTranslateDestName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
62562 606 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
62563 606 : char *arg1 = (char *) 0 ;
62564 606 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
62565 606 : GDALVectorTranslateOptions *arg3 = (GDALVectorTranslateOptions *) 0 ;
62566 606 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
62567 606 : void *arg5 = (void *) NULL ;
62568 606 : int bToFree1 = 0 ;
62569 606 : void *argp2 = 0 ;
62570 606 : int res2 = 0 ;
62571 606 : void *argp3 = 0 ;
62572 606 : int res3 = 0 ;
62573 606 : PyObject *swig_obj[5] ;
62574 606 : GDALDatasetShadow *result = 0 ;
62575 :
62576 : /* %typemap(arginit) ( const char* callback_data=NULL) */
62577 606 : PyProgressData *psProgressInfo;
62578 606 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
62579 606 : psProgressInfo->nLastReported = -1;
62580 606 : psProgressInfo->psPyCallback = NULL;
62581 606 : psProgressInfo->psPyCallbackData = NULL;
62582 606 : arg5 = psProgressInfo;
62583 606 : if (!SWIG_Python_UnpackTuple(args, "wrapper_GDALVectorTranslateDestName", 3, 5, swig_obj)) SWIG_fail;
62584 606 : {
62585 : /* %typemap(in) (const char *utf8_path) */
62586 606 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
62587 : {
62588 484 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
62589 : }
62590 : else
62591 : {
62592 122 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
62593 :
62594 : }
62595 606 : if (arg1 == NULL)
62596 : {
62597 1 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
62598 1 : SWIG_fail;
62599 : }
62600 : }
62601 605 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
62602 605 : if (!SWIG_IsOK(res2)) {
62603 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wrapper_GDALVectorTranslateDestName" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
62604 : }
62605 605 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
62606 605 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALVectorTranslateOptions, 0 | 0 );
62607 605 : if (!SWIG_IsOK(res3)) {
62608 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wrapper_GDALVectorTranslateDestName" "', argument " "3"" of type '" "GDALVectorTranslateOptions *""'");
62609 : }
62610 605 : arg3 = reinterpret_cast< GDALVectorTranslateOptions * >(argp3);
62611 605 : if (swig_obj[3]) {
62612 605 : {
62613 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
62614 : /* callback_func typemap */
62615 :
62616 : /* In some cases 0 is passed instead of None. */
62617 : /* See https://github.com/OSGeo/gdal/pull/219 */
62618 605 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
62619 : {
62620 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
62621 : {
62622 0 : swig_obj[3] = Py_None;
62623 : }
62624 : }
62625 :
62626 605 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
62627 3 : void* cbfunction = NULL;
62628 3 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
62629 : (void**)&cbfunction,
62630 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
62631 : SWIG_POINTER_EXCEPTION | 0 ));
62632 :
62633 3 : if ( cbfunction == GDALTermProgress ) {
62634 : arg4 = GDALTermProgress;
62635 : } else {
62636 3 : if (!PyCallable_Check(swig_obj[3])) {
62637 0 : PyErr_SetString( PyExc_RuntimeError,
62638 : "Object given is not a Python function" );
62639 0 : SWIG_fail;
62640 : }
62641 3 : psProgressInfo->psPyCallback = swig_obj[3];
62642 3 : arg4 = PyProgressProxy;
62643 : }
62644 :
62645 : }
62646 :
62647 : }
62648 : }
62649 605 : if (swig_obj[4]) {
62650 605 : {
62651 : /* %typemap(in) ( void* callback_data=NULL) */
62652 605 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
62653 : }
62654 : }
62655 605 : {
62656 605 : if (!arg1) {
62657 605 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
62658 : }
62659 : }
62660 605 : {
62661 605 : const int bLocalUseExceptions = GetUseExceptions();
62662 605 : if ( bLocalUseExceptions ) {
62663 455 : pushErrorHandler();
62664 : }
62665 605 : {
62666 605 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
62667 605 : result = (GDALDatasetShadow *)wrapper_GDALVectorTranslateDestName((char const *)arg1,arg2,arg3,arg4,arg5);
62668 605 : SWIG_PYTHON_THREAD_END_ALLOW;
62669 : }
62670 605 : if ( bLocalUseExceptions ) {
62671 455 : popErrorHandler();
62672 : }
62673 : #ifndef SED_HACKS
62674 : if ( bLocalUseExceptions ) {
62675 : CPLErr eclass = CPLGetLastErrorType();
62676 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
62677 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
62678 : }
62679 : }
62680 : #endif
62681 : }
62682 605 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
62683 605 : {
62684 : /* %typemap(freearg) (const char *utf8_path) */
62685 605 : GDALPythonFreeCStr(arg1, bToFree1);
62686 : }
62687 605 : {
62688 : /* %typemap(freearg) ( void* callback_data=NULL) */
62689 :
62690 605 : CPLFree(psProgressInfo);
62691 :
62692 : }
62693 640 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
62694 : return resultobj;
62695 1 : fail:
62696 1 : {
62697 : /* %typemap(freearg) (const char *utf8_path) */
62698 1 : GDALPythonFreeCStr(arg1, bToFree1);
62699 : }
62700 1 : {
62701 : /* %typemap(freearg) ( void* callback_data=NULL) */
62702 :
62703 1 : CPLFree(psProgressInfo);
62704 :
62705 : }
62706 : return NULL;
62707 : }
62708 :
62709 :
62710 93 : SWIGINTERN PyObject *_wrap_new_GDALDEMProcessingOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
62711 93 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
62712 93 : char **arg1 = (char **) 0 ;
62713 93 : PyObject *swig_obj[1] ;
62714 93 : GDALDEMProcessingOptions *result = 0 ;
62715 :
62716 93 : if (!args) SWIG_fail;
62717 93 : swig_obj[0] = args;
62718 93 : {
62719 : /* %typemap(in) char **dict */
62720 93 : arg1 = NULL;
62721 93 : if ( PySequence_Check( swig_obj[0] ) ) {
62722 93 : int bErr = FALSE;
62723 93 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
62724 93 : if ( bErr )
62725 : {
62726 0 : SWIG_fail;
62727 : }
62728 : }
62729 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
62730 0 : int bErr = FALSE;
62731 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
62732 0 : if ( bErr )
62733 : {
62734 0 : SWIG_fail;
62735 : }
62736 : }
62737 : else {
62738 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
62739 0 : SWIG_fail;
62740 : }
62741 : }
62742 93 : {
62743 93 : const int bLocalUseExceptions = GetUseExceptions();
62744 93 : if ( bLocalUseExceptions ) {
62745 93 : pushErrorHandler();
62746 : }
62747 93 : {
62748 93 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
62749 93 : result = (GDALDEMProcessingOptions *)new_GDALDEMProcessingOptions(arg1);
62750 93 : SWIG_PYTHON_THREAD_END_ALLOW;
62751 : }
62752 93 : if ( bLocalUseExceptions ) {
62753 93 : popErrorHandler();
62754 : }
62755 : #ifndef SED_HACKS
62756 : if ( bLocalUseExceptions ) {
62757 : CPLErr eclass = CPLGetLastErrorType();
62758 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
62759 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
62760 : }
62761 : }
62762 : #endif
62763 : }
62764 93 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDEMProcessingOptions, SWIG_POINTER_NEW | 0 );
62765 93 : {
62766 : /* %typemap(freearg) char **dict */
62767 93 : CSLDestroy( arg1 );
62768 : }
62769 101 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
62770 : return resultobj;
62771 0 : fail:
62772 0 : {
62773 : /* %typemap(freearg) char **dict */
62774 0 : CSLDestroy( arg1 );
62775 : }
62776 : return NULL;
62777 : }
62778 :
62779 :
62780 89 : SWIGINTERN PyObject *_wrap_delete_GDALDEMProcessingOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
62781 89 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
62782 89 : GDALDEMProcessingOptions *arg1 = (GDALDEMProcessingOptions *) 0 ;
62783 89 : void *argp1 = 0 ;
62784 89 : int res1 = 0 ;
62785 89 : PyObject *swig_obj[1] ;
62786 :
62787 89 : if (!args) SWIG_fail;
62788 89 : swig_obj[0] = args;
62789 89 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDEMProcessingOptions, SWIG_POINTER_DISOWN | 0 );
62790 89 : if (!SWIG_IsOK(res1)) {
62791 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALDEMProcessingOptions" "', argument " "1"" of type '" "GDALDEMProcessingOptions *""'");
62792 : }
62793 89 : arg1 = reinterpret_cast< GDALDEMProcessingOptions * >(argp1);
62794 89 : {
62795 89 : const int bLocalUseExceptions = GetUseExceptions();
62796 89 : if ( bLocalUseExceptions ) {
62797 89 : pushErrorHandler();
62798 : }
62799 89 : {
62800 89 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
62801 89 : delete_GDALDEMProcessingOptions(arg1);
62802 89 : SWIG_PYTHON_THREAD_END_ALLOW;
62803 : }
62804 89 : if ( bLocalUseExceptions ) {
62805 89 : popErrorHandler();
62806 : }
62807 : #ifndef SED_HACKS
62808 : if ( bLocalUseExceptions ) {
62809 : CPLErr eclass = CPLGetLastErrorType();
62810 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
62811 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
62812 : }
62813 : }
62814 : #endif
62815 : }
62816 89 : resultobj = SWIG_Py_Void();
62817 89 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
62818 : return resultobj;
62819 : fail:
62820 : return NULL;
62821 : }
62822 :
62823 :
62824 277 : SWIGINTERN PyObject *GDALDEMProcessingOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
62825 277 : PyObject *obj;
62826 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
62827 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALDEMProcessingOptions, SWIG_NewClientData(obj));
62828 277 : return SWIG_Py_Void();
62829 : }
62830 :
62831 89 : SWIGINTERN PyObject *GDALDEMProcessingOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
62832 89 : return SWIG_Python_InitShadowInstance(args);
62833 : }
62834 :
62835 89 : SWIGINTERN PyObject *_wrap_DEMProcessingInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
62836 89 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
62837 89 : char *arg1 = (char *) 0 ;
62838 89 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
62839 89 : char *arg3 = (char *) 0 ;
62840 89 : char *arg4 = (char *) 0 ;
62841 89 : GDALDEMProcessingOptions *arg5 = (GDALDEMProcessingOptions *) 0 ;
62842 89 : GDALProgressFunc arg6 = (GDALProgressFunc) NULL ;
62843 89 : void *arg7 = (void *) NULL ;
62844 89 : int bToFree1 = 0 ;
62845 89 : void *argp2 = 0 ;
62846 89 : int res2 = 0 ;
62847 89 : int res3 ;
62848 89 : char *buf3 = 0 ;
62849 89 : int alloc3 = 0 ;
62850 89 : int res4 ;
62851 89 : char *buf4 = 0 ;
62852 89 : int alloc4 = 0 ;
62853 89 : void *argp5 = 0 ;
62854 89 : int res5 = 0 ;
62855 89 : PyObject *swig_obj[7] ;
62856 89 : GDALDatasetShadow *result = 0 ;
62857 :
62858 : /* %typemap(arginit) ( const char* callback_data=NULL) */
62859 89 : PyProgressData *psProgressInfo;
62860 89 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
62861 89 : psProgressInfo->nLastReported = -1;
62862 89 : psProgressInfo->psPyCallback = NULL;
62863 89 : psProgressInfo->psPyCallbackData = NULL;
62864 89 : arg7 = psProgressInfo;
62865 89 : if (!SWIG_Python_UnpackTuple(args, "DEMProcessingInternal", 5, 7, swig_obj)) SWIG_fail;
62866 89 : {
62867 : /* %typemap(in) (const char *utf8_path) */
62868 89 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
62869 : {
62870 88 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
62871 : }
62872 : else
62873 : {
62874 1 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
62875 :
62876 : }
62877 89 : if (arg1 == NULL)
62878 : {
62879 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
62880 0 : SWIG_fail;
62881 : }
62882 : }
62883 89 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
62884 89 : if (!SWIG_IsOK(res2)) {
62885 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DEMProcessingInternal" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
62886 : }
62887 89 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
62888 89 : res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
62889 89 : if (!SWIG_IsOK(res3)) {
62890 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DEMProcessingInternal" "', argument " "3"" of type '" "char const *""'");
62891 : }
62892 89 : arg3 = reinterpret_cast< char * >(buf3);
62893 89 : res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
62894 89 : if (!SWIG_IsOK(res4)) {
62895 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DEMProcessingInternal" "', argument " "4"" of type '" "char const *""'");
62896 : }
62897 89 : arg4 = reinterpret_cast< char * >(buf4);
62898 89 : res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_GDALDEMProcessingOptions, 0 | 0 );
62899 89 : if (!SWIG_IsOK(res5)) {
62900 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DEMProcessingInternal" "', argument " "5"" of type '" "GDALDEMProcessingOptions *""'");
62901 : }
62902 89 : arg5 = reinterpret_cast< GDALDEMProcessingOptions * >(argp5);
62903 89 : if (swig_obj[5]) {
62904 89 : {
62905 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
62906 : /* callback_func typemap */
62907 :
62908 : /* In some cases 0 is passed instead of None. */
62909 : /* See https://github.com/OSGeo/gdal/pull/219 */
62910 89 : if ( PyLong_Check(swig_obj[5]) || PyInt_Check(swig_obj[5]) )
62911 : {
62912 0 : if( PyLong_AsLong(swig_obj[5]) == 0 )
62913 : {
62914 0 : swig_obj[5] = Py_None;
62915 : }
62916 : }
62917 :
62918 89 : if (swig_obj[5] && swig_obj[5] != Py_None ) {
62919 0 : void* cbfunction = NULL;
62920 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[5],
62921 : (void**)&cbfunction,
62922 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
62923 : SWIG_POINTER_EXCEPTION | 0 ));
62924 :
62925 0 : if ( cbfunction == GDALTermProgress ) {
62926 : arg6 = GDALTermProgress;
62927 : } else {
62928 0 : if (!PyCallable_Check(swig_obj[5])) {
62929 0 : PyErr_SetString( PyExc_RuntimeError,
62930 : "Object given is not a Python function" );
62931 0 : SWIG_fail;
62932 : }
62933 0 : psProgressInfo->psPyCallback = swig_obj[5];
62934 0 : arg6 = PyProgressProxy;
62935 : }
62936 :
62937 : }
62938 :
62939 : }
62940 : }
62941 89 : if (swig_obj[6]) {
62942 89 : {
62943 : /* %typemap(in) ( void* callback_data=NULL) */
62944 89 : psProgressInfo->psPyCallbackData = swig_obj[6] ;
62945 : }
62946 : }
62947 89 : {
62948 89 : if (!arg1) {
62949 89 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
62950 : }
62951 : }
62952 89 : {
62953 89 : if (!arg2) {
62954 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
62955 : }
62956 : }
62957 89 : {
62958 89 : if (!arg3) {
62959 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
62960 : }
62961 : }
62962 89 : {
62963 89 : const int bLocalUseExceptions = GetUseExceptions();
62964 89 : if ( bLocalUseExceptions ) {
62965 89 : pushErrorHandler();
62966 : }
62967 89 : {
62968 89 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
62969 89 : result = (GDALDatasetShadow *)wrapper_GDALDEMProcessing((char const *)arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7);
62970 89 : SWIG_PYTHON_THREAD_END_ALLOW;
62971 : }
62972 89 : if ( bLocalUseExceptions ) {
62973 89 : popErrorHandler();
62974 : }
62975 : #ifndef SED_HACKS
62976 : if ( bLocalUseExceptions ) {
62977 : CPLErr eclass = CPLGetLastErrorType();
62978 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
62979 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
62980 : }
62981 : }
62982 : #endif
62983 : }
62984 89 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
62985 89 : {
62986 : /* %typemap(freearg) (const char *utf8_path) */
62987 89 : GDALPythonFreeCStr(arg1, bToFree1);
62988 : }
62989 89 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
62990 89 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
62991 89 : {
62992 : /* %typemap(freearg) ( void* callback_data=NULL) */
62993 :
62994 89 : CPLFree(psProgressInfo);
62995 :
62996 : }
62997 89 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
62998 : return resultobj;
62999 0 : fail:
63000 0 : {
63001 : /* %typemap(freearg) (const char *utf8_path) */
63002 0 : GDALPythonFreeCStr(arg1, bToFree1);
63003 : }
63004 0 : if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
63005 0 : if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
63006 0 : {
63007 : /* %typemap(freearg) ( void* callback_data=NULL) */
63008 :
63009 0 : CPLFree(psProgressInfo);
63010 :
63011 : }
63012 : return NULL;
63013 : }
63014 :
63015 :
63016 45 : SWIGINTERN PyObject *_wrap_new_GDALNearblackOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63017 45 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
63018 45 : char **arg1 = (char **) 0 ;
63019 45 : PyObject *swig_obj[1] ;
63020 45 : GDALNearblackOptions *result = 0 ;
63021 :
63022 45 : if (!args) SWIG_fail;
63023 45 : swig_obj[0] = args;
63024 45 : {
63025 : /* %typemap(in) char **dict */
63026 45 : arg1 = NULL;
63027 45 : if ( PySequence_Check( swig_obj[0] ) ) {
63028 45 : int bErr = FALSE;
63029 45 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
63030 45 : if ( bErr )
63031 : {
63032 0 : SWIG_fail;
63033 : }
63034 : }
63035 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
63036 0 : int bErr = FALSE;
63037 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
63038 0 : if ( bErr )
63039 : {
63040 0 : SWIG_fail;
63041 : }
63042 : }
63043 : else {
63044 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
63045 0 : SWIG_fail;
63046 : }
63047 : }
63048 45 : {
63049 45 : const int bLocalUseExceptions = GetUseExceptions();
63050 45 : if ( bLocalUseExceptions ) {
63051 45 : pushErrorHandler();
63052 : }
63053 45 : {
63054 45 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
63055 45 : result = (GDALNearblackOptions *)new_GDALNearblackOptions(arg1);
63056 45 : SWIG_PYTHON_THREAD_END_ALLOW;
63057 : }
63058 45 : if ( bLocalUseExceptions ) {
63059 45 : popErrorHandler();
63060 : }
63061 : #ifndef SED_HACKS
63062 : if ( bLocalUseExceptions ) {
63063 : CPLErr eclass = CPLGetLastErrorType();
63064 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
63065 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
63066 : }
63067 : }
63068 : #endif
63069 : }
63070 45 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALNearblackOptions, SWIG_POINTER_NEW | 0 );
63071 45 : {
63072 : /* %typemap(freearg) char **dict */
63073 45 : CSLDestroy( arg1 );
63074 : }
63075 45 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
63076 : return resultobj;
63077 0 : fail:
63078 0 : {
63079 : /* %typemap(freearg) char **dict */
63080 0 : CSLDestroy( arg1 );
63081 : }
63082 : return NULL;
63083 : }
63084 :
63085 :
63086 45 : SWIGINTERN PyObject *_wrap_delete_GDALNearblackOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63087 45 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
63088 45 : GDALNearblackOptions *arg1 = (GDALNearblackOptions *) 0 ;
63089 45 : void *argp1 = 0 ;
63090 45 : int res1 = 0 ;
63091 45 : PyObject *swig_obj[1] ;
63092 :
63093 45 : if (!args) SWIG_fail;
63094 45 : swig_obj[0] = args;
63095 45 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALNearblackOptions, SWIG_POINTER_DISOWN | 0 );
63096 45 : if (!SWIG_IsOK(res1)) {
63097 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALNearblackOptions" "', argument " "1"" of type '" "GDALNearblackOptions *""'");
63098 : }
63099 45 : arg1 = reinterpret_cast< GDALNearblackOptions * >(argp1);
63100 45 : {
63101 45 : const int bLocalUseExceptions = GetUseExceptions();
63102 45 : if ( bLocalUseExceptions ) {
63103 45 : pushErrorHandler();
63104 : }
63105 45 : {
63106 45 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
63107 45 : delete_GDALNearblackOptions(arg1);
63108 45 : SWIG_PYTHON_THREAD_END_ALLOW;
63109 : }
63110 45 : if ( bLocalUseExceptions ) {
63111 45 : popErrorHandler();
63112 : }
63113 : #ifndef SED_HACKS
63114 : if ( bLocalUseExceptions ) {
63115 : CPLErr eclass = CPLGetLastErrorType();
63116 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
63117 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
63118 : }
63119 : }
63120 : #endif
63121 : }
63122 45 : resultobj = SWIG_Py_Void();
63123 45 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
63124 : return resultobj;
63125 : fail:
63126 : return NULL;
63127 : }
63128 :
63129 :
63130 277 : SWIGINTERN PyObject *GDALNearblackOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63131 277 : PyObject *obj;
63132 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
63133 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALNearblackOptions, SWIG_NewClientData(obj));
63134 277 : return SWIG_Py_Void();
63135 : }
63136 :
63137 45 : SWIGINTERN PyObject *GDALNearblackOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63138 45 : return SWIG_Python_InitShadowInstance(args);
63139 : }
63140 :
63141 2 : SWIGINTERN PyObject *_wrap_wrapper_GDALNearblackDestDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63142 2 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
63143 2 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
63144 2 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
63145 2 : GDALNearblackOptions *arg3 = (GDALNearblackOptions *) 0 ;
63146 2 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
63147 2 : void *arg5 = (void *) NULL ;
63148 2 : void *argp1 = 0 ;
63149 2 : int res1 = 0 ;
63150 2 : void *argp2 = 0 ;
63151 2 : int res2 = 0 ;
63152 2 : void *argp3 = 0 ;
63153 2 : int res3 = 0 ;
63154 2 : PyObject *swig_obj[5] ;
63155 2 : int result;
63156 :
63157 : /* %typemap(arginit) ( const char* callback_data=NULL) */
63158 2 : PyProgressData *psProgressInfo;
63159 2 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
63160 2 : psProgressInfo->nLastReported = -1;
63161 2 : psProgressInfo->psPyCallback = NULL;
63162 2 : psProgressInfo->psPyCallbackData = NULL;
63163 2 : arg5 = psProgressInfo;
63164 2 : if (!SWIG_Python_UnpackTuple(args, "wrapper_GDALNearblackDestDS", 3, 5, swig_obj)) SWIG_fail;
63165 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
63166 2 : if (!SWIG_IsOK(res1)) {
63167 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wrapper_GDALNearblackDestDS" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
63168 : }
63169 2 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
63170 2 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
63171 2 : if (!SWIG_IsOK(res2)) {
63172 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wrapper_GDALNearblackDestDS" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
63173 : }
63174 2 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
63175 2 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALNearblackOptions, 0 | 0 );
63176 2 : if (!SWIG_IsOK(res3)) {
63177 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wrapper_GDALNearblackDestDS" "', argument " "3"" of type '" "GDALNearblackOptions *""'");
63178 : }
63179 2 : arg3 = reinterpret_cast< GDALNearblackOptions * >(argp3);
63180 2 : if (swig_obj[3]) {
63181 2 : {
63182 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
63183 : /* callback_func typemap */
63184 :
63185 : /* In some cases 0 is passed instead of None. */
63186 : /* See https://github.com/OSGeo/gdal/pull/219 */
63187 2 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
63188 : {
63189 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
63190 : {
63191 0 : swig_obj[3] = Py_None;
63192 : }
63193 : }
63194 :
63195 2 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
63196 0 : void* cbfunction = NULL;
63197 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
63198 : (void**)&cbfunction,
63199 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
63200 : SWIG_POINTER_EXCEPTION | 0 ));
63201 :
63202 0 : if ( cbfunction == GDALTermProgress ) {
63203 : arg4 = GDALTermProgress;
63204 : } else {
63205 0 : if (!PyCallable_Check(swig_obj[3])) {
63206 0 : PyErr_SetString( PyExc_RuntimeError,
63207 : "Object given is not a Python function" );
63208 0 : SWIG_fail;
63209 : }
63210 0 : psProgressInfo->psPyCallback = swig_obj[3];
63211 0 : arg4 = PyProgressProxy;
63212 : }
63213 :
63214 : }
63215 :
63216 : }
63217 : }
63218 2 : if (swig_obj[4]) {
63219 2 : {
63220 : /* %typemap(in) ( void* callback_data=NULL) */
63221 2 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
63222 : }
63223 : }
63224 2 : {
63225 2 : const int bLocalUseExceptions = GetUseExceptions();
63226 2 : if ( bLocalUseExceptions ) {
63227 2 : pushErrorHandler();
63228 : }
63229 2 : {
63230 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
63231 2 : result = (int)wrapper_GDALNearblackDestDS(arg1,arg2,arg3,arg4,arg5);
63232 2 : SWIG_PYTHON_THREAD_END_ALLOW;
63233 : }
63234 2 : if ( bLocalUseExceptions ) {
63235 2 : popErrorHandler();
63236 : }
63237 : #ifndef SED_HACKS
63238 : if ( bLocalUseExceptions ) {
63239 : CPLErr eclass = CPLGetLastErrorType();
63240 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
63241 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
63242 : }
63243 : }
63244 : #endif
63245 : }
63246 2 : resultobj = SWIG_From_int(static_cast< int >(result));
63247 2 : {
63248 : /* %typemap(freearg) ( void* callback_data=NULL) */
63249 :
63250 2 : CPLFree(psProgressInfo);
63251 :
63252 : }
63253 2 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
63254 : return resultobj;
63255 0 : fail:
63256 0 : {
63257 : /* %typemap(freearg) ( void* callback_data=NULL) */
63258 :
63259 0 : CPLFree(psProgressInfo);
63260 :
63261 : }
63262 : return NULL;
63263 : }
63264 :
63265 :
63266 43 : SWIGINTERN PyObject *_wrap_wrapper_GDALNearblackDestName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63267 43 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
63268 43 : char *arg1 = (char *) 0 ;
63269 43 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
63270 43 : GDALNearblackOptions *arg3 = (GDALNearblackOptions *) 0 ;
63271 43 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
63272 43 : void *arg5 = (void *) NULL ;
63273 43 : int bToFree1 = 0 ;
63274 43 : void *argp2 = 0 ;
63275 43 : int res2 = 0 ;
63276 43 : void *argp3 = 0 ;
63277 43 : int res3 = 0 ;
63278 43 : PyObject *swig_obj[5] ;
63279 43 : GDALDatasetShadow *result = 0 ;
63280 :
63281 : /* %typemap(arginit) ( const char* callback_data=NULL) */
63282 43 : PyProgressData *psProgressInfo;
63283 43 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
63284 43 : psProgressInfo->nLastReported = -1;
63285 43 : psProgressInfo->psPyCallback = NULL;
63286 43 : psProgressInfo->psPyCallbackData = NULL;
63287 43 : arg5 = psProgressInfo;
63288 43 : if (!SWIG_Python_UnpackTuple(args, "wrapper_GDALNearblackDestName", 3, 5, swig_obj)) SWIG_fail;
63289 43 : {
63290 : /* %typemap(in) (const char *utf8_path) */
63291 43 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
63292 : {
63293 41 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
63294 : }
63295 : else
63296 : {
63297 2 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
63298 :
63299 : }
63300 43 : if (arg1 == NULL)
63301 : {
63302 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
63303 0 : SWIG_fail;
63304 : }
63305 : }
63306 43 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
63307 43 : if (!SWIG_IsOK(res2)) {
63308 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wrapper_GDALNearblackDestName" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
63309 : }
63310 43 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
63311 43 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALNearblackOptions, 0 | 0 );
63312 43 : if (!SWIG_IsOK(res3)) {
63313 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wrapper_GDALNearblackDestName" "', argument " "3"" of type '" "GDALNearblackOptions *""'");
63314 : }
63315 43 : arg3 = reinterpret_cast< GDALNearblackOptions * >(argp3);
63316 43 : if (swig_obj[3]) {
63317 43 : {
63318 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
63319 : /* callback_func typemap */
63320 :
63321 : /* In some cases 0 is passed instead of None. */
63322 : /* See https://github.com/OSGeo/gdal/pull/219 */
63323 43 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
63324 : {
63325 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
63326 : {
63327 0 : swig_obj[3] = Py_None;
63328 : }
63329 : }
63330 :
63331 43 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
63332 0 : void* cbfunction = NULL;
63333 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
63334 : (void**)&cbfunction,
63335 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
63336 : SWIG_POINTER_EXCEPTION | 0 ));
63337 :
63338 0 : if ( cbfunction == GDALTermProgress ) {
63339 : arg4 = GDALTermProgress;
63340 : } else {
63341 0 : if (!PyCallable_Check(swig_obj[3])) {
63342 0 : PyErr_SetString( PyExc_RuntimeError,
63343 : "Object given is not a Python function" );
63344 0 : SWIG_fail;
63345 : }
63346 0 : psProgressInfo->psPyCallback = swig_obj[3];
63347 0 : arg4 = PyProgressProxy;
63348 : }
63349 :
63350 : }
63351 :
63352 : }
63353 : }
63354 43 : if (swig_obj[4]) {
63355 43 : {
63356 : /* %typemap(in) ( void* callback_data=NULL) */
63357 43 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
63358 : }
63359 : }
63360 43 : {
63361 43 : if (!arg1) {
63362 43 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
63363 : }
63364 : }
63365 43 : {
63366 43 : const int bLocalUseExceptions = GetUseExceptions();
63367 43 : if ( bLocalUseExceptions ) {
63368 43 : pushErrorHandler();
63369 : }
63370 43 : {
63371 43 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
63372 43 : result = (GDALDatasetShadow *)wrapper_GDALNearblackDestName((char const *)arg1,arg2,arg3,arg4,arg5);
63373 43 : SWIG_PYTHON_THREAD_END_ALLOW;
63374 : }
63375 43 : if ( bLocalUseExceptions ) {
63376 43 : popErrorHandler();
63377 : }
63378 : #ifndef SED_HACKS
63379 : if ( bLocalUseExceptions ) {
63380 : CPLErr eclass = CPLGetLastErrorType();
63381 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
63382 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
63383 : }
63384 : }
63385 : #endif
63386 : }
63387 43 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
63388 43 : {
63389 : /* %typemap(freearg) (const char *utf8_path) */
63390 43 : GDALPythonFreeCStr(arg1, bToFree1);
63391 : }
63392 43 : {
63393 : /* %typemap(freearg) ( void* callback_data=NULL) */
63394 :
63395 43 : CPLFree(psProgressInfo);
63396 :
63397 : }
63398 43 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
63399 : return resultobj;
63400 0 : fail:
63401 0 : {
63402 : /* %typemap(freearg) (const char *utf8_path) */
63403 0 : GDALPythonFreeCStr(arg1, bToFree1);
63404 : }
63405 0 : {
63406 : /* %typemap(freearg) ( void* callback_data=NULL) */
63407 :
63408 0 : CPLFree(psProgressInfo);
63409 :
63410 : }
63411 : return NULL;
63412 : }
63413 :
63414 :
63415 52 : SWIGINTERN PyObject *_wrap_new_GDALGridOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63416 52 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
63417 52 : char **arg1 = (char **) 0 ;
63418 52 : PyObject *swig_obj[1] ;
63419 52 : GDALGridOptions *result = 0 ;
63420 :
63421 52 : if (!args) SWIG_fail;
63422 52 : swig_obj[0] = args;
63423 52 : {
63424 : /* %typemap(in) char **dict */
63425 52 : arg1 = NULL;
63426 52 : if ( PySequence_Check( swig_obj[0] ) ) {
63427 52 : int bErr = FALSE;
63428 52 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
63429 52 : if ( bErr )
63430 : {
63431 0 : SWIG_fail;
63432 : }
63433 : }
63434 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
63435 0 : int bErr = FALSE;
63436 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
63437 0 : if ( bErr )
63438 : {
63439 0 : SWIG_fail;
63440 : }
63441 : }
63442 : else {
63443 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
63444 0 : SWIG_fail;
63445 : }
63446 : }
63447 52 : {
63448 52 : const int bLocalUseExceptions = GetUseExceptions();
63449 52 : if ( bLocalUseExceptions ) {
63450 51 : pushErrorHandler();
63451 : }
63452 52 : {
63453 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
63454 52 : result = (GDALGridOptions *)new_GDALGridOptions(arg1);
63455 52 : SWIG_PYTHON_THREAD_END_ALLOW;
63456 : }
63457 52 : if ( bLocalUseExceptions ) {
63458 51 : popErrorHandler();
63459 : }
63460 : #ifndef SED_HACKS
63461 : if ( bLocalUseExceptions ) {
63462 : CPLErr eclass = CPLGetLastErrorType();
63463 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
63464 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
63465 : }
63466 : }
63467 : #endif
63468 : }
63469 52 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALGridOptions, SWIG_POINTER_NEW | 0 );
63470 52 : {
63471 : /* %typemap(freearg) char **dict */
63472 52 : CSLDestroy( arg1 );
63473 : }
63474 52 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
63475 : return resultobj;
63476 0 : fail:
63477 0 : {
63478 : /* %typemap(freearg) char **dict */
63479 0 : CSLDestroy( arg1 );
63480 : }
63481 : return NULL;
63482 : }
63483 :
63484 :
63485 52 : SWIGINTERN PyObject *_wrap_delete_GDALGridOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63486 52 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
63487 52 : GDALGridOptions *arg1 = (GDALGridOptions *) 0 ;
63488 52 : void *argp1 = 0 ;
63489 52 : int res1 = 0 ;
63490 52 : PyObject *swig_obj[1] ;
63491 :
63492 52 : if (!args) SWIG_fail;
63493 52 : swig_obj[0] = args;
63494 52 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALGridOptions, SWIG_POINTER_DISOWN | 0 );
63495 52 : if (!SWIG_IsOK(res1)) {
63496 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALGridOptions" "', argument " "1"" of type '" "GDALGridOptions *""'");
63497 : }
63498 52 : arg1 = reinterpret_cast< GDALGridOptions * >(argp1);
63499 52 : {
63500 52 : const int bLocalUseExceptions = GetUseExceptions();
63501 52 : if ( bLocalUseExceptions ) {
63502 51 : pushErrorHandler();
63503 : }
63504 52 : {
63505 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
63506 52 : delete_GDALGridOptions(arg1);
63507 52 : SWIG_PYTHON_THREAD_END_ALLOW;
63508 : }
63509 52 : if ( bLocalUseExceptions ) {
63510 51 : popErrorHandler();
63511 : }
63512 : #ifndef SED_HACKS
63513 : if ( bLocalUseExceptions ) {
63514 : CPLErr eclass = CPLGetLastErrorType();
63515 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
63516 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
63517 : }
63518 : }
63519 : #endif
63520 : }
63521 52 : resultobj = SWIG_Py_Void();
63522 52 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
63523 : return resultobj;
63524 : fail:
63525 : return NULL;
63526 : }
63527 :
63528 :
63529 277 : SWIGINTERN PyObject *GDALGridOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63530 277 : PyObject *obj;
63531 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
63532 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALGridOptions, SWIG_NewClientData(obj));
63533 277 : return SWIG_Py_Void();
63534 : }
63535 :
63536 52 : SWIGINTERN PyObject *GDALGridOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63537 52 : return SWIG_Python_InitShadowInstance(args);
63538 : }
63539 :
63540 52 : SWIGINTERN PyObject *_wrap_GridInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63541 52 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
63542 52 : char *arg1 = (char *) 0 ;
63543 52 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
63544 52 : GDALGridOptions *arg3 = (GDALGridOptions *) 0 ;
63545 52 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
63546 52 : void *arg5 = (void *) NULL ;
63547 52 : int bToFree1 = 0 ;
63548 52 : void *argp2 = 0 ;
63549 52 : int res2 = 0 ;
63550 52 : void *argp3 = 0 ;
63551 52 : int res3 = 0 ;
63552 52 : PyObject *swig_obj[5] ;
63553 52 : GDALDatasetShadow *result = 0 ;
63554 :
63555 : /* %typemap(arginit) ( const char* callback_data=NULL) */
63556 52 : PyProgressData *psProgressInfo;
63557 52 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
63558 52 : psProgressInfo->nLastReported = -1;
63559 52 : psProgressInfo->psPyCallback = NULL;
63560 52 : psProgressInfo->psPyCallbackData = NULL;
63561 52 : arg5 = psProgressInfo;
63562 52 : if (!SWIG_Python_UnpackTuple(args, "GridInternal", 3, 5, swig_obj)) SWIG_fail;
63563 52 : {
63564 : /* %typemap(in) (const char *utf8_path) */
63565 52 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
63566 : {
63567 52 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
63568 : }
63569 : else
63570 : {
63571 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
63572 :
63573 : }
63574 52 : if (arg1 == NULL)
63575 : {
63576 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
63577 0 : SWIG_fail;
63578 : }
63579 : }
63580 52 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
63581 52 : if (!SWIG_IsOK(res2)) {
63582 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridInternal" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
63583 : }
63584 52 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
63585 52 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALGridOptions, 0 | 0 );
63586 52 : if (!SWIG_IsOK(res3)) {
63587 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridInternal" "', argument " "3"" of type '" "GDALGridOptions *""'");
63588 : }
63589 52 : arg3 = reinterpret_cast< GDALGridOptions * >(argp3);
63590 52 : if (swig_obj[3]) {
63591 52 : {
63592 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
63593 : /* callback_func typemap */
63594 :
63595 : /* In some cases 0 is passed instead of None. */
63596 : /* See https://github.com/OSGeo/gdal/pull/219 */
63597 52 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
63598 : {
63599 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
63600 : {
63601 0 : swig_obj[3] = Py_None;
63602 : }
63603 : }
63604 :
63605 52 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
63606 0 : void* cbfunction = NULL;
63607 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
63608 : (void**)&cbfunction,
63609 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
63610 : SWIG_POINTER_EXCEPTION | 0 ));
63611 :
63612 0 : if ( cbfunction == GDALTermProgress ) {
63613 : arg4 = GDALTermProgress;
63614 : } else {
63615 0 : if (!PyCallable_Check(swig_obj[3])) {
63616 0 : PyErr_SetString( PyExc_RuntimeError,
63617 : "Object given is not a Python function" );
63618 0 : SWIG_fail;
63619 : }
63620 0 : psProgressInfo->psPyCallback = swig_obj[3];
63621 0 : arg4 = PyProgressProxy;
63622 : }
63623 :
63624 : }
63625 :
63626 : }
63627 : }
63628 52 : if (swig_obj[4]) {
63629 52 : {
63630 : /* %typemap(in) ( void* callback_data=NULL) */
63631 52 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
63632 : }
63633 : }
63634 52 : {
63635 52 : if (!arg1) {
63636 52 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
63637 : }
63638 : }
63639 52 : {
63640 52 : if (!arg2) {
63641 0 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
63642 : }
63643 : }
63644 52 : {
63645 52 : const int bLocalUseExceptions = GetUseExceptions();
63646 52 : if ( bLocalUseExceptions ) {
63647 51 : pushErrorHandler();
63648 : }
63649 52 : {
63650 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
63651 52 : result = (GDALDatasetShadow *)wrapper_GDALGrid((char const *)arg1,arg2,arg3,arg4,arg5);
63652 52 : SWIG_PYTHON_THREAD_END_ALLOW;
63653 : }
63654 52 : if ( bLocalUseExceptions ) {
63655 51 : popErrorHandler();
63656 : }
63657 : #ifndef SED_HACKS
63658 : if ( bLocalUseExceptions ) {
63659 : CPLErr eclass = CPLGetLastErrorType();
63660 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
63661 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
63662 : }
63663 : }
63664 : #endif
63665 : }
63666 52 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
63667 52 : {
63668 : /* %typemap(freearg) (const char *utf8_path) */
63669 52 : GDALPythonFreeCStr(arg1, bToFree1);
63670 : }
63671 52 : {
63672 : /* %typemap(freearg) ( void* callback_data=NULL) */
63673 :
63674 52 : CPLFree(psProgressInfo);
63675 :
63676 : }
63677 58 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
63678 : return resultobj;
63679 0 : fail:
63680 0 : {
63681 : /* %typemap(freearg) (const char *utf8_path) */
63682 0 : GDALPythonFreeCStr(arg1, bToFree1);
63683 : }
63684 0 : {
63685 : /* %typemap(freearg) ( void* callback_data=NULL) */
63686 :
63687 0 : CPLFree(psProgressInfo);
63688 :
63689 : }
63690 : return NULL;
63691 : }
63692 :
63693 :
63694 12 : SWIGINTERN PyObject *_wrap_new_GDALContourOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63695 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
63696 12 : char **arg1 = (char **) 0 ;
63697 12 : PyObject *swig_obj[1] ;
63698 12 : GDALContourOptions *result = 0 ;
63699 :
63700 12 : if (!args) SWIG_fail;
63701 12 : swig_obj[0] = args;
63702 12 : {
63703 : /* %typemap(in) char **dict */
63704 12 : arg1 = NULL;
63705 12 : if ( PySequence_Check( swig_obj[0] ) ) {
63706 12 : int bErr = FALSE;
63707 12 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
63708 12 : if ( bErr )
63709 : {
63710 0 : SWIG_fail;
63711 : }
63712 : }
63713 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
63714 0 : int bErr = FALSE;
63715 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
63716 0 : if ( bErr )
63717 : {
63718 0 : SWIG_fail;
63719 : }
63720 : }
63721 : else {
63722 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
63723 0 : SWIG_fail;
63724 : }
63725 : }
63726 12 : {
63727 12 : const int bLocalUseExceptions = GetUseExceptions();
63728 12 : if ( bLocalUseExceptions ) {
63729 12 : pushErrorHandler();
63730 : }
63731 12 : {
63732 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
63733 12 : result = (GDALContourOptions *)new_GDALContourOptions(arg1);
63734 12 : SWIG_PYTHON_THREAD_END_ALLOW;
63735 : }
63736 12 : if ( bLocalUseExceptions ) {
63737 12 : popErrorHandler();
63738 : }
63739 : #ifndef SED_HACKS
63740 : if ( bLocalUseExceptions ) {
63741 : CPLErr eclass = CPLGetLastErrorType();
63742 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
63743 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
63744 : }
63745 : }
63746 : #endif
63747 : }
63748 12 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALContourOptions, SWIG_POINTER_NEW | 0 );
63749 12 : {
63750 : /* %typemap(freearg) char **dict */
63751 12 : CSLDestroy( arg1 );
63752 : }
63753 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
63754 : return resultobj;
63755 0 : fail:
63756 0 : {
63757 : /* %typemap(freearg) char **dict */
63758 0 : CSLDestroy( arg1 );
63759 : }
63760 : return NULL;
63761 : }
63762 :
63763 :
63764 12 : SWIGINTERN PyObject *_wrap_delete_GDALContourOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63765 12 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
63766 12 : GDALContourOptions *arg1 = (GDALContourOptions *) 0 ;
63767 12 : void *argp1 = 0 ;
63768 12 : int res1 = 0 ;
63769 12 : PyObject *swig_obj[1] ;
63770 :
63771 12 : if (!args) SWIG_fail;
63772 12 : swig_obj[0] = args;
63773 12 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALContourOptions, SWIG_POINTER_DISOWN | 0 );
63774 12 : if (!SWIG_IsOK(res1)) {
63775 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALContourOptions" "', argument " "1"" of type '" "GDALContourOptions *""'");
63776 : }
63777 12 : arg1 = reinterpret_cast< GDALContourOptions * >(argp1);
63778 12 : {
63779 12 : const int bLocalUseExceptions = GetUseExceptions();
63780 12 : if ( bLocalUseExceptions ) {
63781 12 : pushErrorHandler();
63782 : }
63783 12 : {
63784 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
63785 12 : delete_GDALContourOptions(arg1);
63786 12 : SWIG_PYTHON_THREAD_END_ALLOW;
63787 : }
63788 12 : if ( bLocalUseExceptions ) {
63789 12 : popErrorHandler();
63790 : }
63791 : #ifndef SED_HACKS
63792 : if ( bLocalUseExceptions ) {
63793 : CPLErr eclass = CPLGetLastErrorType();
63794 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
63795 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
63796 : }
63797 : }
63798 : #endif
63799 : }
63800 12 : resultobj = SWIG_Py_Void();
63801 12 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
63802 : return resultobj;
63803 : fail:
63804 : return NULL;
63805 : }
63806 :
63807 :
63808 277 : SWIGINTERN PyObject *GDALContourOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63809 277 : PyObject *obj;
63810 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
63811 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALContourOptions, SWIG_NewClientData(obj));
63812 277 : return SWIG_Py_Void();
63813 : }
63814 :
63815 12 : SWIGINTERN PyObject *GDALContourOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63816 12 : return SWIG_Python_InitShadowInstance(args);
63817 : }
63818 :
63819 6 : SWIGINTERN PyObject *_wrap_wrapper_GDALContourDestDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63820 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
63821 6 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
63822 6 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
63823 6 : GDALContourOptions *arg3 = (GDALContourOptions *) 0 ;
63824 6 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
63825 6 : void *arg5 = (void *) NULL ;
63826 6 : void *argp1 = 0 ;
63827 6 : int res1 = 0 ;
63828 6 : void *argp2 = 0 ;
63829 6 : int res2 = 0 ;
63830 6 : void *argp3 = 0 ;
63831 6 : int res3 = 0 ;
63832 6 : PyObject *swig_obj[5] ;
63833 6 : int result;
63834 :
63835 : /* %typemap(arginit) ( const char* callback_data=NULL) */
63836 6 : PyProgressData *psProgressInfo;
63837 6 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
63838 6 : psProgressInfo->nLastReported = -1;
63839 6 : psProgressInfo->psPyCallback = NULL;
63840 6 : psProgressInfo->psPyCallbackData = NULL;
63841 6 : arg5 = psProgressInfo;
63842 6 : if (!SWIG_Python_UnpackTuple(args, "wrapper_GDALContourDestDS", 3, 5, swig_obj)) SWIG_fail;
63843 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
63844 6 : if (!SWIG_IsOK(res1)) {
63845 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wrapper_GDALContourDestDS" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
63846 : }
63847 6 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
63848 6 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
63849 6 : if (!SWIG_IsOK(res2)) {
63850 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wrapper_GDALContourDestDS" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
63851 : }
63852 6 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
63853 6 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALContourOptions, 0 | 0 );
63854 6 : if (!SWIG_IsOK(res3)) {
63855 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wrapper_GDALContourDestDS" "', argument " "3"" of type '" "GDALContourOptions *""'");
63856 : }
63857 6 : arg3 = reinterpret_cast< GDALContourOptions * >(argp3);
63858 6 : if (swig_obj[3]) {
63859 6 : {
63860 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
63861 : /* callback_func typemap */
63862 :
63863 : /* In some cases 0 is passed instead of None. */
63864 : /* See https://github.com/OSGeo/gdal/pull/219 */
63865 6 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
63866 : {
63867 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
63868 : {
63869 0 : swig_obj[3] = Py_None;
63870 : }
63871 : }
63872 :
63873 6 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
63874 0 : void* cbfunction = NULL;
63875 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
63876 : (void**)&cbfunction,
63877 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
63878 : SWIG_POINTER_EXCEPTION | 0 ));
63879 :
63880 0 : if ( cbfunction == GDALTermProgress ) {
63881 : arg4 = GDALTermProgress;
63882 : } else {
63883 0 : if (!PyCallable_Check(swig_obj[3])) {
63884 0 : PyErr_SetString( PyExc_RuntimeError,
63885 : "Object given is not a Python function" );
63886 0 : SWIG_fail;
63887 : }
63888 0 : psProgressInfo->psPyCallback = swig_obj[3];
63889 0 : arg4 = PyProgressProxy;
63890 : }
63891 :
63892 : }
63893 :
63894 : }
63895 : }
63896 6 : if (swig_obj[4]) {
63897 6 : {
63898 : /* %typemap(in) ( void* callback_data=NULL) */
63899 6 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
63900 : }
63901 : }
63902 6 : {
63903 6 : const int bLocalUseExceptions = GetUseExceptions();
63904 6 : if ( bLocalUseExceptions ) {
63905 6 : pushErrorHandler();
63906 : }
63907 6 : {
63908 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
63909 6 : result = (int)wrapper_GDALContourDestDS(arg1,arg2,arg3,arg4,arg5);
63910 6 : SWIG_PYTHON_THREAD_END_ALLOW;
63911 : }
63912 6 : if ( bLocalUseExceptions ) {
63913 6 : popErrorHandler();
63914 : }
63915 : #ifndef SED_HACKS
63916 : if ( bLocalUseExceptions ) {
63917 : CPLErr eclass = CPLGetLastErrorType();
63918 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
63919 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
63920 : }
63921 : }
63922 : #endif
63923 : }
63924 6 : resultobj = SWIG_From_int(static_cast< int >(result));
63925 6 : {
63926 : /* %typemap(freearg) ( void* callback_data=NULL) */
63927 :
63928 6 : CPLFree(psProgressInfo);
63929 :
63930 : }
63931 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
63932 : return resultobj;
63933 0 : fail:
63934 0 : {
63935 : /* %typemap(freearg) ( void* callback_data=NULL) */
63936 :
63937 0 : CPLFree(psProgressInfo);
63938 :
63939 : }
63940 : return NULL;
63941 : }
63942 :
63943 :
63944 6 : SWIGINTERN PyObject *_wrap_wrapper_GDALContourDestName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
63945 6 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
63946 6 : char *arg1 = (char *) 0 ;
63947 6 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
63948 6 : GDALContourOptions *arg3 = (GDALContourOptions *) 0 ;
63949 6 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
63950 6 : void *arg5 = (void *) NULL ;
63951 6 : int bToFree1 = 0 ;
63952 6 : void *argp2 = 0 ;
63953 6 : int res2 = 0 ;
63954 6 : void *argp3 = 0 ;
63955 6 : int res3 = 0 ;
63956 6 : PyObject *swig_obj[5] ;
63957 6 : GDALDatasetShadow *result = 0 ;
63958 :
63959 : /* %typemap(arginit) ( const char* callback_data=NULL) */
63960 6 : PyProgressData *psProgressInfo;
63961 6 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
63962 6 : psProgressInfo->nLastReported = -1;
63963 6 : psProgressInfo->psPyCallback = NULL;
63964 6 : psProgressInfo->psPyCallbackData = NULL;
63965 6 : arg5 = psProgressInfo;
63966 6 : if (!SWIG_Python_UnpackTuple(args, "wrapper_GDALContourDestName", 3, 5, swig_obj)) SWIG_fail;
63967 6 : {
63968 : /* %typemap(in) (const char *utf8_path) */
63969 6 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
63970 : {
63971 6 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
63972 : }
63973 : else
63974 : {
63975 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
63976 :
63977 : }
63978 6 : if (arg1 == NULL)
63979 : {
63980 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
63981 0 : SWIG_fail;
63982 : }
63983 : }
63984 6 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
63985 6 : if (!SWIG_IsOK(res2)) {
63986 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wrapper_GDALContourDestName" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
63987 : }
63988 6 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
63989 6 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALContourOptions, 0 | 0 );
63990 6 : if (!SWIG_IsOK(res3)) {
63991 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wrapper_GDALContourDestName" "', argument " "3"" of type '" "GDALContourOptions *""'");
63992 : }
63993 6 : arg3 = reinterpret_cast< GDALContourOptions * >(argp3);
63994 6 : if (swig_obj[3]) {
63995 6 : {
63996 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
63997 : /* callback_func typemap */
63998 :
63999 : /* In some cases 0 is passed instead of None. */
64000 : /* See https://github.com/OSGeo/gdal/pull/219 */
64001 6 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
64002 : {
64003 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
64004 : {
64005 0 : swig_obj[3] = Py_None;
64006 : }
64007 : }
64008 :
64009 6 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
64010 0 : void* cbfunction = NULL;
64011 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
64012 : (void**)&cbfunction,
64013 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
64014 : SWIG_POINTER_EXCEPTION | 0 ));
64015 :
64016 0 : if ( cbfunction == GDALTermProgress ) {
64017 : arg4 = GDALTermProgress;
64018 : } else {
64019 0 : if (!PyCallable_Check(swig_obj[3])) {
64020 0 : PyErr_SetString( PyExc_RuntimeError,
64021 : "Object given is not a Python function" );
64022 0 : SWIG_fail;
64023 : }
64024 0 : psProgressInfo->psPyCallback = swig_obj[3];
64025 0 : arg4 = PyProgressProxy;
64026 : }
64027 :
64028 : }
64029 :
64030 : }
64031 : }
64032 6 : if (swig_obj[4]) {
64033 6 : {
64034 : /* %typemap(in) ( void* callback_data=NULL) */
64035 6 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
64036 : }
64037 : }
64038 6 : {
64039 6 : if (!arg1) {
64040 6 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
64041 : }
64042 : }
64043 6 : {
64044 6 : const int bLocalUseExceptions = GetUseExceptions();
64045 6 : if ( bLocalUseExceptions ) {
64046 6 : pushErrorHandler();
64047 : }
64048 6 : {
64049 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
64050 6 : result = (GDALDatasetShadow *)wrapper_GDALContourDestName((char const *)arg1,arg2,arg3,arg4,arg5);
64051 6 : SWIG_PYTHON_THREAD_END_ALLOW;
64052 : }
64053 6 : if ( bLocalUseExceptions ) {
64054 6 : popErrorHandler();
64055 : }
64056 : #ifndef SED_HACKS
64057 : if ( bLocalUseExceptions ) {
64058 : CPLErr eclass = CPLGetLastErrorType();
64059 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
64060 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
64061 : }
64062 : }
64063 : #endif
64064 : }
64065 6 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
64066 6 : {
64067 : /* %typemap(freearg) (const char *utf8_path) */
64068 6 : GDALPythonFreeCStr(arg1, bToFree1);
64069 : }
64070 6 : {
64071 : /* %typemap(freearg) ( void* callback_data=NULL) */
64072 :
64073 6 : CPLFree(psProgressInfo);
64074 :
64075 : }
64076 6 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
64077 : return resultobj;
64078 0 : fail:
64079 0 : {
64080 : /* %typemap(freearg) (const char *utf8_path) */
64081 0 : GDALPythonFreeCStr(arg1, bToFree1);
64082 : }
64083 0 : {
64084 : /* %typemap(freearg) ( void* callback_data=NULL) */
64085 :
64086 0 : CPLFree(psProgressInfo);
64087 :
64088 : }
64089 : return NULL;
64090 : }
64091 :
64092 :
64093 23 : SWIGINTERN PyObject *_wrap_new_GDALRasterizeOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
64094 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
64095 23 : char **arg1 = (char **) 0 ;
64096 23 : PyObject *swig_obj[1] ;
64097 23 : GDALRasterizeOptions *result = 0 ;
64098 :
64099 23 : if (!args) SWIG_fail;
64100 23 : swig_obj[0] = args;
64101 23 : {
64102 : /* %typemap(in) char **dict */
64103 23 : arg1 = NULL;
64104 23 : if ( PySequence_Check( swig_obj[0] ) ) {
64105 23 : int bErr = FALSE;
64106 23 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
64107 23 : if ( bErr )
64108 : {
64109 0 : SWIG_fail;
64110 : }
64111 : }
64112 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
64113 0 : int bErr = FALSE;
64114 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
64115 0 : if ( bErr )
64116 : {
64117 0 : SWIG_fail;
64118 : }
64119 : }
64120 : else {
64121 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
64122 0 : SWIG_fail;
64123 : }
64124 : }
64125 23 : {
64126 23 : const int bLocalUseExceptions = GetUseExceptions();
64127 23 : if ( bLocalUseExceptions ) {
64128 23 : pushErrorHandler();
64129 : }
64130 23 : {
64131 23 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
64132 23 : result = (GDALRasterizeOptions *)new_GDALRasterizeOptions(arg1);
64133 23 : SWIG_PYTHON_THREAD_END_ALLOW;
64134 : }
64135 23 : if ( bLocalUseExceptions ) {
64136 23 : popErrorHandler();
64137 : }
64138 : #ifndef SED_HACKS
64139 : if ( bLocalUseExceptions ) {
64140 : CPLErr eclass = CPLGetLastErrorType();
64141 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
64142 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
64143 : }
64144 : }
64145 : #endif
64146 : }
64147 23 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALRasterizeOptions, SWIG_POINTER_NEW | 0 );
64148 23 : {
64149 : /* %typemap(freearg) char **dict */
64150 23 : CSLDestroy( arg1 );
64151 : }
64152 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
64153 : return resultobj;
64154 0 : fail:
64155 0 : {
64156 : /* %typemap(freearg) char **dict */
64157 0 : CSLDestroy( arg1 );
64158 : }
64159 : return NULL;
64160 : }
64161 :
64162 :
64163 23 : SWIGINTERN PyObject *_wrap_delete_GDALRasterizeOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
64164 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
64165 23 : GDALRasterizeOptions *arg1 = (GDALRasterizeOptions *) 0 ;
64166 23 : void *argp1 = 0 ;
64167 23 : int res1 = 0 ;
64168 23 : PyObject *swig_obj[1] ;
64169 :
64170 23 : if (!args) SWIG_fail;
64171 23 : swig_obj[0] = args;
64172 23 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALRasterizeOptions, SWIG_POINTER_DISOWN | 0 );
64173 23 : if (!SWIG_IsOK(res1)) {
64174 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALRasterizeOptions" "', argument " "1"" of type '" "GDALRasterizeOptions *""'");
64175 : }
64176 23 : arg1 = reinterpret_cast< GDALRasterizeOptions * >(argp1);
64177 23 : {
64178 23 : const int bLocalUseExceptions = GetUseExceptions();
64179 23 : if ( bLocalUseExceptions ) {
64180 23 : pushErrorHandler();
64181 : }
64182 23 : {
64183 23 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
64184 23 : delete_GDALRasterizeOptions(arg1);
64185 23 : SWIG_PYTHON_THREAD_END_ALLOW;
64186 : }
64187 23 : if ( bLocalUseExceptions ) {
64188 23 : popErrorHandler();
64189 : }
64190 : #ifndef SED_HACKS
64191 : if ( bLocalUseExceptions ) {
64192 : CPLErr eclass = CPLGetLastErrorType();
64193 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
64194 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
64195 : }
64196 : }
64197 : #endif
64198 : }
64199 23 : resultobj = SWIG_Py_Void();
64200 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
64201 : return resultobj;
64202 : fail:
64203 : return NULL;
64204 : }
64205 :
64206 :
64207 277 : SWIGINTERN PyObject *GDALRasterizeOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
64208 277 : PyObject *obj;
64209 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
64210 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALRasterizeOptions, SWIG_NewClientData(obj));
64211 277 : return SWIG_Py_Void();
64212 : }
64213 :
64214 23 : SWIGINTERN PyObject *GDALRasterizeOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
64215 23 : return SWIG_Python_InitShadowInstance(args);
64216 : }
64217 :
64218 13 : SWIGINTERN PyObject *_wrap_wrapper_GDALRasterizeDestDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
64219 13 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
64220 13 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
64221 13 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
64222 13 : GDALRasterizeOptions *arg3 = (GDALRasterizeOptions *) 0 ;
64223 13 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
64224 13 : void *arg5 = (void *) NULL ;
64225 13 : void *argp1 = 0 ;
64226 13 : int res1 = 0 ;
64227 13 : void *argp2 = 0 ;
64228 13 : int res2 = 0 ;
64229 13 : void *argp3 = 0 ;
64230 13 : int res3 = 0 ;
64231 13 : PyObject *swig_obj[5] ;
64232 13 : int result;
64233 :
64234 : /* %typemap(arginit) ( const char* callback_data=NULL) */
64235 13 : PyProgressData *psProgressInfo;
64236 13 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
64237 13 : psProgressInfo->nLastReported = -1;
64238 13 : psProgressInfo->psPyCallback = NULL;
64239 13 : psProgressInfo->psPyCallbackData = NULL;
64240 13 : arg5 = psProgressInfo;
64241 13 : if (!SWIG_Python_UnpackTuple(args, "wrapper_GDALRasterizeDestDS", 3, 5, swig_obj)) SWIG_fail;
64242 13 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
64243 13 : if (!SWIG_IsOK(res1)) {
64244 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wrapper_GDALRasterizeDestDS" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
64245 : }
64246 13 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
64247 13 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
64248 13 : if (!SWIG_IsOK(res2)) {
64249 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wrapper_GDALRasterizeDestDS" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
64250 : }
64251 13 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
64252 13 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALRasterizeOptions, 0 | 0 );
64253 13 : if (!SWIG_IsOK(res3)) {
64254 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wrapper_GDALRasterizeDestDS" "', argument " "3"" of type '" "GDALRasterizeOptions *""'");
64255 : }
64256 13 : arg3 = reinterpret_cast< GDALRasterizeOptions * >(argp3);
64257 13 : if (swig_obj[3]) {
64258 13 : {
64259 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
64260 : /* callback_func typemap */
64261 :
64262 : /* In some cases 0 is passed instead of None. */
64263 : /* See https://github.com/OSGeo/gdal/pull/219 */
64264 13 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
64265 : {
64266 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
64267 : {
64268 0 : swig_obj[3] = Py_None;
64269 : }
64270 : }
64271 :
64272 13 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
64273 0 : void* cbfunction = NULL;
64274 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
64275 : (void**)&cbfunction,
64276 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
64277 : SWIG_POINTER_EXCEPTION | 0 ));
64278 :
64279 0 : if ( cbfunction == GDALTermProgress ) {
64280 : arg4 = GDALTermProgress;
64281 : } else {
64282 0 : if (!PyCallable_Check(swig_obj[3])) {
64283 0 : PyErr_SetString( PyExc_RuntimeError,
64284 : "Object given is not a Python function" );
64285 0 : SWIG_fail;
64286 : }
64287 0 : psProgressInfo->psPyCallback = swig_obj[3];
64288 0 : arg4 = PyProgressProxy;
64289 : }
64290 :
64291 : }
64292 :
64293 : }
64294 : }
64295 13 : if (swig_obj[4]) {
64296 13 : {
64297 : /* %typemap(in) ( void* callback_data=NULL) */
64298 13 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
64299 : }
64300 : }
64301 13 : {
64302 13 : const int bLocalUseExceptions = GetUseExceptions();
64303 13 : if ( bLocalUseExceptions ) {
64304 13 : pushErrorHandler();
64305 : }
64306 13 : {
64307 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
64308 13 : result = (int)wrapper_GDALRasterizeDestDS(arg1,arg2,arg3,arg4,arg5);
64309 13 : SWIG_PYTHON_THREAD_END_ALLOW;
64310 : }
64311 13 : if ( bLocalUseExceptions ) {
64312 13 : popErrorHandler();
64313 : }
64314 : #ifndef SED_HACKS
64315 : if ( bLocalUseExceptions ) {
64316 : CPLErr eclass = CPLGetLastErrorType();
64317 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
64318 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
64319 : }
64320 : }
64321 : #endif
64322 : }
64323 13 : resultobj = SWIG_From_int(static_cast< int >(result));
64324 13 : {
64325 : /* %typemap(freearg) ( void* callback_data=NULL) */
64326 :
64327 13 : CPLFree(psProgressInfo);
64328 :
64329 : }
64330 13 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
64331 : return resultobj;
64332 0 : fail:
64333 0 : {
64334 : /* %typemap(freearg) ( void* callback_data=NULL) */
64335 :
64336 0 : CPLFree(psProgressInfo);
64337 :
64338 : }
64339 : return NULL;
64340 : }
64341 :
64342 :
64343 10 : SWIGINTERN PyObject *_wrap_wrapper_GDALRasterizeDestName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
64344 10 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
64345 10 : char *arg1 = (char *) 0 ;
64346 10 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
64347 10 : GDALRasterizeOptions *arg3 = (GDALRasterizeOptions *) 0 ;
64348 10 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
64349 10 : void *arg5 = (void *) NULL ;
64350 10 : int bToFree1 = 0 ;
64351 10 : void *argp2 = 0 ;
64352 10 : int res2 = 0 ;
64353 10 : void *argp3 = 0 ;
64354 10 : int res3 = 0 ;
64355 10 : PyObject *swig_obj[5] ;
64356 10 : GDALDatasetShadow *result = 0 ;
64357 :
64358 : /* %typemap(arginit) ( const char* callback_data=NULL) */
64359 10 : PyProgressData *psProgressInfo;
64360 10 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
64361 10 : psProgressInfo->nLastReported = -1;
64362 10 : psProgressInfo->psPyCallback = NULL;
64363 10 : psProgressInfo->psPyCallbackData = NULL;
64364 10 : arg5 = psProgressInfo;
64365 10 : if (!SWIG_Python_UnpackTuple(args, "wrapper_GDALRasterizeDestName", 3, 5, swig_obj)) SWIG_fail;
64366 10 : {
64367 : /* %typemap(in) (const char *utf8_path) */
64368 10 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
64369 : {
64370 6 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
64371 : }
64372 : else
64373 : {
64374 4 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
64375 :
64376 : }
64377 10 : if (arg1 == NULL)
64378 : {
64379 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
64380 0 : SWIG_fail;
64381 : }
64382 : }
64383 10 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
64384 10 : if (!SWIG_IsOK(res2)) {
64385 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wrapper_GDALRasterizeDestName" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
64386 : }
64387 10 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
64388 10 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALRasterizeOptions, 0 | 0 );
64389 10 : if (!SWIG_IsOK(res3)) {
64390 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wrapper_GDALRasterizeDestName" "', argument " "3"" of type '" "GDALRasterizeOptions *""'");
64391 : }
64392 10 : arg3 = reinterpret_cast< GDALRasterizeOptions * >(argp3);
64393 10 : if (swig_obj[3]) {
64394 10 : {
64395 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
64396 : /* callback_func typemap */
64397 :
64398 : /* In some cases 0 is passed instead of None. */
64399 : /* See https://github.com/OSGeo/gdal/pull/219 */
64400 10 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
64401 : {
64402 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
64403 : {
64404 0 : swig_obj[3] = Py_None;
64405 : }
64406 : }
64407 :
64408 10 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
64409 0 : void* cbfunction = NULL;
64410 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
64411 : (void**)&cbfunction,
64412 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
64413 : SWIG_POINTER_EXCEPTION | 0 ));
64414 :
64415 0 : if ( cbfunction == GDALTermProgress ) {
64416 : arg4 = GDALTermProgress;
64417 : } else {
64418 0 : if (!PyCallable_Check(swig_obj[3])) {
64419 0 : PyErr_SetString( PyExc_RuntimeError,
64420 : "Object given is not a Python function" );
64421 0 : SWIG_fail;
64422 : }
64423 0 : psProgressInfo->psPyCallback = swig_obj[3];
64424 0 : arg4 = PyProgressProxy;
64425 : }
64426 :
64427 : }
64428 :
64429 : }
64430 : }
64431 10 : if (swig_obj[4]) {
64432 10 : {
64433 : /* %typemap(in) ( void* callback_data=NULL) */
64434 10 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
64435 : }
64436 : }
64437 10 : {
64438 10 : if (!arg1) {
64439 10 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
64440 : }
64441 : }
64442 10 : {
64443 10 : const int bLocalUseExceptions = GetUseExceptions();
64444 10 : if ( bLocalUseExceptions ) {
64445 10 : pushErrorHandler();
64446 : }
64447 10 : {
64448 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
64449 10 : result = (GDALDatasetShadow *)wrapper_GDALRasterizeDestName((char const *)arg1,arg2,arg3,arg4,arg5);
64450 10 : SWIG_PYTHON_THREAD_END_ALLOW;
64451 : }
64452 10 : if ( bLocalUseExceptions ) {
64453 10 : popErrorHandler();
64454 : }
64455 : #ifndef SED_HACKS
64456 : if ( bLocalUseExceptions ) {
64457 : CPLErr eclass = CPLGetLastErrorType();
64458 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
64459 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
64460 : }
64461 : }
64462 : #endif
64463 : }
64464 10 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
64465 10 : {
64466 : /* %typemap(freearg) (const char *utf8_path) */
64467 10 : GDALPythonFreeCStr(arg1, bToFree1);
64468 : }
64469 10 : {
64470 : /* %typemap(freearg) ( void* callback_data=NULL) */
64471 :
64472 10 : CPLFree(psProgressInfo);
64473 :
64474 : }
64475 26 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
64476 : return resultobj;
64477 0 : fail:
64478 0 : {
64479 : /* %typemap(freearg) (const char *utf8_path) */
64480 0 : GDALPythonFreeCStr(arg1, bToFree1);
64481 : }
64482 0 : {
64483 : /* %typemap(freearg) ( void* callback_data=NULL) */
64484 :
64485 0 : CPLFree(psProgressInfo);
64486 :
64487 : }
64488 : return NULL;
64489 : }
64490 :
64491 :
64492 39 : SWIGINTERN PyObject *_wrap_new_GDALFootprintOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
64493 39 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
64494 39 : char **arg1 = (char **) 0 ;
64495 39 : PyObject *swig_obj[1] ;
64496 39 : GDALFootprintOptions *result = 0 ;
64497 :
64498 39 : if (!args) SWIG_fail;
64499 39 : swig_obj[0] = args;
64500 39 : {
64501 : /* %typemap(in) char **dict */
64502 39 : arg1 = NULL;
64503 39 : if ( PySequence_Check( swig_obj[0] ) ) {
64504 39 : int bErr = FALSE;
64505 39 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
64506 39 : if ( bErr )
64507 : {
64508 0 : SWIG_fail;
64509 : }
64510 : }
64511 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
64512 0 : int bErr = FALSE;
64513 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
64514 0 : if ( bErr )
64515 : {
64516 0 : SWIG_fail;
64517 : }
64518 : }
64519 : else {
64520 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
64521 0 : SWIG_fail;
64522 : }
64523 : }
64524 39 : {
64525 39 : const int bLocalUseExceptions = GetUseExceptions();
64526 39 : if ( bLocalUseExceptions ) {
64527 39 : pushErrorHandler();
64528 : }
64529 39 : {
64530 39 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
64531 39 : result = (GDALFootprintOptions *)new_GDALFootprintOptions(arg1);
64532 39 : SWIG_PYTHON_THREAD_END_ALLOW;
64533 : }
64534 39 : if ( bLocalUseExceptions ) {
64535 39 : popErrorHandler();
64536 : }
64537 : #ifndef SED_HACKS
64538 : if ( bLocalUseExceptions ) {
64539 : CPLErr eclass = CPLGetLastErrorType();
64540 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
64541 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
64542 : }
64543 : }
64544 : #endif
64545 : }
64546 39 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALFootprintOptions, SWIG_POINTER_NEW | 0 );
64547 39 : {
64548 : /* %typemap(freearg) char **dict */
64549 39 : CSLDestroy( arg1 );
64550 : }
64551 43 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
64552 : return resultobj;
64553 0 : fail:
64554 0 : {
64555 : /* %typemap(freearg) char **dict */
64556 0 : CSLDestroy( arg1 );
64557 : }
64558 : return NULL;
64559 : }
64560 :
64561 :
64562 37 : SWIGINTERN PyObject *_wrap_delete_GDALFootprintOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
64563 37 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
64564 37 : GDALFootprintOptions *arg1 = (GDALFootprintOptions *) 0 ;
64565 37 : void *argp1 = 0 ;
64566 37 : int res1 = 0 ;
64567 37 : PyObject *swig_obj[1] ;
64568 :
64569 37 : if (!args) SWIG_fail;
64570 37 : swig_obj[0] = args;
64571 37 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALFootprintOptions, SWIG_POINTER_DISOWN | 0 );
64572 37 : if (!SWIG_IsOK(res1)) {
64573 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALFootprintOptions" "', argument " "1"" of type '" "GDALFootprintOptions *""'");
64574 : }
64575 37 : arg1 = reinterpret_cast< GDALFootprintOptions * >(argp1);
64576 37 : {
64577 37 : const int bLocalUseExceptions = GetUseExceptions();
64578 37 : if ( bLocalUseExceptions ) {
64579 37 : pushErrorHandler();
64580 : }
64581 37 : {
64582 37 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
64583 37 : delete_GDALFootprintOptions(arg1);
64584 37 : SWIG_PYTHON_THREAD_END_ALLOW;
64585 : }
64586 37 : if ( bLocalUseExceptions ) {
64587 37 : popErrorHandler();
64588 : }
64589 : #ifndef SED_HACKS
64590 : if ( bLocalUseExceptions ) {
64591 : CPLErr eclass = CPLGetLastErrorType();
64592 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
64593 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
64594 : }
64595 : }
64596 : #endif
64597 : }
64598 37 : resultobj = SWIG_Py_Void();
64599 37 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
64600 : return resultobj;
64601 : fail:
64602 : return NULL;
64603 : }
64604 :
64605 :
64606 277 : SWIGINTERN PyObject *GDALFootprintOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
64607 277 : PyObject *obj;
64608 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
64609 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALFootprintOptions, SWIG_NewClientData(obj));
64610 277 : return SWIG_Py_Void();
64611 : }
64612 :
64613 37 : SWIGINTERN PyObject *GDALFootprintOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
64614 37 : return SWIG_Python_InitShadowInstance(args);
64615 : }
64616 :
64617 3 : SWIGINTERN PyObject *_wrap_wrapper_GDALFootprintDestDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
64618 3 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
64619 3 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
64620 3 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
64621 3 : GDALFootprintOptions *arg3 = (GDALFootprintOptions *) 0 ;
64622 3 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
64623 3 : void *arg5 = (void *) NULL ;
64624 3 : void *argp1 = 0 ;
64625 3 : int res1 = 0 ;
64626 3 : void *argp2 = 0 ;
64627 3 : int res2 = 0 ;
64628 3 : void *argp3 = 0 ;
64629 3 : int res3 = 0 ;
64630 3 : PyObject *swig_obj[5] ;
64631 3 : int result;
64632 :
64633 : /* %typemap(arginit) ( const char* callback_data=NULL) */
64634 3 : PyProgressData *psProgressInfo;
64635 3 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
64636 3 : psProgressInfo->nLastReported = -1;
64637 3 : psProgressInfo->psPyCallback = NULL;
64638 3 : psProgressInfo->psPyCallbackData = NULL;
64639 3 : arg5 = psProgressInfo;
64640 3 : if (!SWIG_Python_UnpackTuple(args, "wrapper_GDALFootprintDestDS", 3, 5, swig_obj)) SWIG_fail;
64641 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
64642 3 : if (!SWIG_IsOK(res1)) {
64643 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wrapper_GDALFootprintDestDS" "', argument " "1"" of type '" "GDALDatasetShadow *""'");
64644 : }
64645 3 : arg1 = reinterpret_cast< GDALDatasetShadow * >(argp1);
64646 3 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
64647 3 : if (!SWIG_IsOK(res2)) {
64648 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wrapper_GDALFootprintDestDS" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
64649 : }
64650 3 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
64651 3 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALFootprintOptions, 0 | 0 );
64652 3 : if (!SWIG_IsOK(res3)) {
64653 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wrapper_GDALFootprintDestDS" "', argument " "3"" of type '" "GDALFootprintOptions *""'");
64654 : }
64655 3 : arg3 = reinterpret_cast< GDALFootprintOptions * >(argp3);
64656 3 : if (swig_obj[3]) {
64657 3 : {
64658 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
64659 : /* callback_func typemap */
64660 :
64661 : /* In some cases 0 is passed instead of None. */
64662 : /* See https://github.com/OSGeo/gdal/pull/219 */
64663 3 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
64664 : {
64665 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
64666 : {
64667 0 : swig_obj[3] = Py_None;
64668 : }
64669 : }
64670 :
64671 3 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
64672 0 : void* cbfunction = NULL;
64673 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
64674 : (void**)&cbfunction,
64675 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
64676 : SWIG_POINTER_EXCEPTION | 0 ));
64677 :
64678 0 : if ( cbfunction == GDALTermProgress ) {
64679 : arg4 = GDALTermProgress;
64680 : } else {
64681 0 : if (!PyCallable_Check(swig_obj[3])) {
64682 0 : PyErr_SetString( PyExc_RuntimeError,
64683 : "Object given is not a Python function" );
64684 0 : SWIG_fail;
64685 : }
64686 0 : psProgressInfo->psPyCallback = swig_obj[3];
64687 0 : arg4 = PyProgressProxy;
64688 : }
64689 :
64690 : }
64691 :
64692 : }
64693 : }
64694 3 : if (swig_obj[4]) {
64695 3 : {
64696 : /* %typemap(in) ( void* callback_data=NULL) */
64697 3 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
64698 : }
64699 : }
64700 3 : {
64701 3 : const int bLocalUseExceptions = GetUseExceptions();
64702 3 : if ( bLocalUseExceptions ) {
64703 3 : pushErrorHandler();
64704 : }
64705 3 : {
64706 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
64707 3 : result = (int)wrapper_GDALFootprintDestDS(arg1,arg2,arg3,arg4,arg5);
64708 3 : SWIG_PYTHON_THREAD_END_ALLOW;
64709 : }
64710 3 : if ( bLocalUseExceptions ) {
64711 3 : popErrorHandler();
64712 : }
64713 : #ifndef SED_HACKS
64714 : if ( bLocalUseExceptions ) {
64715 : CPLErr eclass = CPLGetLastErrorType();
64716 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
64717 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
64718 : }
64719 : }
64720 : #endif
64721 : }
64722 3 : resultobj = SWIG_From_int(static_cast< int >(result));
64723 3 : {
64724 : /* %typemap(freearg) ( void* callback_data=NULL) */
64725 :
64726 3 : CPLFree(psProgressInfo);
64727 :
64728 : }
64729 7 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
64730 : return resultobj;
64731 0 : fail:
64732 0 : {
64733 : /* %typemap(freearg) ( void* callback_data=NULL) */
64734 :
64735 0 : CPLFree(psProgressInfo);
64736 :
64737 : }
64738 : return NULL;
64739 : }
64740 :
64741 :
64742 34 : SWIGINTERN PyObject *_wrap_wrapper_GDALFootprintDestName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
64743 34 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
64744 34 : char *arg1 = (char *) 0 ;
64745 34 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
64746 34 : GDALFootprintOptions *arg3 = (GDALFootprintOptions *) 0 ;
64747 34 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
64748 34 : void *arg5 = (void *) NULL ;
64749 34 : int bToFree1 = 0 ;
64750 34 : void *argp2 = 0 ;
64751 34 : int res2 = 0 ;
64752 34 : void *argp3 = 0 ;
64753 34 : int res3 = 0 ;
64754 34 : PyObject *swig_obj[5] ;
64755 34 : GDALDatasetShadow *result = 0 ;
64756 :
64757 : /* %typemap(arginit) ( const char* callback_data=NULL) */
64758 34 : PyProgressData *psProgressInfo;
64759 34 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
64760 34 : psProgressInfo->nLastReported = -1;
64761 34 : psProgressInfo->psPyCallback = NULL;
64762 34 : psProgressInfo->psPyCallbackData = NULL;
64763 34 : arg5 = psProgressInfo;
64764 34 : if (!SWIG_Python_UnpackTuple(args, "wrapper_GDALFootprintDestName", 3, 5, swig_obj)) SWIG_fail;
64765 34 : {
64766 : /* %typemap(in) (const char *utf8_path) */
64767 34 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
64768 : {
64769 33 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
64770 : }
64771 : else
64772 : {
64773 1 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
64774 :
64775 : }
64776 34 : if (arg1 == NULL)
64777 : {
64778 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
64779 0 : SWIG_fail;
64780 : }
64781 : }
64782 34 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_GDALDatasetShadow, 0 | 0 );
64783 34 : if (!SWIG_IsOK(res2)) {
64784 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wrapper_GDALFootprintDestName" "', argument " "2"" of type '" "GDALDatasetShadow *""'");
64785 : }
64786 34 : arg2 = reinterpret_cast< GDALDatasetShadow * >(argp2);
64787 34 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALFootprintOptions, 0 | 0 );
64788 34 : if (!SWIG_IsOK(res3)) {
64789 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wrapper_GDALFootprintDestName" "', argument " "3"" of type '" "GDALFootprintOptions *""'");
64790 : }
64791 34 : arg3 = reinterpret_cast< GDALFootprintOptions * >(argp3);
64792 34 : if (swig_obj[3]) {
64793 34 : {
64794 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
64795 : /* callback_func typemap */
64796 :
64797 : /* In some cases 0 is passed instead of None. */
64798 : /* See https://github.com/OSGeo/gdal/pull/219 */
64799 34 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
64800 : {
64801 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
64802 : {
64803 0 : swig_obj[3] = Py_None;
64804 : }
64805 : }
64806 :
64807 34 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
64808 0 : void* cbfunction = NULL;
64809 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
64810 : (void**)&cbfunction,
64811 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
64812 : SWIG_POINTER_EXCEPTION | 0 ));
64813 :
64814 0 : if ( cbfunction == GDALTermProgress ) {
64815 : arg4 = GDALTermProgress;
64816 : } else {
64817 0 : if (!PyCallable_Check(swig_obj[3])) {
64818 0 : PyErr_SetString( PyExc_RuntimeError,
64819 : "Object given is not a Python function" );
64820 0 : SWIG_fail;
64821 : }
64822 0 : psProgressInfo->psPyCallback = swig_obj[3];
64823 0 : arg4 = PyProgressProxy;
64824 : }
64825 :
64826 : }
64827 :
64828 : }
64829 : }
64830 34 : if (swig_obj[4]) {
64831 34 : {
64832 : /* %typemap(in) ( void* callback_data=NULL) */
64833 34 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
64834 : }
64835 : }
64836 34 : {
64837 34 : if (!arg1) {
64838 34 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
64839 : }
64840 : }
64841 34 : {
64842 34 : const int bLocalUseExceptions = GetUseExceptions();
64843 34 : if ( bLocalUseExceptions ) {
64844 34 : pushErrorHandler();
64845 : }
64846 34 : {
64847 34 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
64848 34 : result = (GDALDatasetShadow *)wrapper_GDALFootprintDestName((char const *)arg1,arg2,arg3,arg4,arg5);
64849 34 : SWIG_PYTHON_THREAD_END_ALLOW;
64850 : }
64851 34 : if ( bLocalUseExceptions ) {
64852 34 : popErrorHandler();
64853 : }
64854 : #ifndef SED_HACKS
64855 : if ( bLocalUseExceptions ) {
64856 : CPLErr eclass = CPLGetLastErrorType();
64857 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
64858 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
64859 : }
64860 : }
64861 : #endif
64862 : }
64863 34 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
64864 34 : {
64865 : /* %typemap(freearg) (const char *utf8_path) */
64866 34 : GDALPythonFreeCStr(arg1, bToFree1);
64867 : }
64868 34 : {
64869 : /* %typemap(freearg) ( void* callback_data=NULL) */
64870 :
64871 34 : CPLFree(psProgressInfo);
64872 :
64873 : }
64874 54 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
64875 : return resultobj;
64876 0 : fail:
64877 0 : {
64878 : /* %typemap(freearg) (const char *utf8_path) */
64879 0 : GDALPythonFreeCStr(arg1, bToFree1);
64880 : }
64881 0 : {
64882 : /* %typemap(freearg) ( void* callback_data=NULL) */
64883 :
64884 0 : CPLFree(psProgressInfo);
64885 :
64886 : }
64887 : return NULL;
64888 : }
64889 :
64890 :
64891 172 : SWIGINTERN PyObject *_wrap_new_GDALBuildVRTOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
64892 172 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
64893 172 : char **arg1 = (char **) 0 ;
64894 172 : PyObject *swig_obj[1] ;
64895 172 : GDALBuildVRTOptions *result = 0 ;
64896 :
64897 172 : if (!args) SWIG_fail;
64898 172 : swig_obj[0] = args;
64899 172 : {
64900 : /* %typemap(in) char **dict */
64901 172 : arg1 = NULL;
64902 172 : if ( PySequence_Check( swig_obj[0] ) ) {
64903 172 : int bErr = FALSE;
64904 172 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
64905 172 : if ( bErr )
64906 : {
64907 0 : SWIG_fail;
64908 : }
64909 : }
64910 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
64911 0 : int bErr = FALSE;
64912 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
64913 0 : if ( bErr )
64914 : {
64915 0 : SWIG_fail;
64916 : }
64917 : }
64918 : else {
64919 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
64920 0 : SWIG_fail;
64921 : }
64922 : }
64923 172 : {
64924 172 : const int bLocalUseExceptions = GetUseExceptions();
64925 172 : if ( bLocalUseExceptions ) {
64926 144 : pushErrorHandler();
64927 : }
64928 172 : {
64929 172 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
64930 172 : result = (GDALBuildVRTOptions *)new_GDALBuildVRTOptions(arg1);
64931 172 : SWIG_PYTHON_THREAD_END_ALLOW;
64932 : }
64933 172 : if ( bLocalUseExceptions ) {
64934 144 : popErrorHandler();
64935 : }
64936 : #ifndef SED_HACKS
64937 : if ( bLocalUseExceptions ) {
64938 : CPLErr eclass = CPLGetLastErrorType();
64939 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
64940 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
64941 : }
64942 : }
64943 : #endif
64944 : }
64945 172 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALBuildVRTOptions, SWIG_POINTER_NEW | 0 );
64946 172 : {
64947 : /* %typemap(freearg) char **dict */
64948 172 : CSLDestroy( arg1 );
64949 : }
64950 178 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
64951 : return resultobj;
64952 0 : fail:
64953 0 : {
64954 : /* %typemap(freearg) char **dict */
64955 0 : CSLDestroy( arg1 );
64956 : }
64957 : return NULL;
64958 : }
64959 :
64960 :
64961 169 : SWIGINTERN PyObject *_wrap_delete_GDALBuildVRTOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
64962 169 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
64963 169 : GDALBuildVRTOptions *arg1 = (GDALBuildVRTOptions *) 0 ;
64964 169 : void *argp1 = 0 ;
64965 169 : int res1 = 0 ;
64966 169 : PyObject *swig_obj[1] ;
64967 :
64968 169 : if (!args) SWIG_fail;
64969 169 : swig_obj[0] = args;
64970 169 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALBuildVRTOptions, SWIG_POINTER_DISOWN | 0 );
64971 169 : if (!SWIG_IsOK(res1)) {
64972 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALBuildVRTOptions" "', argument " "1"" of type '" "GDALBuildVRTOptions *""'");
64973 : }
64974 169 : arg1 = reinterpret_cast< GDALBuildVRTOptions * >(argp1);
64975 169 : {
64976 169 : const int bLocalUseExceptions = GetUseExceptions();
64977 169 : if ( bLocalUseExceptions ) {
64978 141 : pushErrorHandler();
64979 : }
64980 169 : {
64981 169 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
64982 169 : delete_GDALBuildVRTOptions(arg1);
64983 169 : SWIG_PYTHON_THREAD_END_ALLOW;
64984 : }
64985 169 : if ( bLocalUseExceptions ) {
64986 141 : popErrorHandler();
64987 : }
64988 : #ifndef SED_HACKS
64989 : if ( bLocalUseExceptions ) {
64990 : CPLErr eclass = CPLGetLastErrorType();
64991 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
64992 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
64993 : }
64994 : }
64995 : #endif
64996 : }
64997 169 : resultobj = SWIG_Py_Void();
64998 169 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
64999 : return resultobj;
65000 : fail:
65001 : return NULL;
65002 : }
65003 :
65004 :
65005 277 : SWIGINTERN PyObject *GDALBuildVRTOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
65006 277 : PyObject *obj;
65007 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
65008 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALBuildVRTOptions, SWIG_NewClientData(obj));
65009 277 : return SWIG_Py_Void();
65010 : }
65011 :
65012 169 : SWIGINTERN PyObject *GDALBuildVRTOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
65013 169 : return SWIG_Python_InitShadowInstance(args);
65014 : }
65015 :
65016 69 : SWIGINTERN PyObject *_wrap_BuildVRTInternalObjects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
65017 69 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
65018 69 : char *arg1 = (char *) 0 ;
65019 69 : int arg2 ;
65020 69 : GDALDatasetShadow **arg3 = (GDALDatasetShadow **) 0 ;
65021 69 : GDALBuildVRTOptions *arg4 = (GDALBuildVRTOptions *) 0 ;
65022 69 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
65023 69 : void *arg6 = (void *) NULL ;
65024 69 : int bToFree1 = 0 ;
65025 69 : void *argp4 = 0 ;
65026 69 : int res4 = 0 ;
65027 69 : PyObject *swig_obj[5] ;
65028 69 : GDALDatasetShadow *result = 0 ;
65029 :
65030 : /* %typemap(arginit) ( const char* callback_data=NULL) */
65031 69 : PyProgressData *psProgressInfo;
65032 69 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
65033 69 : psProgressInfo->nLastReported = -1;
65034 69 : psProgressInfo->psPyCallback = NULL;
65035 69 : psProgressInfo->psPyCallbackData = NULL;
65036 69 : arg6 = psProgressInfo;
65037 69 : if (!SWIG_Python_UnpackTuple(args, "BuildVRTInternalObjects", 3, 5, swig_obj)) SWIG_fail;
65038 69 : {
65039 : /* %typemap(in) (const char *utf8_path) */
65040 69 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
65041 : {
65042 64 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
65043 : }
65044 : else
65045 : {
65046 5 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
65047 :
65048 : }
65049 69 : if (arg1 == NULL)
65050 : {
65051 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
65052 0 : SWIG_fail;
65053 : }
65054 : }
65055 69 : {
65056 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALDatasetShadow *optional_##GDALDatasetShadow)*/
65057 69 : if ( !PySequence_Check(swig_obj[1]) ) {
65058 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
65059 0 : SWIG_fail;
65060 : }
65061 69 : Py_ssize_t size = PySequence_Size(swig_obj[1]);
65062 69 : if( size > (Py_ssize_t)INT_MAX ) {
65063 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
65064 0 : SWIG_fail;
65065 : }
65066 69 : if( (size_t)size > SIZE_MAX / sizeof(GDALDatasetShadow*) ) {
65067 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
65068 0 : SWIG_fail;
65069 : }
65070 69 : arg2 = (int)size;
65071 69 : arg3 = (GDALDatasetShadow**) VSIMalloc(arg2*sizeof(GDALDatasetShadow*));
65072 69 : if( !arg3) {
65073 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
65074 0 : SWIG_fail;
65075 : }
65076 :
65077 1173 : for( int i = 0; i<arg2; i++ ) {
65078 1104 : PyObject *o = PySequence_GetItem(swig_obj[1],i);
65079 1104 : GDALDatasetShadow* rawobjectpointer = NULL;
65080 1104 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_EXCEPTION | 0 ));
65081 1104 : if (!rawobjectpointer) {
65082 0 : Py_DECREF(o);
65083 0 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALDatasetShadow");
65084 0 : SWIG_fail;
65085 : }
65086 1104 : arg3[i] = rawobjectpointer;
65087 1104 : Py_DECREF(o);
65088 :
65089 : }
65090 : }
65091 69 : res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_GDALBuildVRTOptions, 0 | 0 );
65092 69 : if (!SWIG_IsOK(res4)) {
65093 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BuildVRTInternalObjects" "', argument " "4"" of type '" "GDALBuildVRTOptions *""'");
65094 : }
65095 69 : arg4 = reinterpret_cast< GDALBuildVRTOptions * >(argp4);
65096 69 : if (swig_obj[3]) {
65097 69 : {
65098 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
65099 : /* callback_func typemap */
65100 :
65101 : /* In some cases 0 is passed instead of None. */
65102 : /* See https://github.com/OSGeo/gdal/pull/219 */
65103 69 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
65104 : {
65105 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
65106 : {
65107 0 : swig_obj[3] = Py_None;
65108 : }
65109 : }
65110 :
65111 69 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
65112 0 : void* cbfunction = NULL;
65113 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
65114 : (void**)&cbfunction,
65115 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
65116 : SWIG_POINTER_EXCEPTION | 0 ));
65117 :
65118 0 : if ( cbfunction == GDALTermProgress ) {
65119 : arg5 = GDALTermProgress;
65120 : } else {
65121 0 : if (!PyCallable_Check(swig_obj[3])) {
65122 0 : PyErr_SetString( PyExc_RuntimeError,
65123 : "Object given is not a Python function" );
65124 0 : SWIG_fail;
65125 : }
65126 0 : psProgressInfo->psPyCallback = swig_obj[3];
65127 0 : arg5 = PyProgressProxy;
65128 : }
65129 :
65130 : }
65131 :
65132 : }
65133 : }
65134 69 : if (swig_obj[4]) {
65135 69 : {
65136 : /* %typemap(in) ( void* callback_data=NULL) */
65137 69 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
65138 : }
65139 : }
65140 69 : {
65141 69 : if (!arg1) {
65142 69 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
65143 : }
65144 : }
65145 69 : {
65146 69 : const int bLocalUseExceptions = GetUseExceptions();
65147 69 : if ( bLocalUseExceptions ) {
65148 56 : pushErrorHandler();
65149 : }
65150 69 : {
65151 69 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
65152 69 : result = (GDALDatasetShadow *)wrapper_GDALBuildVRT_objects((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
65153 69 : SWIG_PYTHON_THREAD_END_ALLOW;
65154 : }
65155 69 : if ( bLocalUseExceptions ) {
65156 56 : popErrorHandler();
65157 : }
65158 : #ifndef SED_HACKS
65159 : if ( bLocalUseExceptions ) {
65160 : CPLErr eclass = CPLGetLastErrorType();
65161 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
65162 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
65163 : }
65164 : }
65165 : #endif
65166 : }
65167 69 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
65168 69 : {
65169 : /* %typemap(freearg) (const char *utf8_path) */
65170 69 : GDALPythonFreeCStr(arg1, bToFree1);
65171 : }
65172 69 : {
65173 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects)*/
65174 69 : CPLFree( arg3 );
65175 : }
65176 69 : {
65177 : /* %typemap(freearg) ( void* callback_data=NULL) */
65178 :
65179 69 : CPLFree(psProgressInfo);
65180 :
65181 : }
65182 69 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
65183 : return resultobj;
65184 0 : fail:
65185 0 : {
65186 : /* %typemap(freearg) (const char *utf8_path) */
65187 0 : GDALPythonFreeCStr(arg1, bToFree1);
65188 : }
65189 0 : {
65190 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects)*/
65191 0 : CPLFree( arg3 );
65192 : }
65193 0 : {
65194 : /* %typemap(freearg) ( void* callback_data=NULL) */
65195 :
65196 0 : CPLFree(psProgressInfo);
65197 :
65198 : }
65199 : return NULL;
65200 : }
65201 :
65202 :
65203 100 : SWIGINTERN PyObject *_wrap_BuildVRTInternalNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
65204 100 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
65205 100 : char *arg1 = (char *) 0 ;
65206 100 : char **arg2 = (char **) 0 ;
65207 100 : GDALBuildVRTOptions *arg3 = (GDALBuildVRTOptions *) 0 ;
65208 100 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
65209 100 : void *arg5 = (void *) NULL ;
65210 100 : int bToFree1 = 0 ;
65211 100 : void *argp3 = 0 ;
65212 100 : int res3 = 0 ;
65213 100 : PyObject *swig_obj[5] ;
65214 100 : GDALDatasetShadow *result = 0 ;
65215 :
65216 : /* %typemap(arginit) ( const char* callback_data=NULL) */
65217 100 : PyProgressData *psProgressInfo;
65218 100 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
65219 100 : psProgressInfo->nLastReported = -1;
65220 100 : psProgressInfo->psPyCallback = NULL;
65221 100 : psProgressInfo->psPyCallbackData = NULL;
65222 100 : arg5 = psProgressInfo;
65223 100 : if (!SWIG_Python_UnpackTuple(args, "BuildVRTInternalNames", 3, 5, swig_obj)) SWIG_fail;
65224 100 : {
65225 : /* %typemap(in) (const char *utf8_path) */
65226 100 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
65227 : {
65228 93 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
65229 : }
65230 : else
65231 : {
65232 7 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
65233 :
65234 : }
65235 100 : if (arg1 == NULL)
65236 : {
65237 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
65238 0 : SWIG_fail;
65239 : }
65240 : }
65241 100 : {
65242 : /* %typemap(in) char **dict */
65243 100 : arg2 = NULL;
65244 100 : if ( PySequence_Check( swig_obj[1] ) ) {
65245 100 : int bErr = FALSE;
65246 100 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
65247 100 : if ( bErr )
65248 : {
65249 0 : SWIG_fail;
65250 : }
65251 : }
65252 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
65253 0 : int bErr = FALSE;
65254 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
65255 0 : if ( bErr )
65256 : {
65257 0 : SWIG_fail;
65258 : }
65259 : }
65260 : else {
65261 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
65262 0 : SWIG_fail;
65263 : }
65264 : }
65265 100 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALBuildVRTOptions, 0 | 0 );
65266 100 : if (!SWIG_IsOK(res3)) {
65267 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BuildVRTInternalNames" "', argument " "3"" of type '" "GDALBuildVRTOptions *""'");
65268 : }
65269 100 : arg3 = reinterpret_cast< GDALBuildVRTOptions * >(argp3);
65270 100 : if (swig_obj[3]) {
65271 100 : {
65272 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
65273 : /* callback_func typemap */
65274 :
65275 : /* In some cases 0 is passed instead of None. */
65276 : /* See https://github.com/OSGeo/gdal/pull/219 */
65277 100 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
65278 : {
65279 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
65280 : {
65281 0 : swig_obj[3] = Py_None;
65282 : }
65283 : }
65284 :
65285 100 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
65286 1 : void* cbfunction = NULL;
65287 1 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
65288 : (void**)&cbfunction,
65289 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
65290 : SWIG_POINTER_EXCEPTION | 0 ));
65291 :
65292 1 : if ( cbfunction == GDALTermProgress ) {
65293 : arg4 = GDALTermProgress;
65294 : } else {
65295 1 : if (!PyCallable_Check(swig_obj[3])) {
65296 0 : PyErr_SetString( PyExc_RuntimeError,
65297 : "Object given is not a Python function" );
65298 0 : SWIG_fail;
65299 : }
65300 1 : psProgressInfo->psPyCallback = swig_obj[3];
65301 1 : arg4 = PyProgressProxy;
65302 : }
65303 :
65304 : }
65305 :
65306 : }
65307 : }
65308 100 : if (swig_obj[4]) {
65309 100 : {
65310 : /* %typemap(in) ( void* callback_data=NULL) */
65311 100 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
65312 : }
65313 : }
65314 100 : {
65315 100 : if (!arg1) {
65316 100 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
65317 : }
65318 : }
65319 100 : {
65320 100 : const int bLocalUseExceptions = GetUseExceptions();
65321 100 : if ( bLocalUseExceptions ) {
65322 85 : pushErrorHandler();
65323 : }
65324 100 : {
65325 100 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
65326 100 : result = (GDALDatasetShadow *)wrapper_GDALBuildVRT_names((char const *)arg1,arg2,arg3,arg4,arg5);
65327 100 : SWIG_PYTHON_THREAD_END_ALLOW;
65328 : }
65329 100 : if ( bLocalUseExceptions ) {
65330 85 : popErrorHandler();
65331 : }
65332 : #ifndef SED_HACKS
65333 : if ( bLocalUseExceptions ) {
65334 : CPLErr eclass = CPLGetLastErrorType();
65335 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
65336 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
65337 : }
65338 : }
65339 : #endif
65340 : }
65341 100 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
65342 100 : {
65343 : /* %typemap(freearg) (const char *utf8_path) */
65344 100 : GDALPythonFreeCStr(arg1, bToFree1);
65345 : }
65346 100 : {
65347 : /* %typemap(freearg) char **dict */
65348 100 : CSLDestroy( arg2 );
65349 : }
65350 100 : {
65351 : /* %typemap(freearg) ( void* callback_data=NULL) */
65352 :
65353 100 : CPLFree(psProgressInfo);
65354 :
65355 : }
65356 104 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
65357 : return resultobj;
65358 0 : fail:
65359 0 : {
65360 : /* %typemap(freearg) (const char *utf8_path) */
65361 0 : GDALPythonFreeCStr(arg1, bToFree1);
65362 : }
65363 0 : {
65364 : /* %typemap(freearg) char **dict */
65365 0 : CSLDestroy( arg2 );
65366 : }
65367 0 : {
65368 : /* %typemap(freearg) ( void* callback_data=NULL) */
65369 :
65370 0 : CPLFree(psProgressInfo);
65371 :
65372 : }
65373 : return NULL;
65374 : }
65375 :
65376 :
65377 23 : SWIGINTERN PyObject *_wrap_new_GDALTileIndexOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
65378 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
65379 23 : char **arg1 = (char **) 0 ;
65380 23 : PyObject *swig_obj[1] ;
65381 23 : GDALTileIndexOptions *result = 0 ;
65382 :
65383 23 : if (!args) SWIG_fail;
65384 23 : swig_obj[0] = args;
65385 23 : {
65386 : /* %typemap(in) char **dict */
65387 23 : arg1 = NULL;
65388 23 : if ( PySequence_Check( swig_obj[0] ) ) {
65389 23 : int bErr = FALSE;
65390 23 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
65391 23 : if ( bErr )
65392 : {
65393 0 : SWIG_fail;
65394 : }
65395 : }
65396 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
65397 0 : int bErr = FALSE;
65398 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
65399 0 : if ( bErr )
65400 : {
65401 0 : SWIG_fail;
65402 : }
65403 : }
65404 : else {
65405 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
65406 0 : SWIG_fail;
65407 : }
65408 : }
65409 23 : {
65410 23 : const int bLocalUseExceptions = GetUseExceptions();
65411 23 : if ( bLocalUseExceptions ) {
65412 23 : pushErrorHandler();
65413 : }
65414 23 : {
65415 23 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
65416 23 : result = (GDALTileIndexOptions *)new_GDALTileIndexOptions(arg1);
65417 23 : SWIG_PYTHON_THREAD_END_ALLOW;
65418 : }
65419 23 : if ( bLocalUseExceptions ) {
65420 23 : popErrorHandler();
65421 : }
65422 : #ifndef SED_HACKS
65423 : if ( bLocalUseExceptions ) {
65424 : CPLErr eclass = CPLGetLastErrorType();
65425 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
65426 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
65427 : }
65428 : }
65429 : #endif
65430 : }
65431 23 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALTileIndexOptions, SWIG_POINTER_NEW | 0 );
65432 23 : {
65433 : /* %typemap(freearg) char **dict */
65434 23 : CSLDestroy( arg1 );
65435 : }
65436 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
65437 : return resultobj;
65438 0 : fail:
65439 0 : {
65440 : /* %typemap(freearg) char **dict */
65441 0 : CSLDestroy( arg1 );
65442 : }
65443 : return NULL;
65444 : }
65445 :
65446 :
65447 23 : SWIGINTERN PyObject *_wrap_delete_GDALTileIndexOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
65448 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
65449 23 : GDALTileIndexOptions *arg1 = (GDALTileIndexOptions *) 0 ;
65450 23 : void *argp1 = 0 ;
65451 23 : int res1 = 0 ;
65452 23 : PyObject *swig_obj[1] ;
65453 :
65454 23 : if (!args) SWIG_fail;
65455 23 : swig_obj[0] = args;
65456 23 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALTileIndexOptions, SWIG_POINTER_DISOWN | 0 );
65457 23 : if (!SWIG_IsOK(res1)) {
65458 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALTileIndexOptions" "', argument " "1"" of type '" "GDALTileIndexOptions *""'");
65459 : }
65460 23 : arg1 = reinterpret_cast< GDALTileIndexOptions * >(argp1);
65461 23 : {
65462 23 : const int bLocalUseExceptions = GetUseExceptions();
65463 23 : if ( bLocalUseExceptions ) {
65464 23 : pushErrorHandler();
65465 : }
65466 23 : {
65467 23 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
65468 23 : delete_GDALTileIndexOptions(arg1);
65469 23 : SWIG_PYTHON_THREAD_END_ALLOW;
65470 : }
65471 23 : if ( bLocalUseExceptions ) {
65472 23 : popErrorHandler();
65473 : }
65474 : #ifndef SED_HACKS
65475 : if ( bLocalUseExceptions ) {
65476 : CPLErr eclass = CPLGetLastErrorType();
65477 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
65478 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
65479 : }
65480 : }
65481 : #endif
65482 : }
65483 23 : resultobj = SWIG_Py_Void();
65484 23 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
65485 : return resultobj;
65486 : fail:
65487 : return NULL;
65488 : }
65489 :
65490 :
65491 277 : SWIGINTERN PyObject *GDALTileIndexOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
65492 277 : PyObject *obj;
65493 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
65494 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALTileIndexOptions, SWIG_NewClientData(obj));
65495 277 : return SWIG_Py_Void();
65496 : }
65497 :
65498 23 : SWIGINTERN PyObject *GDALTileIndexOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
65499 23 : return SWIG_Python_InitShadowInstance(args);
65500 : }
65501 :
65502 23 : SWIGINTERN PyObject *_wrap_TileIndexInternalNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
65503 23 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
65504 23 : char *arg1 = (char *) 0 ;
65505 23 : char **arg2 = (char **) 0 ;
65506 23 : GDALTileIndexOptions *arg3 = (GDALTileIndexOptions *) 0 ;
65507 23 : GDALProgressFunc arg4 = (GDALProgressFunc) NULL ;
65508 23 : void *arg5 = (void *) NULL ;
65509 23 : int bToFree1 = 0 ;
65510 23 : void *argp3 = 0 ;
65511 23 : int res3 = 0 ;
65512 23 : PyObject *swig_obj[5] ;
65513 23 : GDALDatasetShadow *result = 0 ;
65514 :
65515 : /* %typemap(arginit) ( const char* callback_data=NULL) */
65516 23 : PyProgressData *psProgressInfo;
65517 23 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
65518 23 : psProgressInfo->nLastReported = -1;
65519 23 : psProgressInfo->psPyCallback = NULL;
65520 23 : psProgressInfo->psPyCallbackData = NULL;
65521 23 : arg5 = psProgressInfo;
65522 23 : if (!SWIG_Python_UnpackTuple(args, "TileIndexInternalNames", 3, 5, swig_obj)) SWIG_fail;
65523 23 : {
65524 : /* %typemap(in) (const char *utf8_path) */
65525 23 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
65526 : {
65527 23 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
65528 : }
65529 : else
65530 : {
65531 0 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
65532 :
65533 : }
65534 23 : if (arg1 == NULL)
65535 : {
65536 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
65537 0 : SWIG_fail;
65538 : }
65539 : }
65540 23 : {
65541 : /* %typemap(in) char **dict */
65542 23 : arg2 = NULL;
65543 23 : if ( PySequence_Check( swig_obj[1] ) ) {
65544 23 : int bErr = FALSE;
65545 23 : arg2 = CSLFromPySequence(swig_obj[1], &bErr);
65546 23 : if ( bErr )
65547 : {
65548 0 : SWIG_fail;
65549 : }
65550 : }
65551 0 : else if ( PyMapping_Check( swig_obj[1] ) ) {
65552 0 : int bErr = FALSE;
65553 0 : arg2 = CSLFromPyMapping(swig_obj[1], &bErr);
65554 0 : if ( bErr )
65555 : {
65556 0 : SWIG_fail;
65557 : }
65558 : }
65559 : else {
65560 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
65561 0 : SWIG_fail;
65562 : }
65563 : }
65564 23 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_GDALTileIndexOptions, 0 | 0 );
65565 23 : if (!SWIG_IsOK(res3)) {
65566 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TileIndexInternalNames" "', argument " "3"" of type '" "GDALTileIndexOptions *""'");
65567 : }
65568 23 : arg3 = reinterpret_cast< GDALTileIndexOptions * >(argp3);
65569 23 : if (swig_obj[3]) {
65570 23 : {
65571 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
65572 : /* callback_func typemap */
65573 :
65574 : /* In some cases 0 is passed instead of None. */
65575 : /* See https://github.com/OSGeo/gdal/pull/219 */
65576 23 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
65577 : {
65578 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
65579 : {
65580 0 : swig_obj[3] = Py_None;
65581 : }
65582 : }
65583 :
65584 23 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
65585 0 : void* cbfunction = NULL;
65586 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
65587 : (void**)&cbfunction,
65588 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
65589 : SWIG_POINTER_EXCEPTION | 0 ));
65590 :
65591 0 : if ( cbfunction == GDALTermProgress ) {
65592 : arg4 = GDALTermProgress;
65593 : } else {
65594 0 : if (!PyCallable_Check(swig_obj[3])) {
65595 0 : PyErr_SetString( PyExc_RuntimeError,
65596 : "Object given is not a Python function" );
65597 0 : SWIG_fail;
65598 : }
65599 0 : psProgressInfo->psPyCallback = swig_obj[3];
65600 0 : arg4 = PyProgressProxy;
65601 : }
65602 :
65603 : }
65604 :
65605 : }
65606 : }
65607 23 : if (swig_obj[4]) {
65608 23 : {
65609 : /* %typemap(in) ( void* callback_data=NULL) */
65610 23 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
65611 : }
65612 : }
65613 23 : {
65614 23 : if (!arg1) {
65615 23 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
65616 : }
65617 : }
65618 23 : {
65619 23 : const int bLocalUseExceptions = GetUseExceptions();
65620 23 : if ( bLocalUseExceptions ) {
65621 23 : pushErrorHandler();
65622 : }
65623 23 : {
65624 23 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
65625 23 : result = (GDALDatasetShadow *)wrapper_TileIndex_names((char const *)arg1,arg2,arg3,arg4,arg5);
65626 23 : SWIG_PYTHON_THREAD_END_ALLOW;
65627 : }
65628 23 : if ( bLocalUseExceptions ) {
65629 23 : popErrorHandler();
65630 : }
65631 : #ifndef SED_HACKS
65632 : if ( bLocalUseExceptions ) {
65633 : CPLErr eclass = CPLGetLastErrorType();
65634 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
65635 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
65636 : }
65637 : }
65638 : #endif
65639 : }
65640 23 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
65641 23 : {
65642 : /* %typemap(freearg) (const char *utf8_path) */
65643 23 : GDALPythonFreeCStr(arg1, bToFree1);
65644 : }
65645 23 : {
65646 : /* %typemap(freearg) char **dict */
65647 23 : CSLDestroy( arg2 );
65648 : }
65649 23 : {
65650 : /* %typemap(freearg) ( void* callback_data=NULL) */
65651 :
65652 23 : CPLFree(psProgressInfo);
65653 :
65654 : }
65655 25 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
65656 : return resultobj;
65657 0 : fail:
65658 0 : {
65659 : /* %typemap(freearg) (const char *utf8_path) */
65660 0 : GDALPythonFreeCStr(arg1, bToFree1);
65661 : }
65662 0 : {
65663 : /* %typemap(freearg) char **dict */
65664 0 : CSLDestroy( arg2 );
65665 : }
65666 0 : {
65667 : /* %typemap(freearg) ( void* callback_data=NULL) */
65668 :
65669 0 : CPLFree(psProgressInfo);
65670 :
65671 : }
65672 : return NULL;
65673 : }
65674 :
65675 :
65676 109 : SWIGINTERN PyObject *_wrap_new_GDALMultiDimTranslateOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
65677 109 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
65678 109 : char **arg1 = (char **) 0 ;
65679 109 : PyObject *swig_obj[1] ;
65680 109 : GDALMultiDimTranslateOptions *result = 0 ;
65681 :
65682 109 : if (!args) SWIG_fail;
65683 109 : swig_obj[0] = args;
65684 109 : {
65685 : /* %typemap(in) char **dict */
65686 109 : arg1 = NULL;
65687 109 : if ( PySequence_Check( swig_obj[0] ) ) {
65688 109 : int bErr = FALSE;
65689 109 : arg1 = CSLFromPySequence(swig_obj[0], &bErr);
65690 109 : if ( bErr )
65691 : {
65692 0 : SWIG_fail;
65693 : }
65694 : }
65695 0 : else if ( PyMapping_Check( swig_obj[0] ) ) {
65696 0 : int bErr = FALSE;
65697 0 : arg1 = CSLFromPyMapping(swig_obj[0], &bErr);
65698 0 : if ( bErr )
65699 : {
65700 0 : SWIG_fail;
65701 : }
65702 : }
65703 : else {
65704 0 : PyErr_SetString(PyExc_TypeError,"Argument must be dictionary or sequence of strings");
65705 0 : SWIG_fail;
65706 : }
65707 : }
65708 109 : {
65709 109 : const int bLocalUseExceptions = GetUseExceptions();
65710 109 : if ( bLocalUseExceptions ) {
65711 30 : pushErrorHandler();
65712 : }
65713 109 : {
65714 109 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
65715 109 : result = (GDALMultiDimTranslateOptions *)new_GDALMultiDimTranslateOptions(arg1);
65716 109 : SWIG_PYTHON_THREAD_END_ALLOW;
65717 : }
65718 109 : if ( bLocalUseExceptions ) {
65719 30 : popErrorHandler();
65720 : }
65721 : #ifndef SED_HACKS
65722 : if ( bLocalUseExceptions ) {
65723 : CPLErr eclass = CPLGetLastErrorType();
65724 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
65725 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
65726 : }
65727 : }
65728 : #endif
65729 : }
65730 109 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALMultiDimTranslateOptions, SWIG_POINTER_NEW | 0 );
65731 109 : {
65732 : /* %typemap(freearg) char **dict */
65733 109 : CSLDestroy( arg1 );
65734 : }
65735 109 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
65736 : return resultobj;
65737 0 : fail:
65738 0 : {
65739 : /* %typemap(freearg) char **dict */
65740 0 : CSLDestroy( arg1 );
65741 : }
65742 : return NULL;
65743 : }
65744 :
65745 :
65746 109 : SWIGINTERN PyObject *_wrap_delete_GDALMultiDimTranslateOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
65747 109 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
65748 109 : GDALMultiDimTranslateOptions *arg1 = (GDALMultiDimTranslateOptions *) 0 ;
65749 109 : void *argp1 = 0 ;
65750 109 : int res1 = 0 ;
65751 109 : PyObject *swig_obj[1] ;
65752 :
65753 109 : if (!args) SWIG_fail;
65754 109 : swig_obj[0] = args;
65755 109 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GDALMultiDimTranslateOptions, SWIG_POINTER_DISOWN | 0 );
65756 109 : if (!SWIG_IsOK(res1)) {
65757 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDALMultiDimTranslateOptions" "', argument " "1"" of type '" "GDALMultiDimTranslateOptions *""'");
65758 : }
65759 109 : arg1 = reinterpret_cast< GDALMultiDimTranslateOptions * >(argp1);
65760 109 : {
65761 109 : const int bLocalUseExceptions = GetUseExceptions();
65762 109 : if ( bLocalUseExceptions ) {
65763 30 : pushErrorHandler();
65764 : }
65765 109 : {
65766 109 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
65767 109 : delete_GDALMultiDimTranslateOptions(arg1);
65768 109 : SWIG_PYTHON_THREAD_END_ALLOW;
65769 : }
65770 109 : if ( bLocalUseExceptions ) {
65771 30 : popErrorHandler();
65772 : }
65773 : #ifndef SED_HACKS
65774 : if ( bLocalUseExceptions ) {
65775 : CPLErr eclass = CPLGetLastErrorType();
65776 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
65777 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
65778 : }
65779 : }
65780 : #endif
65781 : }
65782 109 : resultobj = SWIG_Py_Void();
65783 109 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
65784 : return resultobj;
65785 : fail:
65786 : return NULL;
65787 : }
65788 :
65789 :
65790 277 : SWIGINTERN PyObject *GDALMultiDimTranslateOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
65791 277 : PyObject *obj;
65792 277 : if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
65793 277 : SWIG_TypeNewClientData(SWIGTYPE_p_GDALMultiDimTranslateOptions, SWIG_NewClientData(obj));
65794 277 : return SWIG_Py_Void();
65795 : }
65796 :
65797 109 : SWIGINTERN PyObject *GDALMultiDimTranslateOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
65798 109 : return SWIG_Python_InitShadowInstance(args);
65799 : }
65800 :
65801 109 : SWIGINTERN PyObject *_wrap_wrapper_GDALMultiDimTranslateDestName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
65802 109 : PyObject *resultobj = 0; int bLocalUseExceptionsCode = GetUseExceptions();
65803 109 : char *arg1 = (char *) 0 ;
65804 109 : int arg2 ;
65805 109 : GDALDatasetShadow **arg3 = (GDALDatasetShadow **) 0 ;
65806 109 : GDALMultiDimTranslateOptions *arg4 = (GDALMultiDimTranslateOptions *) 0 ;
65807 109 : GDALProgressFunc arg5 = (GDALProgressFunc) NULL ;
65808 109 : void *arg6 = (void *) NULL ;
65809 109 : int bToFree1 = 0 ;
65810 109 : void *argp4 = 0 ;
65811 109 : int res4 = 0 ;
65812 109 : PyObject *swig_obj[5] ;
65813 109 : GDALDatasetShadow *result = 0 ;
65814 :
65815 : /* %typemap(arginit) ( const char* callback_data=NULL) */
65816 109 : PyProgressData *psProgressInfo;
65817 109 : psProgressInfo = (PyProgressData *) CPLCalloc(1,sizeof(PyProgressData));
65818 109 : psProgressInfo->nLastReported = -1;
65819 109 : psProgressInfo->psPyCallback = NULL;
65820 109 : psProgressInfo->psPyCallbackData = NULL;
65821 109 : arg6 = psProgressInfo;
65822 109 : if (!SWIG_Python_UnpackTuple(args, "wrapper_GDALMultiDimTranslateDestName", 3, 5, swig_obj)) SWIG_fail;
65823 109 : {
65824 : /* %typemap(in) (const char *utf8_path) */
65825 109 : if (PyUnicode_Check(swig_obj[0]) || PyBytes_Check(swig_obj[0]))
65826 : {
65827 10 : arg1 = GDALPythonObjectToCStr( swig_obj[0], &bToFree1 );
65828 : }
65829 : else
65830 : {
65831 99 : arg1 = GDALPythonPathToCStr(swig_obj[0], &bToFree1);
65832 :
65833 : }
65834 109 : if (arg1 == NULL)
65835 : {
65836 0 : PyErr_SetString( PyExc_RuntimeError, "not a string or os.PathLike" );
65837 0 : SWIG_fail;
65838 : }
65839 : }
65840 109 : {
65841 : /* OBJECT_LIST_INPUT %typemap(in) (int itemcount, GDALDatasetShadow *optional_##GDALDatasetShadow)*/
65842 109 : if ( !PySequence_Check(swig_obj[1]) ) {
65843 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
65844 0 : SWIG_fail;
65845 : }
65846 109 : Py_ssize_t size = PySequence_Size(swig_obj[1]);
65847 109 : if( size > (Py_ssize_t)INT_MAX ) {
65848 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
65849 0 : SWIG_fail;
65850 : }
65851 109 : if( (size_t)size > SIZE_MAX / sizeof(GDALDatasetShadow*) ) {
65852 0 : PyErr_SetString(PyExc_TypeError, "too big sequence");
65853 0 : SWIG_fail;
65854 : }
65855 109 : arg2 = (int)size;
65856 109 : arg3 = (GDALDatasetShadow**) VSIMalloc(arg2*sizeof(GDALDatasetShadow*));
65857 109 : if( !arg3) {
65858 0 : PyErr_SetString(PyExc_MemoryError, "cannot allocate temporary buffer");
65859 0 : SWIG_fail;
65860 : }
65861 :
65862 218 : for( int i = 0; i<arg2; i++ ) {
65863 109 : PyObject *o = PySequence_GetItem(swig_obj[1],i);
65864 109 : GDALDatasetShadow* rawobjectpointer = NULL;
65865 109 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( o, (void**)&rawobjectpointer, SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_EXCEPTION | 0 ));
65866 109 : if (!rawobjectpointer) {
65867 0 : Py_DECREF(o);
65868 0 : PyErr_SetString(PyExc_TypeError, "object of wrong GDALDatasetShadow");
65869 0 : SWIG_fail;
65870 : }
65871 109 : arg3[i] = rawobjectpointer;
65872 109 : Py_DECREF(o);
65873 :
65874 : }
65875 : }
65876 109 : res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_GDALMultiDimTranslateOptions, 0 | 0 );
65877 109 : if (!SWIG_IsOK(res4)) {
65878 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "wrapper_GDALMultiDimTranslateDestName" "', argument " "4"" of type '" "GDALMultiDimTranslateOptions *""'");
65879 : }
65880 109 : arg4 = reinterpret_cast< GDALMultiDimTranslateOptions * >(argp4);
65881 109 : if (swig_obj[3]) {
65882 109 : {
65883 : /* %typemap(in) (GDALProgressFunc callback = NULL) */
65884 : /* callback_func typemap */
65885 :
65886 : /* In some cases 0 is passed instead of None. */
65887 : /* See https://github.com/OSGeo/gdal/pull/219 */
65888 109 : if ( PyLong_Check(swig_obj[3]) || PyInt_Check(swig_obj[3]) )
65889 : {
65890 0 : if( PyLong_AsLong(swig_obj[3]) == 0 )
65891 : {
65892 0 : swig_obj[3] = Py_None;
65893 : }
65894 : }
65895 :
65896 109 : if (swig_obj[3] && swig_obj[3] != Py_None ) {
65897 0 : void* cbfunction = NULL;
65898 0 : CPL_IGNORE_RET_VAL(SWIG_ConvertPtr( swig_obj[3],
65899 : (void**)&cbfunction,
65900 : SWIGTYPE_p_f_double_p_q_const__char_p_void__int,
65901 : SWIG_POINTER_EXCEPTION | 0 ));
65902 :
65903 0 : if ( cbfunction == GDALTermProgress ) {
65904 : arg5 = GDALTermProgress;
65905 : } else {
65906 0 : if (!PyCallable_Check(swig_obj[3])) {
65907 0 : PyErr_SetString( PyExc_RuntimeError,
65908 : "Object given is not a Python function" );
65909 0 : SWIG_fail;
65910 : }
65911 0 : psProgressInfo->psPyCallback = swig_obj[3];
65912 0 : arg5 = PyProgressProxy;
65913 : }
65914 :
65915 : }
65916 :
65917 : }
65918 : }
65919 109 : if (swig_obj[4]) {
65920 109 : {
65921 : /* %typemap(in) ( void* callback_data=NULL) */
65922 109 : psProgressInfo->psPyCallbackData = swig_obj[4] ;
65923 : }
65924 : }
65925 109 : {
65926 109 : if (!arg1) {
65927 109 : SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
65928 : }
65929 : }
65930 109 : {
65931 109 : const int bLocalUseExceptions = GetUseExceptions();
65932 109 : if ( bLocalUseExceptions ) {
65933 30 : pushErrorHandler();
65934 : }
65935 109 : {
65936 109 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
65937 109 : result = (GDALDatasetShadow *)wrapper_GDALMultiDimTranslateDestName((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
65938 109 : SWIG_PYTHON_THREAD_END_ALLOW;
65939 : }
65940 109 : if ( bLocalUseExceptions ) {
65941 30 : popErrorHandler();
65942 : }
65943 : #ifndef SED_HACKS
65944 : if ( bLocalUseExceptions ) {
65945 : CPLErr eclass = CPLGetLastErrorType();
65946 : if ( eclass == CE_Failure || eclass == CE_Fatal ) {
65947 : SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
65948 : }
65949 : }
65950 : #endif
65951 : }
65952 109 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GDALDatasetShadow, SWIG_POINTER_OWN | 0 );
65953 109 : {
65954 : /* %typemap(freearg) (const char *utf8_path) */
65955 109 : GDALPythonFreeCStr(arg1, bToFree1);
65956 : }
65957 109 : {
65958 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects)*/
65959 109 : CPLFree( arg3 );
65960 : }
65961 109 : {
65962 : /* %typemap(freearg) ( void* callback_data=NULL) */
65963 :
65964 109 : CPLFree(psProgressInfo);
65965 :
65966 : }
65967 127 : if ( ReturnSame(bLocalUseExceptionsCode) ) { CPLErr eclass = CPLGetLastErrorType(); if ( eclass == CE_Failure || eclass == CE_Fatal ) { std::string osMsg = CPLGetLastErrorMsg(); Py_XDECREF(resultobj); SWIG_Error( SWIG_RuntimeError, osMsg.c_str() ); return NULL; } }
65968 : return resultobj;
65969 0 : fail:
65970 0 : {
65971 : /* %typemap(freearg) (const char *utf8_path) */
65972 0 : GDALPythonFreeCStr(arg1, bToFree1);
65973 : }
65974 0 : {
65975 : /* OBJECT_LIST_INPUT %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects)*/
65976 0 : CPLFree( arg3 );
65977 : }
65978 0 : {
65979 : /* %typemap(freearg) ( void* callback_data=NULL) */
65980 :
65981 0 : CPLFree(psProgressInfo);
65982 :
65983 : }
65984 : return NULL;
65985 : }
65986 :
65987 :
65988 : static PyMethodDef SwigMethods[] = {
65989 : { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
65990 : { "GetUseExceptions", _wrap_GetUseExceptions, METH_NOARGS, "GetUseExceptions() -> int"},
65991 : { "_GetExceptionsLocal", _wrap__GetExceptionsLocal, METH_NOARGS, "_GetExceptionsLocal() -> int"},
65992 : { "_SetExceptionsLocal", _wrap__SetExceptionsLocal, METH_O, "_SetExceptionsLocal(int bVal)"},
65993 : { "_UseExceptions", _wrap__UseExceptions, METH_NOARGS, "_UseExceptions()"},
65994 : { "_DontUseExceptions", _wrap__DontUseExceptions, METH_NOARGS, "_DontUseExceptions()"},
65995 : { "_UserHasSpecifiedIfUsingExceptions", _wrap__UserHasSpecifiedIfUsingExceptions, METH_NOARGS, "_UserHasSpecifiedIfUsingExceptions() -> int"},
65996 : { "VSIFReadL", _wrap_VSIFReadL, METH_VARARGS, "VSIFReadL(unsigned int nMembSize, unsigned int nMembCount, VSILFILE fp) -> unsigned int"},
65997 : { "VSIGetMemFileBuffer_unsafe", _wrap_VSIGetMemFileBuffer_unsafe, METH_O, "VSIGetMemFileBuffer_unsafe(char const * utf8_path)"},
65998 : { "Debug", _wrap_Debug, METH_VARARGS, "Debug(char const * msg_class, char const * message)"},
65999 : { "SetErrorHandler", _wrap_SetErrorHandler, METH_VARARGS, "SetErrorHandler(CPLErrorHandler pfnErrorHandler=0) -> CPLErr"},
66000 : { "SetCurrentErrorHandlerCatchDebug", _wrap_SetCurrentErrorHandlerCatchDebug, METH_O, "SetCurrentErrorHandlerCatchDebug(int bCatchDebug)"},
66001 : { "PushErrorHandler", _wrap_PushErrorHandler, METH_VARARGS, "PushErrorHandler(CPLErrorHandler pfnErrorHandler=0) -> CPLErr"},
66002 : { "PopErrorHandler", _wrap_PopErrorHandler, METH_NOARGS, "PopErrorHandler()"},
66003 : { "Error", _wrap_Error, METH_VARARGS, "Error(CPLErr msg_class=CE_Failure, int err_code=0, char const * msg=\"error\")"},
66004 : { "GOA2GetAuthorizationURL", _wrap_GOA2GetAuthorizationURL, METH_O, "GOA2GetAuthorizationURL(char const * pszScope) -> retStringAndCPLFree *"},
66005 : { "GOA2GetRefreshToken", _wrap_GOA2GetRefreshToken, METH_VARARGS, "GOA2GetRefreshToken(char const * pszAuthToken, char const * pszScope) -> retStringAndCPLFree *"},
66006 : { "GOA2GetAccessToken", _wrap_GOA2GetAccessToken, METH_VARARGS, "GOA2GetAccessToken(char const * pszRefreshToken, char const * pszScope) -> retStringAndCPLFree *"},
66007 : { "ErrorReset", _wrap_ErrorReset, METH_NOARGS, "ErrorReset()"},
66008 : { "wrapper_EscapeString", (PyCFunction)(void(*)(void))_wrap_wrapper_EscapeString, METH_VARARGS|METH_KEYWORDS, "wrapper_EscapeString(int len, int scheme=CPLES_SQL) -> retStringAndCPLFree *"},
66009 : { "EscapeBinary", (PyCFunction)(void(*)(void))_wrap_EscapeBinary, METH_VARARGS|METH_KEYWORDS, "EscapeBinary(int len, int scheme=CPLES_SQL)"},
66010 : { "GetLastErrorNo", _wrap_GetLastErrorNo, METH_NOARGS, "GetLastErrorNo() -> int"},
66011 : { "GetLastErrorType", _wrap_GetLastErrorType, METH_NOARGS, "GetLastErrorType() -> int"},
66012 : { "GetLastErrorMsg", _wrap_GetLastErrorMsg, METH_NOARGS, "GetLastErrorMsg() -> char const *"},
66013 : { "GetErrorCounter", _wrap_GetErrorCounter, METH_NOARGS, "GetErrorCounter() -> unsigned int"},
66014 : { "VSIGetLastErrorNo", _wrap_VSIGetLastErrorNo, METH_NOARGS, "VSIGetLastErrorNo() -> int"},
66015 : { "VSIGetLastErrorMsg", _wrap_VSIGetLastErrorMsg, METH_NOARGS, "VSIGetLastErrorMsg() -> char const *"},
66016 : { "VSIErrorReset", _wrap_VSIErrorReset, METH_NOARGS, "VSIErrorReset()"},
66017 : { "PushFinderLocation", _wrap_PushFinderLocation, METH_O, "PushFinderLocation(char const * utf8_path)"},
66018 : { "PopFinderLocation", _wrap_PopFinderLocation, METH_NOARGS, "PopFinderLocation()"},
66019 : { "FinderClean", _wrap_FinderClean, METH_NOARGS, "FinderClean()"},
66020 : { "FindFile", _wrap_FindFile, METH_VARARGS, "FindFile(char const * pszClass, char const * utf8_path) -> char const *"},
66021 : { "ReadDir", _wrap_ReadDir, METH_VARARGS, "ReadDir(char const * utf8_path, int nMaxFiles=0) -> char **"},
66022 : { "ReadDirRecursive", _wrap_ReadDirRecursive, METH_O, "ReadDirRecursive(char const * utf8_path) -> char **"},
66023 : { "OpenDir", _wrap_OpenDir, METH_VARARGS, "OpenDir(char const * utf8_path, int nRecurseDepth=-1, char ** options=None) -> VSIDIR *"},
66024 : { "DirEntry_name_get", _wrap_DirEntry_name_get, METH_O, "DirEntry_name_get(DirEntry self) -> char *"},
66025 : { "DirEntry_mode_get", _wrap_DirEntry_mode_get, METH_O, "DirEntry_mode_get(DirEntry self) -> int"},
66026 : { "DirEntry_size_get", _wrap_DirEntry_size_get, METH_O, "DirEntry_size_get(DirEntry self) -> GIntBig"},
66027 : { "DirEntry_mtime_get", _wrap_DirEntry_mtime_get, METH_O, "DirEntry_mtime_get(DirEntry self) -> GIntBig"},
66028 : { "DirEntry_modeKnown_get", _wrap_DirEntry_modeKnown_get, METH_O, "DirEntry_modeKnown_get(DirEntry self) -> bool"},
66029 : { "DirEntry_sizeKnown_get", _wrap_DirEntry_sizeKnown_get, METH_O, "DirEntry_sizeKnown_get(DirEntry self) -> bool"},
66030 : { "DirEntry_mtimeKnown_get", _wrap_DirEntry_mtimeKnown_get, METH_O, "DirEntry_mtimeKnown_get(DirEntry self) -> bool"},
66031 : { "DirEntry_extra_get", _wrap_DirEntry_extra_get, METH_O, "DirEntry_extra_get(DirEntry self) -> char **"},
66032 : { "new_DirEntry", _wrap_new_DirEntry, METH_O, "new_DirEntry(DirEntry entryIn) -> DirEntry"},
66033 : { "delete_DirEntry", _wrap_delete_DirEntry, METH_O, "delete_DirEntry(DirEntry self)"},
66034 : { "DirEntry_IsDirectory", _wrap_DirEntry_IsDirectory, METH_O, "DirEntry_IsDirectory(DirEntry self) -> bool"},
66035 : { "DirEntry_swigregister", DirEntry_swigregister, METH_O, NULL},
66036 : { "DirEntry_swiginit", DirEntry_swiginit, METH_VARARGS, NULL},
66037 : { "GetNextDirEntry", _wrap_GetNextDirEntry, METH_O, "GetNextDirEntry(VSIDIR * dir) -> DirEntry"},
66038 : { "CloseDir", _wrap_CloseDir, METH_O, "CloseDir(VSIDIR * dir)"},
66039 : { "SetConfigOption", _wrap_SetConfigOption, METH_VARARGS, "\n"
66040 : "SetConfigOption(char const * pszKey, char const * pszValue)\n"
66041 : "\n"
66042 : "\n"
66043 : "Set the value of a configuration option for all threads.\n"
66044 : "See :cpp:func:`CPLSetConfigOption`.\n"
66045 : "\n"
66046 : "Parameters\n"
66047 : "----------\n"
66048 : "pszKey : str\n"
66049 : " name of the configuration option\n"
66050 : "pszValue : str\n"
66051 : " value of the configuration option\n"
66052 : "\n"
66053 : "See Also\n"
66054 : "--------\n"
66055 : ":py:func:`SetThreadLocalConfigOption`\n"
66056 : ":py:func:`config_option`\n"
66057 : ":py:func:`config_options`\n"
66058 : "\n"
66059 : "\n"
66060 : ""},
66061 : { "SetThreadLocalConfigOption", _wrap_SetThreadLocalConfigOption, METH_VARARGS, "\n"
66062 : "SetThreadLocalConfigOption(char const * pszKey, char const * pszValue)\n"
66063 : "\n"
66064 : "\n"
66065 : "Set the value of a configuration option for the current thread.\n"
66066 : "See :cpp:func:`CPLSetThreadLocalConfigOption`.\n"
66067 : "\n"
66068 : "Parameters\n"
66069 : "----------\n"
66070 : "pszKey : str\n"
66071 : " name of the configuration option\n"
66072 : "pszValue : str\n"
66073 : " value of the configuration option\n"
66074 : "\n"
66075 : "See Also\n"
66076 : "--------\n"
66077 : ":py:func:`SetConfigOption`\n"
66078 : ":py:func:`config_option`\n"
66079 : ":py:func:`config_options`\n"
66080 : "\n"
66081 : ""},
66082 : { "GetConfigOption", _wrap_GetConfigOption, METH_VARARGS, "\n"
66083 : "GetConfigOption(char const * pszKey, char const * pszDefault=None) -> char const *\n"
66084 : "\n"
66085 : "\n"
66086 : "Return the value of a configuration option.\n"
66087 : "See :cpp:func:`CPLGetConfigOption`.\n"
66088 : "\n"
66089 : "Parameters\n"
66090 : "----------\n"
66091 : "pszKey : str\n"
66092 : " name of the configuration option\n"
66093 : "pszDefault : str, optional\n"
66094 : " default value to return if the option has not been set\n"
66095 : "\n"
66096 : "Returns\n"
66097 : "-------\n"
66098 : "str\n"
66099 : "\n"
66100 : "See Also\n"
66101 : "--------\n"
66102 : ":py:func:`GetConfigOptions`\n"
66103 : ":py:func:`GetThreadLocalConfigOption`\n"
66104 : "\n"
66105 : ""},
66106 : { "GetGlobalConfigOption", _wrap_GetGlobalConfigOption, METH_VARARGS, "\n"
66107 : "GetGlobalConfigOption(char const * pszKey, char const * pszDefault=None) -> char const *\n"
66108 : "\n"
66109 : "\n"
66110 : "Return the value of a global (not thread-local) configuration option.\n"
66111 : "See :cpp:func:`CPLGetGlobalConfigOption`.\n"
66112 : "\n"
66113 : "Parameters\n"
66114 : "----------\n"
66115 : "pszKey : str\n"
66116 : " name of the configuration option\n"
66117 : "pszDefault : str, optional\n"
66118 : " default value to return if the option has not been set\n"
66119 : "\n"
66120 : "Returns\n"
66121 : "-------\n"
66122 : "str\n"
66123 : "\n"
66124 : ""},
66125 : { "GetThreadLocalConfigOption", _wrap_GetThreadLocalConfigOption, METH_VARARGS, "\n"
66126 : "GetThreadLocalConfigOption(char const * pszKey, char const * pszDefault=None) -> char const *\n"
66127 : "\n"
66128 : "\n"
66129 : "Return the value of a thread-local configuration option.\n"
66130 : "See :cpp:func:`CPLGetThreadLocalConfigOption`.\n"
66131 : "\n"
66132 : "Parameters\n"
66133 : "----------\n"
66134 : "pszKey : str\n"
66135 : " name of the configuration option\n"
66136 : "pszDefault : str, optional\n"
66137 : " default value to return if the option has not been set\n"
66138 : "\n"
66139 : "Returns\n"
66140 : "-------\n"
66141 : "str\n"
66142 : "\n"
66143 : "\n"
66144 : ""},
66145 : { "GetConfigOptions", _wrap_GetConfigOptions, METH_NOARGS, "\n"
66146 : "GetConfigOptions() -> char **\n"
66147 : "\n"
66148 : "\n"
66149 : "Return a dictionary of currently set configuration options.\n"
66150 : "See :cpp:func:`CPLGetConfigOptions`.\n"
66151 : "\n"
66152 : "Returns\n"
66153 : "-------\n"
66154 : "dict\n"
66155 : "\n"
66156 : "Examples\n"
66157 : "--------\n"
66158 : ">>> with gdal.config_options({'A': '3', 'B': '4'}):\n"
66159 : "... gdal.SetConfigOption('C', '5')\n"
66160 : "... gdal.GetConfigOptions()\n"
66161 : "...\n"
66162 : "{'C': '5', 'A': '3', 'B': '4'}\n"
66163 : "\n"
66164 : "See Also\n"
66165 : "--------\n"
66166 : ":py:func:`GetConfigOption`\n"
66167 : ":py:func:`GetGlobalConfigOptions`\n"
66168 : "\n"
66169 : ""},
66170 : { "SetPathSpecificOption", _wrap_SetPathSpecificOption, METH_VARARGS, "SetPathSpecificOption(char const * pszPathPrefix, char const * pszKey, char const * pszValue)"},
66171 : { "SetCredential", _wrap_SetCredential, METH_VARARGS, "SetCredential(char const * pszPathPrefix, char const * pszKey, char const * pszValue)"},
66172 : { "GetCredential", _wrap_GetCredential, METH_VARARGS, "GetCredential(char const * pszPathPrefix, char const * pszKey, char const * pszDefault=None) -> char const *"},
66173 : { "GetPathSpecificOption", _wrap_GetPathSpecificOption, METH_VARARGS, "GetPathSpecificOption(char const * pszPathPrefix, char const * pszKey, char const * pszDefault=None) -> char const *"},
66174 : { "ClearCredentials", _wrap_ClearCredentials, METH_VARARGS, "ClearCredentials(char const * pszPathPrefix=None)"},
66175 : { "ClearPathSpecificOptions", _wrap_ClearPathSpecificOptions, METH_VARARGS, "ClearPathSpecificOptions(char const * pszPathPrefix=None)"},
66176 : { "CPLBinaryToHex", _wrap_CPLBinaryToHex, METH_O, "CPLBinaryToHex(int nBytes) -> retStringAndCPLFree *"},
66177 : { "CPLHexToBinary", _wrap_CPLHexToBinary, METH_VARARGS, "CPLHexToBinary(char const * pszHex, int * pnBytes) -> GByte *"},
66178 : { "FileFromMemBuffer", _wrap_FileFromMemBuffer, METH_VARARGS, "FileFromMemBuffer(char const * utf8_path, GIntBig nBytes) -> VSI_RETVAL"},
66179 : { "Unlink", _wrap_Unlink, METH_O, "Unlink(char const * utf8_path) -> VSI_RETVAL"},
66180 : { "UnlinkBatch", _wrap_UnlinkBatch, METH_O, "UnlinkBatch(char ** files) -> bool"},
66181 : { "HasThreadSupport", _wrap_HasThreadSupport, METH_NOARGS, "HasThreadSupport() -> int"},
66182 : { "GetCurrentThreadCount", _wrap_GetCurrentThreadCount, METH_NOARGS, "GetCurrentThreadCount() -> int"},
66183 : { "Mkdir", _wrap_Mkdir, METH_VARARGS, "Mkdir(char const * utf8_path, int mode) -> VSI_RETVAL"},
66184 : { "Rmdir", _wrap_Rmdir, METH_O, "Rmdir(char const * utf8_path) -> VSI_RETVAL"},
66185 : { "MkdirRecursive", _wrap_MkdirRecursive, METH_VARARGS, "MkdirRecursive(char const * utf8_path, int mode) -> VSI_RETVAL"},
66186 : { "RmdirRecursive", _wrap_RmdirRecursive, METH_O, "RmdirRecursive(char const * utf8_path) -> VSI_RETVAL"},
66187 : { "Rename", _wrap_Rename, METH_VARARGS, "Rename(char const * old_path, char const * new_path) -> VSI_RETVAL"},
66188 : { "Move", (PyCFunction)(void(*)(void))_wrap_Move, METH_VARARGS|METH_KEYWORDS, "Move(char const * old_path, char const * new_path, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> VSI_RETVAL"},
66189 : { "Sync", (PyCFunction)(void(*)(void))_wrap_Sync, METH_VARARGS|METH_KEYWORDS, "Sync(char const * pszSource, char const * pszTarget, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> bool"},
66190 : { "AbortPendingUploads", _wrap_AbortPendingUploads, METH_O, "AbortPendingUploads(char const * utf8_path) -> bool"},
66191 : { "CopyFile", (PyCFunction)(void(*)(void))_wrap_CopyFile, METH_VARARGS|METH_KEYWORDS, "CopyFile(char const * pszSource, char const * pszTarget, VSILFILE fpSource=None, GIntBig nSourceSize=-1, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
66192 : { "CopyFileRestartable", _wrap_CopyFileRestartable, METH_VARARGS, "CopyFileRestartable(char const * pszSource, char const * pszTarget, char const * pszInputPayload, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None)"},
66193 : { "MoveFile", _wrap_MoveFile, METH_VARARGS, "MoveFile(char const * pszSource, char const * pszTarget) -> int"},
66194 : { "GetActualURL", _wrap_GetActualURL, METH_O, "GetActualURL(char const * utf8_path) -> char const *"},
66195 : { "GetSignedURL", _wrap_GetSignedURL, METH_VARARGS, "GetSignedURL(char const * utf8_path, char ** options=None) -> retStringAndCPLFree *"},
66196 : { "GetFileSystemsPrefixes", _wrap_GetFileSystemsPrefixes, METH_NOARGS, "GetFileSystemsPrefixes() -> char **"},
66197 : { "GetFileSystemOptions", _wrap_GetFileSystemOptions, METH_O, "GetFileSystemOptions(char const * utf8_path) -> char const *"},
66198 : { "VSILFILE_swigregister", VSILFILE_swigregister, METH_O, NULL},
66199 : { "StatBuf_mode_get", _wrap_StatBuf_mode_get, METH_O, "StatBuf_mode_get(StatBuf self) -> int"},
66200 : { "StatBuf_size_get", _wrap_StatBuf_size_get, METH_O, "StatBuf_size_get(StatBuf self) -> GIntBig"},
66201 : { "StatBuf_mtime_get", _wrap_StatBuf_mtime_get, METH_O, "StatBuf_mtime_get(StatBuf self) -> GIntBig"},
66202 : { "new_StatBuf", _wrap_new_StatBuf, METH_O, "new_StatBuf(StatBuf psStatBuf) -> StatBuf"},
66203 : { "delete_StatBuf", _wrap_delete_StatBuf, METH_O, "delete_StatBuf(StatBuf self)"},
66204 : { "StatBuf_IsDirectory", _wrap_StatBuf_IsDirectory, METH_O, "StatBuf_IsDirectory(StatBuf self) -> int"},
66205 : { "StatBuf_swigregister", StatBuf_swigregister, METH_O, NULL},
66206 : { "StatBuf_swiginit", StatBuf_swiginit, METH_VARARGS, NULL},
66207 : { "VSIStatL", _wrap_VSIStatL, METH_VARARGS, "VSIStatL(char const * utf8_path, int nFlags=0) -> int"},
66208 : { "GetFileMetadata", _wrap_GetFileMetadata, METH_VARARGS, "GetFileMetadata(char const * utf8_path, char const * domain, char ** options=None) -> char **"},
66209 : { "SetFileMetadata", _wrap_SetFileMetadata, METH_VARARGS, "SetFileMetadata(char const * utf8_path, char ** metadata, char const * domain, char ** options=None) -> bool"},
66210 : { "VSIFOpenL", _wrap_VSIFOpenL, METH_VARARGS, "VSIFOpenL(char const * utf8_path, char const * pszMode) -> VSILFILE"},
66211 : { "VSIFOpenExL", _wrap_VSIFOpenExL, METH_VARARGS, "VSIFOpenExL(char const * utf8_path, char const * pszMode, int bSetError=FALSE, char ** options=None) -> VSILFILE"},
66212 : { "VSIFEofL", _wrap_VSIFEofL, METH_O, "VSIFEofL(VSILFILE fp) -> int"},
66213 : { "VSIFErrorL", _wrap_VSIFErrorL, METH_O, "VSIFErrorL(VSILFILE fp) -> int"},
66214 : { "VSIFClearErrL", _wrap_VSIFClearErrL, METH_O, "VSIFClearErrL(VSILFILE fp)"},
66215 : { "VSIFFlushL", _wrap_VSIFFlushL, METH_O, "VSIFFlushL(VSILFILE fp) -> int"},
66216 : { "VSIFCloseL", _wrap_VSIFCloseL, METH_O, "VSIFCloseL(VSILFILE fp) -> VSI_RETVAL"},
66217 : { "VSIFSeekL", _wrap_VSIFSeekL, METH_VARARGS, "VSIFSeekL(VSILFILE fp, GIntBig offset, int whence) -> int"},
66218 : { "VSIFTellL", _wrap_VSIFTellL, METH_O, "VSIFTellL(VSILFILE fp) -> GIntBig"},
66219 : { "VSIFTruncateL", _wrap_VSIFTruncateL, METH_VARARGS, "VSIFTruncateL(VSILFILE fp, GIntBig length) -> int"},
66220 : { "VSISupportsSparseFiles", _wrap_VSISupportsSparseFiles, METH_O, "VSISupportsSparseFiles(char const * utf8_path) -> int"},
66221 : { "VSIFGetRangeStatusL", _wrap_VSIFGetRangeStatusL, METH_VARARGS, "VSIFGetRangeStatusL(VSILFILE fp, GIntBig offset, GIntBig length) -> int"},
66222 : { "VSIFWriteL", _wrap_VSIFWriteL, METH_VARARGS, "VSIFWriteL(int nLen, int size, int memb, VSILFILE fp) -> int"},
66223 : { "CPLReadLineL", _wrap_CPLReadLineL, METH_O, "CPLReadLineL(VSILFILE fp) -> char const *"},
66224 : { "VSICurlClearCache", _wrap_VSICurlClearCache, METH_NOARGS, "VSICurlClearCache()"},
66225 : { "VSICurlPartialClearCache", _wrap_VSICurlPartialClearCache, METH_O, "VSICurlPartialClearCache(char const * utf8_path)"},
66226 : { "NetworkStatsReset", _wrap_NetworkStatsReset, METH_NOARGS, "NetworkStatsReset()"},
66227 : { "NetworkStatsGetAsSerializedJSON", _wrap_NetworkStatsGetAsSerializedJSON, METH_VARARGS, "NetworkStatsGetAsSerializedJSON(char ** options=None) -> retStringAndCPLFree *"},
66228 : { "ParseCommandLine", _wrap_ParseCommandLine, METH_O, "ParseCommandLine(char const * utf8_path) -> char **"},
66229 : { "GetNumCPUs", _wrap_GetNumCPUs, METH_NOARGS, "\n"
66230 : "GetNumCPUs() -> int\n"
66231 : "\n"
66232 : "\n"
66233 : "Return the number of processors detected by GDAL.\n"
66234 : "\n"
66235 : "Returns\n"
66236 : "-------\n"
66237 : "int\n"
66238 : "\n"
66239 : ""},
66240 : { "GetUsablePhysicalRAM", _wrap_GetUsablePhysicalRAM, METH_NOARGS, "GetUsablePhysicalRAM() -> GIntBig"},
66241 : { "MultipartUploadGetCapabilities", _wrap_MultipartUploadGetCapabilities, METH_O, "MultipartUploadGetCapabilities(char const * pszFilename)"},
66242 : { "MultipartUploadStart", _wrap_MultipartUploadStart, METH_VARARGS, "MultipartUploadStart(char const * pszFilename, char ** options=None) -> retStringAndCPLFree *"},
66243 : { "MultipartUploadAddPart", _wrap_MultipartUploadAddPart, METH_VARARGS, "MultipartUploadAddPart(char const * pszFilename, char const * pszUploadId, int nPartNumber, GUIntBig nFileOffset, size_t nDataLength, char ** options=None) -> retStringAndCPLFree *"},
66244 : { "MultipartUploadEnd", _wrap_MultipartUploadEnd, METH_VARARGS, "MultipartUploadEnd(char const * pszFilename, char const * pszUploadId, char ** partIds, GUIntBig nTotalSize, char ** options=None) -> bool"},
66245 : { "MultipartUploadAbort", _wrap_MultipartUploadAbort, METH_VARARGS, "MultipartUploadAbort(char const * pszFilename, char const * pszUploadId, char ** options=None) -> bool"},
66246 : { "MajorObject_GetDescription", _wrap_MajorObject_GetDescription, METH_O, "MajorObject_GetDescription(MajorObject self) -> char const *"},
66247 : { "MajorObject_SetDescription", _wrap_MajorObject_SetDescription, METH_VARARGS, "MajorObject_SetDescription(MajorObject self, char const * pszNewDesc)"},
66248 : { "MajorObject_GetMetadataDomainList", _wrap_MajorObject_GetMetadataDomainList, METH_O, "MajorObject_GetMetadataDomainList(MajorObject self) -> char **"},
66249 : { "MajorObject_GetMetadata_Dict", _wrap_MajorObject_GetMetadata_Dict, METH_VARARGS, "MajorObject_GetMetadata_Dict(MajorObject self, char const * pszDomain=\"\") -> char **"},
66250 : { "MajorObject_GetMetadata_List", _wrap_MajorObject_GetMetadata_List, METH_VARARGS, "MajorObject_GetMetadata_List(MajorObject self, char const * pszDomain=\"\") -> char **"},
66251 : { "MajorObject_SetMetadata", _wrap_MajorObject_SetMetadata, METH_VARARGS, "\n"
66252 : "MajorObject_SetMetadata(MajorObject self, char ** papszMetadata, char const * pszDomain=\"\") -> CPLErr\n"
66253 : "MajorObject_SetMetadata(MajorObject self, char * pszMetadataString, char const * pszDomain=\"\") -> CPLErr\n"
66254 : ""},
66255 : { "MajorObject_GetMetadataItem", _wrap_MajorObject_GetMetadataItem, METH_VARARGS, "MajorObject_GetMetadataItem(MajorObject self, char const * pszName, char const * pszDomain=\"\") -> char const *"},
66256 : { "MajorObject_SetMetadataItem", _wrap_MajorObject_SetMetadataItem, METH_VARARGS, "MajorObject_SetMetadataItem(MajorObject self, char const * pszName, char const * pszValue, char const * pszDomain=\"\") -> CPLErr"},
66257 : { "MajorObject_swigregister", MajorObject_swigregister, METH_O, NULL},
66258 : { "Driver_ShortName_get", _wrap_Driver_ShortName_get, METH_O, "\n"
66259 : "Driver_ShortName_get(Driver self) -> char const *\n"
66260 : "\n"
66261 : "The short name of a :py:class:`Driver` that can be passed to\n"
66262 : ":py:func:`GetDriverByName`.\n"
66263 : "See :cpp:func:`GDALGetDriverShortName`.\n"
66264 : "\n"
66265 : ""},
66266 : { "Driver_LongName_get", _wrap_Driver_LongName_get, METH_O, "\n"
66267 : "Driver_LongName_get(Driver self) -> char const *\n"
66268 : "\n"
66269 : "The long name of the driver.\n"
66270 : "See :cpp:func:`GDALGetDriverLongName`.\n"
66271 : "\n"
66272 : ""},
66273 : { "Driver_HelpTopic_get", _wrap_Driver_HelpTopic_get, METH_O, "\n"
66274 : "Driver_HelpTopic_get(Driver self) -> char const *\n"
66275 : "\n"
66276 : "The URL for driver documentation, relative to the GDAL documentation directory.\n"
66277 : "See :cpp:func:`GDALGetDriverHelpTopic`.\n"
66278 : "\n"
66279 : ""},
66280 : { "Driver_Create", (PyCFunction)(void(*)(void))_wrap_Driver_Create, METH_VARARGS|METH_KEYWORDS, "\n"
66281 : "Driver_Create(Driver self, char const * utf8_path, int xsize, int ysize, int bands=1, GDALDataType eType=GDT_Byte, char ** options=None) -> Dataset\n"
66282 : "\n"
66283 : "\n"
66284 : "Create a new :py:class:`Dataset` with this driver.\n"
66285 : "See :cpp:func:`GDALDriver::Create`.\n"
66286 : "\n"
66287 : "Parameters\n"
66288 : "----------\n"
66289 : "utf8_path : str\n"
66290 : " Path of the dataset to create.\n"
66291 : "xsize : int\n"
66292 : " Width of created raster in pixels. Set to zero for vector datasets.\n"
66293 : "ysize : int\n"
66294 : " Height of created raster in pixels. Set to zero for vector datasets.\n"
66295 : "bands : int, default = 1\n"
66296 : " Number of bands. Set to zero for vector datasets.\n"
66297 : "eType : int or numpy.dtype, default = :py:const:`GDT_Byte`\n"
66298 : " Raster data type. Set to :py:const:`GDT_Unknown` for vector datasets.\n"
66299 : "options : list or dict\n"
66300 : " List of driver-specific options\n"
66301 : "\n"
66302 : "Returns\n"
66303 : "-------\n"
66304 : "Dataset\n"
66305 : "\n"
66306 : "Examples\n"
66307 : "--------\n"
66308 : ">>> with gdal.GetDriverByName('GTiff').Create('test.tif', 12, 4, 2, gdal.GDT_Float32, {'COMPRESS': 'DEFLATE'}) as ds:\n"
66309 : "... print(gdal.Info(ds))\n"
66310 : "...\n"
66311 : "Driver: GTiff/GeoTIFF\n"
66312 : "Files: test.tif\n"
66313 : "Size is 12, 4\n"
66314 : "Image Structure Metadata:\n"
66315 : " INTERLEAVE=PIXEL\n"
66316 : "Corner Coordinates:\n"
66317 : "Upper Left ( 0.0, 0.0)\n"
66318 : "Lower Left ( 0.0, 4.0)\n"
66319 : "Upper Right ( 12.0, 0.0)\n"
66320 : "Lower Right ( 12.0, 4.0)\n"
66321 : "Center ( 6.0, 2.0)\n"
66322 : "Band 1 Block=12x4 Type=Float32, ColorInterp=Gray\n"
66323 : "Band 2 Block=12x4 Type=Float32, ColorInterp=Undefined\n"
66324 : "\n"
66325 : ">>> with gdal.GetDriverByName('ESRI Shapefile').Create('test.shp', 0, 0, 0, gdal.GDT_Unknown) as ds:\n"
66326 : "... print(gdal.VectorInfo(ds))\n"
66327 : "...\n"
66328 : "INFO: Open of `test.shp'\n"
66329 : " using driver `ESRI Shapefile' successful.\n"
66330 : "\n"
66331 : ""},
66332 : { "Driver_CreateVector", (PyCFunction)(void(*)(void))_wrap_Driver_CreateVector, METH_VARARGS|METH_KEYWORDS, "\n"
66333 : "Driver_CreateVector(Driver self, char const * utf8_path, char ** options=None) -> Dataset\n"
66334 : "\n"
66335 : "\n"
66336 : "Create a new vector :py:class:`Dataset` with this driver.\n"
66337 : "This method is an alias for ``Create(name, 0, 0, 0, gdal.GDT_Unknown)``.\n"
66338 : "\n"
66339 : "Parameters\n"
66340 : "----------\n"
66341 : "utf8_path : str\n"
66342 : " Path of the dataset to create.\n"
66343 : "\n"
66344 : "Returns\n"
66345 : "-------\n"
66346 : "Dataset\n"
66347 : "\n"
66348 : "Examples\n"
66349 : "--------\n"
66350 : ">>> with gdal.GetDriverByName('ESRI Shapefile').CreateVector('test.shp') as ds:\n"
66351 : "... print(ds.GetLayerCount())\n"
66352 : "... \n"
66353 : "0\n"
66354 : "\n"
66355 : "\n"
66356 : ""},
66357 : { "Driver_CreateMultiDimensional", (PyCFunction)(void(*)(void))_wrap_Driver_CreateMultiDimensional, METH_VARARGS|METH_KEYWORDS, "\n"
66358 : "Driver_CreateMultiDimensional(Driver self, char const * utf8_path, char ** root_group_options=None, char ** options=None) -> Dataset\n"
66359 : "\n"
66360 : "\n"
66361 : "Create a new multidimensional dataset.\n"
66362 : "See :cpp:func:`GDALDriver::CreateMultiDimensional`.\n"
66363 : "\n"
66364 : "Parameters\n"
66365 : "----------\n"
66366 : "utf8_path : str\n"
66367 : " Path of the dataset to create.\n"
66368 : "root_group_options : list or dict\n"
66369 : " Driver-specific options regarding the creation of the\n"
66370 : " root group.\n"
66371 : "options : list or dict\n"
66372 : " List of driver-specific options regarding the creation\n"
66373 : " of the Dataset.\n"
66374 : "\n"
66375 : "Returns\n"
66376 : "-------\n"
66377 : "Dataset\n"
66378 : "\n"
66379 : "Examples\n"
66380 : "--------\n"
66381 : ".. testsetup::\n"
66382 : " >>> if gdal.GetDriverByName('netCDF') is None:\n"
66383 : " ... pytest.skip()\n"
66384 : "\n"
66385 : ">>> with gdal.GetDriverByName('netCDF').CreateMultiDimensional('test.nc') as ds:\n"
66386 : "... gdal.MultiDimInfo(ds)\n"
66387 : "...\n"
66388 : "{'type': 'group', 'driver': 'netCDF', 'name': '/', 'attributes': {'Conventions': 'CF-1.6'}, 'structural_info': {'NC_FORMAT': 'NETCDF4'}}\n"
66389 : "\n"
66390 : "\n"
66391 : ""},
66392 : { "Driver_CreateCopy", (PyCFunction)(void(*)(void))_wrap_Driver_CreateCopy, METH_VARARGS|METH_KEYWORDS, "\n"
66393 : "Driver_CreateCopy(Driver self, char const * utf8_path, Dataset src, int strict=1, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset\n"
66394 : "\n"
66395 : "\n"
66396 : "Create a copy of a :py:class:`Dataset`.\n"
66397 : "See :cpp:func:`GDALDriver::CreateCopy`.\n"
66398 : "\n"
66399 : "Parameters\n"
66400 : "----------\n"
66401 : "utf8_path : str\n"
66402 : " Path of the dataset to create.\n"
66403 : "src : Dataset\n"
66404 : " The dataset being duplicated.\n"
66405 : "strict : bool, default=1\n"
66406 : " Indicates whether the copy must be strictly equivalent or if\n"
66407 : " it may be adapted as needed for the output format.\n"
66408 : "options : list or dict\n"
66409 : " List of driver-specific options\n"
66410 : "callback : callable, optional\n"
66411 : " A progress callback function\n"
66412 : "callback_data : any, optional\n"
66413 : " Optional data to be passed to callback function\n"
66414 : "\n"
66415 : "Returns\n"
66416 : "-------\n"
66417 : "Dataset\n"
66418 : "\n"
66419 : ""},
66420 : { "Driver_Delete", _wrap_Driver_Delete, METH_VARARGS, "\n"
66421 : "Driver_Delete(Driver self, char const * utf8_path) -> CPLErr\n"
66422 : "\n"
66423 : "Delete a :py:class:`Dataset`.\n"
66424 : "See :cpp:func:`GDALDriver::Delete`.\n"
66425 : "\n"
66426 : "Parameters\n"
66427 : "----------\n"
66428 : "utf8_path : str\n"
66429 : " Path of the dataset to delete.\n"
66430 : "\n"
66431 : "Returns\n"
66432 : "-------\n"
66433 : "int\n"
66434 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
66435 : "\n"
66436 : ""},
66437 : { "Driver_Rename", _wrap_Driver_Rename, METH_VARARGS, "\n"
66438 : "Driver_Rename(Driver self, char const * newName, char const * oldName) -> CPLErr\n"
66439 : "\n"
66440 : "Rename a :py:class:`Dataset`.\n"
66441 : "See :cpp:func:`GDALDriver::Rename`.\n"
66442 : "\n"
66443 : "Parameters\n"
66444 : "----------\n"
66445 : "newName : str\n"
66446 : " new path for the dataset\n"
66447 : "oldName : str\n"
66448 : " old path for the dataset\n"
66449 : "\n"
66450 : "Returns\n"
66451 : "-------\n"
66452 : "int\n"
66453 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
66454 : "\n"
66455 : ""},
66456 : { "Driver_CopyFiles", _wrap_Driver_CopyFiles, METH_VARARGS, "\n"
66457 : "Driver_CopyFiles(Driver self, char const * newName, char const * oldName) -> CPLErr\n"
66458 : "\n"
66459 : "Copy all the files associated with a :py:class:`Dataset`.\n"
66460 : "\n"
66461 : "Parameters\n"
66462 : "----------\n"
66463 : "newName : str\n"
66464 : " new path for the dataset\n"
66465 : "oldName : str\n"
66466 : " old path for the dataset\n"
66467 : "\n"
66468 : "Returns\n"
66469 : "-------\n"
66470 : "int\n"
66471 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
66472 : "\n"
66473 : ""},
66474 : { "Driver_HasOpenOption", _wrap_Driver_HasOpenOption, METH_VARARGS, "\n"
66475 : "Driver_HasOpenOption(Driver self, char const * openOptionName) -> bool\n"
66476 : "\n"
66477 : "\n"
66478 : "Reports whether the driver supports a specified open option.\n"
66479 : "\n"
66480 : "Parameters\n"
66481 : "----------\n"
66482 : "openOptionName : str\n"
66483 : " The name of the option to test\n"
66484 : "\n"
66485 : "Returns\n"
66486 : "-------\n"
66487 : "bool\n"
66488 : " ``True``, if the option is supported by this driver, ``False`` otherwise.\n"
66489 : "\n"
66490 : "Examples\n"
66491 : "--------\n"
66492 : ">>> gdal.GetDriverByName('GPKG').HasOpenOption('PRELUDE_STATEMENTS')\n"
66493 : "True\n"
66494 : ">>> gdal.GetDriverByName('GPKG').HasOpenOption('CLOSING_STATEMENTS')\n"
66495 : "False\n"
66496 : "\n"
66497 : "\n"
66498 : ""},
66499 : { "Driver_TestCapability", _wrap_Driver_TestCapability, METH_VARARGS, "\n"
66500 : "Driver_TestCapability(Driver self, char const * cap) -> bool\n"
66501 : "\n"
66502 : "\n"
66503 : "Check whether the driver supports a specified capability\n"
66504 : "(:py:const:`ogr.ODrCCreateDataSource` or\n"
66505 : ":py:const:`ogr.ODrCDeleteDataSource`)`.\n"
66506 : "\n"
66507 : "Parameters\n"
66508 : "----------\n"
66509 : "cap : str\n"
66510 : " The name of the capability to test\n"
66511 : "\n"
66512 : "Returns\n"
66513 : "-------\n"
66514 : "bool\n"
66515 : " ``True`` if the driver supports the capability, ``False`` otherwise.\n"
66516 : "\n"
66517 : "Examples\n"
66518 : "--------\n"
66519 : ">>> gdal.GetDriverByName('ESRI Shapefile').TestCapability(ogr.ODrCCreateDataSource)\n"
66520 : "True\n"
66521 : ">>> gdal.GetDriverByName('GTiff').TestCapability(ogr.ODrCCreateDataSource)\n"
66522 : "True\n"
66523 : "\n"
66524 : "\n"
66525 : ""},
66526 : { "Driver_Register", _wrap_Driver_Register, METH_O, "\n"
66527 : "Driver_Register(Driver self) -> int\n"
66528 : "\n"
66529 : "Register the driver for use.\n"
66530 : "See :cpp:func:`GDALDriverManager::RegisterDriver`.\n"
66531 : "\n"
66532 : ""},
66533 : { "Driver_Deregister", _wrap_Driver_Deregister, METH_O, "\n"
66534 : "Driver_Deregister(Driver self)\n"
66535 : "\n"
66536 : "Deregister the driver.\n"
66537 : "See :cpp:func:`GDALDriverManager::DeregisterDriver`.\n"
66538 : "\n"
66539 : ""},
66540 : { "Driver_swigregister", Driver_swigregister, METH_O, NULL},
66541 : { "ColorEntry_c1_set", _wrap_ColorEntry_c1_set, METH_VARARGS, "ColorEntry_c1_set(ColorEntry self, short c1)"},
66542 : { "ColorEntry_c1_get", _wrap_ColorEntry_c1_get, METH_O, "ColorEntry_c1_get(ColorEntry self) -> short"},
66543 : { "ColorEntry_c2_set", _wrap_ColorEntry_c2_set, METH_VARARGS, "ColorEntry_c2_set(ColorEntry self, short c2)"},
66544 : { "ColorEntry_c2_get", _wrap_ColorEntry_c2_get, METH_O, "ColorEntry_c2_get(ColorEntry self) -> short"},
66545 : { "ColorEntry_c3_set", _wrap_ColorEntry_c3_set, METH_VARARGS, "ColorEntry_c3_set(ColorEntry self, short c3)"},
66546 : { "ColorEntry_c3_get", _wrap_ColorEntry_c3_get, METH_O, "ColorEntry_c3_get(ColorEntry self) -> short"},
66547 : { "ColorEntry_c4_set", _wrap_ColorEntry_c4_set, METH_VARARGS, "ColorEntry_c4_set(ColorEntry self, short c4)"},
66548 : { "ColorEntry_c4_get", _wrap_ColorEntry_c4_get, METH_O, "ColorEntry_c4_get(ColorEntry self) -> short"},
66549 : { "ColorEntry_swigregister", ColorEntry_swigregister, METH_O, NULL},
66550 : { "GCP_GCPX_set", _wrap_GCP_GCPX_set, METH_VARARGS, "GCP_GCPX_set(GCP self, double GCPX)"},
66551 : { "GCP_GCPX_get", _wrap_GCP_GCPX_get, METH_O, "GCP_GCPX_get(GCP self) -> double"},
66552 : { "GCP_GCPY_set", _wrap_GCP_GCPY_set, METH_VARARGS, "GCP_GCPY_set(GCP self, double GCPY)"},
66553 : { "GCP_GCPY_get", _wrap_GCP_GCPY_get, METH_O, "GCP_GCPY_get(GCP self) -> double"},
66554 : { "GCP_GCPZ_set", _wrap_GCP_GCPZ_set, METH_VARARGS, "GCP_GCPZ_set(GCP self, double GCPZ)"},
66555 : { "GCP_GCPZ_get", _wrap_GCP_GCPZ_get, METH_O, "GCP_GCPZ_get(GCP self) -> double"},
66556 : { "GCP_GCPPixel_set", _wrap_GCP_GCPPixel_set, METH_VARARGS, "GCP_GCPPixel_set(GCP self, double GCPPixel)"},
66557 : { "GCP_GCPPixel_get", _wrap_GCP_GCPPixel_get, METH_O, "GCP_GCPPixel_get(GCP self) -> double"},
66558 : { "GCP_GCPLine_set", _wrap_GCP_GCPLine_set, METH_VARARGS, "GCP_GCPLine_set(GCP self, double GCPLine)"},
66559 : { "GCP_GCPLine_get", _wrap_GCP_GCPLine_get, METH_O, "GCP_GCPLine_get(GCP self) -> double"},
66560 : { "GCP_Info_set", _wrap_GCP_Info_set, METH_VARARGS, "GCP_Info_set(GCP self, char * Info)"},
66561 : { "GCP_Info_get", _wrap_GCP_Info_get, METH_O, "GCP_Info_get(GCP self) -> char *"},
66562 : { "GCP_Id_set", _wrap_GCP_Id_set, METH_VARARGS, "GCP_Id_set(GCP self, char * Id)"},
66563 : { "GCP_Id_get", _wrap_GCP_Id_get, METH_O, "GCP_Id_get(GCP self) -> char *"},
66564 : { "new_GCP", _wrap_new_GCP, METH_VARARGS, "new_GCP(double x=0.0, double y=0.0, double z=0.0, double pixel=0.0, double line=0.0, char const * info=\"\", char const * id=\"\") -> GCP"},
66565 : { "delete_GCP", _wrap_delete_GCP, METH_O, "delete_GCP(GCP self)"},
66566 : { "GCP_swigregister", GCP_swigregister, METH_O, NULL},
66567 : { "GCP_swiginit", GCP_swiginit, METH_VARARGS, NULL},
66568 : { "GDAL_GCP_GCPX_get", _wrap_GDAL_GCP_GCPX_get, METH_O, "GDAL_GCP_GCPX_get(GCP gcp) -> double"},
66569 : { "GDAL_GCP_GCPX_set", _wrap_GDAL_GCP_GCPX_set, METH_VARARGS, "GDAL_GCP_GCPX_set(GCP gcp, double dfGCPX)"},
66570 : { "GDAL_GCP_GCPY_get", _wrap_GDAL_GCP_GCPY_get, METH_O, "GDAL_GCP_GCPY_get(GCP gcp) -> double"},
66571 : { "GDAL_GCP_GCPY_set", _wrap_GDAL_GCP_GCPY_set, METH_VARARGS, "GDAL_GCP_GCPY_set(GCP gcp, double dfGCPY)"},
66572 : { "GDAL_GCP_GCPZ_get", _wrap_GDAL_GCP_GCPZ_get, METH_O, "GDAL_GCP_GCPZ_get(GCP gcp) -> double"},
66573 : { "GDAL_GCP_GCPZ_set", _wrap_GDAL_GCP_GCPZ_set, METH_VARARGS, "GDAL_GCP_GCPZ_set(GCP gcp, double dfGCPZ)"},
66574 : { "GDAL_GCP_GCPPixel_get", _wrap_GDAL_GCP_GCPPixel_get, METH_O, "GDAL_GCP_GCPPixel_get(GCP gcp) -> double"},
66575 : { "GDAL_GCP_GCPPixel_set", _wrap_GDAL_GCP_GCPPixel_set, METH_VARARGS, "GDAL_GCP_GCPPixel_set(GCP gcp, double dfGCPPixel)"},
66576 : { "GDAL_GCP_GCPLine_get", _wrap_GDAL_GCP_GCPLine_get, METH_O, "GDAL_GCP_GCPLine_get(GCP gcp) -> double"},
66577 : { "GDAL_GCP_GCPLine_set", _wrap_GDAL_GCP_GCPLine_set, METH_VARARGS, "GDAL_GCP_GCPLine_set(GCP gcp, double dfGCPLine)"},
66578 : { "GDAL_GCP_Info_get", _wrap_GDAL_GCP_Info_get, METH_O, "GDAL_GCP_Info_get(GCP gcp) -> char const *"},
66579 : { "GDAL_GCP_Info_set", _wrap_GDAL_GCP_Info_set, METH_VARARGS, "GDAL_GCP_Info_set(GCP gcp, char const * pszInfo)"},
66580 : { "GDAL_GCP_Id_get", _wrap_GDAL_GCP_Id_get, METH_O, "GDAL_GCP_Id_get(GCP gcp) -> char const *"},
66581 : { "GDAL_GCP_Id_set", _wrap_GDAL_GCP_Id_set, METH_VARARGS, "GDAL_GCP_Id_set(GCP gcp, char const * pszId)"},
66582 : { "GCPsToGeoTransform", _wrap_GCPsToGeoTransform, METH_VARARGS, "GCPsToGeoTransform(int nGCPs, int bApproxOK=1) -> RETURN_NONE"},
66583 : { "GCPsToHomography", _wrap_GCPsToHomography, METH_O, "GCPsToHomography(int nGCPs) -> RETURN_NONE"},
66584 : { "delete_VirtualMem", _wrap_delete_VirtualMem, METH_O, "delete_VirtualMem(VirtualMem self)"},
66585 : { "VirtualMem_GetAddr", _wrap_VirtualMem_GetAddr, METH_O, "VirtualMem_GetAddr(VirtualMem self)"},
66586 : { "VirtualMem_Pin", _wrap_VirtualMem_Pin, METH_VARARGS, "VirtualMem_Pin(VirtualMem self, size_t start_offset=0, size_t nsize=0, int bWriteOp=0)"},
66587 : { "VirtualMem_swigregister", VirtualMem_swigregister, METH_O, NULL},
66588 : { "delete_AsyncReader", _wrap_delete_AsyncReader, METH_O, "delete_AsyncReader(AsyncReader self)"},
66589 : { "AsyncReader_GetNextUpdatedRegion", _wrap_AsyncReader_GetNextUpdatedRegion, METH_VARARGS, "AsyncReader_GetNextUpdatedRegion(AsyncReader self, double timeout) -> GDALAsyncStatusType"},
66590 : { "AsyncReader_GetBuffer", _wrap_AsyncReader_GetBuffer, METH_O, "AsyncReader_GetBuffer(AsyncReader self)"},
66591 : { "AsyncReader_LockBuffer", _wrap_AsyncReader_LockBuffer, METH_VARARGS, "AsyncReader_LockBuffer(AsyncReader self, double timeout) -> int"},
66592 : { "AsyncReader_UnlockBuffer", _wrap_AsyncReader_UnlockBuffer, METH_O, "AsyncReader_UnlockBuffer(AsyncReader self)"},
66593 : { "AsyncReader_swigregister", AsyncReader_swigregister, METH_O, NULL},
66594 : { "Dataset_RasterXSize_get", _wrap_Dataset_RasterXSize_get, METH_O, "\n"
66595 : "Dataset_RasterXSize_get(Dataset self) -> int\n"
66596 : "\n"
66597 : "\n"
66598 : "Raster width in pixels. See :cpp:func:`GDALGetRasterXSize`.\n"
66599 : "\n"
66600 : "\n"
66601 : ""},
66602 : { "Dataset_RasterYSize_get", _wrap_Dataset_RasterYSize_get, METH_O, "\n"
66603 : "Dataset_RasterYSize_get(Dataset self) -> int\n"
66604 : "\n"
66605 : "\n"
66606 : "Raster height in pixels. See :cpp:func:`GDALGetRasterYSize`.\n"
66607 : "\n"
66608 : "\n"
66609 : ""},
66610 : { "Dataset_RasterCount_get", _wrap_Dataset_RasterCount_get, METH_O, "\n"
66611 : "Dataset_RasterCount_get(Dataset self) -> int\n"
66612 : "\n"
66613 : "\n"
66614 : "The number of bands in this dataset.\n"
66615 : "\n"
66616 : "\n"
66617 : ""},
66618 : { "delete_Dataset", _wrap_delete_Dataset, METH_O, "delete_Dataset(Dataset self)"},
66619 : { "Dataset_MarkSuppressOnClose", _wrap_Dataset_MarkSuppressOnClose, METH_O, "Dataset_MarkSuppressOnClose(Dataset self)"},
66620 : { "Dataset_Close", _wrap_Dataset_Close, METH_O, "\n"
66621 : "Dataset_Close(Dataset self) -> CPLErr\n"
66622 : "\n"
66623 : "Closes opened dataset and releases allocated resources.\n"
66624 : "\n"
66625 : "This method can be used to force the dataset to close\n"
66626 : "when one more references to the dataset are still\n"
66627 : "reachable. If :py:meth:`Close` is never called, the dataset will\n"
66628 : "be closed automatically during garbage collection.\n"
66629 : "\n"
66630 : "In most cases, it is preferable to open or create a dataset\n"
66631 : "using a context manager instead of calling :py:meth:`Close`\n"
66632 : "directly.\n"
66633 : "\n"
66634 : "\n"
66635 : ""},
66636 : { "Dataset__RunCloseWithoutDestroying", _wrap_Dataset__RunCloseWithoutDestroying, METH_O, "Dataset__RunCloseWithoutDestroying(Dataset self) -> CPLErr"},
66637 : { "Dataset_GetDriver", _wrap_Dataset_GetDriver, METH_O, "\n"
66638 : "Dataset_GetDriver(Dataset self) -> Driver\n"
66639 : "\n"
66640 : "\n"
66641 : "Fetch the driver used to open or create this :py:class:`Dataset`.\n"
66642 : "\n"
66643 : "\n"
66644 : ""},
66645 : { "Dataset_GetRasterBand", _wrap_Dataset_GetRasterBand, METH_VARARGS, "\n"
66646 : "Dataset_GetRasterBand(Dataset self, int nBand) -> Band\n"
66647 : "\n"
66648 : "\n"
66649 : "Fetch a :py:class:`Band` band from a :py:class:`Dataset`. See :cpp:func:`GDALGetRasterBand`.\n"
66650 : "\n"
66651 : "Parameters\n"
66652 : "----------\n"
66653 : "nBand : int\n"
66654 : " the index of the band to fetch, from 1 to :py:attr:`RasterCount`\n"
66655 : "\n"
66656 : "Returns\n"
66657 : "-------\n"
66658 : "Band\n"
66659 : " the :py:class:`Band`, or ``None`` on error.\n"
66660 : "\n"
66661 : "\n"
66662 : ""},
66663 : { "Dataset_IsThreadSafe", _wrap_Dataset_IsThreadSafe, METH_VARARGS, "Dataset_IsThreadSafe(Dataset self, int nScopeFlags) -> bool"},
66664 : { "Dataset_GetThreadSafeDataset", _wrap_Dataset_GetThreadSafeDataset, METH_VARARGS, "Dataset_GetThreadSafeDataset(Dataset self, int nScopeFlags) -> Dataset"},
66665 : { "Dataset_GetRootGroup", _wrap_Dataset_GetRootGroup, METH_O, "\n"
66666 : "Dataset_GetRootGroup(Dataset self) -> Group\n"
66667 : "\n"
66668 : "\n"
66669 : "Return the root :py:class:`Group` of this dataset.\n"
66670 : "Only value for multidimensional datasets.\n"
66671 : "\n"
66672 : "Returns\n"
66673 : "-------\n"
66674 : "Group\n"
66675 : "\n"
66676 : "\n"
66677 : ""},
66678 : { "Dataset_GetProjection", _wrap_Dataset_GetProjection, METH_O, "\n"
66679 : "Dataset_GetProjection(Dataset self) -> char const *\n"
66680 : "\n"
66681 : "\n"
66682 : "Return a WKT representation of the dataset spatial reference.\n"
66683 : "Equivalent to :py:meth:`GetProjectionRef`.\n"
66684 : "\n"
66685 : "Returns\n"
66686 : "-------\n"
66687 : "str\n"
66688 : "\n"
66689 : "\n"
66690 : ""},
66691 : { "Dataset_GetProjectionRef", _wrap_Dataset_GetProjectionRef, METH_O, "\n"
66692 : "Dataset_GetProjectionRef(Dataset self) -> char const *\n"
66693 : "\n"
66694 : "\n"
66695 : "Return a WKT representation of the dataset spatial reference.\n"
66696 : "\n"
66697 : "Returns\n"
66698 : "-------\n"
66699 : "str\n"
66700 : "\n"
66701 : "\n"
66702 : ""},
66703 : { "Dataset_GetRefCount", _wrap_Dataset_GetRefCount, METH_O, "Dataset_GetRefCount(Dataset self) -> int"},
66704 : { "Dataset_GetSummaryRefCount", _wrap_Dataset_GetSummaryRefCount, METH_O, "Dataset_GetSummaryRefCount(Dataset self) -> int"},
66705 : { "Dataset_GetSpatialRef", _wrap_Dataset_GetSpatialRef, METH_O, "\n"
66706 : "Dataset_GetSpatialRef(Dataset self) -> SpatialReference\n"
66707 : "\n"
66708 : "\n"
66709 : "Fetch the spatial reference for this dataset.\n"
66710 : "\n"
66711 : "Returns\n"
66712 : "-------\n"
66713 : "SpatialReference\n"
66714 : "\n"
66715 : "\n"
66716 : ""},
66717 : { "Dataset_SetProjection", _wrap_Dataset_SetProjection, METH_VARARGS, "\n"
66718 : "Dataset_SetProjection(Dataset self, char const * prj) -> CPLErr\n"
66719 : "\n"
66720 : "\n"
66721 : "Set the spatial reference system for this dataset.\n"
66722 : "\n"
66723 : "See :cpp:func:`GDALDataset::SetProjection`.\n"
66724 : "\n"
66725 : "Parameters\n"
66726 : "----------\n"
66727 : "prj : str\n"
66728 : " The projection string in OGC WKT or PROJ.4 format\n"
66729 : "\n"
66730 : "Returns\n"
66731 : "-------\n"
66732 : "int\n"
66733 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
66734 : "\n"
66735 : "\n"
66736 : ""},
66737 : { "Dataset_SetSpatialRef", _wrap_Dataset_SetSpatialRef, METH_VARARGS, "\n"
66738 : "Dataset_SetSpatialRef(Dataset self, SpatialReference srs) -> CPLErr\n"
66739 : "\n"
66740 : "\n"
66741 : "Set the spatial reference system for this dataset.\n"
66742 : "\n"
66743 : "Parameters\n"
66744 : "----------\n"
66745 : "srs : SpatialReference\n"
66746 : "\n"
66747 : "Returns\n"
66748 : "-------\n"
66749 : "int\n"
66750 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
66751 : "\n"
66752 : "\n"
66753 : ""},
66754 : { "Dataset_GetGeoTransform", (PyCFunction)(void(*)(void))_wrap_Dataset_GetGeoTransform, METH_VARARGS|METH_KEYWORDS, "\n"
66755 : "Dataset_GetGeoTransform(Dataset self, int * can_return_null=None)\n"
66756 : "\n"
66757 : "\n"
66758 : "Fetch the affine transformation coefficients.\n"
66759 : "\n"
66760 : "See :cpp:func:`GDALGetGeoTransform`.\n"
66761 : "\n"
66762 : "Parameters\n"
66763 : "----------\n"
66764 : "can_return_null : bool, default=False\n"
66765 : " if ``True``, return ``None`` instead of the default transformation\n"
66766 : " if the transformation for this :py:class:`Dataset` has not been defined.\n"
66767 : "\n"
66768 : "Returns\n"
66769 : "-------\n"
66770 : "tuple\n"
66771 : " a 6-member tuple representing the transformation coefficients\n"
66772 : "\n"
66773 : "\n"
66774 : "\n"
66775 : ""},
66776 : { "Dataset_SetGeoTransform", _wrap_Dataset_SetGeoTransform, METH_VARARGS, "\n"
66777 : "Dataset_SetGeoTransform(Dataset self, double [6] argin) -> CPLErr\n"
66778 : "\n"
66779 : "\n"
66780 : "Set the affine transformation coefficients.\n"
66781 : "\n"
66782 : "See :py:meth:`GetGeoTransform` for details on the meaning of the coefficients.\n"
66783 : "\n"
66784 : "Parameters\n"
66785 : "----------\n"
66786 : "argin : tuple\n"
66787 : "\n"
66788 : "Returns\n"
66789 : "-------\n"
66790 : "int\n"
66791 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
66792 : "\n"
66793 : "\n"
66794 : ""},
66795 : { "Dataset_GetExtent", (PyCFunction)(void(*)(void))_wrap_Dataset_GetExtent, METH_VARARGS|METH_KEYWORDS, "\n"
66796 : "Dataset_GetExtent(Dataset self, SpatialReference srs=None)\n"
66797 : "\n"
66798 : "Get the extent of the dataset.\n"
66799 : "\n"
66800 : "See :cpp:func:`GDALDataset::GetExtent`\n"
66801 : "\n"
66802 : ".. versionadded:: 3.12\n"
66803 : "\n"
66804 : ".. warning:: Check the return order of the bounds.\n"
66805 : "\n"
66806 : "Parameters\n"
66807 : "----------\n"
66808 : "srs : SpatialReference, optional\n"
66809 : " Optional spatial reference in which the bounds should be \n"
66810 : " returned. Defaults to ``None``.\n"
66811 : "\n"
66812 : "Returns\n"
66813 : "-------\n"
66814 : "tuple or None\n"
66815 : " tuple of (minx, maxx, miny, maxy) or None if the extent cannot be\n"
66816 : " determined in the specified spatial reference system\n"
66817 : "\n"
66818 : "Examples\n"
66819 : "--------\n"
66820 : ">>> # Get extent in native SRS (NAD27 / UTM 11N)\n"
66821 : ">>> with gdal.Open('byte.tif') as ds:\n"
66822 : "... ds.GetExtent()\n"
66823 : "(440720.0, 441920.0, 3750120.0, 3751320.0)\n"
66824 : "\n"
66825 : ">>> # Get extent in US National Atlas Equal Area\n"
66826 : ">>> with gdal.Open('byte.tif') as ds:\n"
66827 : "... ds.GetExtent(osr.SpatialReference(epsg=9311))\n"
66828 : "... \n"
66829 : "(-1621603.0, -1620214.9, -1064263.1, -1062837.1)\n"
66830 : "\n"
66831 : "See Also\n"
66832 : "--------\n"
66833 : ":py:meth:`GetExtentWGS84LongLat`\n"
66834 : "\n"
66835 : "\n"
66836 : ""},
66837 : { "Dataset_GetExtentWGS84LongLat", _wrap_Dataset_GetExtentWGS84LongLat, METH_O, "\n"
66838 : "Dataset_GetExtentWGS84LongLat(Dataset self)\n"
66839 : "\n"
66840 : "\n"
66841 : "Return the extent of the dataset in WGS84, with the x-axis representing\n"
66842 : "longitude and the y-axis representing latitude.\n"
66843 : "\n"
66844 : "See :cpp:func:`GDALDataset::GetExtentWGS84LongLat`\n"
66845 : "\n"
66846 : ".. versionadded:: 3.12\n"
66847 : "\n"
66848 : ".. warning:: Check the return order of the bounds.\n"
66849 : "\n"
66850 : "Returns\n"
66851 : "-------\n"
66852 : "tuple or None\n"
66853 : " tuple of (minlon, maxlon, minlat, maxlat) or None if the extent cannot be\n"
66854 : " determined in WGS84\n"
66855 : "\n"
66856 : "Examples\n"
66857 : "--------\n"
66858 : ">>> with gdal.Open('byte.tif') as ds:\n"
66859 : "... ds.GetExtentWGS84LongLat()\n"
66860 : "... \n"
66861 : "(-117.642, -117.629, 33.892, 33.902)\n"
66862 : "\n"
66863 : "See Also\n"
66864 : "--------\n"
66865 : ":py:meth:`GetExtent`\n"
66866 : "\n"
66867 : "\n"
66868 : "\n"
66869 : ""},
66870 : { "Dataset_BuildOverviews", (PyCFunction)(void(*)(void))_wrap_Dataset_BuildOverviews, METH_VARARGS|METH_KEYWORDS, "\n"
66871 : "Dataset_BuildOverviews(Dataset self, char const * resampling=\"NEAREST\", int overviewlist=0, GDALProgressFunc callback=0, void * callback_data=None, char ** options=None) -> int\n"
66872 : "\n"
66873 : "\n"
66874 : "Build raster overview(s) for all bands.\n"
66875 : "\n"
66876 : "See :cpp:func:`GDALDataset::BuildOverviews`\n"
66877 : "\n"
66878 : "Parameters\n"
66879 : "----------\n"
66880 : "resampling : str, optional\n"
66881 : " The resampling method to use. See :cpp:func:`GDALDataset::BuildOverviews`.\n"
66882 : "overviewlist : list\n"
66883 : " A list of overview levels (decimation factors) to build, or an\n"
66884 : " empty list to clear existing overviews.\n"
66885 : "callback : callable, optional\n"
66886 : " A progress callback function\n"
66887 : "callback_data : any, optional\n"
66888 : " Optional data to be passed to callback function\n"
66889 : "options : dict or list, optional\n"
66890 : " A dict or list of key=value options\n"
66891 : "\n"
66892 : "Returns\n"
66893 : "-------\n"
66894 : "int\n"
66895 : " :py:const:`CE_Failure` if an error occurs, otherwise\n"
66896 : " :py:const:`CE_None`.\n"
66897 : "\n"
66898 : "Examples\n"
66899 : "--------\n"
66900 : ">>> import numpy as np\n"
66901 : ">>> ds = gdal.GetDriverByName('GTiff').Create('test.tif', 12, 12)\n"
66902 : ">>> ds.GetRasterBand(1).WriteArray(np.arange(12*12).reshape((12, 12)))\n"
66903 : "0\n"
66904 : ">>> ds.BuildOverviews('AVERAGE', [2, 4])\n"
66905 : "0\n"
66906 : ">>> ds.GetRasterBand(1).GetOverviewCount()\n"
66907 : "2\n"
66908 : ">>> ds.BuildOverviews(overviewlist=[])\n"
66909 : "0\n"
66910 : ">>> ds.GetRasterBand(1).GetOverviewCount()\n"
66911 : "0\n"
66912 : "\n"
66913 : ""},
66914 : { "Dataset_GetGCPCount", _wrap_Dataset_GetGCPCount, METH_O, "\n"
66915 : "Dataset_GetGCPCount(Dataset self) -> int\n"
66916 : "\n"
66917 : "\n"
66918 : "Get number of GCPs. See :cpp:func:`GDALGetGCPCount`.\n"
66919 : "\n"
66920 : "Returns\n"
66921 : "-------\n"
66922 : "int\n"
66923 : "\n"
66924 : "\n"
66925 : ""},
66926 : { "Dataset_GetGCPProjection", _wrap_Dataset_GetGCPProjection, METH_O, "\n"
66927 : "Dataset_GetGCPProjection(Dataset self) -> char const *\n"
66928 : "\n"
66929 : "\n"
66930 : "Return a WKT representation of the GCP spatial reference.\n"
66931 : "\n"
66932 : "Returns\n"
66933 : "-------\n"
66934 : "str\n"
66935 : "\n"
66936 : "\n"
66937 : ""},
66938 : { "Dataset_GetGCPSpatialRef", _wrap_Dataset_GetGCPSpatialRef, METH_O, "\n"
66939 : "Dataset_GetGCPSpatialRef(Dataset self) -> SpatialReference\n"
66940 : "\n"
66941 : "\n"
66942 : "Get output spatial reference system for GCPs.\n"
66943 : "\n"
66944 : "See :cpp:func:`GDALGetGCPSpatialRef`\n"
66945 : "\n"
66946 : "\n"
66947 : ""},
66948 : { "Dataset_GetGCPs", _wrap_Dataset_GetGCPs, METH_O, "\n"
66949 : "Dataset_GetGCPs(Dataset self)\n"
66950 : "\n"
66951 : "\n"
66952 : "Get the GCPs. See :cpp:func:`GDALGetGCPs`.\n"
66953 : "\n"
66954 : "Returns\n"
66955 : "-------\n"
66956 : "tuple\n"
66957 : " a tuple of :py:class:`GCP` objects.\n"
66958 : "\n"
66959 : "\n"
66960 : ""},
66961 : { "Dataset__SetGCPs", _wrap_Dataset__SetGCPs, METH_VARARGS, "\n"
66962 : "Dataset__SetGCPs(Dataset self, int nGCPs, char const * pszGCPProjection) -> CPLErr\n"
66963 : "\n"
66964 : "\n"
66965 : ""},
66966 : { "Dataset__SetGCPs2", _wrap_Dataset__SetGCPs2, METH_VARARGS, "Dataset__SetGCPs2(Dataset self, int nGCPs, SpatialReference hSRS) -> CPLErr"},
66967 : { "Dataset_FlushCache", _wrap_Dataset_FlushCache, METH_O, "\n"
66968 : "Dataset_FlushCache(Dataset self) -> CPLErr\n"
66969 : "\n"
66970 : "\n"
66971 : "Flush all write-cached data to disk.\n"
66972 : "\n"
66973 : "See :cpp:func:`GDALDataset::FlushCache`.\n"
66974 : "\n"
66975 : "Returns\n"
66976 : "-------\n"
66977 : "int\n"
66978 : " `gdal.CE_None` in case of success\n"
66979 : "\n"
66980 : ""},
66981 : { "Dataset_AddBand", (PyCFunction)(void(*)(void))_wrap_Dataset_AddBand, METH_VARARGS|METH_KEYWORDS, "\n"
66982 : "Dataset_AddBand(Dataset self, GDALDataType datatype=GDT_Byte, char ** options=None) -> CPLErr\n"
66983 : "\n"
66984 : "\n"
66985 : "Adds a band to a :py:class:`Dataset`.\n"
66986 : "\n"
66987 : "Not supported by all drivers.\n"
66988 : "\n"
66989 : "Parameters\n"
66990 : "----------\n"
66991 : "datatype : int\n"
66992 : " the data type of the pixels in the new band\n"
66993 : "options : dict or list, optional\n"
66994 : " an optional dict or list of format-specific ``NAME=VALUE`` option strings.\n"
66995 : "\n"
66996 : "Returns\n"
66997 : "-------\n"
66998 : "int\n"
66999 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
67000 : "\n"
67001 : "Examples\n"
67002 : "--------\n"
67003 : ">>> ds=gdal.GetDriverByName('MEM').Create('', 10, 10)\n"
67004 : ">>> ds.RasterCount\n"
67005 : "1\n"
67006 : ">>> ds.AddBand(gdal.GDT_Float32)\n"
67007 : "0\n"
67008 : ">>> ds.RasterCount\n"
67009 : "2\n"
67010 : "\n"
67011 : ""},
67012 : { "Dataset_CreateMaskBand", _wrap_Dataset_CreateMaskBand, METH_VARARGS, "\n"
67013 : "Dataset_CreateMaskBand(Dataset self, int nFlags) -> CPLErr\n"
67014 : "\n"
67015 : "\n"
67016 : "Adds a mask band to the dataset.\n"
67017 : "\n"
67018 : "See :cpp:func:`GDALDataset::CreateMaskBand`.\n"
67019 : "\n"
67020 : "Parameters\n"
67021 : "----------\n"
67022 : "flags : int\n"
67023 : "\n"
67024 : "Returns\n"
67025 : "-------\n"
67026 : "int\n"
67027 : " :py:const:`CE_Failure` if an error occurs, otherwise :py:const:`CE_None`.\n"
67028 : "\n"
67029 : "\n"
67030 : ""},
67031 : { "Dataset_GetFileList", _wrap_Dataset_GetFileList, METH_O, "\n"
67032 : "Dataset_GetFileList(Dataset self) -> char **\n"
67033 : "\n"
67034 : "\n"
67035 : "Returns a list of files believed to be part of this dataset.\n"
67036 : "See :cpp:func:`GDALGetFileList`.\n"
67037 : "\n"
67038 : "\n"
67039 : ""},
67040 : { "Dataset_WriteRaster", (PyCFunction)(void(*)(void))_wrap_Dataset_WriteRaster, METH_VARARGS|METH_KEYWORDS, "Dataset_WriteRaster(Dataset self, int xoff, int yoff, int xsize, int ysize, GIntBig buf_len, int * buf_xsize=None, int * buf_ysize=None, GDALDataType * buf_type=None, int band_list=0, GIntBig * buf_pixel_space=None, GIntBig * buf_line_space=None, GIntBig * buf_band_space=None) -> CPLErr"},
67041 : { "Dataset_AdviseRead", _wrap_Dataset_AdviseRead, METH_VARARGS, "\n"
67042 : "Dataset_AdviseRead(Dataset self, int xoff, int yoff, int xsize, int ysize, int * buf_xsize=None, int * buf_ysize=None, GDALDataType * buf_type=None, int band_list=0, char ** options=None) -> CPLErr\n"
67043 : "\n"
67044 : "\n"
67045 : "Advise driver of upcoming read requests.\n"
67046 : "\n"
67047 : "See :cpp:func:`GDALDataset::AdviseRead`.\n"
67048 : "\n"
67049 : "\n"
67050 : ""},
67051 : { "Dataset_BeginAsyncReader", (PyCFunction)(void(*)(void))_wrap_Dataset_BeginAsyncReader, METH_VARARGS|METH_KEYWORDS, "Dataset_BeginAsyncReader(Dataset self, int xOff, int yOff, int xSize, int ySize, size_t buf_len, int buf_xsize, int buf_ysize, GDALDataType bufType=(GDALDataType) 0, int band_list=0, int nPixelSpace=0, int nLineSpace=0, int nBandSpace=0, char ** options=None) -> AsyncReader"},
67052 : { "Dataset_EndAsyncReader", _wrap_Dataset_EndAsyncReader, METH_VARARGS, "Dataset_EndAsyncReader(Dataset self, AsyncReader ario)"},
67053 : { "Dataset_GetVirtualMem", (PyCFunction)(void(*)(void))_wrap_Dataset_GetVirtualMem, METH_VARARGS|METH_KEYWORDS, "Dataset_GetVirtualMem(Dataset self, GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, int nBufXSize, int nBufYSize, GDALDataType eBufType, int band_list, int bIsBandSequential, size_t nCacheSize, size_t nPageSizeHint, char ** options=None) -> VirtualMem"},
67054 : { "Dataset_GetTiledVirtualMem", (PyCFunction)(void(*)(void))_wrap_Dataset_GetTiledVirtualMem, METH_VARARGS|METH_KEYWORDS, "Dataset_GetTiledVirtualMem(Dataset self, GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, int nTileXSize, int nTileYSize, GDALDataType eBufType, int band_list, GDALTileOrganization eTileOrganization, size_t nCacheSize, char ** options=None) -> VirtualMem"},
67055 : { "Dataset_CreateLayer", (PyCFunction)(void(*)(void))_wrap_Dataset_CreateLayer, METH_VARARGS|METH_KEYWORDS, "\n"
67056 : "Dataset_CreateLayer(Dataset self, char const * name, SpatialReference srs=None, OGRwkbGeometryType geom_type=wkbUnknown, char ** options=None) -> Layer\n"
67057 : "\n"
67058 : "\n"
67059 : "Create a new layer in a vector Dataset.\n"
67060 : "\n"
67061 : "Parameters\n"
67062 : "----------\n"
67063 : "name : str\n"
67064 : " the name for the new layer. This should ideally not\n"
67065 : " match any existing layer on the datasource.\n"
67066 : "srs : SpatialReference, optional\n"
67067 : " The coordinate system to use for the new layer,\n"
67068 : " or ``None`` if no coordinate system is available. Defaults to ``None``.\n"
67069 : "geom_type : int, default = :py:const:`ogr.wkbUnknown`\n"
67070 : " geometry type for the layer. Use :py:const:`ogr.wkbUnknown` if there\n"
67071 : " are no constraints on the types geometry to be written.\n"
67072 : "options : dict or list, optional\n"
67073 : " Driver-specific dict or list of name=value options\n"
67074 : "\n"
67075 : "Returns\n"
67076 : "-------\n"
67077 : "Layer or None\n"
67078 : " The layer object if successful, or ``None`` on failure.\n"
67079 : "\n"
67080 : "\n"
67081 : "Examples\n"
67082 : "--------\n"
67083 : ">>> ds = gdal.GetDriverByName('GPKG').Create('test.gpkg', 0, 0)\n"
67084 : ">>> ds.GetLayerCount()\n"
67085 : "0\n"
67086 : ">>> lyr = ds.CreateLayer('poly', geom_type=ogr.wkbPolygon)\n"
67087 : ">>> ds.GetLayerCount()\n"
67088 : "1\n"
67089 : "\n"
67090 : "\n"
67091 : ""},
67092 : { "Dataset_CreateLayerFromGeomFieldDefn", _wrap_Dataset_CreateLayerFromGeomFieldDefn, METH_VARARGS, "Dataset_CreateLayerFromGeomFieldDefn(Dataset self, char const * name, GeomFieldDefn geom_field, char ** options=None) -> Layer"},
67093 : { "Dataset_CopyLayer", (PyCFunction)(void(*)(void))_wrap_Dataset_CopyLayer, METH_VARARGS|METH_KEYWORDS, "\n"
67094 : "Dataset_CopyLayer(Dataset self, Layer src_layer, char const * new_name, char ** options=None) -> Layer\n"
67095 : "\n"
67096 : "\n"
67097 : "Duplicate an existing :py:class:`ogr.Layer`.\n"
67098 : "\n"
67099 : "See :cpp:func:`GDALDataset::CopyLayer`.\n"
67100 : "\n"
67101 : "Parameters\n"
67102 : "----------\n"
67103 : "src_layer : Layer\n"
67104 : " source layer\n"
67105 : "new_name : str\n"
67106 : " name of the layer to create\n"
67107 : "options : dict or list\n"
67108 : " a dict or list of name=value driver-specific creation options\n"
67109 : "\n"
67110 : "Returns\n"
67111 : "-------\n"
67112 : "Layer or None\n"
67113 : " A layer if successful, or ``None`` if an error occurs.\n"
67114 : "\n"
67115 : ""},
67116 : { "Dataset_DeleteLayer", _wrap_Dataset_DeleteLayer, METH_VARARGS, "Dataset_DeleteLayer(Dataset self, int index) -> OGRErr"},
67117 : { "Dataset_IsLayerPrivate", _wrap_Dataset_IsLayerPrivate, METH_VARARGS, "\n"
67118 : "Dataset_IsLayerPrivate(Dataset self, int index) -> bool\n"
67119 : "\n"
67120 : "\n"
67121 : "Parameters\n"
67122 : "----------\n"
67123 : "index : int\n"
67124 : " Index o layer to check\n"
67125 : "\n"
67126 : "Returns\n"
67127 : "-------\n"
67128 : "bool\n"
67129 : " ``True`` if the layer is a private or system table, ``False`` otherwise\n"
67130 : "\n"
67131 : "\n"
67132 : "\n"
67133 : ""},
67134 : { "Dataset_GetNextFeature", (PyCFunction)(void(*)(void))_wrap_Dataset_GetNextFeature, METH_VARARGS|METH_KEYWORDS, "\n"
67135 : "Dataset_GetNextFeature(Dataset self, bool include_layer=True, bool include_pct=False, GDALProgressFunc callback=0, void * callback_data=None) -> Feature\n"
67136 : "\n"
67137 : "\n"
67138 : "Fetch the next available feature from this dataset.\n"
67139 : "\n"
67140 : "This method is intended for the few drivers where\n"
67141 : ":py:meth:`OGRLayer.GetNextFeature` is not efficient, but in general\n"
67142 : ":py:meth:`OGRLayer.GetNextFeature` is a more natural API.\n"
67143 : "\n"
67144 : "See :cpp:func:`GDALDataset::GetNextFeature`.\n"
67145 : "\n"
67146 : "Returns\n"
67147 : "-------\n"
67148 : "Feature\n"
67149 : "\n"
67150 : "\n"
67151 : ""},
67152 : { "Dataset_TestCapability", _wrap_Dataset_TestCapability, METH_VARARGS, "\n"
67153 : "Dataset_TestCapability(Dataset self, char const * cap) -> bool\n"
67154 : "\n"
67155 : "\n"
67156 : "Test if a capability is available.\n"
67157 : "\n"
67158 : "Parameters\n"
67159 : "----------\n"
67160 : "cap : str\n"
67161 : " Name of the capability (e.g., :py:const:`ogr.ODsCTransactions`)\n"
67162 : "\n"
67163 : "Returns\n"
67164 : "-------\n"
67165 : "bool\n"
67166 : " ``True`` if the capability is available, ``False`` if invalid or unavailable\n"
67167 : "\n"
67168 : "Examples\n"
67169 : "--------\n"
67170 : ">>> ds = gdal.GetDriverByName('ESRI Shapefile').Create('test.shp', 0, 0, 0, gdal.GDT_Unknown)\n"
67171 : ">>> ds.TestCapability(ogr.ODsCTransactions)\n"
67172 : "False\n"
67173 : ">>> ds.TestCapability(ogr.ODsCMeasuredGeometries)\n"
67174 : "True\n"
67175 : ">>> ds.TestCapability(gdal.GDsCAddRelationship)\n"
67176 : "False\n"
67177 : "\n"
67178 : "\n"
67179 : ""},
67180 : { "Dataset_ExecuteSQL", (PyCFunction)(void(*)(void))_wrap_Dataset_ExecuteSQL, METH_VARARGS|METH_KEYWORDS, "Dataset_ExecuteSQL(Dataset self, char const * statement, Geometry spatialFilter=None, char const * dialect=\"\") -> Layer"},
67181 : { "Dataset_ReleaseResultSet", _wrap_Dataset_ReleaseResultSet, METH_VARARGS, "Dataset_ReleaseResultSet(Dataset self, Layer layer)"},
67182 : { "Dataset_GetStyleTable", _wrap_Dataset_GetStyleTable, METH_O, "\n"
67183 : "Dataset_GetStyleTable(Dataset self) -> StyleTable\n"
67184 : "\n"
67185 : "\n"
67186 : "Returns dataset style table.\n"
67187 : "\n"
67188 : "Returns\n"
67189 : "-------\n"
67190 : "StyleTable\n"
67191 : "\n"
67192 : "\n"
67193 : ""},
67194 : { "Dataset_SetStyleTable", _wrap_Dataset_SetStyleTable, METH_VARARGS, "\n"
67195 : "Dataset_SetStyleTable(Dataset self, StyleTable table)\n"
67196 : "\n"
67197 : "\n"
67198 : "Set dataset style table\n"
67199 : "\n"
67200 : "Parameters\n"
67201 : "----------\n"
67202 : "table : StyleTable\n"
67203 : "\n"
67204 : ""},
67205 : { "Dataset_GetLayerByIndex", _wrap_Dataset_GetLayerByIndex, METH_VARARGS, "\n"
67206 : "Dataset_GetLayerByIndex(Dataset self, int index=0) -> Layer\n"
67207 : "\n"
67208 : "\n"
67209 : "Fetch a layer by index.\n"
67210 : "\n"
67211 : "Parameters\n"
67212 : "----------\n"
67213 : "index : int\n"
67214 : " A layer number between 0 and ``GetLayerCount() - 1``\n"
67215 : "\n"
67216 : "Returns\n"
67217 : "-------\n"
67218 : "Layer or None\n"
67219 : " An layer if successful, or ``None`` on error.\n"
67220 : "\n"
67221 : ""},
67222 : { "Dataset_GetLayerByName", _wrap_Dataset_GetLayerByName, METH_VARARGS, "Dataset_GetLayerByName(Dataset self, char const * layer_name) -> Layer"},
67223 : { "Dataset_ResetReading", _wrap_Dataset_ResetReading, METH_O, "\n"
67224 : "Dataset_ResetReading(Dataset self)\n"
67225 : "\n"
67226 : "\n"
67227 : "Reset feature reading to start on the first feature.\n"
67228 : "\n"
67229 : "This affects :py:meth:`GetNextFeature`.\n"
67230 : "\n"
67231 : "Depending on drivers, this may also have the side effect of calling\n"
67232 : ":py:meth:`OGRLayer.ResetReading` on the layers of this dataset.\n"
67233 : "\n"
67234 : "\n"
67235 : ""},
67236 : { "Dataset_GetLayerCount", _wrap_Dataset_GetLayerCount, METH_O, "\n"
67237 : "Dataset_GetLayerCount(Dataset self) -> int\n"
67238 : "\n"
67239 : "\n"
67240 : "Get the number of layers in this dataset.\n"
67241 : "\n"
67242 : "Returns\n"
67243 : "-------\n"
67244 : "int\n"
67245 : "\n"
67246 : "\n"
67247 : ""},
67248 : { "Dataset_AbortSQL", _wrap_Dataset_AbortSQL, METH_O, "\n"
67249 : "Dataset_AbortSQL(Dataset self) -> OGRErr\n"
67250 : "\n"
67251 : "\n"
67252 : "Abort any SQL statement running in the data store.\n"
67253 : "\n"
67254 : "Not implemented by all drivers. See :cpp:func:`GDALDataset::AbortSQL`.\n"
67255 : "\n"
67256 : "Returns\n"
67257 : "-------\n"
67258 : "int\n"
67259 : " :py:const:`ogr.OGRERR_NONE` on success, or\n"
67260 : " :py:const:`ogr.OGRERR_UNSUPPORTED_OPERATION` if AbortSQL is not supported\n"
67261 : " for this dataset.\n"
67262 : "\n"
67263 : ""},
67264 : { "Dataset_StartTransaction", (PyCFunction)(void(*)(void))_wrap_Dataset_StartTransaction, METH_VARARGS|METH_KEYWORDS, "\n"
67265 : "Dataset_StartTransaction(Dataset self, int force=FALSE) -> OGRErr\n"
67266 : "\n"
67267 : "\n"
67268 : "Creates a transaction. See :cpp:func:`GDALDataset::StartTransaction`.\n"
67269 : "\n"
67270 : "Returns\n"
67271 : "-------\n"
67272 : "int\n"
67273 : " If starting the transaction fails, will return\n"
67274 : " :py:const:`ogr.OGRERR_FAILURE`. Datasources which do not support transactions will\n"
67275 : " always return :py:const:`OGRERR_UNSUPPORTED_OPERATION`.\n"
67276 : "\n"
67277 : "\n"
67278 : ""},
67279 : { "Dataset_CommitTransaction", _wrap_Dataset_CommitTransaction, METH_O, "\n"
67280 : "Dataset_CommitTransaction(Dataset self) -> OGRErr\n"
67281 : "\n"
67282 : "Commits a transaction, for `Datasets` that support transactions.\n"
67283 : "\n"
67284 : "See :cpp:func:`GDALDataset::CommitTransaction`.\n"
67285 : "\n"
67286 : ""},
67287 : { "Dataset_RollbackTransaction", _wrap_Dataset_RollbackTransaction, METH_O, "\n"
67288 : "Dataset_RollbackTransaction(Dataset self) -> OGRErr\n"
67289 : "\n"
67290 : "\n"
67291 : "Roll back a Dataset to its state before the start of the current transaction.\n"
67292 : "\n"
67293 : "For datasets that support transactions.\n"
67294 : "\n"
67295 : "Returns\n"
67296 : "-------\n"
67297 : "int\n"
67298 : " If no transaction is active, or the rollback fails, will return\n"
67299 : " :py:const:`OGRERR_FAILURE`. Datasources which do not support transactions will\n"
67300 : " always return :py:const:`OGRERR_UNSUPPORTED_OPERATION`.\n"
67301 : "\n"
67302 : "\n"
67303 : ""},
67304 : { "Dataset_ClearStatistics", _wrap_Dataset_ClearStatistics, METH_O, "\n"
67305 : "Dataset_ClearStatistics(Dataset self)\n"
67306 : "\n"
67307 : "\n"
67308 : "Clear statistics\n"
67309 : "\n"
67310 : "See :cpp:func:`GDALDataset::ClearStatistics`.\n"
67311 : "\n"
67312 : "\n"
67313 : ""},
67314 : { "Dataset_GetFieldDomainNames", _wrap_Dataset_GetFieldDomainNames, METH_VARARGS, "\n"
67315 : "Dataset_GetFieldDomainNames(Dataset self, char ** options=None) -> char **\n"
67316 : "\n"
67317 : "\n"
67318 : "Get a list of the names of all field domains stored in the dataset.\n"
67319 : "\n"
67320 : "Parameters\n"
67321 : "----------\n"
67322 : "options : dict or list, optional\n"
67323 : " Driver-specific options determining how attributes should\n"
67324 : " be retrieved.\n"
67325 : "\n"
67326 : "Returns\n"
67327 : "-------\n"
67328 : "list or None\n"
67329 : " ``None`` if no field domains are stored in the dataset.\n"
67330 : "\n"
67331 : ""},
67332 : { "Dataset_GetFieldDomain", _wrap_Dataset_GetFieldDomain, METH_VARARGS, "\n"
67333 : "Dataset_GetFieldDomain(Dataset self, char const * name) -> FieldDomain\n"
67334 : "\n"
67335 : "\n"
67336 : "Get a field domain from its name.\n"
67337 : "\n"
67338 : "Parameters\n"
67339 : "----------\n"
67340 : "name : str\n"
67341 : " The name of the field domain\n"
67342 : "\n"
67343 : "Returns\n"
67344 : "-------\n"
67345 : "FieldDomain or None\n"
67346 : " An FieldDomain instance if found, or ``None`` if it is not found.\n"
67347 : "\n"
67348 : ""},
67349 : { "Dataset_AddFieldDomain", _wrap_Dataset_AddFieldDomain, METH_VARARGS, "\n"
67350 : "Dataset_AddFieldDomain(Dataset self, FieldDomain fieldDomain) -> bool\n"
67351 : "\n"
67352 : "\n"
67353 : "Add a :py:class:`ogr.FieldDomain` to the dataset.\n"
67354 : "\n"
67355 : "Only a few drivers support this operation. See :cpp:func:`GDALDataset::AddFieldDomain`.\n"
67356 : "\n"
67357 : "Parameters\n"
67358 : "----------\n"
67359 : "fieldDomain : FieldDomain\n"
67360 : " The field domain to add\n"
67361 : "\n"
67362 : "Returns\n"
67363 : "-------\n"
67364 : "bool\n"
67365 : " ``True`` if the field domain was added, ``False`` in case of error.\n"
67366 : "\n"
67367 : "\n"
67368 : "\n"
67369 : ""},
67370 : { "Dataset_DeleteFieldDomain", _wrap_Dataset_DeleteFieldDomain, METH_VARARGS, "\n"
67371 : "Dataset_DeleteFieldDomain(Dataset self, char const * name) -> bool\n"
67372 : "\n"
67373 : "\n"
67374 : "Removes a field domain from the Dataset.\n"
67375 : "\n"
67376 : "Parameters\n"
67377 : "----------\n"
67378 : "name : str\n"
67379 : " Name of the field domain to delete\n"
67380 : "\n"
67381 : "Returns\n"
67382 : "-------\n"
67383 : "bool\n"
67384 : " ``True`` if the field domain was removed, otherwise ``False``.\n"
67385 : "\n"
67386 : "\n"
67387 : ""},
67388 : { "Dataset_UpdateFieldDomain", _wrap_Dataset_UpdateFieldDomain, METH_VARARGS, "\n"
67389 : "Dataset_UpdateFieldDomain(Dataset self, FieldDomain fieldDomain) -> bool\n"
67390 : "\n"
67391 : "\n"
67392 : "Update an existing field domain by replacing its definition.\n"
67393 : "\n"
67394 : "The existing field domain with matching name will be replaced.\n"
67395 : "\n"
67396 : "Requires the :py:const:`ogr.ODsCUpdateFieldDomain` datasset capability.\n"
67397 : "\n"
67398 : "Parameters\n"
67399 : "----------\n"
67400 : "fieldDomain : FieldDomain\n"
67401 : " Updated field domain.\n"
67402 : "\n"
67403 : "Returns\n"
67404 : "-------\n"
67405 : "bool\n"
67406 : " ``True`` in case of success\n"
67407 : "\n"
67408 : "\n"
67409 : ""},
67410 : { "Dataset_GetRelationshipNames", _wrap_Dataset_GetRelationshipNames, METH_VARARGS, "\n"
67411 : "Dataset_GetRelationshipNames(Dataset self, char ** options=None) -> char **\n"
67412 : "\n"
67413 : "\n"
67414 : "Get a list of the names of all relationships stored in the dataset.\n"
67415 : "\n"
67416 : "Parameters\n"
67417 : "----------\n"
67418 : "options : dict or list, optional\n"
67419 : " driver-specific options determining how the relationships should be retrieved\n"
67420 : "\n"
67421 : "\n"
67422 : ""},
67423 : { "Dataset_GetRelationship", _wrap_Dataset_GetRelationship, METH_VARARGS, "\n"
67424 : "Dataset_GetRelationship(Dataset self, char const * name) -> Relationship\n"
67425 : "\n"
67426 : "\n"
67427 : "Get a relationship from its name.\n"
67428 : "\n"
67429 : "Returns\n"
67430 : "-------\n"
67431 : "Relationship, or ``None`` if not found.\n"
67432 : "\n"
67433 : ""},
67434 : { "Dataset_AddRelationship", _wrap_Dataset_AddRelationship, METH_VARARGS, "\n"
67435 : "Dataset_AddRelationship(Dataset self, Relationship relationship) -> bool\n"
67436 : "\n"
67437 : "\n"
67438 : "Add a :py:class:`Relationship` to the dataset.\n"
67439 : "\n"
67440 : "See :cpp:func:`GDALDataset::AddRelationship`.\n"
67441 : "\n"
67442 : "Parameters\n"
67443 : "----------\n"
67444 : "relationship : Relationship\n"
67445 : " The relationship to add\n"
67446 : "\n"
67447 : "Returns\n"
67448 : "-------\n"
67449 : "bool\n"
67450 : " ``True`` if the field domain was added, ``False`` in case of error.\n"
67451 : "\n"
67452 : "\n"
67453 : ""},
67454 : { "Dataset_DeleteRelationship", _wrap_Dataset_DeleteRelationship, METH_VARARGS, "\n"
67455 : "Dataset_DeleteRelationship(Dataset self, char const * name) -> bool\n"
67456 : "\n"
67457 : "\n"
67458 : "Removes a relationship from the Dataset.\n"
67459 : "\n"
67460 : "Parameters\n"
67461 : "----------\n"
67462 : "name : str\n"
67463 : " Name of the relationship to remove.\n"
67464 : "\n"
67465 : "Returns\n"
67466 : "-------\n"
67467 : "bool\n"
67468 : " ``True`` if the relationship was removed, otherwise ``False``.\n"
67469 : "\n"
67470 : "\n"
67471 : "\n"
67472 : ""},
67473 : { "Dataset_UpdateRelationship", _wrap_Dataset_UpdateRelationship, METH_VARARGS, "\n"
67474 : "Dataset_UpdateRelationship(Dataset self, Relationship relationship) -> bool\n"
67475 : "\n"
67476 : "\n"
67477 : "Update an existing relationship by replacing its definition.\n"
67478 : "\n"
67479 : "The existing relationship with matching name will be replaced.\n"
67480 : "\n"
67481 : "Requires the :py:const:`gdal.GDsCUpdateFieldDomain` dataset capability.\n"
67482 : "\n"
67483 : "Parameters\n"
67484 : "----------\n"
67485 : "relationship : Relationship\n"
67486 : " Updated relationship\n"
67487 : "\n"
67488 : "Returns\n"
67489 : "-------\n"
67490 : "bool\n"
67491 : " ``True`` in case of success\n"
67492 : "\n"
67493 : "\n"
67494 : ""},
67495 : { "Dataset_AsMDArray", _wrap_Dataset_AsMDArray, METH_VARARGS, "Dataset_AsMDArray(Dataset self, char ** options=None) -> MDArray"},
67496 : { "Dataset_ReadRaster1", (PyCFunction)(void(*)(void))_wrap_Dataset_ReadRaster1, METH_VARARGS|METH_KEYWORDS, "Dataset_ReadRaster1(Dataset self, double xoff, double yoff, double xsize, double ysize, int * buf_xsize=None, int * buf_ysize=None, GDALDataType * buf_type=None, int band_list=0, GIntBig * buf_pixel_space=None, GIntBig * buf_line_space=None, GIntBig * buf_band_space=None, GDALRIOResampleAlg resample_alg=GRIORA_NearestNeighbour, GDALProgressFunc callback=0, void * callback_data=None, void * inputOutputBuf=None) -> CPLErr"},
67497 : { "Dataset_swigregister", Dataset_swigregister, METH_O, NULL},
67498 : { "RATDateTime_nYear_set", _wrap_RATDateTime_nYear_set, METH_VARARGS, "RATDateTime_nYear_set(RATDateTime self, int nYear)"},
67499 : { "RATDateTime_nYear_get", _wrap_RATDateTime_nYear_get, METH_O, "RATDateTime_nYear_get(RATDateTime self) -> int"},
67500 : { "RATDateTime_nMonth_set", _wrap_RATDateTime_nMonth_set, METH_VARARGS, "RATDateTime_nMonth_set(RATDateTime self, int nMonth)"},
67501 : { "RATDateTime_nMonth_get", _wrap_RATDateTime_nMonth_get, METH_O, "RATDateTime_nMonth_get(RATDateTime self) -> int"},
67502 : { "RATDateTime_nDay_set", _wrap_RATDateTime_nDay_set, METH_VARARGS, "RATDateTime_nDay_set(RATDateTime self, int nDay)"},
67503 : { "RATDateTime_nDay_get", _wrap_RATDateTime_nDay_get, METH_O, "RATDateTime_nDay_get(RATDateTime self) -> int"},
67504 : { "RATDateTime_nHour_set", _wrap_RATDateTime_nHour_set, METH_VARARGS, "RATDateTime_nHour_set(RATDateTime self, int nHour)"},
67505 : { "RATDateTime_nHour_get", _wrap_RATDateTime_nHour_get, METH_O, "RATDateTime_nHour_get(RATDateTime self) -> int"},
67506 : { "RATDateTime_nMinute_set", _wrap_RATDateTime_nMinute_set, METH_VARARGS, "RATDateTime_nMinute_set(RATDateTime self, int nMinute)"},
67507 : { "RATDateTime_nMinute_get", _wrap_RATDateTime_nMinute_get, METH_O, "RATDateTime_nMinute_get(RATDateTime self) -> int"},
67508 : { "RATDateTime_fSecond_set", _wrap_RATDateTime_fSecond_set, METH_VARARGS, "RATDateTime_fSecond_set(RATDateTime self, float fSecond)"},
67509 : { "RATDateTime_fSecond_get", _wrap_RATDateTime_fSecond_get, METH_O, "RATDateTime_fSecond_get(RATDateTime self) -> float"},
67510 : { "RATDateTime_nTimeZoneHour_set", _wrap_RATDateTime_nTimeZoneHour_set, METH_VARARGS, "RATDateTime_nTimeZoneHour_set(RATDateTime self, int nTimeZoneHour)"},
67511 : { "RATDateTime_nTimeZoneHour_get", _wrap_RATDateTime_nTimeZoneHour_get, METH_O, "RATDateTime_nTimeZoneHour_get(RATDateTime self) -> int"},
67512 : { "RATDateTime_nTimeZoneMinute_set", _wrap_RATDateTime_nTimeZoneMinute_set, METH_VARARGS, "RATDateTime_nTimeZoneMinute_set(RATDateTime self, int nTimeZoneMinute)"},
67513 : { "RATDateTime_nTimeZoneMinute_get", _wrap_RATDateTime_nTimeZoneMinute_get, METH_O, "RATDateTime_nTimeZoneMinute_get(RATDateTime self) -> int"},
67514 : { "RATDateTime_bPositiveTimeZone_set", _wrap_RATDateTime_bPositiveTimeZone_set, METH_VARARGS, "RATDateTime_bPositiveTimeZone_set(RATDateTime self, bool bPositiveTimeZone)"},
67515 : { "RATDateTime_bPositiveTimeZone_get", _wrap_RATDateTime_bPositiveTimeZone_get, METH_O, "RATDateTime_bPositiveTimeZone_get(RATDateTime self) -> bool"},
67516 : { "RATDateTime_bIsValid_set", _wrap_RATDateTime_bIsValid_set, METH_VARARGS, "RATDateTime_bIsValid_set(RATDateTime self, bool bIsValid)"},
67517 : { "RATDateTime_bIsValid_get", _wrap_RATDateTime_bIsValid_get, METH_O, "RATDateTime_bIsValid_get(RATDateTime self) -> bool"},
67518 : { "new_RATDateTime", _wrap_new_RATDateTime, METH_NOARGS, "new_RATDateTime() -> RATDateTime"},
67519 : { "delete_RATDateTime", _wrap_delete_RATDateTime, METH_O, "delete_RATDateTime(RATDateTime self)"},
67520 : { "RATDateTime_swigregister", RATDateTime_swigregister, METH_O, NULL},
67521 : { "RATDateTime_swiginit", RATDateTime_swiginit, METH_VARARGS, NULL},
67522 : { "new_RasterAttributeTable", _wrap_new_RasterAttributeTable, METH_NOARGS, "new_RasterAttributeTable() -> RasterAttributeTable"},
67523 : { "delete_RasterAttributeTable", _wrap_delete_RasterAttributeTable, METH_O, "delete_RasterAttributeTable(RasterAttributeTable self)"},
67524 : { "RasterAttributeTable_Clone", _wrap_RasterAttributeTable_Clone, METH_O, "\n"
67525 : "RasterAttributeTable_Clone(RasterAttributeTable self) -> RasterAttributeTable\n"
67526 : "\n"
67527 : "\n"
67528 : "Create a copy of the RAT.\n"
67529 : "\n"
67530 : "Returns\n"
67531 : "-------\n"
67532 : "RasterAttributeTable\n"
67533 : " A Python proxy of a :cpp:class:`GDALRasterAttributeTable`\n"
67534 : "\n"
67535 : "\n"
67536 : ""},
67537 : { "RasterAttributeTable_GetColumnCount", _wrap_RasterAttributeTable_GetColumnCount, METH_O, "\n"
67538 : "RasterAttributeTable_GetColumnCount(RasterAttributeTable self) -> int\n"
67539 : "\n"
67540 : "\n"
67541 : "Return the number of columns in the RAT. \n"
67542 : "\n"
67543 : "See :cpp:func:`GDALRasterAttributeTable::GetColumnCount`.\n"
67544 : "\n"
67545 : "Returns\n"
67546 : "-------\n"
67547 : "int\n"
67548 : " The number of columns in the RAT\n"
67549 : "\n"
67550 : "Examples\n"
67551 : "--------\n"
67552 : ">>> with gdal.Open('testrat.tif') as ds:\n"
67553 : "... ds.GetRasterBand(1).GetDefaultRAT().GetColumnCount()\n"
67554 : "... \n"
67555 : "9\n"
67556 : "\n"
67557 : "\n"
67558 : ""},
67559 : { "RasterAttributeTable_GetNameOfCol", _wrap_RasterAttributeTable_GetNameOfCol, METH_VARARGS, "\n"
67560 : "RasterAttributeTable_GetNameOfCol(RasterAttributeTable self, int iCol) -> char const *\n"
67561 : "\n"
67562 : "\n"
67563 : "Get the name of a specified column (0-indexed).\n"
67564 : "\n"
67565 : "See :cpp:func:`GDALRasterAttributeTable::GetNameOfCol`.\n"
67566 : "\n"
67567 : "Parameters\n"
67568 : "----------\n"
67569 : "iCol : int\n"
67570 : " The index of the column (starting at 0)\n"
67571 : "\n"
67572 : "Returns\n"
67573 : "-------\n"
67574 : "str\n"
67575 : " The name of the column\n"
67576 : "\n"
67577 : "Examples\n"
67578 : "--------\n"
67579 : ">>> ds = gdal.Open('testrat.tif')\n"
67580 : ">>> rat = ds.GetRasterBand(1).GetDefaultRAT()\n"
67581 : ">>> [rat.GetNameOfCol(i) for i in range(rat.GetColumnCount())]\n"
67582 : "['VALUE', 'COUNT', 'CLASS', 'Red', 'Green', 'Blue', 'OtherInt', 'OtherReal', 'OtherStr']\n"
67583 : "\n"
67584 : "\n"
67585 : ""},
67586 : { "RasterAttributeTable_GetUsageOfCol", _wrap_RasterAttributeTable_GetUsageOfCol, METH_VARARGS, "\n"
67587 : "RasterAttributeTable_GetUsageOfCol(RasterAttributeTable self, int iCol) -> GDALRATFieldUsage\n"
67588 : "\n"
67589 : "\n"
67590 : "Return the usage of a column in the RAT.\n"
67591 : "\n"
67592 : "See :cpp:func:`GDALRasterAttributeTable::GetUsageOfCol`.\n"
67593 : "\n"
67594 : "Parameters\n"
67595 : "----------\n"
67596 : "iCol : int\n"
67597 : " The index of the column (starting at 0)\n"
67598 : "\n"
67599 : "Returns\n"
67600 : "-------\n"
67601 : "int\n"
67602 : " Usage code for the specified column\n"
67603 : "\n"
67604 : "Examples\n"
67605 : "--------\n"
67606 : ">>> ds = gdal.Open('testrat.tif')\n"
67607 : ">>> rat = ds.GetRasterBand(1).GetDefaultRAT()\n"
67608 : ">>> [rat.GetUsageOfCol(i) for i in range(rat.GetColumnCount())]\n"
67609 : "[5, 1, 2, 6, 7, 8, 0, 0, 0]\n"
67610 : ">>> [rat.GetUsageOfCol(i) == gdal.GFU_Red for i in range(rat.GetColumnCount())]\n"
67611 : "[False, False, False, True, False, False, False, False, False]\n"
67612 : "\n"
67613 : "\n"
67614 : ""},
67615 : { "RasterAttributeTable_GetTypeOfCol", _wrap_RasterAttributeTable_GetTypeOfCol, METH_VARARGS, "\n"
67616 : "RasterAttributeTable_GetTypeOfCol(RasterAttributeTable self, int iCol) -> GDALRATFieldType\n"
67617 : "\n"
67618 : "\n"
67619 : "Return the data type of a column in the RAT (one of :py:const:`GFT_Integer`, :py:const:`GFT_Real`, or :py:const:`GFT_String`).\n"
67620 : "\n"
67621 : "See :cpp:func:`GDALRasterAttributeTable::GetTypeOfCol`.\n"
67622 : "\n"
67623 : "Parameters\n"
67624 : "----------\n"
67625 : "iCol : int\n"
67626 : " The index of the column (starting at 0)\n"
67627 : "\n"
67628 : "Returns\n"
67629 : "-------\n"
67630 : "int\n"
67631 : " type code for the specified column\n"
67632 : "\n"
67633 : "Examples\n"
67634 : "--------\n"
67635 : ">>> ds = gdal.Open('testrat.tif')\n"
67636 : ">>> rat = ds.GetRasterBand(1).GetDefaultRAT()\n"
67637 : ">>> rat.GetTypeOfCol(2) == gdal.GFT_String\n"
67638 : "True\n"
67639 : "\n"
67640 : "\n"
67641 : ""},
67642 : { "RasterAttributeTable_GetColOfUsage", _wrap_RasterAttributeTable_GetColOfUsage, METH_VARARGS, "\n"
67643 : "RasterAttributeTable_GetColOfUsage(RasterAttributeTable self, GDALRATFieldUsage eUsage) -> int\n"
67644 : "\n"
67645 : "\n"
67646 : "Return the first column of a specified usage the a RAT.\n"
67647 : "\n"
67648 : "See :cpp:func:`GDALRasterAttributeTable::GetColOfUsage`.\n"
67649 : "\n"
67650 : "Parameters\n"
67651 : "----------\n"
67652 : "eUsage : int\n"
67653 : " Usage code such as :py:const:`gdal.GFU_Red`.\n"
67654 : "\n"
67655 : "Returns\n"
67656 : "-------\n"
67657 : "int\n"
67658 : " Index of the column, or -1 if no such column can be found.\n"
67659 : "\n"
67660 : "Examples\n"
67661 : "--------\n"
67662 : ">>> ds = gdal.Open('testrat.tif')\n"
67663 : ">>> rat = ds.GetRasterBand(1).GetDefaultRAT()\n"
67664 : ">>> rat.GetColOfUsage(gdal.GFU_Name)\n"
67665 : "2\n"
67666 : ">>> rat.GetColOfUsage(gdal.GFU_RedMin)\n"
67667 : "-1\n"
67668 : "\n"
67669 : "\n"
67670 : ""},
67671 : { "RasterAttributeTable_GetRowCount", _wrap_RasterAttributeTable_GetRowCount, METH_O, "\n"
67672 : "RasterAttributeTable_GetRowCount(RasterAttributeTable self) -> int\n"
67673 : "\n"
67674 : "\n"
67675 : "Return the number of rows in the RAT. \n"
67676 : "\n"
67677 : "See :cpp:func:`GDALRasterAttributeTable::GetRowCount`.\n"
67678 : "\n"
67679 : "Returns\n"
67680 : "-------\n"
67681 : "int\n"
67682 : " The number of rows in the RAT\n"
67683 : "\n"
67684 : "Examples\n"
67685 : "--------\n"
67686 : ">>> with gdal.Open('testrat.tif') as ds:\n"
67687 : "... ds.GetRasterBand(1).GetDefaultRAT().GetRowCount()\n"
67688 : "... \n"
67689 : "2\n"
67690 : "\n"
67691 : "\n"
67692 : ""},
67693 : { "RasterAttributeTable_GetValueAsString", _wrap_RasterAttributeTable_GetValueAsString, METH_VARARGS, "\n"
67694 : "RasterAttributeTable_GetValueAsString(RasterAttributeTable self, int iRow, int iCol) -> char const *\n"
67695 : "\n"
67696 : "\n"
67697 : "Get the value of a single cell in the RAT.\n"
67698 : "\n"
67699 : "Parameters\n"
67700 : "----------\n"
67701 : "iRow : int\n"
67702 : " Row index (0-based)\n"
67703 : "iCol : int\n"
67704 : " Column index (0-based)\n"
67705 : "\n"
67706 : ""},
67707 : { "RasterAttributeTable_GetValueAsInt", _wrap_RasterAttributeTable_GetValueAsInt, METH_VARARGS, "\n"
67708 : "RasterAttributeTable_GetValueAsInt(RasterAttributeTable self, int iRow, int iCol) -> int\n"
67709 : "\n"
67710 : "\n"
67711 : "Get the value of a single cell in the RAT.\n"
67712 : "\n"
67713 : "Parameters\n"
67714 : "----------\n"
67715 : "iRow : int\n"
67716 : " Row index (0-based)\n"
67717 : "iCol : int\n"
67718 : " Column index (0-based)\n"
67719 : "\n"
67720 : ""},
67721 : { "RasterAttributeTable_GetValueAsDouble", _wrap_RasterAttributeTable_GetValueAsDouble, METH_VARARGS, "\n"
67722 : "RasterAttributeTable_GetValueAsDouble(RasterAttributeTable self, int iRow, int iCol) -> double\n"
67723 : "\n"
67724 : "\n"
67725 : "Get the value of a single cell in the RAT.\n"
67726 : "\n"
67727 : "Parameters\n"
67728 : "----------\n"
67729 : "iRow : int\n"
67730 : " Row index (0-based)\n"
67731 : "iCol : int\n"
67732 : " Column index (0-based)\n"
67733 : "\n"
67734 : ""},
67735 : { "RasterAttributeTable_GetValueAsBoolean", _wrap_RasterAttributeTable_GetValueAsBoolean, METH_VARARGS, "RasterAttributeTable_GetValueAsBoolean(RasterAttributeTable self, int iRow, int iCol) -> bool"},
67736 : { "RasterAttributeTable_GetValueAsDateTime", _wrap_RasterAttributeTable_GetValueAsDateTime, METH_VARARGS, "RasterAttributeTable_GetValueAsDateTime(RasterAttributeTable self, int iRow, int iCol) -> RATDateTime"},
67737 : { "RasterAttributeTable_GetValueAsWKBGeometry", _wrap_RasterAttributeTable_GetValueAsWKBGeometry, METH_VARARGS, "RasterAttributeTable_GetValueAsWKBGeometry(RasterAttributeTable self, int iRow, int iCol) -> CPLErr"},
67738 : { "RasterAttributeTable_SetValueAsWKBGeometry", _wrap_RasterAttributeTable_SetValueAsWKBGeometry, METH_VARARGS, "RasterAttributeTable_SetValueAsWKBGeometry(RasterAttributeTable self, int iRow, int iCol, int nLen) -> CPLErr"},
67739 : { "RasterAttributeTable_ReadValuesIOAsString", _wrap_RasterAttributeTable_ReadValuesIOAsString, METH_VARARGS, "\n"
67740 : "RasterAttributeTable_ReadValuesIOAsString(RasterAttributeTable self, int iField, int iStartRow, int iLength) -> CPLErr\n"
67741 : "\n"
67742 : "\n"
67743 : "Read a single column of a RAT into a list of strings.\n"
67744 : "\n"
67745 : "Parameters\n"
67746 : "----------\n"
67747 : "iField : int\n"
67748 : " The index of the column (starting at 0)\n"
67749 : "iStartRow : int, default = 0\n"
67750 : " The index of the first row to read (starting at 0)\n"
67751 : "iLength : int, default = None\n"
67752 : " The number of rows to read \n"
67753 : "\n"
67754 : "Returns\n"
67755 : "-------\n"
67756 : "list\n"
67757 : "\n"
67758 : "Examples\n"
67759 : "--------\n"
67760 : ">>> ds = gdal.Open('testrat.tif')\n"
67761 : ">>> rat = ds.GetRasterBand(1).GetDefaultRAT()\n"
67762 : ">>> rat.ReadValuesIOAsString(2, 0, 2)\n"
67763 : "['my class', 'my class2']\n"
67764 : "\n"
67765 : "See Also\n"
67766 : "--------\n"
67767 : ":py:meth:`ReadAsArray`\n"
67768 : "\n"
67769 : "\n"
67770 : ""},
67771 : { "RasterAttributeTable_ReadValuesIOAsInteger", _wrap_RasterAttributeTable_ReadValuesIOAsInteger, METH_VARARGS, "\n"
67772 : "RasterAttributeTable_ReadValuesIOAsInteger(RasterAttributeTable self, int iField, int iStartRow, int iLength) -> CPLErr\n"
67773 : "\n"
67774 : "\n"
67775 : "Read a single column of a RAT into a list of ints.\n"
67776 : "\n"
67777 : "Parameters\n"
67778 : "----------\n"
67779 : "iField : int\n"
67780 : " The index of the column (starting at 0)\n"
67781 : "iStartRow : int, default = 0\n"
67782 : " The index of the first row to read (starting at 0)\n"
67783 : "iLength : int, default = None\n"
67784 : " The number of rows to read \n"
67785 : "\n"
67786 : "Returns\n"
67787 : "-------\n"
67788 : "list\n"
67789 : "\n"
67790 : "Examples\n"
67791 : "--------\n"
67792 : ">>> ds = gdal.Open('testrat.tif')\n"
67793 : ">>> rat = ds.GetRasterBand(1).GetDefaultRAT()\n"
67794 : ">>> rat.ReadValuesIOAsInteger(3, 0, 2)\n"
67795 : "[26, 26]\n"
67796 : "\n"
67797 : "See Also\n"
67798 : "--------\n"
67799 : ":py:meth:`ReadAsArray`\n"
67800 : "\n"
67801 : "\n"
67802 : ""},
67803 : { "RasterAttributeTable_ReadValuesIOAsDouble", _wrap_RasterAttributeTable_ReadValuesIOAsDouble, METH_VARARGS, "\n"
67804 : "RasterAttributeTable_ReadValuesIOAsDouble(RasterAttributeTable self, int iField, int iStartRow, int iLength) -> CPLErr\n"
67805 : "\n"
67806 : "\n"
67807 : "Read a single column of a RAT into a list of floats.\n"
67808 : "\n"
67809 : "Parameters\n"
67810 : "----------\n"
67811 : "iField : int\n"
67812 : " The index of the column (starting at 0)\n"
67813 : "iStartRow : int, default = 0\n"
67814 : " The index of the first row to read (starting at 0)\n"
67815 : "iLength : int, default = None\n"
67816 : " The number of rows to read \n"
67817 : "\n"
67818 : "Returns\n"
67819 : "-------\n"
67820 : "list\n"
67821 : "\n"
67822 : "Examples\n"
67823 : "--------\n"
67824 : ">>> ds = gdal.Open('testrat.tif')\n"
67825 : ">>> rat = ds.GetRasterBand(1).GetDefaultRAT()\n"
67826 : ">>> rat.ReadValuesIOAsDouble(3, 0, 2)\n"
67827 : "[26.0, 26.0]\n"
67828 : "\n"
67829 : "See Also\n"
67830 : "--------\n"
67831 : ":py:meth:`ReadAsArray`\n"
67832 : "\n"
67833 : "\n"
67834 : ""},
67835 : { "RasterAttributeTable_ReadValuesIOAsBoolean", _wrap_RasterAttributeTable_ReadValuesIOAsBoolean, METH_VARARGS, "RasterAttributeTable_ReadValuesIOAsBoolean(RasterAttributeTable self, int iField, int iStartRow, int iLength) -> CPLErr"},
67836 : { "RasterAttributeTable_SetValueAsString", _wrap_RasterAttributeTable_SetValueAsString, METH_VARARGS, "\n"
67837 : "RasterAttributeTable_SetValueAsString(RasterAttributeTable self, int iRow, int iCol, char const * pszValue)\n"
67838 : "\n"
67839 : "\n"
67840 : "Set the value of a single cell in the RAT.\n"
67841 : "\n"
67842 : "If ``iRow`` is equal to the number of rows in the table, the table\n"
67843 : "size will be increased by one. However, it is more efficient to\n"
67844 : "call :py:meth:`SetRowCount` before repeated insertions.\n"
67845 : "\n"
67846 : "Parameters\n"
67847 : "----------\n"
67848 : "iRow : int\n"
67849 : " Row index (0-based)\n"
67850 : "iCol : int\n"
67851 : " Column index (0-based)\n"
67852 : "pszValue : str\n"
67853 : " Cell value\n"
67854 : "\n"
67855 : ""},
67856 : { "RasterAttributeTable_SetValueAsInt", _wrap_RasterAttributeTable_SetValueAsInt, METH_VARARGS, "\n"
67857 : "RasterAttributeTable_SetValueAsInt(RasterAttributeTable self, int iRow, int iCol, int nValue)\n"
67858 : "\n"
67859 : "\n"
67860 : "Set the value of a single cell in the RAT.\n"
67861 : "\n"
67862 : "If ``iRow`` is equal to the number of rows in the table, the table\n"
67863 : "size will be increased by one. However, it is more efficient to\n"
67864 : "call :py:meth:`SetRowCount` before repeated insertions.\n"
67865 : "\n"
67866 : "Parameters\n"
67867 : "----------\n"
67868 : "iRow : int\n"
67869 : " Row index (0-based)\n"
67870 : "iCol : int\n"
67871 : " Column index (0-based)\n"
67872 : "nValue : int\n"
67873 : " Cell value\n"
67874 : "\n"
67875 : ""},
67876 : { "RasterAttributeTable_SetValueAsDouble", _wrap_RasterAttributeTable_SetValueAsDouble, METH_VARARGS, "\n"
67877 : "RasterAttributeTable_SetValueAsDouble(RasterAttributeTable self, int iRow, int iCol, double dfValue)\n"
67878 : "\n"
67879 : "\n"
67880 : "Set the value of a single cell in the RAT.\n"
67881 : "\n"
67882 : "If ``iRow`` is equal to the number of rows in the table, the table\n"
67883 : "size will be increased by one. However, it is more efficient to\n"
67884 : "call :py:meth:`SetRowCount` before repeated insertions.\n"
67885 : "\n"
67886 : "Parameters\n"
67887 : "----------\n"
67888 : "iRow : int\n"
67889 : " Row index (0-based)\n"
67890 : "iCol : int\n"
67891 : " Column index (0-based)\n"
67892 : "dfValue : float\n"
67893 : " Cell value\n"
67894 : "\n"
67895 : ""},
67896 : { "RasterAttributeTable_SetValueAsBoolean", _wrap_RasterAttributeTable_SetValueAsBoolean, METH_VARARGS, "RasterAttributeTable_SetValueAsBoolean(RasterAttributeTable self, int iRow, int iCol, bool value)"},
67897 : { "RasterAttributeTable_SetValueAsDateTime", _wrap_RasterAttributeTable_SetValueAsDateTime, METH_VARARGS, "RasterAttributeTable_SetValueAsDateTime(RasterAttributeTable self, int iRow, int iCol, RATDateTime value)"},
67898 : { "RasterAttributeTable_SetRowCount", _wrap_RasterAttributeTable_SetRowCount, METH_VARARGS, "\n"
67899 : "RasterAttributeTable_SetRowCount(RasterAttributeTable self, int nCount)\n"
67900 : "\n"
67901 : "\n"
67902 : "Resizes the table to include the indicated number of rows. Newly created\n"
67903 : "rows will be initialized to '' for strings and zero for numeric fields.\n"
67904 : "\n"
67905 : "See :cpp:func:`GDALRasterAttributeTable::SetRowCount`.\n"
67906 : "\n"
67907 : "Parameters\n"
67908 : "----------\n"
67909 : "nCount : int\n"
67910 : " The number of rows in the resized table\n"
67911 : "\n"
67912 : "\n"
67913 : ""},
67914 : { "RasterAttributeTable_CreateColumn", _wrap_RasterAttributeTable_CreateColumn, METH_VARARGS, "\n"
67915 : "RasterAttributeTable_CreateColumn(RasterAttributeTable self, char const * pszName, GDALRATFieldType eType, GDALRATFieldUsage eUsage) -> int\n"
67916 : "\n"
67917 : "\n"
67918 : "Create a new column in the RAT.\n"
67919 : "\n"
67920 : "If the table already has rows, all row values for the new column will\n"
67921 : "be initialized to the default value ('', or zero). The new column is\n"
67922 : "always created as the last column.\n"
67923 : "\n"
67924 : "Parameters\n"
67925 : "----------\n"
67926 : "pszName : str\n"
67927 : " Name of the new column\n"
67928 : "eType : int\n"
67929 : " Data type of the new column (one of :py:const:`GFT_Integer`, :py:const:`GFT_Real`, or :py:const:`GFT_String`).\n"
67930 : "eUsage : int\n"
67931 : " Usage of the new column (see :cpp:enum:`GDALRATFieldUsage`)\n"
67932 : "\n"
67933 : "Returns\n"
67934 : "-------\n"
67935 : "int\n"
67936 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
67937 : "\n"
67938 : "\n"
67939 : ""},
67940 : { "RasterAttributeTable_GetLinearBinning", _wrap_RasterAttributeTable_GetLinearBinning, METH_O, "\n"
67941 : "RasterAttributeTable_GetLinearBinning(RasterAttributeTable self) -> bool\n"
67942 : "\n"
67943 : "\n"
67944 : "Get linear binning information, if any.\n"
67945 : "\n"
67946 : "See :cpp:func:`GDALRasterAttributeTable::GetLinearBinning`.\n"
67947 : "\n"
67948 : "Returns\n"
67949 : "-------\n"
67950 : "list\n"
67951 : " a three-element list indicating whether linear binning information\n"
67952 : " is available, the minimum value associated with the smallest bin,\n"
67953 : " and the size of each bin.\n"
67954 : "\n"
67955 : "\n"
67956 : ""},
67957 : { "RasterAttributeTable_SetLinearBinning", _wrap_RasterAttributeTable_SetLinearBinning, METH_VARARGS, "\n"
67958 : "RasterAttributeTable_SetLinearBinning(RasterAttributeTable self, double dfRow0Min, double dfBinSize) -> int\n"
67959 : "\n"
67960 : "\n"
67961 : "Set linear binning information.\n"
67962 : "\n"
67963 : "This can be used to provide optimized table look-ups (via\n"
67964 : ":py:meth:`GetRowOfValue`) when the rows of the table represent\n"
67965 : "uniformly sized bins. \n"
67966 : "\n"
67967 : "It is the responsibility of the user to actually define the \n"
67968 : "appropriate bins. If the bins do not correspond to the provided\n"
67969 : "binning information, lookup values will be incorrect.\n"
67970 : "\n"
67971 : "See :cpp:func:`GDALRasterAttributeTable::SetLinearBinning`.\n"
67972 : "\n"
67973 : "Parameters\n"
67974 : "----------\n"
67975 : "dfRow0Min : float\n"
67976 : " Minimum value associated with the smallest bin \n"
67977 : "dfBinSize : float\n"
67978 : " Size of each bin\n"
67979 : "\n"
67980 : ""},
67981 : { "RasterAttributeTable_GetRowOfValue", _wrap_RasterAttributeTable_GetRowOfValue, METH_VARARGS, "\n"
67982 : "RasterAttributeTable_GetRowOfValue(RasterAttributeTable self, double dfValue) -> int\n"
67983 : "\n"
67984 : "\n"
67985 : "Return the index of the row that applies to a specific value,\n"
67986 : "or -1 of no such row exists.\n"
67987 : "\n"
67988 : "See :cpp:func:`GDALRasterAttributeTable::GetRowOfValue`.\n"
67989 : "\n"
67990 : "Parameters\n"
67991 : "----------\n"
67992 : "dfValue : float\n"
67993 : " Value for which a row should be found\n"
67994 : "\n"
67995 : "Returns\n"
67996 : "-------\n"
67997 : "int\n"
67998 : " Index of the row (0-based), or -1 of no row was found\n"
67999 : "\n"
68000 : "Examples\n"
68001 : "--------\n"
68002 : ">>> ds = gdal.Open('testrat.tif')\n"
68003 : ">>> rat = ds.GetRasterBand(1).GetDefaultRAT()\n"
68004 : ">>> rat.GetValueAsString(rat.GetRowOfValue(2), 2)\n"
68005 : "'my class2'\n"
68006 : ">>> rat.GetValueAsString(rat.GetRowOfValue(802), 2)\n"
68007 : "''\n"
68008 : "\n"
68009 : "See Also\n"
68010 : "--------\n"
68011 : ":py:meth:`SetLinearBinning`\n"
68012 : "\n"
68013 : "\n"
68014 : ""},
68015 : { "RasterAttributeTable_ChangesAreWrittenToFile", _wrap_RasterAttributeTable_ChangesAreWrittenToFile, METH_O, "RasterAttributeTable_ChangesAreWrittenToFile(RasterAttributeTable self) -> int"},
68016 : { "RasterAttributeTable_DumpReadable", _wrap_RasterAttributeTable_DumpReadable, METH_O, "\n"
68017 : "RasterAttributeTable_DumpReadable(RasterAttributeTable self)\n"
68018 : "\n"
68019 : "\n"
68020 : "Return an XML representation of the RAT.\n"
68021 : "\n"
68022 : "Returns\n"
68023 : "-------\n"
68024 : "str\n"
68025 : "\n"
68026 : "\n"
68027 : ""},
68028 : { "RasterAttributeTable_SetTableType", _wrap_RasterAttributeTable_SetTableType, METH_VARARGS, "\n"
68029 : "RasterAttributeTable_SetTableType(RasterAttributeTable self, GDALRATTableType eTableType)\n"
68030 : "\n"
68031 : "\n"
68032 : "Set the type of the RAT (thematic or athematic).\n"
68033 : "\n"
68034 : "Parameters\n"
68035 : "----------\n"
68036 : "eTableType : int\n"
68037 : " Table type (:py:const:`GRTT_THEMATIC` or :py:const:`GRTT_ATHEMATIC`) \n"
68038 : "\n"
68039 : ""},
68040 : { "RasterAttributeTable_GetTableType", _wrap_RasterAttributeTable_GetTableType, METH_O, "\n"
68041 : "RasterAttributeTable_GetTableType(RasterAttributeTable self) -> GDALRATTableType\n"
68042 : "\n"
68043 : "\n"
68044 : "Returns the type of the RAT (:py:const:`GRTT_THEMATIC` or :py:const:`GRTT_ATHEMATIC`).\n"
68045 : "\n"
68046 : "See :cpp:func:`GDALRasterAttributeTable::GetTableType`.\n"
68047 : "\n"
68048 : "Returns\n"
68049 : "-------\n"
68050 : "int\n"
68051 : " table type code\n"
68052 : "\n"
68053 : "\n"
68054 : ""},
68055 : { "RasterAttributeTable_RemoveStatistics", _wrap_RasterAttributeTable_RemoveStatistics, METH_O, "\n"
68056 : "RasterAttributeTable_RemoveStatistics(RasterAttributeTable self)\n"
68057 : "\n"
68058 : "\n"
68059 : "Remove statistics information, such as a histogram, from the RAT.\n"
68060 : "\n"
68061 : "See :cpp:func:`GDALRasterAttributeTable::RemoveStatistics`.\n"
68062 : "\n"
68063 : "\n"
68064 : ""},
68065 : { "RasterAttributeTable_swigregister", RasterAttributeTable_swigregister, METH_O, NULL},
68066 : { "RasterAttributeTable_swiginit", RasterAttributeTable_swiginit, METH_VARARGS, NULL},
68067 : { "delete_Group", _wrap_delete_Group, METH_O, "delete_Group(Group self)"},
68068 : { "Group_GetName", _wrap_Group_GetName, METH_O, "Group_GetName(Group self) -> char const *"},
68069 : { "Group_GetFullName", _wrap_Group_GetFullName, METH_O, "Group_GetFullName(Group self) -> char const *"},
68070 : { "Group_GetMDArrayNames", _wrap_Group_GetMDArrayNames, METH_VARARGS, "Group_GetMDArrayNames(Group self, char ** options=None) -> char **"},
68071 : { "Group_GetMDArrayFullNamesRecursive", _wrap_Group_GetMDArrayFullNamesRecursive, METH_VARARGS, "Group_GetMDArrayFullNamesRecursive(Group self, char ** groupOptions=None, char ** arrayOptions=None) -> char **"},
68072 : { "Group_OpenMDArray", _wrap_Group_OpenMDArray, METH_VARARGS, "Group_OpenMDArray(Group self, char const * name, char ** options=None) -> MDArray"},
68073 : { "Group_OpenMDArrayFromFullname", _wrap_Group_OpenMDArrayFromFullname, METH_VARARGS, "Group_OpenMDArrayFromFullname(Group self, char const * name, char ** options=None) -> MDArray"},
68074 : { "Group_ResolveMDArray", _wrap_Group_ResolveMDArray, METH_VARARGS, "Group_ResolveMDArray(Group self, char const * name, char const * starting_point, char ** options=None) -> MDArray"},
68075 : { "Group_GetGroupNames", _wrap_Group_GetGroupNames, METH_VARARGS, "Group_GetGroupNames(Group self, char ** options=None) -> char **"},
68076 : { "Group_OpenGroup", _wrap_Group_OpenGroup, METH_VARARGS, "Group_OpenGroup(Group self, char const * name, char ** options=None) -> Group"},
68077 : { "Group_OpenGroupFromFullname", _wrap_Group_OpenGroupFromFullname, METH_VARARGS, "Group_OpenGroupFromFullname(Group self, char const * name, char ** options=None) -> Group"},
68078 : { "Group_GetVectorLayerNames", _wrap_Group_GetVectorLayerNames, METH_VARARGS, "Group_GetVectorLayerNames(Group self, char ** options=None) -> char **"},
68079 : { "Group_OpenVectorLayer", _wrap_Group_OpenVectorLayer, METH_VARARGS, "Group_OpenVectorLayer(Group self, char const * name, char ** options=None) -> Layer"},
68080 : { "Group_GetDimensions", _wrap_Group_GetDimensions, METH_VARARGS, "Group_GetDimensions(Group self, char ** options=None)"},
68081 : { "Group_GetAttribute", _wrap_Group_GetAttribute, METH_VARARGS, "Group_GetAttribute(Group self, char const * name) -> Attribute"},
68082 : { "Group_GetAttributes", _wrap_Group_GetAttributes, METH_VARARGS, "Group_GetAttributes(Group self, char ** options=None)"},
68083 : { "Group_GetStructuralInfo", _wrap_Group_GetStructuralInfo, METH_O, "Group_GetStructuralInfo(Group self) -> char **"},
68084 : { "Group_CreateGroup", (PyCFunction)(void(*)(void))_wrap_Group_CreateGroup, METH_VARARGS|METH_KEYWORDS, "Group_CreateGroup(Group self, char const * name, char ** options=None) -> Group"},
68085 : { "Group_DeleteGroup", _wrap_Group_DeleteGroup, METH_VARARGS, "Group_DeleteGroup(Group self, char const * name, char ** options=None) -> CPLErr"},
68086 : { "Group_CreateDimension", (PyCFunction)(void(*)(void))_wrap_Group_CreateDimension, METH_VARARGS|METH_KEYWORDS, "\n"
68087 : "Group_CreateDimension(Group self, char const * name, char const * dim_type, char const * direction, GUIntBig size, char ** options=None) -> Dimension\n"
68088 : "\n"
68089 : "\n"
68090 : "Create a dimension within a :py:class:`Group`.\n"
68091 : "\n"
68092 : "See :cpp:func:`GDALGroup::CreateDimension`.\n"
68093 : "\n"
68094 : "Parameters\n"
68095 : "----------\n"
68096 : "name : str\n"
68097 : " Dimension name\n"
68098 : "dim_type : str\n"
68099 : " Dimension type (might be empty, and ignored by drivers)\n"
68100 : "direction : str\n"
68101 : " Dimension direction (might be empty, and ignored by drivers)\n"
68102 : "size : int\n"
68103 : " Number of values indexed by this dimension. Should be > 0\n"
68104 : "options : dict or list, optional\n"
68105 : " dict or list of driver specific ``NAME=VALUE`` option strings.\n"
68106 : "\n"
68107 : "Returns\n"
68108 : "-------\n"
68109 : "\n"
68110 : "Dimension\n"
68111 : " the new :py:class:`Dimension` or ``None`` on failure.\n"
68112 : "\n"
68113 : "Examples\n"
68114 : "--------\n"
68115 : "\n"
68116 : ">>> drv = gdal.GetDriverByName('MEM')\n"
68117 : ">>> mem_ds = drv.CreateMultiDimensional('myds')\n"
68118 : ">>> rg = mem_ds.GetRootGroup()\n"
68119 : ">>> dim_band = rg.CreateDimension('band', None, None, 3)\n"
68120 : ">>> dim_x = rg.CreateDimension('X', None, None, 2)\n"
68121 : ">>> dim_x.GetFullName()\n"
68122 : "'/X'\n"
68123 : ">>> lat = rg.CreateDimension('latitude', gdal.DIM_TYPE_HORIZONTAL_X, None, 2)\n"
68124 : ">>> lat.GetType()\n"
68125 : "'HORIZONTAL_X'\n"
68126 : "\n"
68127 : ""},
68128 : { "Group_CreateMDArray", _wrap_Group_CreateMDArray, METH_VARARGS, "\n"
68129 : "Group_CreateMDArray(Group self, char const * name, int dimensions, ExtendedDataType data_type, char ** options=None) -> MDArray\n"
68130 : "\n"
68131 : "\n"
68132 : "Create a multidimensional array within a group.\n"
68133 : "\n"
68134 : "It is recommended that the GDALDimension objects passed in ``dimensions``\n"
68135 : "belong to this group, either by retrieving them with :py:meth:`GetDimensions`\n"
68136 : "or creating a new one with :py:meth:`CreateDimension`.\n"
68137 : "\n"
68138 : "See :cpp:func:`GDALGroup::CreateMDArray`.\n"
68139 : "\n"
68140 : "Parameters\n"
68141 : "----------\n"
68142 : "name : str\n"
68143 : " name\n"
68144 : "dimensions : list\n"
68145 : " List of dimensions, ordered from the slowest varying\n"
68146 : " dimension first to the fastest varying dimension last.\n"
68147 : " Might be empty for a scalar array (if supported by driver)\n"
68148 : "data_type : :py:class:`ExtendedDataType`\n"
68149 : " Array data type\n"
68150 : "options : dict or list, optional\n"
68151 : " dict or list of driver specific ``NAME=VALUE`` option strings.\n"
68152 : "\n"
68153 : "Returns\n"
68154 : "-------\n"
68155 : "\n"
68156 : "MDArray\n"
68157 : " the new :py:class:`MDArray` or ``None`` on failure.\n"
68158 : "\n"
68159 : "Examples\n"
68160 : "--------\n"
68161 : ">>> drv = gdal.GetDriverByName('MEM')\n"
68162 : ">>> mem_ds = drv.CreateMultiDimensional('myds')\n"
68163 : ">>> rg = mem_ds.GetRootGroup()\n"
68164 : ">>> dimX = rg.CreateDimension('X', None, None, 3)\n"
68165 : ">>> ar = rg.CreateMDArray('ar', [dimX], gdal.ExtendedDataType.Create(gdal.GDT_Byte))\n"
68166 : "\n"
68167 : "\n"
68168 : ""},
68169 : { "Group_DeleteMDArray", _wrap_Group_DeleteMDArray, METH_VARARGS, "Group_DeleteMDArray(Group self, char const * name, char ** options=None) -> CPLErr"},
68170 : { "Group_CreateAttribute", _wrap_Group_CreateAttribute, METH_VARARGS, "\n"
68171 : "Group_CreateAttribute(Group self, char const * name, int dimensions, ExtendedDataType data_type, char ** options=None) -> Attribute\n"
68172 : "\n"
68173 : "\n"
68174 : "Create an attribute within a :py:class:`MDArray` or :py:class:`Group`.\n"
68175 : "\n"
68176 : "See :cpp:func:`GDALIHasAttribute::CreateAttribute`.\n"
68177 : "\n"
68178 : "Parameters\n"
68179 : "----------\n"
68180 : "name : str\n"
68181 : " name\n"
68182 : "dimensions : list\n"
68183 : " List of dimensions, ordered from the slowest varying\n"
68184 : " dimension first to the fastest varying dimension last.\n"
68185 : " Might be empty for a scalar array (if supported by driver)\n"
68186 : "data_type : :py:class:`ExtendedDataType`\n"
68187 : " Attribute data type\n"
68188 : "options : dict or list, optional\n"
68189 : " dict or list of driver specific ``NAME=VALUE`` option strings.\n"
68190 : "\n"
68191 : "Returns\n"
68192 : "-------\n"
68193 : "\n"
68194 : "Attribute\n"
68195 : " the new :py:class:`Attribute` or ``None`` on failure.\n"
68196 : "\n"
68197 : "Examples\n"
68198 : "--------\n"
68199 : "\n"
68200 : ">>> drv = gdal.GetDriverByName('MEM')\n"
68201 : ">>> mem_ds = drv.CreateMultiDimensional('myds')\n"
68202 : ">>> rg = mem_ds.GetRootGroup()\n"
68203 : ">>> dim = rg.CreateDimension('dim', None, None, 2)\n"
68204 : ">>> ar = rg.CreateMDArray('ar_double', [dim], gdal.ExtendedDataType.Create(gdal.GDT_Float64))\n"
68205 : ">>> numeric_attr = ar.CreateAttribute('numeric_attr', [], gdal.ExtendedDataType.Create(gdal.GDT_Float64))\n"
68206 : ">>> string_attr = ar.CreateAttribute('string_attr', [], gdal.ExtendedDataType.CreateString())\n"
68207 : "\n"
68208 : "\n"
68209 : ""},
68210 : { "Group_DeleteAttribute", _wrap_Group_DeleteAttribute, METH_VARARGS, "Group_DeleteAttribute(Group self, char const * name, char ** options=None) -> CPLErr"},
68211 : { "Group_Rename", _wrap_Group_Rename, METH_VARARGS, "Group_Rename(Group self, char const * newName) -> CPLErr"},
68212 : { "Group_SubsetDimensionFromSelection", _wrap_Group_SubsetDimensionFromSelection, METH_VARARGS, "Group_SubsetDimensionFromSelection(Group self, char const * selection, char ** options=None) -> Group"},
68213 : { "Group_GetDataTypeCount", _wrap_Group_GetDataTypeCount, METH_O, "Group_GetDataTypeCount(Group self) -> size_t"},
68214 : { "Group_GetDataType", _wrap_Group_GetDataType, METH_VARARGS, "Group_GetDataType(Group self, size_t idx) -> ExtendedDataType"},
68215 : { "Group_swigregister", Group_swigregister, METH_O, NULL},
68216 : { "Statistics_min_get", _wrap_Statistics_min_get, METH_O, "Statistics_min_get(Statistics self) -> double"},
68217 : { "Statistics_max_get", _wrap_Statistics_max_get, METH_O, "Statistics_max_get(Statistics self) -> double"},
68218 : { "Statistics_mean_get", _wrap_Statistics_mean_get, METH_O, "Statistics_mean_get(Statistics self) -> double"},
68219 : { "Statistics_std_dev_get", _wrap_Statistics_std_dev_get, METH_O, "Statistics_std_dev_get(Statistics self) -> double"},
68220 : { "Statistics_valid_count_get", _wrap_Statistics_valid_count_get, METH_O, "Statistics_valid_count_get(Statistics self) -> GIntBig"},
68221 : { "delete_Statistics", _wrap_delete_Statistics, METH_O, "delete_Statistics(Statistics self)"},
68222 : { "new_Statistics", _wrap_new_Statistics, METH_NOARGS, "new_Statistics() -> Statistics"},
68223 : { "Statistics_swigregister", Statistics_swigregister, METH_O, NULL},
68224 : { "Statistics_swiginit", Statistics_swiginit, METH_VARARGS, NULL},
68225 : { "delete_RawBlockInfo", _wrap_delete_RawBlockInfo, METH_O, "delete_RawBlockInfo(RawBlockInfo self)"},
68226 : { "RawBlockInfo_GetOffset", _wrap_RawBlockInfo_GetOffset, METH_O, "RawBlockInfo_GetOffset(RawBlockInfo self) -> GUIntBig"},
68227 : { "RawBlockInfo_GetSize", _wrap_RawBlockInfo_GetSize, METH_O, "RawBlockInfo_GetSize(RawBlockInfo self) -> GUIntBig"},
68228 : { "RawBlockInfo_GetFilename", _wrap_RawBlockInfo_GetFilename, METH_O, "RawBlockInfo_GetFilename(RawBlockInfo self) -> char const *"},
68229 : { "RawBlockInfo_GetInfo", _wrap_RawBlockInfo_GetInfo, METH_O, "RawBlockInfo_GetInfo(RawBlockInfo self) -> char **"},
68230 : { "RawBlockInfo_GetInlineData", _wrap_RawBlockInfo_GetInlineData, METH_O, "RawBlockInfo_GetInlineData(RawBlockInfo self)"},
68231 : { "new_RawBlockInfo", _wrap_new_RawBlockInfo, METH_NOARGS, "new_RawBlockInfo() -> RawBlockInfo"},
68232 : { "RawBlockInfo_swigregister", RawBlockInfo_swigregister, METH_O, NULL},
68233 : { "RawBlockInfo_swiginit", RawBlockInfo_swiginit, METH_VARARGS, NULL},
68234 : { "delete_MDArray", _wrap_delete_MDArray, METH_O, "delete_MDArray(MDArray self)"},
68235 : { "MDArray_GetName", _wrap_MDArray_GetName, METH_O, "MDArray_GetName(MDArray self) -> char const *"},
68236 : { "MDArray_GetFullName", _wrap_MDArray_GetFullName, METH_O, "MDArray_GetFullName(MDArray self) -> char const *"},
68237 : { "MDArray_GetTotalElementsCount", _wrap_MDArray_GetTotalElementsCount, METH_O, "MDArray_GetTotalElementsCount(MDArray self) -> GUIntBig"},
68238 : { "MDArray_GetDimensionCount", _wrap_MDArray_GetDimensionCount, METH_O, "MDArray_GetDimensionCount(MDArray self) -> size_t"},
68239 : { "MDArray_GetDimensions", _wrap_MDArray_GetDimensions, METH_O, "MDArray_GetDimensions(MDArray self)"},
68240 : { "MDArray_GetCoordinateVariables", _wrap_MDArray_GetCoordinateVariables, METH_O, "MDArray_GetCoordinateVariables(MDArray self)"},
68241 : { "MDArray_GetBlockSize", _wrap_MDArray_GetBlockSize, METH_O, "MDArray_GetBlockSize(MDArray self)"},
68242 : { "MDArray_GetProcessingChunkSize", _wrap_MDArray_GetProcessingChunkSize, METH_VARARGS, "MDArray_GetProcessingChunkSize(MDArray self, size_t nMaxChunkMemory)"},
68243 : { "MDArray_GetDataType", _wrap_MDArray_GetDataType, METH_O, "MDArray_GetDataType(MDArray self) -> ExtendedDataType"},
68244 : { "MDArray_GetStructuralInfo", _wrap_MDArray_GetStructuralInfo, METH_O, "MDArray_GetStructuralInfo(MDArray self) -> char **"},
68245 : { "MDArray_Resize", _wrap_MDArray_Resize, METH_VARARGS, "MDArray_Resize(MDArray self, int newDimensions, char ** options=None) -> CPLErr"},
68246 : { "MDArray_Read", _wrap_MDArray_Read, METH_VARARGS, "MDArray_Read(MDArray self, int nDims1, int nDims2, int nDims3, int nDims4, ExtendedDataType buffer_datatype) -> CPLErr"},
68247 : { "MDArray_WriteStringArray", _wrap_MDArray_WriteStringArray, METH_VARARGS, "MDArray_WriteStringArray(MDArray self, int nDims1, int nDims2, int nDims3, ExtendedDataType buffer_datatype, char ** options) -> CPLErr"},
68248 : { "MDArray_Write", _wrap_MDArray_Write, METH_VARARGS, "MDArray_Write(MDArray self, int nDims1, int nDims2, int nDims3, int nDims4, ExtendedDataType buffer_datatype, GIntBig buf_len) -> CPLErr"},
68249 : { "MDArray_AdviseRead", _wrap_MDArray_AdviseRead, METH_VARARGS, "MDArray_AdviseRead(MDArray self, int nDims1, int nDims2, char ** options=None) -> CPLErr"},
68250 : { "MDArray_GetAttribute", _wrap_MDArray_GetAttribute, METH_VARARGS, "MDArray_GetAttribute(MDArray self, char const * name) -> Attribute"},
68251 : { "MDArray_GetAttributes", _wrap_MDArray_GetAttributes, METH_VARARGS, "MDArray_GetAttributes(MDArray self, char ** options=None)"},
68252 : { "MDArray_CreateAttribute", _wrap_MDArray_CreateAttribute, METH_VARARGS, "\n"
68253 : "MDArray_CreateAttribute(MDArray self, char const * name, int dimensions, ExtendedDataType data_type, char ** options=None) -> Attribute\n"
68254 : "\n"
68255 : "\n"
68256 : "Create an attribute within a :py:class:`MDArray` or :py:class:`Group`.\n"
68257 : "\n"
68258 : "See :cpp:func:`GDALIHasAttribute::CreateAttribute`.\n"
68259 : "\n"
68260 : "Parameters\n"
68261 : "----------\n"
68262 : "name : str\n"
68263 : " name\n"
68264 : "dimensions : list\n"
68265 : " List of dimensions, ordered from the slowest varying\n"
68266 : " dimension first to the fastest varying dimension last.\n"
68267 : " Might be empty for a scalar array (if supported by driver)\n"
68268 : "data_type : :py:class:`ExtendedDataType`\n"
68269 : " Attribute data type\n"
68270 : "options : dict or list, optional\n"
68271 : " dict or list of driver specific ``NAME=VALUE`` option strings.\n"
68272 : "\n"
68273 : "Returns\n"
68274 : "-------\n"
68275 : "\n"
68276 : "Attribute\n"
68277 : " the new :py:class:`Attribute` or ``None`` on failure.\n"
68278 : "\n"
68279 : "Examples\n"
68280 : "--------\n"
68281 : "\n"
68282 : ">>> drv = gdal.GetDriverByName('MEM')\n"
68283 : ">>> mem_ds = drv.CreateMultiDimensional('myds')\n"
68284 : ">>> rg = mem_ds.GetRootGroup()\n"
68285 : ">>> dim = rg.CreateDimension('dim', None, None, 2)\n"
68286 : ">>> ar = rg.CreateMDArray('ar_double', [dim], gdal.ExtendedDataType.Create(gdal.GDT_Float64))\n"
68287 : ">>> numeric_attr = ar.CreateAttribute('numeric_attr', [], gdal.ExtendedDataType.Create(gdal.GDT_Float64))\n"
68288 : ">>> string_attr = ar.CreateAttribute('string_attr', [], gdal.ExtendedDataType.CreateString())\n"
68289 : "\n"
68290 : "\n"
68291 : ""},
68292 : { "MDArray_DeleteAttribute", _wrap_MDArray_DeleteAttribute, METH_VARARGS, "MDArray_DeleteAttribute(MDArray self, char const * name, char ** options=None) -> CPLErr"},
68293 : { "MDArray_GetNoDataValueAsRaw", _wrap_MDArray_GetNoDataValueAsRaw, METH_O, "MDArray_GetNoDataValueAsRaw(MDArray self) -> CPLErr"},
68294 : { "MDArray_GetNoDataValueAsDouble", _wrap_MDArray_GetNoDataValueAsDouble, METH_O, "MDArray_GetNoDataValueAsDouble(MDArray self)"},
68295 : { "MDArray_GetNoDataValueAsInt64", _wrap_MDArray_GetNoDataValueAsInt64, METH_O, "MDArray_GetNoDataValueAsInt64(MDArray self)"},
68296 : { "MDArray_GetNoDataValueAsUInt64", _wrap_MDArray_GetNoDataValueAsUInt64, METH_O, "MDArray_GetNoDataValueAsUInt64(MDArray self)"},
68297 : { "MDArray_GetNoDataValueAsString", _wrap_MDArray_GetNoDataValueAsString, METH_O, "MDArray_GetNoDataValueAsString(MDArray self) -> retStringAndCPLFree *"},
68298 : { "MDArray_SetNoDataValueDouble", _wrap_MDArray_SetNoDataValueDouble, METH_VARARGS, "MDArray_SetNoDataValueDouble(MDArray self, double d) -> CPLErr"},
68299 : { "MDArray_SetNoDataValueInt64", _wrap_MDArray_SetNoDataValueInt64, METH_VARARGS, "MDArray_SetNoDataValueInt64(MDArray self, GIntBig v) -> CPLErr"},
68300 : { "MDArray_SetNoDataValueUInt64", _wrap_MDArray_SetNoDataValueUInt64, METH_VARARGS, "MDArray_SetNoDataValueUInt64(MDArray self, GUIntBig v) -> CPLErr"},
68301 : { "MDArray_SetNoDataValueString", _wrap_MDArray_SetNoDataValueString, METH_VARARGS, "MDArray_SetNoDataValueString(MDArray self, char const * nodata) -> CPLErr"},
68302 : { "MDArray_SetNoDataValueRaw", _wrap_MDArray_SetNoDataValueRaw, METH_VARARGS, "MDArray_SetNoDataValueRaw(MDArray self, GIntBig nLen) -> CPLErr"},
68303 : { "MDArray_DeleteNoDataValue", _wrap_MDArray_DeleteNoDataValue, METH_O, "MDArray_DeleteNoDataValue(MDArray self) -> CPLErr"},
68304 : { "MDArray_GetOffset", _wrap_MDArray_GetOffset, METH_O, "MDArray_GetOffset(MDArray self)"},
68305 : { "MDArray_GetOffsetStorageType", _wrap_MDArray_GetOffsetStorageType, METH_O, "MDArray_GetOffsetStorageType(MDArray self) -> GDALDataType"},
68306 : { "MDArray_GetScale", _wrap_MDArray_GetScale, METH_O, "MDArray_GetScale(MDArray self)"},
68307 : { "MDArray_GetScaleStorageType", _wrap_MDArray_GetScaleStorageType, METH_O, "MDArray_GetScaleStorageType(MDArray self) -> GDALDataType"},
68308 : { "MDArray_SetOffset", (PyCFunction)(void(*)(void))_wrap_MDArray_SetOffset, METH_VARARGS|METH_KEYWORDS, "MDArray_SetOffset(MDArray self, double val, GDALDataType storageType=GDT_Unknown) -> CPLErr"},
68309 : { "MDArray_SetScale", (PyCFunction)(void(*)(void))_wrap_MDArray_SetScale, METH_VARARGS|METH_KEYWORDS, "MDArray_SetScale(MDArray self, double val, GDALDataType storageType=GDT_Unknown) -> CPLErr"},
68310 : { "MDArray_SetUnit", _wrap_MDArray_SetUnit, METH_VARARGS, "MDArray_SetUnit(MDArray self, char const * unit) -> CPLErr"},
68311 : { "MDArray_GetUnit", _wrap_MDArray_GetUnit, METH_O, "MDArray_GetUnit(MDArray self) -> char const *"},
68312 : { "MDArray_SetSpatialRef", _wrap_MDArray_SetSpatialRef, METH_VARARGS, "MDArray_SetSpatialRef(MDArray self, SpatialReference srs) -> OGRErr"},
68313 : { "MDArray_GetSpatialRef", _wrap_MDArray_GetSpatialRef, METH_O, "MDArray_GetSpatialRef(MDArray self) -> SpatialReference"},
68314 : { "MDArray_GetView", _wrap_MDArray_GetView, METH_VARARGS, "MDArray_GetView(MDArray self, char const * viewExpr) -> MDArray"},
68315 : { "MDArray_Transpose", _wrap_MDArray_Transpose, METH_VARARGS, "MDArray_Transpose(MDArray self, int axisMap) -> MDArray"},
68316 : { "MDArray_GetUnscaled", _wrap_MDArray_GetUnscaled, METH_O, "MDArray_GetUnscaled(MDArray self) -> MDArray"},
68317 : { "MDArray_GetMask", _wrap_MDArray_GetMask, METH_VARARGS, "MDArray_GetMask(MDArray self, char ** options=None) -> MDArray"},
68318 : { "MDArray_GetGridded", (PyCFunction)(void(*)(void))_wrap_MDArray_GetGridded, METH_VARARGS|METH_KEYWORDS, "MDArray_GetGridded(MDArray self, char const * pszGridOptions, MDArray xArray=None, MDArray yArray=None, char ** options=None) -> MDArray"},
68319 : { "MDArray_AsClassicDataset", _wrap_MDArray_AsClassicDataset, METH_VARARGS, "MDArray_AsClassicDataset(MDArray self, size_t iXDim, size_t iYDim, Group hRootGroup=None, char ** options=None) -> Dataset"},
68320 : { "MDArray_GetRawBlockInfo", _wrap_MDArray_GetRawBlockInfo, METH_VARARGS, "MDArray_GetRawBlockInfo(MDArray self, int nDims) -> RawBlockInfo"},
68321 : { "MDArray_GetStatistics", (PyCFunction)(void(*)(void))_wrap_MDArray_GetStatistics, METH_VARARGS|METH_KEYWORDS, "MDArray_GetStatistics(MDArray self, bool approx_ok=FALSE, bool force=TRUE, GDALProgressFunc callback=0, void * callback_data=None) -> Statistics"},
68322 : { "MDArray_ComputeStatistics", (PyCFunction)(void(*)(void))_wrap_MDArray_ComputeStatistics, METH_VARARGS|METH_KEYWORDS, "MDArray_ComputeStatistics(MDArray self, bool approx_ok=FALSE, GDALProgressFunc callback=0, void * callback_data=None, char ** options=None) -> Statistics"},
68323 : { "MDArray_GetResampled", _wrap_MDArray_GetResampled, METH_VARARGS, "MDArray_GetResampled(MDArray self, int nDimensions, GDALRIOResampleAlg resample_alg, OSRSpatialReferenceShadow ** srs, char ** options=None) -> MDArray"},
68324 : { "MDArray_GetMeshGrid", _wrap_MDArray_GetMeshGrid, METH_VARARGS, "MDArray_GetMeshGrid(int nInputArrays, char ** options=None)"},
68325 : { "MDArray_Cache", _wrap_MDArray_Cache, METH_VARARGS, "MDArray_Cache(MDArray self, char ** options=None) -> bool"},
68326 : { "MDArray_Rename", _wrap_MDArray_Rename, METH_VARARGS, "MDArray_Rename(MDArray self, char const * newName) -> CPLErr"},
68327 : { "MDArray_swigregister", MDArray_swigregister, METH_O, NULL},
68328 : { "delete_Attribute", _wrap_delete_Attribute, METH_O, "delete_Attribute(Attribute self)"},
68329 : { "Attribute_GetName", _wrap_Attribute_GetName, METH_O, "Attribute_GetName(Attribute self) -> char const *"},
68330 : { "Attribute_GetFullName", _wrap_Attribute_GetFullName, METH_O, "Attribute_GetFullName(Attribute self) -> char const *"},
68331 : { "Attribute_GetTotalElementsCount", _wrap_Attribute_GetTotalElementsCount, METH_O, "Attribute_GetTotalElementsCount(Attribute self) -> GUIntBig"},
68332 : { "Attribute_GetDimensionCount", _wrap_Attribute_GetDimensionCount, METH_O, "Attribute_GetDimensionCount(Attribute self) -> size_t"},
68333 : { "Attribute_GetDimensionsSize", _wrap_Attribute_GetDimensionsSize, METH_O, "Attribute_GetDimensionsSize(Attribute self)"},
68334 : { "Attribute_GetDataType", _wrap_Attribute_GetDataType, METH_O, "Attribute_GetDataType(Attribute self) -> ExtendedDataType"},
68335 : { "Attribute_ReadAsRaw", _wrap_Attribute_ReadAsRaw, METH_O, "Attribute_ReadAsRaw(Attribute self) -> CPLErr"},
68336 : { "Attribute_ReadAsString", _wrap_Attribute_ReadAsString, METH_O, "Attribute_ReadAsString(Attribute self) -> char const *"},
68337 : { "Attribute_ReadAsInt", _wrap_Attribute_ReadAsInt, METH_O, "Attribute_ReadAsInt(Attribute self) -> int"},
68338 : { "Attribute_ReadAsInt64", _wrap_Attribute_ReadAsInt64, METH_O, "Attribute_ReadAsInt64(Attribute self) -> long long"},
68339 : { "Attribute_ReadAsDouble", _wrap_Attribute_ReadAsDouble, METH_O, "Attribute_ReadAsDouble(Attribute self) -> double"},
68340 : { "Attribute_ReadAsStringArray", _wrap_Attribute_ReadAsStringArray, METH_O, "Attribute_ReadAsStringArray(Attribute self) -> char **"},
68341 : { "Attribute_ReadAsIntArray", _wrap_Attribute_ReadAsIntArray, METH_O, "Attribute_ReadAsIntArray(Attribute self)"},
68342 : { "Attribute_ReadAsInt64Array", _wrap_Attribute_ReadAsInt64Array, METH_O, "Attribute_ReadAsInt64Array(Attribute self)"},
68343 : { "Attribute_ReadAsDoubleArray", _wrap_Attribute_ReadAsDoubleArray, METH_O, "Attribute_ReadAsDoubleArray(Attribute self)"},
68344 : { "Attribute_WriteRaw", _wrap_Attribute_WriteRaw, METH_VARARGS, "Attribute_WriteRaw(Attribute self, GIntBig nLen) -> CPLErr"},
68345 : { "Attribute_WriteString", _wrap_Attribute_WriteString, METH_VARARGS, "Attribute_WriteString(Attribute self, char const * val) -> CPLErr"},
68346 : { "Attribute_WriteStringArray", _wrap_Attribute_WriteStringArray, METH_VARARGS, "Attribute_WriteStringArray(Attribute self, char ** vals) -> CPLErr"},
68347 : { "Attribute_WriteInt", _wrap_Attribute_WriteInt, METH_VARARGS, "Attribute_WriteInt(Attribute self, int val) -> CPLErr"},
68348 : { "Attribute_WriteInt64", _wrap_Attribute_WriteInt64, METH_VARARGS, "Attribute_WriteInt64(Attribute self, long long val) -> CPLErr"},
68349 : { "Attribute_WriteDouble", _wrap_Attribute_WriteDouble, METH_VARARGS, "Attribute_WriteDouble(Attribute self, double val) -> CPLErr"},
68350 : { "Attribute_WriteIntArray", _wrap_Attribute_WriteIntArray, METH_VARARGS, "Attribute_WriteIntArray(Attribute self, int nList) -> CPLErr"},
68351 : { "Attribute_WriteInt64Array", _wrap_Attribute_WriteInt64Array, METH_VARARGS, "Attribute_WriteInt64Array(Attribute self, int nList) -> CPLErr"},
68352 : { "Attribute_WriteDoubleArray", _wrap_Attribute_WriteDoubleArray, METH_VARARGS, "Attribute_WriteDoubleArray(Attribute self, int nList) -> CPLErr"},
68353 : { "Attribute_Rename", _wrap_Attribute_Rename, METH_VARARGS, "Attribute_Rename(Attribute self, char const * newName) -> CPLErr"},
68354 : { "Attribute_swigregister", Attribute_swigregister, METH_O, NULL},
68355 : { "delete_Dimension", _wrap_delete_Dimension, METH_O, "delete_Dimension(Dimension self)"},
68356 : { "Dimension_GetName", _wrap_Dimension_GetName, METH_O, "Dimension_GetName(Dimension self) -> char const *"},
68357 : { "Dimension_GetFullName", _wrap_Dimension_GetFullName, METH_O, "Dimension_GetFullName(Dimension self) -> char const *"},
68358 : { "Dimension_GetType", _wrap_Dimension_GetType, METH_O, "Dimension_GetType(Dimension self) -> char const *"},
68359 : { "Dimension_GetDirection", _wrap_Dimension_GetDirection, METH_O, "Dimension_GetDirection(Dimension self) -> char const *"},
68360 : { "Dimension_GetSize", _wrap_Dimension_GetSize, METH_O, "Dimension_GetSize(Dimension self) -> GUIntBig"},
68361 : { "Dimension_GetIndexingVariable", _wrap_Dimension_GetIndexingVariable, METH_O, "Dimension_GetIndexingVariable(Dimension self) -> MDArray"},
68362 : { "Dimension_SetIndexingVariable", _wrap_Dimension_SetIndexingVariable, METH_VARARGS, "Dimension_SetIndexingVariable(Dimension self, MDArray array) -> bool"},
68363 : { "Dimension_Rename", _wrap_Dimension_Rename, METH_VARARGS, "Dimension_Rename(Dimension self, char const * newName) -> CPLErr"},
68364 : { "Dimension_swigregister", Dimension_swigregister, METH_O, NULL},
68365 : { "delete_ExtendedDataType", _wrap_delete_ExtendedDataType, METH_O, "delete_ExtendedDataType(ExtendedDataType self)"},
68366 : { "ExtendedDataType_Create", _wrap_ExtendedDataType_Create, METH_O, "ExtendedDataType_Create(GDALDataType dt) -> ExtendedDataType"},
68367 : { "ExtendedDataType_CreateString", _wrap_ExtendedDataType_CreateString, METH_VARARGS, "ExtendedDataType_CreateString(size_t nMaxStringLength=0, GDALExtendedDataTypeSubType eSubType=GEDTST_NONE) -> ExtendedDataType"},
68368 : { "ExtendedDataType_CreateCompound", _wrap_ExtendedDataType_CreateCompound, METH_VARARGS, "ExtendedDataType_CreateCompound(char const * name, size_t nTotalSize, int nComps) -> ExtendedDataType"},
68369 : { "ExtendedDataType_GetName", _wrap_ExtendedDataType_GetName, METH_O, "ExtendedDataType_GetName(ExtendedDataType self) -> char const *"},
68370 : { "ExtendedDataType_GetClass", _wrap_ExtendedDataType_GetClass, METH_O, "ExtendedDataType_GetClass(ExtendedDataType self) -> GDALExtendedDataTypeClass"},
68371 : { "ExtendedDataType_GetNumericDataType", _wrap_ExtendedDataType_GetNumericDataType, METH_O, "ExtendedDataType_GetNumericDataType(ExtendedDataType self) -> GDALDataType"},
68372 : { "ExtendedDataType_GetSize", _wrap_ExtendedDataType_GetSize, METH_O, "ExtendedDataType_GetSize(ExtendedDataType self) -> size_t"},
68373 : { "ExtendedDataType_GetMaxStringLength", _wrap_ExtendedDataType_GetMaxStringLength, METH_O, "ExtendedDataType_GetMaxStringLength(ExtendedDataType self) -> size_t"},
68374 : { "ExtendedDataType_GetSubType", _wrap_ExtendedDataType_GetSubType, METH_O, "ExtendedDataType_GetSubType(ExtendedDataType self) -> GDALExtendedDataTypeSubType"},
68375 : { "ExtendedDataType_GetRAT", _wrap_ExtendedDataType_GetRAT, METH_O, "ExtendedDataType_GetRAT(ExtendedDataType self) -> RasterAttributeTable"},
68376 : { "ExtendedDataType_GetComponents", _wrap_ExtendedDataType_GetComponents, METH_O, "ExtendedDataType_GetComponents(ExtendedDataType self)"},
68377 : { "ExtendedDataType_CanConvertTo", _wrap_ExtendedDataType_CanConvertTo, METH_VARARGS, "ExtendedDataType_CanConvertTo(ExtendedDataType self, ExtendedDataType other) -> bool"},
68378 : { "ExtendedDataType_Equals", _wrap_ExtendedDataType_Equals, METH_VARARGS, "ExtendedDataType_Equals(ExtendedDataType self, ExtendedDataType other) -> bool"},
68379 : { "ExtendedDataType_swigregister", ExtendedDataType_swigregister, METH_O, NULL},
68380 : { "delete_EDTComponent", _wrap_delete_EDTComponent, METH_O, "delete_EDTComponent(EDTComponent self)"},
68381 : { "EDTComponent_Create", _wrap_EDTComponent_Create, METH_VARARGS, "EDTComponent_Create(char const * name, size_t offset, ExtendedDataType type) -> EDTComponent"},
68382 : { "EDTComponent_GetName", _wrap_EDTComponent_GetName, METH_O, "EDTComponent_GetName(EDTComponent self) -> char const *"},
68383 : { "EDTComponent_GetOffset", _wrap_EDTComponent_GetOffset, METH_O, "EDTComponent_GetOffset(EDTComponent self) -> size_t"},
68384 : { "EDTComponent_GetType", _wrap_EDTComponent_GetType, METH_O, "EDTComponent_GetType(EDTComponent self) -> ExtendedDataType"},
68385 : { "EDTComponent_swigregister", EDTComponent_swigregister, METH_O, NULL},
68386 : { "CreateRasterAttributeTableFromMDArrays", _wrap_CreateRasterAttributeTableFromMDArrays, METH_VARARGS, "CreateRasterAttributeTableFromMDArrays(GDALRATTableType eTableType, int nArrays, int nUsages=0) -> RasterAttributeTable"},
68387 : { "Band_XSize_get", _wrap_Band_XSize_get, METH_O, "Band_XSize_get(Band self) -> int"},
68388 : { "Band_YSize_get", _wrap_Band_YSize_get, METH_O, "Band_YSize_get(Band self) -> int"},
68389 : { "Band_DataType_get", _wrap_Band_DataType_get, METH_O, "Band_DataType_get(Band self) -> GDALDataType"},
68390 : { "Band_GetDataset", _wrap_Band_GetDataset, METH_O, "\n"
68391 : "Band_GetDataset(Band self) -> Dataset\n"
68392 : "\n"
68393 : "\n"
68394 : "Fetch the :py:class:`Dataset` associated with this Band.\n"
68395 : "See :cpp:func:`GDALRasterBand::GetDataset`.\n"
68396 : "\n"
68397 : ""},
68398 : { "Band_GetBand", _wrap_Band_GetBand, METH_O, "\n"
68399 : "Band_GetBand(Band self) -> int\n"
68400 : "\n"
68401 : "\n"
68402 : "Return the index of this band.\n"
68403 : "See :cpp:func:`GDALRasterBand::GetBand`.\n"
68404 : "\n"
68405 : "Returns\n"
68406 : "-------\n"
68407 : "int\n"
68408 : " the (1-based) index of this band\n"
68409 : "\n"
68410 : ""},
68411 : { "Band_GetBlockSize", _wrap_Band_GetBlockSize, METH_O, "\n"
68412 : "Band_GetBlockSize(Band self)\n"
68413 : "\n"
68414 : "\n"
68415 : "Fetch the natural block size of this band.\n"
68416 : "See :cpp:func:`GDALRasterBand::GetBlockSize`.\n"
68417 : "\n"
68418 : "Returns\n"
68419 : "-------\n"
68420 : "list\n"
68421 : " list with the x and y dimensions of a block\n"
68422 : "\n"
68423 : ""},
68424 : { "Band_GetActualBlockSize", _wrap_Band_GetActualBlockSize, METH_VARARGS, "\n"
68425 : "Band_GetActualBlockSize(Band self, int nXBlockOff, int nYBlockOff)\n"
68426 : "\n"
68427 : "\n"
68428 : "Fetch the actual block size for a given block offset.\n"
68429 : "See :cpp:func:`GDALRasterBand::GetActualBlockSize`.\n"
68430 : "\n"
68431 : "Parameters\n"
68432 : "----------\n"
68433 : "nXBlockOff : int\n"
68434 : " the horizontal block offset for which to calculate the\n"
68435 : " number of valid pixels, with zero indicating the left most block, 1 the next\n"
68436 : " block and so forth.\n"
68437 : "nYBlockOff : int\n"
68438 : " the vertical block offset, with zero indicating\n"
68439 : " the top most block, 1 the next block and so forth.\n"
68440 : "\n"
68441 : "Returns\n"
68442 : "-------\n"
68443 : "tuple\n"
68444 : " tuple with the x and y dimensions of the block\n"
68445 : "\n"
68446 : ""},
68447 : { "Band_GetColorInterpretation", _wrap_Band_GetColorInterpretation, METH_O, "\n"
68448 : "Band_GetColorInterpretation(Band self) -> GDALColorInterp\n"
68449 : "\n"
68450 : "\n"
68451 : "Get the :cpp:enum:`GDALColorInterp` value for this band.\n"
68452 : "See :cpp:func:`GDALRasterBand::GetColorInterpretation`.\n"
68453 : "\n"
68454 : "Returns\n"
68455 : "-------\n"
68456 : "int\n"
68457 : "\n"
68458 : ""},
68459 : { "Band_GetRasterColorInterpretation", _wrap_Band_GetRasterColorInterpretation, METH_O, "\n"
68460 : "Band_GetRasterColorInterpretation(Band self) -> GDALColorInterp\n"
68461 : "\n"
68462 : "\n"
68463 : "Return the color interpretation code for this band.\n"
68464 : "See :cpp:func:`GDALRasterBand::GetColorInterpretation`.\n"
68465 : "\n"
68466 : "Returns\n"
68467 : "-------\n"
68468 : "int\n"
68469 : " The color interpretation code (default :py:const:`gdal.GCI_Undefined`)\n"
68470 : "\n"
68471 : "\n"
68472 : ""},
68473 : { "Band_SetColorInterpretation", _wrap_Band_SetColorInterpretation, METH_VARARGS, "\n"
68474 : "Band_SetColorInterpretation(Band self, GDALColorInterp val) -> CPLErr\n"
68475 : "\n"
68476 : "\n"
68477 : "Set color interpretation of the band\n"
68478 : "See :cpp:func:`GDALRasterBand::SetColorInterpretation`.\n"
68479 : "\n"
68480 : "Parameters\n"
68481 : "----------\n"
68482 : "val : int\n"
68483 : " A color interpretation code such as :py:const:`gdal.GCI_RedBand`\n"
68484 : "\n"
68485 : "Returns\n"
68486 : "-------\n"
68487 : "int\n"
68488 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
68489 : "\n"
68490 : ""},
68491 : { "Band_SetRasterColorInterpretation", _wrap_Band_SetRasterColorInterpretation, METH_VARARGS, "\n"
68492 : "Band_SetRasterColorInterpretation(Band self, GDALColorInterp val) -> CPLErr\n"
68493 : "\n"
68494 : "Deprecated. Alternate name for :py:meth:`SetColorInterpretation`.\n"
68495 : "\n"
68496 : ""},
68497 : { "Band_GetNoDataValue", _wrap_Band_GetNoDataValue, METH_O, "Band_GetNoDataValue(Band self)"},
68498 : { "Band_GetNoDataValueAsInt64", _wrap_Band_GetNoDataValueAsInt64, METH_O, "\n"
68499 : "Band_GetNoDataValueAsInt64(Band self)\n"
68500 : "\n"
68501 : "\n"
68502 : "Fetch the nodata value for this band.\n"
68503 : "See :cpp:func:`GDALRasterBand::GetNoDataValueAsInt64`.\n"
68504 : "\n"
68505 : "Returns\n"
68506 : "-------\n"
68507 : "int\n"
68508 : " The nodata value, or ``None`` if it has not been set or\n"
68509 : " the data type of this band is not :py:const:`gdal.GDT_Int64`.\n"
68510 : "\n"
68511 : "\n"
68512 : ""},
68513 : { "Band_GetNoDataValueAsUInt64", _wrap_Band_GetNoDataValueAsUInt64, METH_O, "\n"
68514 : "Band_GetNoDataValueAsUInt64(Band self)\n"
68515 : "\n"
68516 : "\n"
68517 : "Fetch the nodata value for this band.\n"
68518 : "See :cpp:func:`GDALRasterBand::GetNoDataValueAsUInt64`.\n"
68519 : "\n"
68520 : "Returns\n"
68521 : "-------\n"
68522 : "int\n"
68523 : " The nodata value, or ``None`` if it has not been set or\n"
68524 : " the data type of this band is not :py:const:`gdal.GDT_UInt64`.\n"
68525 : "\n"
68526 : "\n"
68527 : ""},
68528 : { "Band_SetNoDataValue", _wrap_Band_SetNoDataValue, METH_VARARGS, "Band_SetNoDataValue(Band self, double d) -> CPLErr"},
68529 : { "Band_SetNoDataValueAsInt64", _wrap_Band_SetNoDataValueAsInt64, METH_VARARGS, "Band_SetNoDataValueAsInt64(Band self, GIntBig v) -> CPLErr"},
68530 : { "Band_SetNoDataValueAsUInt64", _wrap_Band_SetNoDataValueAsUInt64, METH_VARARGS, "Band_SetNoDataValueAsUInt64(Band self, GUIntBig v) -> CPLErr"},
68531 : { "Band_DeleteNoDataValue", _wrap_Band_DeleteNoDataValue, METH_O, "\n"
68532 : "Band_DeleteNoDataValue(Band self) -> CPLErr\n"
68533 : "\n"
68534 : "\n"
68535 : "Remove the nodata value for this band.\n"
68536 : "\n"
68537 : "Returns\n"
68538 : "-------\n"
68539 : "int\n"
68540 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
68541 : "\n"
68542 : "\n"
68543 : ""},
68544 : { "Band_GetUnitType", _wrap_Band_GetUnitType, METH_O, "\n"
68545 : "Band_GetUnitType(Band self) -> char const *\n"
68546 : "\n"
68547 : "\n"
68548 : "Return a name for the units of this raster's values.\n"
68549 : "See :cpp:func:`GDALRasterBand::GetUnitType`.\n"
68550 : "\n"
68551 : "Returns\n"
68552 : "-------\n"
68553 : "str\n"
68554 : "\n"
68555 : "Examples\n"
68556 : "--------\n"
68557 : ">>> ds = gdal.GetDriverByName('MEM').Create('', 10, 10)\n"
68558 : ">>> ds.GetRasterBand(1).SetUnitType('ft')\n"
68559 : "0\n"
68560 : ">>> ds.GetRasterBand(1).GetUnitType()\n"
68561 : "'ft'\n"
68562 : "\n"
68563 : ""},
68564 : { "Band_SetUnitType", _wrap_Band_SetUnitType, METH_VARARGS, "\n"
68565 : "Band_SetUnitType(Band self, char const * val) -> CPLErr\n"
68566 : "\n"
68567 : "\n"
68568 : "Set unit type.\n"
68569 : "See :cpp:func:`GDALRasterBand::SetUnitType`.\n"
68570 : "\n"
68571 : "Parameters\n"
68572 : "----------\n"
68573 : "val : str\n"
68574 : "\n"
68575 : "Returns\n"
68576 : "-------\n"
68577 : "int\n"
68578 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
68579 : "\n"
68580 : ""},
68581 : { "Band_GetRasterCategoryNames", _wrap_Band_GetRasterCategoryNames, METH_O, "\n"
68582 : "Band_GetRasterCategoryNames(Band self) -> char **\n"
68583 : "\n"
68584 : "\n"
68585 : "Fetch the list of category names for this band.\n"
68586 : "See :cpp:func:`GDALRasterBand::GetCategoryNames`.\n"
68587 : "\n"
68588 : "Returns\n"
68589 : "-------\n"
68590 : "list\n"
68591 : " The list of names, or ``None`` if no names exist.\n"
68592 : "\n"
68593 : "\n"
68594 : ""},
68595 : { "Band_SetRasterCategoryNames", _wrap_Band_SetRasterCategoryNames, METH_VARARGS, "\n"
68596 : "Band_SetRasterCategoryNames(Band self, char ** names) -> CPLErr\n"
68597 : "\n"
68598 : "Deprecated. Alternate name for :py:meth:`SetCategoryNames`.\n"
68599 : "\n"
68600 : ""},
68601 : { "Band_GetMinimum", _wrap_Band_GetMinimum, METH_O, "\n"
68602 : "Band_GetMinimum(Band self)\n"
68603 : "\n"
68604 : "\n"
68605 : "Fetch a previously stored maximum value for this band.\n"
68606 : "See :cpp:func:`GDALRasterBand::GetMinimum`.\n"
68607 : "\n"
68608 : "Returns\n"
68609 : "-------\n"
68610 : "float\n"
68611 : " The stored minimum value, or ``None`` if no value\n"
68612 : " has been stored.\n"
68613 : "\n"
68614 : "\n"
68615 : ""},
68616 : { "Band_GetMaximum", _wrap_Band_GetMaximum, METH_O, "\n"
68617 : "Band_GetMaximum(Band self)\n"
68618 : "\n"
68619 : "\n"
68620 : "Fetch a previously stored maximum value for this band.\n"
68621 : "See :cpp:func:`GDALRasterBand::GetMaximum`.\n"
68622 : "\n"
68623 : "Returns\n"
68624 : "-------\n"
68625 : "float\n"
68626 : " The stored maximum value, or ``None`` if no value\n"
68627 : " has been stored.\n"
68628 : "\n"
68629 : "\n"
68630 : ""},
68631 : { "Band_GetOffset", _wrap_Band_GetOffset, METH_O, "\n"
68632 : "Band_GetOffset(Band self)\n"
68633 : "\n"
68634 : "\n"
68635 : "Fetch the raster value offset.\n"
68636 : "See :cpp:func:`GDALRasterBand::GetOffset`.\n"
68637 : "\n"
68638 : "Returns\n"
68639 : "-------\n"
68640 : "double\n"
68641 : " The offset value, or ``0.0``.\n"
68642 : "\n"
68643 : "\n"
68644 : ""},
68645 : { "Band_GetScale", _wrap_Band_GetScale, METH_O, "\n"
68646 : "Band_GetScale(Band self)\n"
68647 : "\n"
68648 : "\n"
68649 : "Fetch the band scale value.\n"
68650 : "See :cpp:func:`GDALRasterBand::GetScale`.\n"
68651 : "\n"
68652 : "Returns\n"
68653 : "-------\n"
68654 : "double\n"
68655 : " The scale value, or ``1.0``.\n"
68656 : "\n"
68657 : ""},
68658 : { "Band_SetOffset", _wrap_Band_SetOffset, METH_VARARGS, "\n"
68659 : "Band_SetOffset(Band self, double val) -> CPLErr\n"
68660 : "\n"
68661 : "\n"
68662 : "Set scaling offset.\n"
68663 : "See :cpp:func:`GDALRasterBand::SetOffset`.\n"
68664 : "\n"
68665 : "Parameters\n"
68666 : "----------\n"
68667 : "val : float\n"
68668 : "\n"
68669 : "Returns\n"
68670 : "-------\n"
68671 : "int\n"
68672 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
68673 : "\n"
68674 : "See Also\n"
68675 : "--------\n"
68676 : ":py:meth:`SetScale`\n"
68677 : "\n"
68678 : ""},
68679 : { "Band_SetScale", _wrap_Band_SetScale, METH_VARARGS, "\n"
68680 : "Band_SetScale(Band self, double val) -> CPLErr\n"
68681 : "\n"
68682 : "Set scaling ratio.\n"
68683 : "See :cpp:func:`GDALRasterBand::SetScale`.\n"
68684 : "\n"
68685 : "Parameters\n"
68686 : "----------\n"
68687 : "val : float\n"
68688 : "\n"
68689 : "Returns\n"
68690 : "-------\n"
68691 : "int\n"
68692 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
68693 : "\n"
68694 : "See Also\n"
68695 : "--------\n"
68696 : ":py:meth:`SetOffset`\n"
68697 : "\n"
68698 : ""},
68699 : { "Band_GetStatistics", _wrap_Band_GetStatistics, METH_VARARGS, "\n"
68700 : "Band_GetStatistics(Band self, int approx_ok, int force) -> CPLErr\n"
68701 : "\n"
68702 : "\n"
68703 : "Return the minimum, maximum, mean, and standard deviation of all pixel values\n"
68704 : "in this band.\n"
68705 : "See :cpp:func:`GDALRasterBand::GetStatistics`\n"
68706 : "\n"
68707 : "Parameters\n"
68708 : "----------\n"
68709 : "approx_ok : bool\n"
68710 : " If ``True``, allow overviews or a subset of image tiles to be used in\n"
68711 : " computing the statistics.\n"
68712 : "force : bool\n"
68713 : " If ``False``, only return a result if it can be obtained without scanning\n"
68714 : " the image, i.e. from pre-existing metadata.\n"
68715 : "\n"
68716 : "Returns\n"
68717 : "-------\n"
68718 : "list\n"
68719 : " a list with the min, max, mean, and standard deviation of values\n"
68720 : " in the Band.\n"
68721 : "\n"
68722 : "See Also\n"
68723 : "--------\n"
68724 : ":py:meth:`ComputeBandStats`\n"
68725 : ":py:meth:`ComputeRasterMinMax`\n"
68726 : ":py:meth:`GetMaximum`\n"
68727 : ":py:meth:`GetMinimum`\n"
68728 : ":py:meth:`GetStatistics`\n"
68729 : "\n"
68730 : ""},
68731 : { "Band_ComputeStatistics", (PyCFunction)(void(*)(void))_wrap_Band_ComputeStatistics, METH_VARARGS|METH_KEYWORDS, "Band_ComputeStatistics(Band self, bool approx_ok, GDALProgressFunc callback=0, void * callback_data=None) -> CPLErr"},
68732 : { "Band_SetStatistics", _wrap_Band_SetStatistics, METH_VARARGS, "\n"
68733 : "Band_SetStatistics(Band self, double min, double max, double mean, double stddev) -> CPLErr\n"
68734 : "\n"
68735 : "\n"
68736 : "Set statistics on band.\n"
68737 : "See :cpp:func:`GDALRasterBand::SetStatistics`.\n"
68738 : "\n"
68739 : "Parameters\n"
68740 : "----------\n"
68741 : "min : float\n"
68742 : "max : float\n"
68743 : "mean : float\n"
68744 : "stdev : float\n"
68745 : "\n"
68746 : "Returns\n"
68747 : "-------\n"
68748 : "int\n"
68749 : " :py:const:`CE_None` on apparent success or :py:const:`CE_Failure` on\n"
68750 : " failure. This method cannot detect whether metadata will be properly saved and\n"
68751 : " so may return :py:const:`gdal.`CE_None` even if the statistics will never be\n"
68752 : " saved.\n"
68753 : "\n"
68754 : "See Also\n"
68755 : "--------\n"
68756 : ":py:meth:`ComputeBandStats`\n"
68757 : ":py:meth:`ComputeRasterMinMax`\n"
68758 : ":py:meth:`ComputeStatistics`\n"
68759 : ":py:meth:`GetMaximum`\n"
68760 : ":py:meth:`GetMinimum`\n"
68761 : ":py:meth:`GetStatistics`\n"
68762 : "\n"
68763 : ""},
68764 : { "Band_GetOverviewCount", _wrap_Band_GetOverviewCount, METH_O, "\n"
68765 : "Band_GetOverviewCount(Band self) -> int\n"
68766 : "\n"
68767 : "\n"
68768 : "Return the number of overview layers available.\n"
68769 : "See :cpp:func:`GDALRasterBand::GetOverviewCount`.\n"
68770 : "\n"
68771 : "Returns\n"
68772 : "-------\n"
68773 : "int\n"
68774 : "\n"
68775 : "\n"
68776 : ""},
68777 : { "Band_GetOverview", _wrap_Band_GetOverview, METH_VARARGS, "\n"
68778 : "Band_GetOverview(Band self, int i) -> Band\n"
68779 : "\n"
68780 : "\n"
68781 : "Fetch a raster overview.\n"
68782 : "See :cpp:func:`GDALRasterBand::GetOverview`.\n"
68783 : "\n"
68784 : "Parameters\n"
68785 : "----------\n"
68786 : "i : int\n"
68787 : " Overview index between 0 and ``GetOverviewCount() - 1``.\n"
68788 : "\n"
68789 : "Returns\n"
68790 : "-------\n"
68791 : "Band\n"
68792 : "\n"
68793 : "\n"
68794 : ""},
68795 : { "Band_GetSampleOverview", _wrap_Band_GetSampleOverview, METH_VARARGS, "Band_GetSampleOverview(Band self, GUIntBig nDesiredSamples) -> Band"},
68796 : { "Band_Checksum", (PyCFunction)(void(*)(void))_wrap_Band_Checksum, METH_VARARGS|METH_KEYWORDS, "\n"
68797 : "Band_Checksum(Band self, int xoff=0, int yoff=0, int * xsize=None, int * ysize=None) -> int\n"
68798 : "\n"
68799 : "\n"
68800 : "Computes a checksum from a region of a RasterBand.\n"
68801 : "See :cpp:func:`GDALChecksumImage`.\n"
68802 : "\n"
68803 : "Parameters\n"
68804 : "----------\n"
68805 : "xoff : int, default=0\n"
68806 : " The pixel offset to left side of the region of the band to\n"
68807 : " be read. This would be zero to start from the left side.\n"
68808 : "yoff : int, default=0\n"
68809 : " The line offset to top side of the region of the band to\n"
68810 : " be read. This would be zero to start from the top side.\n"
68811 : "xsize : int, optional\n"
68812 : " The number of pixels to read in the x direction. By default,\n"
68813 : " equal to the number of columns in the raster.\n"
68814 : "ysize : int, optional\n"
68815 : " The number of rows to read in the y direction. By default,\n"
68816 : " equal to the number of bands in the raster.\n"
68817 : "\n"
68818 : "Returns\n"
68819 : "-------\n"
68820 : "int\n"
68821 : " checksum value, or -1 in case of error\n"
68822 : "\n"
68823 : "\n"
68824 : ""},
68825 : { "Band_ComputeRasterMinMax", (PyCFunction)(void(*)(void))_wrap_Band_ComputeRasterMinMax, METH_VARARGS|METH_KEYWORDS, "Band_ComputeRasterMinMax(Band self, bool approx_ok=False, bool can_return_none=False)"},
68826 : { "Band_ComputeBandStats", _wrap_Band_ComputeBandStats, METH_VARARGS, "\n"
68827 : "Band_ComputeBandStats(Band self, int samplestep=1)\n"
68828 : "\n"
68829 : "\n"
68830 : "Computes the mean and standard deviation of values in this Band.\n"
68831 : "See :cpp:func:`GDALComputeBandStats`.\n"
68832 : "\n"
68833 : "Parameters\n"
68834 : "----------\n"
68835 : "samplestep : int, default=1\n"
68836 : " Step between scanlines used to compute statistics.\n"
68837 : "\n"
68838 : "Returns\n"
68839 : "-------\n"
68840 : "tuple\n"
68841 : " tuple of length 2 with value of mean and standard deviation\n"
68842 : "\n"
68843 : "See Also\n"
68844 : "--------\n"
68845 : ":py:meth:`ComputeRasterMinMax`\n"
68846 : ":py:meth:`ComputeStatistics`\n"
68847 : ":py:meth:`GetMaximum`\n"
68848 : ":py:meth:`GetMinimum`\n"
68849 : ":py:meth:`GetStatistics`\n"
68850 : ":py:meth:`SetStatistics`\n"
68851 : "\n"
68852 : ""},
68853 : { "Band_Fill", _wrap_Band_Fill, METH_VARARGS, "\n"
68854 : "Band_Fill(Band self, double real_fill, double imag_fill=0.0) -> CPLErr\n"
68855 : "\n"
68856 : "\n"
68857 : "Fill this band with a constant value.\n"
68858 : "See :cpp:func:`GDALRasterBand::Fill`.\n"
68859 : "\n"
68860 : "Parameters\n"
68861 : "----------\n"
68862 : "real_fill : float\n"
68863 : " real component of the fill value\n"
68864 : "imag_fill : float, default = 0.0\n"
68865 : " imaginary component of the fill value\n"
68866 : "\n"
68867 : "Returns\n"
68868 : "-------\n"
68869 : "int\n"
68870 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
68871 : "\n"
68872 : "\n"
68873 : ""},
68874 : { "Band_WriteRaster", (PyCFunction)(void(*)(void))_wrap_Band_WriteRaster, METH_VARARGS|METH_KEYWORDS, "Band_WriteRaster(Band self, int xoff, int yoff, int xsize, int ysize, GIntBig buf_len, int * buf_xsize=None, int * buf_ysize=None, GDALDataType * buf_type=None, GIntBig * buf_pixel_space=None, GIntBig * buf_line_space=None) -> CPLErr"},
68875 : { "Band_FlushCache", _wrap_Band_FlushCache, METH_O, "\n"
68876 : "Band_FlushCache(Band self)\n"
68877 : "\n"
68878 : "\n"
68879 : "Flush raster data cache.\n"
68880 : "See :cpp:func:`GDALRasterBand::FlushCache`.\n"
68881 : "\n"
68882 : ""},
68883 : { "Band_GetRasterColorTable", _wrap_Band_GetRasterColorTable, METH_O, "\n"
68884 : "Band_GetRasterColorTable(Band self) -> ColorTable\n"
68885 : "\n"
68886 : "\n"
68887 : "Fetch the color table associated with this band.\n"
68888 : "See :cpp:func:`GDALRasterBand::GetColorTable`.\n"
68889 : "\n"
68890 : "Returns\n"
68891 : "-------\n"
68892 : "ColorTable\n"
68893 : " The :py:class:`ColorTable`, or ``None`` if it has not been defined.\n"
68894 : "\n"
68895 : ""},
68896 : { "Band_GetColorTable", _wrap_Band_GetColorTable, METH_O, "\n"
68897 : "Band_GetColorTable(Band self) -> ColorTable\n"
68898 : "\n"
68899 : "\n"
68900 : "Get the color table associated with this band.\n"
68901 : "See :cpp:func:`GDALRasterBand::GetColorTable`.\n"
68902 : "\n"
68903 : "Returns\n"
68904 : "-------\n"
68905 : "ColorTable or ``None``\n"
68906 : "\n"
68907 : ""},
68908 : { "Band_SetRasterColorTable", _wrap_Band_SetRasterColorTable, METH_VARARGS, "\n"
68909 : "Band_SetRasterColorTable(Band self, ColorTable arg) -> int\n"
68910 : "\n"
68911 : "Deprecated. Alternate name for :py:meth:`SetColorTable`.\n"
68912 : "\n"
68913 : ""},
68914 : { "Band_SetColorTable", _wrap_Band_SetColorTable, METH_VARARGS, "\n"
68915 : "Band_SetColorTable(Band self, ColorTable arg) -> int\n"
68916 : "\n"
68917 : "\n"
68918 : "Set the raster color table.\n"
68919 : "See :cpp:func:`GDALRasterBand::SetColorTable`.\n"
68920 : "\n"
68921 : "Parameters\n"
68922 : "----------\n"
68923 : "arg : ColorTable\n"
68924 : "\n"
68925 : "Returns\n"
68926 : "-------\n"
68927 : "int\n"
68928 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
68929 : "\n"
68930 : ""},
68931 : { "Band_GetDefaultRAT", _wrap_Band_GetDefaultRAT, METH_O, "Band_GetDefaultRAT(Band self) -> RasterAttributeTable"},
68932 : { "Band_SetDefaultRAT", _wrap_Band_SetDefaultRAT, METH_VARARGS, "Band_SetDefaultRAT(Band self, RasterAttributeTable table) -> int"},
68933 : { "Band_GetMaskBand", _wrap_Band_GetMaskBand, METH_O, "\n"
68934 : "Band_GetMaskBand(Band self) -> Band\n"
68935 : "\n"
68936 : "\n"
68937 : "Return the mask band associated with this band.\n"
68938 : "See :cpp:func:`GDALRasterBand::GetMaskBand`.\n"
68939 : "\n"
68940 : "Returns\n"
68941 : "-------\n"
68942 : "Band\n"
68943 : "\n"
68944 : "\n"
68945 : ""},
68946 : { "Band_GetMaskFlags", _wrap_Band_GetMaskFlags, METH_O, "\n"
68947 : "Band_GetMaskFlags(Band self) -> int\n"
68948 : "\n"
68949 : "\n"
68950 : "Return the status flags of the mask band.\n"
68951 : "See :cpp:func:`GDALRasterBand::GetMaskFlags`.\n"
68952 : "\n"
68953 : "Returns\n"
68954 : "-------\n"
68955 : "int\n"
68956 : "\n"
68957 : "Examples\n"
68958 : "--------\n"
68959 : ">>> import numpy as np\n"
68960 : ">>> ds = gdal.GetDriverByName('MEM').Create('', 10, 10)\n"
68961 : ">>> band = ds.GetRasterBand(1)\n"
68962 : ">>> band.GetMaskFlags() == gdal.GMF_ALL_VALID\n"
68963 : "True\n"
68964 : ">>> band.SetNoDataValue(22)\n"
68965 : "0\n"
68966 : ">>> band.WriteArray(np.array([[22]]))\n"
68967 : "0\n"
68968 : ">>> band.GetMaskBand().ReadAsArray(win_xsize=2,win_ysize=2)\n"
68969 : "array([[ 0, 255],\n"
68970 : " [255, 255]], dtype=uint8)\n"
68971 : ">>> band.GetMaskFlags() == gdal.GMF_NODATA\n"
68972 : "True\n"
68973 : "\n"
68974 : "\n"
68975 : ""},
68976 : { "Band_CreateMaskBand", _wrap_Band_CreateMaskBand, METH_VARARGS, "\n"
68977 : "Band_CreateMaskBand(Band self, int nFlags) -> CPLErr\n"
68978 : "\n"
68979 : "\n"
68980 : "Add a mask band to the current band.\n"
68981 : "See :cpp:func:`GDALRasterBand::CreateMaskBand`.\n"
68982 : "\n"
68983 : "Parameters\n"
68984 : "----------\n"
68985 : "nFlags : int\n"
68986 : "\n"
68987 : "Returns\n"
68988 : "-------\n"
68989 : "int\n"
68990 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
68991 : "\n"
68992 : "\n"
68993 : ""},
68994 : { "Band_IsMaskBand", _wrap_Band_IsMaskBand, METH_O, "\n"
68995 : "Band_IsMaskBand(Band self) -> bool\n"
68996 : "\n"
68997 : "\n"
68998 : "Returns whether the band is a mask band.\n"
68999 : "See :cpp:func:`GDALRasterBand::IsMaskBand`.\n"
69000 : "\n"
69001 : "Returns\n"
69002 : "-------\n"
69003 : "bool\n"
69004 : "\n"
69005 : ""},
69006 : { "Band_GetHistogram", (PyCFunction)(void(*)(void))_wrap_Band_GetHistogram, METH_VARARGS|METH_KEYWORDS, "\n"
69007 : "Band_GetHistogram(Band self, double min=-0.5, double max=255.5, int buckets=256, int include_out_of_range=0, int approx_ok=1, GDALProgressFunc callback=0, void * callback_data=None) -> CPLErr\n"
69008 : "\n"
69009 : "\n"
69010 : "Compute raster histogram.\n"
69011 : "See :cpp:func:`GDALRasterBand::GetHistogram`.\n"
69012 : "\n"
69013 : "Parameters\n"
69014 : "----------\n"
69015 : "min : float, default=-0.05\n"
69016 : " the lower bound of the histogram\n"
69017 : "max : float, default=255.5\n"
69018 : " the upper bound of the histogram\n"
69019 : "buckets : int, default=256\n"
69020 : " the number of buckets int he histogram\n"
69021 : "include_out_of_range : bool, default=False\n"
69022 : " if ``True``, add out-of-range values into the first and last buckets\n"
69023 : "approx_ok : bool, default=True\n"
69024 : " if ``True``, compute an approximate histogram by using subsampling or overviews\n"
69025 : "callback : callable, optional\n"
69026 : " A progress callback function\n"
69027 : "callback_data : any, optional\n"
69028 : " Optional data to be passed to callback function\n"
69029 : "\n"
69030 : "Returns\n"
69031 : "-------\n"
69032 : "list\n"
69033 : " list with length equal to ``buckets``. If ``approx_ok`` is ``False``, each\n"
69034 : " the value of each list item will equal the number of pixels in that bucket.\n"
69035 : "\n"
69036 : "Examples\n"
69037 : "--------\n"
69038 : ">>> np.random.seed(123)\n"
69039 : ">>> ds = gdal.GetDriverByName('MEM').Create('', 10, 10, eType=gdal.GDT_Float32)\n"
69040 : ">>> ds.WriteArray(np.random.normal(size=100).reshape(10, 10))\n"
69041 : "0\n"
69042 : ">>> ds.GetRasterBand(1).GetHistogram(min=-3.5, max=3.5, buckets=13, approx_ok=False)\n"
69043 : "[0, 2, 1, 6, 17, 18, 13, 14, 16, 8, 5, 0, 0]\n"
69044 : "\n"
69045 : ""},
69046 : { "Band_GetDefaultHistogram", (PyCFunction)(void(*)(void))_wrap_Band_GetDefaultHistogram, METH_VARARGS|METH_KEYWORDS, "\n"
69047 : "Band_GetDefaultHistogram(Band self, double * min_ret=None, double * max_ret=None, int * buckets_ret=None, GUIntBig ** ppanHistogram=None, int force=1, GDALProgressFunc callback=0, void * callback_data=None) -> CPLErr\n"
69048 : "\n"
69049 : "\n"
69050 : "Fetch the default histogram for this band.\n"
69051 : "See :cpp:func:`GDALRasterBand::GetDefaultHistogram`.\n"
69052 : "\n"
69053 : "Returns\n"
69054 : "-------\n"
69055 : "list\n"
69056 : " List with the following four elements:\n"
69057 : " - lower bound of histogram\n"
69058 : " - upper bound of histogram\n"
69059 : " - number of buckets in histogram\n"
69060 : " - tuple with counts for each bucket\n"
69061 : "\n"
69062 : ""},
69063 : { "Band_SetDefaultHistogram", _wrap_Band_SetDefaultHistogram, METH_VARARGS, "\n"
69064 : "Band_SetDefaultHistogram(Band self, double min, double max, int buckets_in) -> CPLErr\n"
69065 : "\n"
69066 : "\n"
69067 : "Set default histogram.\n"
69068 : "See :cpp:func:`GDALRasterBand::SetDefaultHistogram`.\n"
69069 : "\n"
69070 : "Parameters\n"
69071 : "----------\n"
69072 : "min : float\n"
69073 : " minimum value\n"
69074 : "max : float\n"
69075 : " maximum value\n"
69076 : "buckets_in : list\n"
69077 : " list of pixel counts for each bucket\n"
69078 : "\n"
69079 : "Returns\n"
69080 : "-------\n"
69081 : "int\n"
69082 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
69083 : "\n"
69084 : "See Also\n"
69085 : "--------\n"
69086 : ":py:meth:`SetHistogram`\n"
69087 : "\n"
69088 : ""},
69089 : { "Band_HasArbitraryOverviews", _wrap_Band_HasArbitraryOverviews, METH_O, "\n"
69090 : "Band_HasArbitraryOverviews(Band self) -> bool\n"
69091 : "\n"
69092 : "\n"
69093 : "Check for arbitrary overviews.\n"
69094 : "See :cpp:func:`GDALRasterBand::HasArbitraryOverviews`.\n"
69095 : "\n"
69096 : "Returns\n"
69097 : "-------\n"
69098 : "bool\n"
69099 : "\n"
69100 : ""},
69101 : { "Band_GetCategoryNames", _wrap_Band_GetCategoryNames, METH_O, "\n"
69102 : "Band_GetCategoryNames(Band self) -> char **\n"
69103 : "\n"
69104 : "\n"
69105 : "Fetch the list of category names for this raster.\n"
69106 : "See :cpp:func:`GDALRasterBand::GetCategoryNames`.\n"
69107 : "\n"
69108 : "Returns\n"
69109 : "-------\n"
69110 : "list\n"
69111 : " A list of category names, or ``None``\n"
69112 : "\n"
69113 : ""},
69114 : { "Band_SetCategoryNames", _wrap_Band_SetCategoryNames, METH_VARARGS, "\n"
69115 : "Band_SetCategoryNames(Band self, char ** papszCategoryNames) -> CPLErr\n"
69116 : "\n"
69117 : "\n"
69118 : "Set the category names for this band.\n"
69119 : "See :cpp:func:`GDALRasterBand::SetCategoryNames`.\n"
69120 : "\n"
69121 : "Parameters\n"
69122 : "----------\n"
69123 : "papszCategoryNames : list\n"
69124 : "\n"
69125 : "Returns\n"
69126 : "-------\n"
69127 : "int\n"
69128 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
69129 : "\n"
69130 : ""},
69131 : { "Band_GetVirtualMem", (PyCFunction)(void(*)(void))_wrap_Band_GetVirtualMem, METH_VARARGS|METH_KEYWORDS, "Band_GetVirtualMem(Band self, GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, int nBufXSize, int nBufYSize, GDALDataType eBufType, size_t nCacheSize, size_t nPageSizeHint, char ** options=None) -> VirtualMem"},
69132 : { "Band_GetVirtualMemAuto", (PyCFunction)(void(*)(void))_wrap_Band_GetVirtualMemAuto, METH_VARARGS|METH_KEYWORDS, "Band_GetVirtualMemAuto(Band self, GDALRWFlag eRWFlag, char ** options=None) -> VirtualMem"},
69133 : { "Band_GetTiledVirtualMem", (PyCFunction)(void(*)(void))_wrap_Band_GetTiledVirtualMem, METH_VARARGS|METH_KEYWORDS, "Band_GetTiledVirtualMem(Band self, GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, int nTileXSize, int nTileYSize, GDALDataType eBufType, size_t nCacheSize, char ** options=None) -> VirtualMem"},
69134 : { "Band_GetDataCoverageStatus", _wrap_Band_GetDataCoverageStatus, METH_VARARGS, "\n"
69135 : "Band_GetDataCoverageStatus(Band self, int nXOff, int nYOff, int nXSize, int nYSize, int nMaskFlagStop=0) -> int\n"
69136 : "\n"
69137 : "\n"
69138 : "Determine whether a sub-window of the Band contains only data, only empty blocks, or a mix of both.\n"
69139 : "See :cpp:func:`GDALRasterBand::GetDataCoverageStatus`.\n"
69140 : "\n"
69141 : "Parameters\n"
69142 : "----------\n"
69143 : "nXOff : int\n"
69144 : "nYOff : int\n"
69145 : "nXSize : int\n"
69146 : "nYSize : int\n"
69147 : "nMaskFlagStop : int, default=0\n"
69148 : "\n"
69149 : "Returns\n"
69150 : "-------\n"
69151 : "list\n"
69152 : " First value represents a bitwise-or value of the following constants\n"
69153 : " - :py:const:`gdalconst.GDAL_DATA_COVERAGE_STATUS_DATA`\n"
69154 : " - :py:const:`gdalconst.GDAL_DATA_COVERAGE_STATUS_EMPTY`\n"
69155 : " - :py:const:`gdalconst.GDAL_DATA_COVERAGE_STATUS_UNIMPLEMENTED`\n"
69156 : " Second value represents the approximate percentage in [0, 100] of pixels in the window that have valid values\n"
69157 : "\n"
69158 : "Examples\n"
69159 : "--------\n"
69160 : ">>> import numpy as np\n"
69161 : ">>> # Create a raster with four blocks\n"
69162 : ">>> ds = gdal.GetDriverByName('GTiff').Create('test.tif', 64, 64, options = {'SPARSE_OK':True, 'TILED':True, 'BLOCKXSIZE':32, 'BLOCKYSIZE':32})\n"
69163 : ">>> band = ds.GetRasterBand(1)\n"
69164 : ">>> # Write some data to upper-left block\n"
69165 : ">>> band.WriteArray(np.array([[1, 2], [3, 4]]))\n"
69166 : "0\n"
69167 : ">>> # Check status of upper-left block\n"
69168 : ">>> flags, pct = band.GetDataCoverageStatus(0, 0, 32, 32)\n"
69169 : ">>> flags == gdal.GDAL_DATA_COVERAGE_STATUS_DATA\n"
69170 : "True\n"
69171 : ">>> pct\n"
69172 : "100.0\n"
69173 : ">>> # Check status of upper-right block\n"
69174 : ">>> flags, pct = band.GetDataCoverageStatus(32, 0, 32, 32)\n"
69175 : ">>> flags == gdal.GDAL_DATA_COVERAGE_STATUS_EMPTY\n"
69176 : "True\n"
69177 : ">>> pct\n"
69178 : "0.0\n"
69179 : ">>> # Check status of window touching all four blocks\n"
69180 : ">>> flags, pct = band.GetDataCoverageStatus(16, 16, 32, 32)\n"
69181 : ">>> flags == gdal.GDAL_DATA_COVERAGE_STATUS_DATA | gdal.GDAL_DATA_COVERAGE_STATUS_EMPTY\n"
69182 : "True\n"
69183 : ">>> pct\n"
69184 : "25.0\n"
69185 : "\n"
69186 : ""},
69187 : { "Band_AdviseRead", _wrap_Band_AdviseRead, METH_VARARGS, "Band_AdviseRead(Band self, int xoff, int yoff, int xsize, int ysize, int * buf_xsize=None, int * buf_ysize=None, GDALDataType * buf_type=None, char ** options=None) -> CPLErr"},
69188 : { "Band_InterpolateAtPoint", _wrap_Band_InterpolateAtPoint, METH_VARARGS, "Band_InterpolateAtPoint(Band self, double pixel, double line, GDALRIOResampleAlg interpolation) -> CPLErr"},
69189 : { "Band_InterpolateAtGeolocation", _wrap_Band_InterpolateAtGeolocation, METH_VARARGS, "Band_InterpolateAtGeolocation(Band self, double geolocX, double geolocY, SpatialReference srs, GDALRIOResampleAlg interpolation, char ** transformerOptions=None) -> CPLErr"},
69190 : { "Band_ComputeMinMaxLocation", _wrap_Band_ComputeMinMaxLocation, METH_O, "Band_ComputeMinMaxLocation(Band self) -> CPLErr"},
69191 : { "Band_AsMDArray", _wrap_Band_AsMDArray, METH_O, "Band_AsMDArray(Band self) -> MDArray"},
69192 : { "Band__EnablePixelTypeSignedByteWarning", _wrap_Band__EnablePixelTypeSignedByteWarning, METH_VARARGS, "Band__EnablePixelTypeSignedByteWarning(Band self, bool b)"},
69193 : { "Band_UnaryOp", _wrap_Band_UnaryOp, METH_VARARGS, "Band_UnaryOp(Band self, GDALRasterAlgebraUnaryOperation op) -> ComputedBand"},
69194 : { "Band_BinaryOpBand", _wrap_Band_BinaryOpBand, METH_VARARGS, "Band_BinaryOpBand(Band self, GDALRasterAlgebraBinaryOperation op, Band other) -> ComputedBand"},
69195 : { "Band_BinaryOpDouble", _wrap_Band_BinaryOpDouble, METH_VARARGS, "Band_BinaryOpDouble(Band self, GDALRasterAlgebraBinaryOperation op, double constant) -> ComputedBand"},
69196 : { "Band_BinaryOpDoubleToBand", _wrap_Band_BinaryOpDoubleToBand, METH_VARARGS, "Band_BinaryOpDoubleToBand(double constant, GDALRasterAlgebraBinaryOperation op, Band band) -> ComputedBand"},
69197 : { "Band_IfThenElse", _wrap_Band_IfThenElse, METH_VARARGS, "Band_IfThenElse(Band condBand, Band thenBand, Band elseBand) -> ComputedBand"},
69198 : { "Band_AsType", _wrap_Band_AsType, METH_VARARGS, "Band_AsType(Band self, GDALDataType dt) -> ComputedBand"},
69199 : { "Band_MaximumOfNBands", _wrap_Band_MaximumOfNBands, METH_O, "Band_MaximumOfNBands(int band_count) -> ComputedBand"},
69200 : { "Band_MaxConstant", _wrap_Band_MaxConstant, METH_VARARGS, "Band_MaxConstant(Band self, double constant) -> ComputedBand"},
69201 : { "Band_MinimumOfNBands", _wrap_Band_MinimumOfNBands, METH_O, "Band_MinimumOfNBands(int band_count) -> ComputedBand"},
69202 : { "Band_MinConstant", _wrap_Band_MinConstant, METH_VARARGS, "Band_MinConstant(Band self, double constant) -> ComputedBand"},
69203 : { "Band_MeanOfNBands", _wrap_Band_MeanOfNBands, METH_O, "Band_MeanOfNBands(int band_count) -> ComputedBand"},
69204 : { "Band_ReadRaster1", (PyCFunction)(void(*)(void))_wrap_Band_ReadRaster1, METH_VARARGS|METH_KEYWORDS, "Band_ReadRaster1(Band self, double xoff, double yoff, double xsize, double ysize, int * buf_xsize=None, int * buf_ysize=None, GDALDataType * buf_type=None, GIntBig * buf_pixel_space=None, GIntBig * buf_line_space=None, GDALRIOResampleAlg resample_alg=GRIORA_NearestNeighbour, GDALProgressFunc callback=0, void * callback_data=None, void * inputOutputBuf=None) -> CPLErr"},
69205 : { "Band_ReadBlock", (PyCFunction)(void(*)(void))_wrap_Band_ReadBlock, METH_VARARGS|METH_KEYWORDS, "Band_ReadBlock(Band self, int xoff, int yoff, void * buf_obj=None) -> CPLErr"},
69206 : { "Band_swigregister", Band_swigregister, METH_O, NULL},
69207 : { "delete_ComputedBand", _wrap_delete_ComputedBand, METH_O, "delete_ComputedBand(ComputedBand self)"},
69208 : { "ComputedBand_swigregister", ComputedBand_swigregister, METH_O, NULL},
69209 : { "new_ColorTable", (PyCFunction)(void(*)(void))_wrap_new_ColorTable, METH_VARARGS|METH_KEYWORDS, "new_ColorTable(GDALPaletteInterp palette=GPI_RGB) -> ColorTable"},
69210 : { "delete_ColorTable", _wrap_delete_ColorTable, METH_O, "delete_ColorTable(ColorTable self)"},
69211 : { "ColorTable_Clone", _wrap_ColorTable_Clone, METH_O, "ColorTable_Clone(ColorTable self) -> ColorTable"},
69212 : { "ColorTable_GetPaletteInterpretation", _wrap_ColorTable_GetPaletteInterpretation, METH_O, "ColorTable_GetPaletteInterpretation(ColorTable self) -> GDALPaletteInterp"},
69213 : { "ColorTable_GetCount", _wrap_ColorTable_GetCount, METH_O, "ColorTable_GetCount(ColorTable self) -> int"},
69214 : { "ColorTable_GetColorEntry", _wrap_ColorTable_GetColorEntry, METH_VARARGS, "ColorTable_GetColorEntry(ColorTable self, int entry) -> ColorEntry"},
69215 : { "ColorTable_GetColorEntryAsRGB", _wrap_ColorTable_GetColorEntryAsRGB, METH_VARARGS, "ColorTable_GetColorEntryAsRGB(ColorTable self, int entry, ColorEntry centry) -> int"},
69216 : { "ColorTable_SetColorEntry", _wrap_ColorTable_SetColorEntry, METH_VARARGS, "ColorTable_SetColorEntry(ColorTable self, int entry, ColorEntry centry)"},
69217 : { "ColorTable_CreateColorRamp", _wrap_ColorTable_CreateColorRamp, METH_VARARGS, "ColorTable_CreateColorRamp(ColorTable self, int nStartIndex, ColorEntry startcolor, int nEndIndex, ColorEntry endcolor)"},
69218 : { "ColorTable_swigregister", ColorTable_swigregister, METH_O, NULL},
69219 : { "ColorTable_swiginit", ColorTable_swiginit, METH_VARARGS, NULL},
69220 : { "delete_SubdatasetInfo", _wrap_delete_SubdatasetInfo, METH_O, "delete_SubdatasetInfo(SubdatasetInfo self)"},
69221 : { "SubdatasetInfo_GetPathComponent", _wrap_SubdatasetInfo_GetPathComponent, METH_O, "SubdatasetInfo_GetPathComponent(SubdatasetInfo self) -> retStringAndCPLFree *"},
69222 : { "SubdatasetInfo_GetSubdatasetComponent", _wrap_SubdatasetInfo_GetSubdatasetComponent, METH_O, "SubdatasetInfo_GetSubdatasetComponent(SubdatasetInfo self) -> retStringAndCPLFree *"},
69223 : { "SubdatasetInfo_ModifyPathComponent", _wrap_SubdatasetInfo_ModifyPathComponent, METH_VARARGS, "SubdatasetInfo_ModifyPathComponent(SubdatasetInfo self, char const * pszNewFileName) -> retStringAndCPLFree *"},
69224 : { "SubdatasetInfo_swigregister", SubdatasetInfo_swigregister, METH_O, NULL},
69225 : { "GetSubdatasetInfo", _wrap_GetSubdatasetInfo, METH_O, "GetSubdatasetInfo(char const * pszFileName) -> GDALSubdatasetInfoShadow *"},
69226 : { "new_Relationship", _wrap_new_Relationship, METH_VARARGS, "new_Relationship(char const * name, char const * leftTableName, char const * rightTableName, GDALRelationshipCardinality cardinality) -> Relationship"},
69227 : { "delete_Relationship", _wrap_delete_Relationship, METH_O, "delete_Relationship(Relationship self)"},
69228 : { "Relationship_GetName", _wrap_Relationship_GetName, METH_O, "Relationship_GetName(Relationship self) -> char const *"},
69229 : { "Relationship_GetCardinality", _wrap_Relationship_GetCardinality, METH_O, "Relationship_GetCardinality(Relationship self) -> GDALRelationshipCardinality"},
69230 : { "Relationship_GetLeftTableName", _wrap_Relationship_GetLeftTableName, METH_O, "Relationship_GetLeftTableName(Relationship self) -> char const *"},
69231 : { "Relationship_GetRightTableName", _wrap_Relationship_GetRightTableName, METH_O, "Relationship_GetRightTableName(Relationship self) -> char const *"},
69232 : { "Relationship_GetMappingTableName", _wrap_Relationship_GetMappingTableName, METH_O, "Relationship_GetMappingTableName(Relationship self) -> char const *"},
69233 : { "Relationship_SetMappingTableName", _wrap_Relationship_SetMappingTableName, METH_VARARGS, "Relationship_SetMappingTableName(Relationship self, char const * pszName)"},
69234 : { "Relationship_GetLeftTableFields", _wrap_Relationship_GetLeftTableFields, METH_O, "Relationship_GetLeftTableFields(Relationship self) -> char **"},
69235 : { "Relationship_GetRightTableFields", _wrap_Relationship_GetRightTableFields, METH_O, "Relationship_GetRightTableFields(Relationship self) -> char **"},
69236 : { "Relationship_SetLeftTableFields", _wrap_Relationship_SetLeftTableFields, METH_VARARGS, "Relationship_SetLeftTableFields(Relationship self, char ** pFields)"},
69237 : { "Relationship_SetRightTableFields", _wrap_Relationship_SetRightTableFields, METH_VARARGS, "Relationship_SetRightTableFields(Relationship self, char ** pFields)"},
69238 : { "Relationship_GetLeftMappingTableFields", _wrap_Relationship_GetLeftMappingTableFields, METH_O, "Relationship_GetLeftMappingTableFields(Relationship self) -> char **"},
69239 : { "Relationship_GetRightMappingTableFields", _wrap_Relationship_GetRightMappingTableFields, METH_O, "Relationship_GetRightMappingTableFields(Relationship self) -> char **"},
69240 : { "Relationship_SetLeftMappingTableFields", _wrap_Relationship_SetLeftMappingTableFields, METH_VARARGS, "Relationship_SetLeftMappingTableFields(Relationship self, char ** pFields)"},
69241 : { "Relationship_SetRightMappingTableFields", _wrap_Relationship_SetRightMappingTableFields, METH_VARARGS, "Relationship_SetRightMappingTableFields(Relationship self, char ** pFields)"},
69242 : { "Relationship_GetType", _wrap_Relationship_GetType, METH_O, "Relationship_GetType(Relationship self) -> GDALRelationshipType"},
69243 : { "Relationship_SetType", _wrap_Relationship_SetType, METH_VARARGS, "Relationship_SetType(Relationship self, GDALRelationshipType type)"},
69244 : { "Relationship_GetForwardPathLabel", _wrap_Relationship_GetForwardPathLabel, METH_O, "Relationship_GetForwardPathLabel(Relationship self) -> char const *"},
69245 : { "Relationship_SetForwardPathLabel", _wrap_Relationship_SetForwardPathLabel, METH_VARARGS, "Relationship_SetForwardPathLabel(Relationship self, char const * pszLabel)"},
69246 : { "Relationship_GetBackwardPathLabel", _wrap_Relationship_GetBackwardPathLabel, METH_O, "Relationship_GetBackwardPathLabel(Relationship self) -> char const *"},
69247 : { "Relationship_SetBackwardPathLabel", _wrap_Relationship_SetBackwardPathLabel, METH_VARARGS, "Relationship_SetBackwardPathLabel(Relationship self, char const * pszLabel)"},
69248 : { "Relationship_GetRelatedTableType", _wrap_Relationship_GetRelatedTableType, METH_O, "Relationship_GetRelatedTableType(Relationship self) -> char const *"},
69249 : { "Relationship_SetRelatedTableType", _wrap_Relationship_SetRelatedTableType, METH_VARARGS, "Relationship_SetRelatedTableType(Relationship self, char const * pszType)"},
69250 : { "Relationship_swigregister", Relationship_swigregister, METH_O, NULL},
69251 : { "Relationship_swiginit", Relationship_swiginit, METH_VARARGS, NULL},
69252 : { "TermProgress_nocb", (PyCFunction)(void(*)(void))_wrap_TermProgress_nocb, METH_VARARGS|METH_KEYWORDS, "TermProgress_nocb(double dfProgress, char const * pszMessage=None, void * pData=None) -> int"},
69253 : { "ComputeMedianCutPCT", (PyCFunction)(void(*)(void))_wrap_ComputeMedianCutPCT, METH_VARARGS|METH_KEYWORDS, "ComputeMedianCutPCT(Band red, Band green, Band blue, int num_colors, ColorTable colors, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
69254 : { "DitherRGB2PCT", (PyCFunction)(void(*)(void))_wrap_DitherRGB2PCT, METH_VARARGS|METH_KEYWORDS, "DitherRGB2PCT(Band red, Band green, Band blue, Band target, ColorTable colors, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
69255 : { "ReprojectImage", (PyCFunction)(void(*)(void))_wrap_ReprojectImage, METH_VARARGS|METH_KEYWORDS, "\n"
69256 : "ReprojectImage(Dataset src_ds, Dataset dst_ds, char const * src_wkt=None, char const * dst_wkt=None, GDALResampleAlg eResampleAlg=GRA_NearestNeighbour, double WarpMemoryLimit=0.0, double maxerror=0.0, GDALProgressFunc callback=0, void * callback_data=None, char ** options=None) -> CPLErr\n"
69257 : "\n"
69258 : "\n"
69259 : "Reproject image.\n"
69260 : "\n"
69261 : "See :cpp:func:`GDALReprojectImage`.\n"
69262 : "\n"
69263 : "Consider using :py:func:`osgeo.gdal.Warp` and :py:func:`osgeo.gdal.WarpOptions` instead\n"
69264 : "\n"
69265 : ""},
69266 : { "ComputeProximity", (PyCFunction)(void(*)(void))_wrap_ComputeProximity, METH_VARARGS|METH_KEYWORDS, "ComputeProximity(Band srcBand, Band proximityBand, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
69267 : { "RasterizeLayer", (PyCFunction)(void(*)(void))_wrap_RasterizeLayer, METH_VARARGS|METH_KEYWORDS, "RasterizeLayer(Dataset dataset, int bands, Layer layer, void * pfnTransformer=None, void * pTransformArg=None, int burn_values=0, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
69268 : { "Polygonize", (PyCFunction)(void(*)(void))_wrap_Polygonize, METH_VARARGS|METH_KEYWORDS, "Polygonize(Band srcBand, Band maskBand, Layer outLayer, int iPixValField, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
69269 : { "FPolygonize", (PyCFunction)(void(*)(void))_wrap_FPolygonize, METH_VARARGS|METH_KEYWORDS, "FPolygonize(Band srcBand, Band maskBand, Layer outLayer, int iPixValField, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
69270 : { "FillNodata", (PyCFunction)(void(*)(void))_wrap_FillNodata, METH_VARARGS|METH_KEYWORDS, "\n"
69271 : "FillNodata(Band targetBand, Band maskBand, double maxSearchDist, int smoothingIterations, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int\n"
69272 : "\n"
69273 : "\n"
69274 : "Fill selected raster regions by interpolation from the edges.\n"
69275 : "\n"
69276 : "This algorithm will interpolate values for all designated\n"
69277 : "nodata pixels (marked by zeros in ``maskBand``). For each pixel\n"
69278 : "a four direction conic search is done to find values to interpolate\n"
69279 : "from (using inverse distance weighting by default). Once all values are\n"
69280 : "interpolated, zero or more smoothing iterations (3x3 average\n"
69281 : "filters on interpolated pixels) are applied to smooth out\n"
69282 : "artifacts.\n"
69283 : "\n"
69284 : "This algorithm is generally suitable for interpolating missing\n"
69285 : "regions of fairly continuously varying rasters (such as elevation\n"
69286 : "models for instance). It is also suitable for filling small holes\n"
69287 : "and cracks in more irregularly varying images (like airphotos). It\n"
69288 : "is generally not so great for interpolating a raster from sparse\n"
69289 : "point data. See :py:func:`Grid` for that case.\n"
69290 : "\n"
69291 : "See :cpp:func:`GDALFillNodata`.\n"
69292 : "\n"
69293 : "Parameters\n"
69294 : "----------\n"
69295 : "targetBand : Band\n"
69296 : " Band containing values to fill. Will be modified in-place.\n"
69297 : "maskBand : Band\n"
69298 : " Mask band with a value of 0 indicating values that should be filled.\n"
69299 : " If not specified, the mask band associated with ``targetBand`` will be used.\n"
69300 : "maxSearchDist : float\n"
69301 : " the maximum number of pixels to search in all directions to find values to interpolate from.\n"
69302 : "smoothingIterations : int\n"
69303 : " the number of 3x3 smoothing filter passes to run (0 or more)\n"
69304 : "options : dict or list, optional\n"
69305 : " A dict or list of name=value options. Available options are\n"
69306 : " described in :cpp:func:`GDALFillNodata`.\n"
69307 : "callback : callable, optional\n"
69308 : " A progress callback function\n"
69309 : "callback_data : any, optional\n"
69310 : " Optional data to be passed to callback function\n"
69311 : "\n"
69312 : "Returns\n"
69313 : "-------\n"
69314 : "int\n"
69315 : " :py:const:`CE_None` on success or :py:const:`CE_Failure` on failure.\n"
69316 : "\n"
69317 : "Examples\n"
69318 : "--------\n"
69319 : ">>> import numpy as np\n"
69320 : ">>> data = np.array([[1, 2], [9, 9], [9, 9], [3, 4]], dtype=np.float32)\n"
69321 : ">>> ds = gdal.GetDriverByName('MEM').Create('', 2, 4, eType=gdal.GDT_Float32)\n"
69322 : ">>> ds.WriteArray(data)\n"
69323 : "0\n"
69324 : ">>> mask = data != 9 # replace pixels with value = 9\n"
69325 : ">>> mask_ds = gdal.GetDriverByName('MEM').Create('', 2, 4, eType=gdal.GDT_Byte)\n"
69326 : ">>> mask_ds.WriteArray(mask)\n"
69327 : "0\n"
69328 : ">>> gdal.FillNodata(ds.GetRasterBand(1), mask_ds.GetRasterBand(1), 5, 0)\n"
69329 : "0\n"
69330 : ">>> ds.ReadAsArray()\n"
69331 : "array([[1. , 2. ],\n"
69332 : " [2.1485982, 2.6666667],\n"
69333 : " [2.721169 , 3.3333333],\n"
69334 : " [3. , 4. ]], dtype=float32)\n"
69335 : ">>> gdal.FillNodata(ds.GetRasterBand(1), mask_ds.GetRasterBand(1), 5, 0, {'INTERPOLATION':'NEAREST'})\n"
69336 : "0\n"
69337 : ">>> ds.ReadAsArray()\n"
69338 : "array([[1., 2.],\n"
69339 : " [1., 2.],\n"
69340 : " [3., 4.],\n"
69341 : " [3., 4.]], dtype=float32)\n"
69342 : "\n"
69343 : "\n"
69344 : ""},
69345 : { "SieveFilter", (PyCFunction)(void(*)(void))_wrap_SieveFilter, METH_VARARGS|METH_KEYWORDS, "SieveFilter(Band srcBand, Band maskBand, Band dstBand, int threshold, int connectedness=4, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
69346 : { "RegenerateOverviews", (PyCFunction)(void(*)(void))_wrap_RegenerateOverviews, METH_VARARGS|METH_KEYWORDS, "RegenerateOverviews(Band srcBand, int overviewBandCount, char const * resampling=\"average\", GDALProgressFunc callback=0, void * callback_data=None) -> int"},
69347 : { "RegenerateOverview", (PyCFunction)(void(*)(void))_wrap_RegenerateOverview, METH_VARARGS|METH_KEYWORDS, "RegenerateOverview(Band srcBand, Band overviewBand, char const * resampling=\"average\", GDALProgressFunc callback=0, void * callback_data=None) -> int"},
69348 : { "ContourGenerate", (PyCFunction)(void(*)(void))_wrap_ContourGenerate, METH_VARARGS|METH_KEYWORDS, "ContourGenerate(Band srcBand, double contourInterval, double contourBase, int fixedLevelCount, int useNoData, double noDataValue, Layer dstLayer, int idField, int elevField, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
69349 : { "ContourGenerateEx", (PyCFunction)(void(*)(void))_wrap_ContourGenerateEx, METH_VARARGS|METH_KEYWORDS, "ContourGenerateEx(Band srcBand, Layer dstLayer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
69350 : { "ViewshedGenerate", (PyCFunction)(void(*)(void))_wrap_ViewshedGenerate, METH_VARARGS|METH_KEYWORDS, "ViewshedGenerate(Band srcBand, char const * driverName, char const * targetRasterName, char ** creationOptions, double observerX, double observerY, double observerHeight, double targetHeight, double visibleVal, double invisibleVal, double outOfRangeVal, double noDataVal, double dfCurvCoeff, GDALViewshedMode mode, double maxDistance, GDALProgressFunc callback=0, void * callback_data=None, GDALViewshedOutputType heightMode=GVOT_NORMAL, char ** options=None) -> Dataset"},
69351 : { "IsLineOfSightVisible", (PyCFunction)(void(*)(void))_wrap_IsLineOfSightVisible, METH_VARARGS|METH_KEYWORDS, "\n"
69352 : "IsLineOfSightVisible(Band band, int xA, int yA, double zA, int xB, int yB, double zB, char ** options=None)\n"
69353 : "\n"
69354 : "\n"
69355 : "Check Line of Sight between two points.\n"
69356 : "Both input coordinates must be within the raster coordinate bounds.\n"
69357 : "\n"
69358 : " See :cpp:func:`GDALIsLineOfSightVisible`.\n"
69359 : "\n"
69360 : ".. versionadded:: 3.9\n"
69361 : "\n"
69362 : "Parameters\n"
69363 : "----------\n"
69364 : "band : Band\n"
69365 : " The band to read the DEM data from. This must NOT be null.\n"
69366 : "xA : int\n"
69367 : " The X location (raster column) of the first point to check on the raster.\n"
69368 : "yA : int\n"
69369 : " The Y location (raster row) of the first point to check on the raster.\n"
69370 : "zA : float\n"
69371 : " The Z location (height) of the first point to check.\n"
69372 : "xB : int\n"
69373 : " The X location (raster column) of the second point to check on the raster.\n"
69374 : "yB : int\n"
69375 : " The Y location (raster row) of the second point to check on the raster.\n"
69376 : "zB : float\n"
69377 : " The Z location (height) of the second point to check.\n"
69378 : "options : dict or list, optional\n"
69379 : " A dict or list of name=value of options for the line of sight algorithm (currently ignored).\n"
69380 : "\n"
69381 : "Returns\n"
69382 : "-------\n"
69383 : "tuple\n"
69384 : " A named tuple with the following fields:\n"
69385 : "\n"
69386 : " - ``is_visible`` (bool): True if the two points are within Line of Sight.\n"
69387 : " - ``col_intersection`` (int): Raster column index where the LOS line intersects terrain.\n"
69388 : " Will be set in the future; currently -1.\n"
69389 : " - ``row_intersection`` (int): Raster row index where the LOS line intersects terrain.\n"
69390 : " Will be set in the future; currently -1.\n"
69391 : "\n"
69392 : ""},
69393 : { "AutoCreateWarpedVRT", _wrap_AutoCreateWarpedVRT, METH_VARARGS, "AutoCreateWarpedVRT(Dataset src_ds, char const * src_wkt=None, char const * dst_wkt=None, GDALResampleAlg eResampleAlg=GRA_NearestNeighbour, double maxerror=0.0) -> Dataset"},
69394 : { "CreatePansharpenedVRT", _wrap_CreatePansharpenedVRT, METH_VARARGS, "CreatePansharpenedVRT(char const * pszXML, Band panchroBand, int nInputSpectralBands) -> Dataset"},
69395 : { "GetTranformerOptionList", _wrap_GetTranformerOptionList, METH_NOARGS, "GetTranformerOptionList() -> char const *"},
69396 : { "delete_GDALTransformerInfoShadow", _wrap_delete_GDALTransformerInfoShadow, METH_O, "delete_GDALTransformerInfoShadow(GDALTransformerInfoShadow self)"},
69397 : { "GDALTransformerInfoShadow_TransformPoint", _wrap_GDALTransformerInfoShadow_TransformPoint, METH_VARARGS, "\n"
69398 : "GDALTransformerInfoShadow_TransformPoint(GDALTransformerInfoShadow self, int bDstToSrc, double [3] inout) -> int\n"
69399 : "GDALTransformerInfoShadow_TransformPoint(GDALTransformerInfoShadow self, int bDstToSrc, double x, double y, double z=0.0) -> int\n"
69400 : ""},
69401 : { "GDALTransformerInfoShadow_TransformPoints", _wrap_GDALTransformerInfoShadow_TransformPoints, METH_VARARGS, "GDALTransformerInfoShadow_TransformPoints(GDALTransformerInfoShadow self, int bDstToSrc, int nCount) -> int"},
69402 : { "GDALTransformerInfoShadow_TransformGeolocations", (PyCFunction)(void(*)(void))_wrap_GDALTransformerInfoShadow_TransformGeolocations, METH_VARARGS|METH_KEYWORDS, "GDALTransformerInfoShadow_TransformGeolocations(GDALTransformerInfoShadow self, Band xBand, Band yBand, Band zBand, GDALProgressFunc callback=0, void * callback_data=None, char ** options=None) -> int"},
69403 : { "GDALTransformerInfoShadow_swigregister", GDALTransformerInfoShadow_swigregister, METH_O, NULL},
69404 : { "Transformer", _wrap_Transformer, METH_VARARGS, "Transformer(Dataset src, Dataset dst, char ** options) -> GDALTransformerInfoShadow"},
69405 : { "WarpGetOptionList", _wrap_WarpGetOptionList, METH_NOARGS, "WarpGetOptionList() -> char const *"},
69406 : { "SuggestedWarpOutputRes_width_get", _wrap_SuggestedWarpOutputRes_width_get, METH_O, "SuggestedWarpOutputRes_width_get(SuggestedWarpOutputRes self) -> int"},
69407 : { "SuggestedWarpOutputRes_height_get", _wrap_SuggestedWarpOutputRes_height_get, METH_O, "SuggestedWarpOutputRes_height_get(SuggestedWarpOutputRes self) -> int"},
69408 : { "SuggestedWarpOutputRes_xmin_get", _wrap_SuggestedWarpOutputRes_xmin_get, METH_O, "SuggestedWarpOutputRes_xmin_get(SuggestedWarpOutputRes self) -> double"},
69409 : { "SuggestedWarpOutputRes_ymin_get", _wrap_SuggestedWarpOutputRes_ymin_get, METH_O, "SuggestedWarpOutputRes_ymin_get(SuggestedWarpOutputRes self) -> double"},
69410 : { "SuggestedWarpOutputRes_xmax_get", _wrap_SuggestedWarpOutputRes_xmax_get, METH_O, "SuggestedWarpOutputRes_xmax_get(SuggestedWarpOutputRes self) -> double"},
69411 : { "SuggestedWarpOutputRes_ymax_get", _wrap_SuggestedWarpOutputRes_ymax_get, METH_O, "SuggestedWarpOutputRes_ymax_get(SuggestedWarpOutputRes self) -> double"},
69412 : { "delete_SuggestedWarpOutputRes", _wrap_delete_SuggestedWarpOutputRes, METH_O, "delete_SuggestedWarpOutputRes(SuggestedWarpOutputRes self)"},
69413 : { "SuggestedWarpOutputRes_GetGeotransform", _wrap_SuggestedWarpOutputRes_GetGeotransform, METH_O, "SuggestedWarpOutputRes_GetGeotransform(SuggestedWarpOutputRes self)"},
69414 : { "SuggestedWarpOutputRes_swigregister", SuggestedWarpOutputRes_swigregister, METH_O, NULL},
69415 : { "SuggestedWarpOutputFromTransformer", _wrap_SuggestedWarpOutputFromTransformer, METH_VARARGS, "SuggestedWarpOutputFromTransformer(Dataset src, GDALTransformerInfoShadow transformer) -> SuggestedWarpOutputRes"},
69416 : { "SuggestedWarpOutputFromOptions", _wrap_SuggestedWarpOutputFromOptions, METH_VARARGS, "SuggestedWarpOutputFromOptions(Dataset src, char ** options) -> SuggestedWarpOutputRes"},
69417 : { "_ApplyVerticalShiftGrid", (PyCFunction)(void(*)(void))_wrap__ApplyVerticalShiftGrid, METH_VARARGS|METH_KEYWORDS, "_ApplyVerticalShiftGrid(Dataset src_ds, Dataset grid_ds, bool inverse=False, double srcUnitToMeter=1.0, double dstUnitToMeter=1.0, char ** options=None) -> Dataset"},
69418 : { "GetGlobalAlgorithmRegistry", _wrap_GetGlobalAlgorithmRegistry, METH_NOARGS, "\n"
69419 : "GetGlobalAlgorithmRegistry() -> AlgorithmRegistry\n"
69420 : "\n"
69421 : "\n"
69422 : "Return the default algorithm registry.\n"
69423 : "\n"
69424 : "Returns\n"
69425 : "-------\n"
69426 : "AlgorithmRegistry\n"
69427 : "\n"
69428 : "\n"
69429 : ""},
69430 : { "AlgorithmArgTypeIsList", _wrap_AlgorithmArgTypeIsList, METH_O, "\n"
69431 : "AlgorithmArgTypeIsList(GDALAlgorithmArgType type) -> bool\n"
69432 : "\n"
69433 : "\n"
69434 : "Test whether an argument type represents a list.\n"
69435 : "\n"
69436 : "Parameters\n"
69437 : "----------\n"
69438 : "type : int\n"
69439 : "\n"
69440 : "Returns\n"
69441 : "-------\n"
69442 : "bool\n"
69443 : "\n"
69444 : "Examples\n"
69445 : "--------\n"
69446 : ">>> gdal.AlgorithmArgTypeIsList(gdal.GAAT_REAL)\n"
69447 : "False\n"
69448 : ">>> gdal.AlgorithmArgTypeIsList(gdal.GAAT_REAL_LIST)\n"
69449 : "True\n"
69450 : "\n"
69451 : "\n"
69452 : ""},
69453 : { "AlgorithmArgTypeName", _wrap_AlgorithmArgTypeName, METH_O, "\n"
69454 : "AlgorithmArgTypeName(GDALAlgorithmArgType type) -> char const *\n"
69455 : "\n"
69456 : "\n"
69457 : "Return a text representation of an argument type code.\n"
69458 : "\n"
69459 : "Parameters\n"
69460 : "----------\n"
69461 : "type : int\n"
69462 : "\n"
69463 : "Returns\n"
69464 : "-------\n"
69465 : "str\n"
69466 : "\n"
69467 : "Examples\n"
69468 : "--------\n"
69469 : ">>> gdal.AlgorithmArgTypeName(gdal.GAAT_REAL)\n"
69470 : "'real'\n"
69471 : "\n"
69472 : "\n"
69473 : ""},
69474 : { "delete_AlgorithmArg", _wrap_delete_AlgorithmArg, METH_O, "delete_AlgorithmArg(AlgorithmArg self)"},
69475 : { "AlgorithmArg_GetName", _wrap_AlgorithmArg_GetName, METH_O, "AlgorithmArg_GetName(AlgorithmArg self) -> char const *"},
69476 : { "AlgorithmArg_GetType", _wrap_AlgorithmArg_GetType, METH_O, "AlgorithmArg_GetType(AlgorithmArg self) -> GDALAlgorithmArgType"},
69477 : { "AlgorithmArg_GetDescription", _wrap_AlgorithmArg_GetDescription, METH_O, "AlgorithmArg_GetDescription(AlgorithmArg self) -> char const *"},
69478 : { "AlgorithmArg_GetShortName", _wrap_AlgorithmArg_GetShortName, METH_O, "AlgorithmArg_GetShortName(AlgorithmArg self) -> char const *"},
69479 : { "AlgorithmArg_GetAliases", _wrap_AlgorithmArg_GetAliases, METH_O, "AlgorithmArg_GetAliases(AlgorithmArg self) -> char **"},
69480 : { "AlgorithmArg_GetMetaVar", _wrap_AlgorithmArg_GetMetaVar, METH_O, "AlgorithmArg_GetMetaVar(AlgorithmArg self) -> char const *"},
69481 : { "AlgorithmArg_GetCategory", _wrap_AlgorithmArg_GetCategory, METH_O, "AlgorithmArg_GetCategory(AlgorithmArg self) -> char const *"},
69482 : { "AlgorithmArg_IsPositional", _wrap_AlgorithmArg_IsPositional, METH_O, "AlgorithmArg_IsPositional(AlgorithmArg self) -> bool"},
69483 : { "AlgorithmArg_IsRequired", _wrap_AlgorithmArg_IsRequired, METH_O, "AlgorithmArg_IsRequired(AlgorithmArg self) -> bool"},
69484 : { "AlgorithmArg_GetMinCount", _wrap_AlgorithmArg_GetMinCount, METH_O, "AlgorithmArg_GetMinCount(AlgorithmArg self) -> int"},
69485 : { "AlgorithmArg_GetMaxCount", _wrap_AlgorithmArg_GetMaxCount, METH_O, "AlgorithmArg_GetMaxCount(AlgorithmArg self) -> int"},
69486 : { "AlgorithmArg_GetPackedValuesAllowed", _wrap_AlgorithmArg_GetPackedValuesAllowed, METH_O, "AlgorithmArg_GetPackedValuesAllowed(AlgorithmArg self) -> bool"},
69487 : { "AlgorithmArg_GetRepeatedArgAllowed", _wrap_AlgorithmArg_GetRepeatedArgAllowed, METH_O, "AlgorithmArg_GetRepeatedArgAllowed(AlgorithmArg self) -> bool"},
69488 : { "AlgorithmArg_GetChoices", _wrap_AlgorithmArg_GetChoices, METH_O, "AlgorithmArg_GetChoices(AlgorithmArg self) -> char **"},
69489 : { "AlgorithmArg_GetMetadataItem", _wrap_AlgorithmArg_GetMetadataItem, METH_VARARGS, "AlgorithmArg_GetMetadataItem(AlgorithmArg self, char const * item) -> char **"},
69490 : { "AlgorithmArg_IsExplicitlySet", _wrap_AlgorithmArg_IsExplicitlySet, METH_O, "AlgorithmArg_IsExplicitlySet(AlgorithmArg self) -> bool"},
69491 : { "AlgorithmArg_HasDefaultValue", _wrap_AlgorithmArg_HasDefaultValue, METH_O, "AlgorithmArg_HasDefaultValue(AlgorithmArg self) -> bool"},
69492 : { "AlgorithmArg_GetDefaultAsBoolean", _wrap_AlgorithmArg_GetDefaultAsBoolean, METH_O, "AlgorithmArg_GetDefaultAsBoolean(AlgorithmArg self) -> bool"},
69493 : { "AlgorithmArg_GetDefaultAsString", _wrap_AlgorithmArg_GetDefaultAsString, METH_O, "AlgorithmArg_GetDefaultAsString(AlgorithmArg self) -> char const *"},
69494 : { "AlgorithmArg_GetDefaultAsInteger", _wrap_AlgorithmArg_GetDefaultAsInteger, METH_O, "AlgorithmArg_GetDefaultAsInteger(AlgorithmArg self) -> int"},
69495 : { "AlgorithmArg_GetDefaultAsDouble", _wrap_AlgorithmArg_GetDefaultAsDouble, METH_O, "AlgorithmArg_GetDefaultAsDouble(AlgorithmArg self) -> double"},
69496 : { "AlgorithmArg_GetDefaultAsStringList", _wrap_AlgorithmArg_GetDefaultAsStringList, METH_O, "AlgorithmArg_GetDefaultAsStringList(AlgorithmArg self) -> char **"},
69497 : { "AlgorithmArg_GetDefaultAsIntegerList", _wrap_AlgorithmArg_GetDefaultAsIntegerList, METH_O, "AlgorithmArg_GetDefaultAsIntegerList(AlgorithmArg self)"},
69498 : { "AlgorithmArg_GetDefaultAsDoubleList", _wrap_AlgorithmArg_GetDefaultAsDoubleList, METH_O, "AlgorithmArg_GetDefaultAsDoubleList(AlgorithmArg self)"},
69499 : { "AlgorithmArg_IsHidden", _wrap_AlgorithmArg_IsHidden, METH_O, "AlgorithmArg_IsHidden(AlgorithmArg self) -> bool"},
69500 : { "AlgorithmArg_IsHiddenForCLI", _wrap_AlgorithmArg_IsHiddenForCLI, METH_O, "AlgorithmArg_IsHiddenForCLI(AlgorithmArg self) -> bool"},
69501 : { "AlgorithmArg_IsHiddenForAPI", _wrap_AlgorithmArg_IsHiddenForAPI, METH_O, "AlgorithmArg_IsHiddenForAPI(AlgorithmArg self) -> bool"},
69502 : { "AlgorithmArg_IsInput", _wrap_AlgorithmArg_IsInput, METH_O, "AlgorithmArg_IsInput(AlgorithmArg self) -> bool"},
69503 : { "AlgorithmArg_IsOutput", _wrap_AlgorithmArg_IsOutput, METH_O, "AlgorithmArg_IsOutput(AlgorithmArg self) -> bool"},
69504 : { "AlgorithmArg_GetDatasetType", _wrap_AlgorithmArg_GetDatasetType, METH_O, "AlgorithmArg_GetDatasetType(AlgorithmArg self) -> int"},
69505 : { "AlgorithmArg_GetDatasetInputFlags", _wrap_AlgorithmArg_GetDatasetInputFlags, METH_O, "AlgorithmArg_GetDatasetInputFlags(AlgorithmArg self) -> int"},
69506 : { "AlgorithmArg_GetDatasetOutputFlags", _wrap_AlgorithmArg_GetDatasetOutputFlags, METH_O, "AlgorithmArg_GetDatasetOutputFlags(AlgorithmArg self) -> int"},
69507 : { "AlgorithmArg_GetMutualExclusionGroup", _wrap_AlgorithmArg_GetMutualExclusionGroup, METH_O, "AlgorithmArg_GetMutualExclusionGroup(AlgorithmArg self) -> char const *"},
69508 : { "AlgorithmArg_GetAsBoolean", _wrap_AlgorithmArg_GetAsBoolean, METH_O, "AlgorithmArg_GetAsBoolean(AlgorithmArg self) -> bool"},
69509 : { "AlgorithmArg_GetAsString", _wrap_AlgorithmArg_GetAsString, METH_O, "AlgorithmArg_GetAsString(AlgorithmArg self) -> char const *"},
69510 : { "AlgorithmArg_GetAsInteger", _wrap_AlgorithmArg_GetAsInteger, METH_O, "AlgorithmArg_GetAsInteger(AlgorithmArg self) -> int"},
69511 : { "AlgorithmArg_GetAsDouble", _wrap_AlgorithmArg_GetAsDouble, METH_O, "AlgorithmArg_GetAsDouble(AlgorithmArg self) -> double"},
69512 : { "AlgorithmArg_GetAsDatasetValue", _wrap_AlgorithmArg_GetAsDatasetValue, METH_O, "AlgorithmArg_GetAsDatasetValue(AlgorithmArg self) -> ArgDatasetValue"},
69513 : { "AlgorithmArg_GetAsStringList", _wrap_AlgorithmArg_GetAsStringList, METH_O, "AlgorithmArg_GetAsStringList(AlgorithmArg self) -> char **"},
69514 : { "AlgorithmArg_GetAsIntegerList", _wrap_AlgorithmArg_GetAsIntegerList, METH_O, "AlgorithmArg_GetAsIntegerList(AlgorithmArg self)"},
69515 : { "AlgorithmArg_GetAsDoubleList", _wrap_AlgorithmArg_GetAsDoubleList, METH_O, "AlgorithmArg_GetAsDoubleList(AlgorithmArg self)"},
69516 : { "AlgorithmArg_SetAsBoolean", _wrap_AlgorithmArg_SetAsBoolean, METH_VARARGS, "AlgorithmArg_SetAsBoolean(AlgorithmArg self, bool value) -> bool"},
69517 : { "AlgorithmArg_SetAsString", _wrap_AlgorithmArg_SetAsString, METH_VARARGS, "AlgorithmArg_SetAsString(AlgorithmArg self, char const * value) -> bool"},
69518 : { "AlgorithmArg_SetAsInteger", _wrap_AlgorithmArg_SetAsInteger, METH_VARARGS, "AlgorithmArg_SetAsInteger(AlgorithmArg self, int value) -> bool"},
69519 : { "AlgorithmArg_SetAsDouble", _wrap_AlgorithmArg_SetAsDouble, METH_VARARGS, "AlgorithmArg_SetAsDouble(AlgorithmArg self, double value) -> bool"},
69520 : { "AlgorithmArg_SetAsDatasetValue", _wrap_AlgorithmArg_SetAsDatasetValue, METH_VARARGS, "AlgorithmArg_SetAsDatasetValue(AlgorithmArg self, ArgDatasetValue value) -> bool"},
69521 : { "AlgorithmArg_SetAsStringList", _wrap_AlgorithmArg_SetAsStringList, METH_VARARGS, "AlgorithmArg_SetAsStringList(AlgorithmArg self, char ** value) -> bool"},
69522 : { "AlgorithmArg_SetAsIntegerList", _wrap_AlgorithmArg_SetAsIntegerList, METH_VARARGS, "AlgorithmArg_SetAsIntegerList(AlgorithmArg self, int nList) -> bool"},
69523 : { "AlgorithmArg_SetAsDoubleList", _wrap_AlgorithmArg_SetAsDoubleList, METH_VARARGS, "AlgorithmArg_SetAsDoubleList(AlgorithmArg self, int nList) -> bool"},
69524 : { "AlgorithmArg_SetDataset", _wrap_AlgorithmArg_SetDataset, METH_VARARGS, "AlgorithmArg_SetDataset(AlgorithmArg self, Dataset ds) -> bool"},
69525 : { "AlgorithmArg_SetDatasets", _wrap_AlgorithmArg_SetDatasets, METH_VARARGS, "AlgorithmArg_SetDatasets(AlgorithmArg self, int object_list_count) -> bool"},
69526 : { "AlgorithmArg_SetDatasetNames", _wrap_AlgorithmArg_SetDatasetNames, METH_VARARGS, "AlgorithmArg_SetDatasetNames(AlgorithmArg self, char ** names) -> bool"},
69527 : { "AlgorithmArg_swigregister", AlgorithmArg_swigregister, METH_O, NULL},
69528 : { "delete_Algorithm", _wrap_delete_Algorithm, METH_O, "delete_Algorithm(Algorithm self)"},
69529 : { "Algorithm_GetName", _wrap_Algorithm_GetName, METH_O, "\n"
69530 : "Algorithm_GetName(Algorithm self) -> char const *\n"
69531 : "\n"
69532 : "\n"
69533 : "Get the name of the algorithm.\n"
69534 : "\n"
69535 : "Returns\n"
69536 : "-------\n"
69537 : "str\n"
69538 : "\n"
69539 : "Examples\n"
69540 : "--------\n"
69541 : ">>> gdal.Algorithm(\"raster\", \"info\").GetName()\n"
69542 : "'info'\n"
69543 : "\n"
69544 : "\n"
69545 : ""},
69546 : { "Algorithm_GetDescription", _wrap_Algorithm_GetDescription, METH_O, "\n"
69547 : "Algorithm_GetDescription(Algorithm self) -> char const *\n"
69548 : "\n"
69549 : "\n"
69550 : "Get a human-readable description of the Algorithm.\n"
69551 : "\n"
69552 : "Returns\n"
69553 : "-------\n"
69554 : "str\n"
69555 : "\n"
69556 : "Examples\n"
69557 : "--------\n"
69558 : ">>> alg = gdal.Algorithm(\"raster\", \"convert\")\n"
69559 : ">>> alg.GetDescription()\n"
69560 : "'Convert a raster dataset.'\n"
69561 : "\n"
69562 : "\n"
69563 : ""},
69564 : { "Algorithm_GetLongDescription", _wrap_Algorithm_GetLongDescription, METH_O, "\n"
69565 : "Algorithm_GetLongDescription(Algorithm self) -> char const *\n"
69566 : "\n"
69567 : "\n"
69568 : ":meta private:\n"
69569 : "\n"
69570 : "\n"
69571 : ""},
69572 : { "Algorithm_GetHelpFullURL", _wrap_Algorithm_GetHelpFullURL, METH_O, "\n"
69573 : "Algorithm_GetHelpFullURL(Algorithm self) -> char const *\n"
69574 : "\n"
69575 : "\n"
69576 : "Get a URL for the algorithm's documentation.\n"
69577 : "\n"
69578 : "Returns\n"
69579 : "-------\n"
69580 : "str\n"
69581 : "\n"
69582 : "Examples\n"
69583 : "--------\n"
69584 : ">>> alg = gdal.Algorithm(\"raster\", \"convert\")\n"
69585 : ">>> alg.GetHelpFullURL()\n"
69586 : "'https://gdal.org/programs/gdal_raster_convert.html'\n"
69587 : "\n"
69588 : "\n"
69589 : ""},
69590 : { "Algorithm_HasSubAlgorithms", _wrap_Algorithm_HasSubAlgorithms, METH_O, "\n"
69591 : "Algorithm_HasSubAlgorithms(Algorithm self) -> bool\n"
69592 : "\n"
69593 : "\n"
69594 : "Returns whether the algorithm has sub-algorithms.\n"
69595 : "\n"
69596 : "Returns\n"
69597 : "-------\n"
69598 : "bool\n"
69599 : "\n"
69600 : "Examples\n"
69601 : "--------\n"
69602 : ">>> alg = gdal.Algorithm(\"raster\")\n"
69603 : ">>> alg.HasSubAlgorithms()\n"
69604 : "True\n"
69605 : ">>> subalg = alg.InstantiateSubAlgorithm(\"convert\")\n"
69606 : ">>> subalg.HasSubAlgorithms()\n"
69607 : "False\n"
69608 : "\n"
69609 : "\n"
69610 : ""},
69611 : { "Algorithm_GetSubAlgorithmNames", _wrap_Algorithm_GetSubAlgorithmNames, METH_O, "\n"
69612 : "Algorithm_GetSubAlgorithmNames(Algorithm self) -> char **\n"
69613 : "\n"
69614 : "\n"
69615 : "Return a list of names of sub-algorithms.\n"
69616 : "\n"
69617 : "Returns\n"
69618 : "-------\n"
69619 : "list or None\n"
69620 : "\n"
69621 : "Examples\n"
69622 : "--------\n"
69623 : ">>> alg = gdal.Algorithm(\"raster\")\n"
69624 : ">>> alg.GetSubAlgorithmNames()\n"
69625 : "['as-features', 'aspect', ..., 'viewshed', 'zonal-stats']\n"
69626 : "\n"
69627 : "\n"
69628 : ""},
69629 : { "Algorithm_InstantiateSubAlgorithm", _wrap_Algorithm_InstantiateSubAlgorithm, METH_VARARGS, "\n"
69630 : "Algorithm_InstantiateSubAlgorithm(Algorithm self, char const * algName) -> Algorithm\n"
69631 : "\n"
69632 : "\n"
69633 : "Instantiate a sub-algorithm if available.\n"
69634 : "\n"
69635 : "Returns\n"
69636 : "-------\n"
69637 : "Algorithm or None\n"
69638 : "\n"
69639 : "Examples\n"
69640 : "--------\n"
69641 : ">>> alg = gdal.Algorithm(\"raster\")\n"
69642 : ">>> alg.InstantiateSubAlgorithm(\"convert\")\n"
69643 : "<osgeo.gdal.Algorithm; proxy of <Swig Object of type 'GDALAlgorithmHS *' at ...> >\n"
69644 : ">>> subalg = alg.InstantiateSubAlgorithm(\"does_not_exist\")\n"
69645 : "\n"
69646 : "\n"
69647 : ""},
69648 : { "Algorithm_ParseCommandLineArguments", _wrap_Algorithm_ParseCommandLineArguments, METH_VARARGS, "\n"
69649 : "Algorithm_ParseCommandLineArguments(Algorithm self, char ** args) -> bool\n"
69650 : "\n"
69651 : "\n"
69652 : "Parse a list of arguments for the algorithm, setting the appropriate parameters. May only be called once per algorithm.\n"
69653 : "\n"
69654 : "Parameters\n"
69655 : "----------\n"
69656 : "args : list\n"
69657 : " List of named or positional arguments\n"
69658 : "\n"
69659 : "Returns\n"
69660 : "-------\n"
69661 : "bool\n"
69662 : " Whether the arguments were successfully parsed\n"
69663 : "\n"
69664 : "Examples\n"
69665 : "--------\n"
69666 : ">>> alg = gdal.Algorithm(\"vector\", \"info\")\n"
69667 : ">>> alg.ParseCommandLineArguments(['poly.shp', '--format', 'text'])\n"
69668 : "True\n"
69669 : "\n"
69670 : "\n"
69671 : ""},
69672 : { "Algorithm_GetActualAlgorithm", _wrap_Algorithm_GetActualAlgorithm, METH_O, "\n"
69673 : "Algorithm_GetActualAlgorithm(Algorithm self) -> Algorithm\n"
69674 : "\n"
69675 : "\n"
69676 : "Return the actual algorithm that is going to be invoked, if the\n"
69677 : "current algorithm has sub-algorithms.\n"
69678 : "\n"
69679 : "Returns\n"
69680 : "-------\n"
69681 : "Algorithm\n"
69682 : "\n"
69683 : "Examples\n"
69684 : "--------\n"
69685 : ">>> alg = gdal.GetGlobalAlgorithmRegistry().InstantiateAlg(\"raster\")\n"
69686 : ">>> alg.ParseCommandLineArguments([\"convert\" ,\"--input\", \"byte.tif\", \"--output\", \"/tmp/byte.png\"])\n"
69687 : "True\n"
69688 : ">>> alg.GetActualAlgorithm().GetDescription()\n"
69689 : "'Convert a raster dataset.'\n"
69690 : "\n"
69691 : "\n"
69692 : ""},
69693 : { "Algorithm_Run", _wrap_Algorithm_Run, METH_VARARGS, "Algorithm_Run(Algorithm self, GDALProgressFunc callback=0, void * callback_data=None) -> bool"},
69694 : { "Algorithm_Finalize", _wrap_Algorithm_Finalize, METH_O, "\n"
69695 : "Algorithm_Finalize(Algorithm self) -> bool\n"
69696 : "\n"
69697 : "\n"
69698 : "Close any dataset arguments or outputs of the algorithm.\n"
69699 : "\n"
69700 : "Returns\n"
69701 : "-------\n"
69702 : "bool\n"
69703 : "\n"
69704 : "\n"
69705 : ""},
69706 : { "Algorithm_ParseRunAndFinalize", _wrap_Algorithm_ParseRunAndFinalize, METH_VARARGS, "\n"
69707 : "Algorithm_ParseRunAndFinalize(Algorithm self, char ** args, GDALProgressFunc callback=0, void * callback_data=None) -> bool\n"
69708 : "\n"
69709 : "\n"
69710 : "Convenience method that calls :py:meth:`ParseCommandLineArguments`, :py:meth:`Run`, and :py:meth:`Finalize`.\n"
69711 : "\n"
69712 : "Parameters\n"
69713 : "----------\n"
69714 : "args : list\n"
69715 : " List of command line arguments\n"
69716 : "callback : callable, optional\n"
69717 : " Optional progress callback function\n"
69718 : "callback_data\n"
69719 : " Optional value to be provided as final argument to callback function\n"
69720 : "\n"
69721 : "Returns\n"
69722 : "-------\n"
69723 : "bool\n"
69724 : " ``True`` if the algorithm succeeded, ``False`` otherwise\n"
69725 : "\n"
69726 : "\n"
69727 : ""},
69728 : { "Algorithm_GetUsageAsJSON", _wrap_Algorithm_GetUsageAsJSON, METH_O, "\n"
69729 : "Algorithm_GetUsageAsJSON(Algorithm self) -> retStringAndCPLFree *\n"
69730 : "\n"
69731 : "\n"
69732 : "Returns a JSON representation of an algorithm's usage information, serialized to a string.\n"
69733 : "\n"
69734 : "Returns\n"
69735 : "-------\n"
69736 : "str\n"
69737 : "\n"
69738 : "Examples\n"
69739 : "--------\n"
69740 : ">>> import json\n"
69741 : ">>> import pprint\n"
69742 : ">>> usage = json.loads(gdal.Algorithm(\"vector\", \"info\").GetUsageAsJSON())\n"
69743 : ">>> pprint.pprint(usage)\n"
69744 : "{'description': 'Return information on a vector dataset.',\n"
69745 : " 'full_path': ['gdal', 'vector', 'info'],\n"
69746 : " 'input_arguments': [{'category': 'Base',\n"
69747 : " 'choices': ['json', 'text'],\n"
69748 : " 'description': 'Output format',\n"
69749 : " 'name': 'output-format',\n"
69750 : " 'required': False,\n"
69751 : " 'type': 'string'},\n"
69752 : " {'category': 'Advanced',\n"
69753 : " 'description': 'Open options',\n"
69754 : " 'max_count': 2147483647,\n"
69755 : " 'metavar': '<KEY>=<VALUE>',\n"
69756 : " 'min_count': 0,\n"
69757 : " 'name': 'open-option',\n"
69758 : " 'packed_values_allowed': False,\n"
69759 : " 'repeated_arg_allowed': True,\n"
69760 : " 'required': False,\n"
69761 : " 'type': 'string_list'},\n"
69762 : " {'category': 'Advanced',\n"
69763 : " 'description': 'Input formats',\n"
69764 : " 'max_count': 2147483647,\n"
69765 : " 'metadata': {'required_capabilities': ['DCAP_VECTOR']},\n"
69766 : " 'min_count': 0,\n"
69767 : " 'name': 'input-format',\n"
69768 : " 'packed_values_allowed': True,\n"
69769 : " 'repeated_arg_allowed': True,\n"
69770 : " 'required': False,\n"
69771 : " 'type': 'string_list'},\n"
69772 : " {'category': 'Base',\n"
69773 : " 'dataset_type': ['vector'],\n"
69774 : " 'description': 'Input vector datasets',\n"
69775 : " 'input_flags': ['name', 'dataset'],\n"
69776 : " 'max_count': 2147483647,\n"
69777 : " 'min_count': 0,\n"
69778 : " 'name': 'input',\n"
69779 : " 'packed_values_allowed': False,\n"
69780 : " 'repeated_arg_allowed': True,\n"
69781 : " 'required': True,\n"
69782 : " 'type': 'dataset_list'},\n"
69783 : " {'category': 'Base',\n"
69784 : " 'description': 'Input layer name',\n"
69785 : " 'max_count': 2147483647,\n"
69786 : " 'min_count': 0,\n"
69787 : " 'mutual_exclusion_group': 'layer-sql',\n"
69788 : " 'name': 'input-layer',\n"
69789 : " 'packed_values_allowed': True,\n"
69790 : " 'repeated_arg_allowed': True,\n"
69791 : " 'required': False,\n"
69792 : " 'type': 'string_list'},\n"
69793 : " {'category': 'Base',\n"
69794 : " 'description': 'List all features (beware of RAM '\n"
69795 : " 'consumption on large layers)',\n"
69796 : " 'mutual_exclusion_group': 'summary-features',\n"
69797 : " 'name': 'features',\n"
69798 : " 'required': False,\n"
69799 : " 'type': 'boolean'},\n"
69800 : " {'category': 'Base',\n"
69801 : " 'description': 'List the layer names and the geometry '\n"
69802 : " 'type',\n"
69803 : " 'mutual_exclusion_group': 'summary-features',\n"
69804 : " 'name': 'summary',\n"
69805 : " 'required': False,\n"
69806 : " 'type': 'boolean'},\n"
69807 : " {'category': 'Base',\n"
69808 : " 'description': 'Limit the number of features per layer '\n"
69809 : " '(implies --features)',\n"
69810 : " 'metavar': 'FEATURE-COUNT',\n"
69811 : " 'min_value': 0,\n"
69812 : " 'min_value_is_included': True,\n"
69813 : " 'name': 'limit',\n"
69814 : " 'required': False,\n"
69815 : " 'type': 'integer'},\n"
69816 : " {'category': 'Base',\n"
69817 : " 'description': 'Execute the indicated SQL statement and '\n"
69818 : " 'return the result',\n"
69819 : " 'metavar': '<statement>|@<filename>',\n"
69820 : " 'mutual_exclusion_group': 'layer-sql',\n"
69821 : " 'name': 'sql',\n"
69822 : " 'required': False,\n"
69823 : " 'type': 'string'},\n"
69824 : " {'category': 'Base',\n"
69825 : " 'description': 'Attribute query in a restricted form of '\n"
69826 : " 'the queries used in the SQL WHERE '\n"
69827 : " 'statement',\n"
69828 : " 'metavar': '<WHERE>|@<filename>',\n"
69829 : " 'name': 'where',\n"
69830 : " 'required': False,\n"
69831 : " 'type': 'string'},\n"
69832 : " {'category': 'Base',\n"
69833 : " 'description': 'SQL dialect',\n"
69834 : " 'name': 'dialect',\n"
69835 : " 'required': False,\n"
69836 : " 'type': 'string'},\n"
69837 : " {'category': 'Base',\n"
69838 : " 'description': 'Open the dataset in update mode',\n"
69839 : " 'name': 'update',\n"
69840 : " 'required': False,\n"
69841 : " 'type': 'boolean'}],\n"
69842 : " 'input_output_arguments': [],\n"
69843 : " 'name': 'info',\n"
69844 : " 'output_arguments': [{'category': 'Base',\n"
69845 : " 'description': 'Output string, in which the result is '\n"
69846 : " 'placed',\n"
69847 : " 'name': 'output-string',\n"
69848 : " 'required': False,\n"
69849 : " 'type': 'string'}],\n"
69850 : " 'short_url': '/programs/gdal_vector_info.html',\n"
69851 : " 'sub_algorithms': [],\n"
69852 : " 'supports_streamed_output': True,\n"
69853 : " 'url': 'https://gdal.org/programs/gdal_vector_info.html'}\n"
69854 : "\n"
69855 : "\n"
69856 : ""},
69857 : { "Algorithm_GetArgNames", _wrap_Algorithm_GetArgNames, METH_O, "\n"
69858 : "Algorithm_GetArgNames(Algorithm self) -> char **\n"
69859 : "\n"
69860 : "\n"
69861 : "Get a list of arguments understood by the Algorithm.\n"
69862 : "\n"
69863 : "Returns\n"
69864 : "-------\n"
69865 : "list\n"
69866 : "\n"
69867 : "Examples\n"
69868 : "--------\n"
69869 : ">>> alg = gdal.Algorithm(\"raster\", \"convert\")\n"
69870 : ">>> sorted(alg.GetArgNames())\n"
69871 : "['append', 'config', 'creation-option', ..., 'progress', 'quiet']\n"
69872 : "\n"
69873 : "\n"
69874 : "\n"
69875 : ""},
69876 : { "Algorithm_GetArg", _wrap_Algorithm_GetArg, METH_VARARGS, "\n"
69877 : "Algorithm_GetArg(Algorithm self, char const * argName) -> AlgorithmArg\n"
69878 : "\n"
69879 : "\n"
69880 : "Get an :py:class:`AlgorithmArg` object that can be queried for information about an argument.\n"
69881 : "\n"
69882 : "Parameters\n"
69883 : "----------\n"
69884 : "argName : str\n"
69885 : "\n"
69886 : "Returns\n"
69887 : "-------\n"
69888 : "AlgorithmArg\n"
69889 : "\n"
69890 : "Examples\n"
69891 : "--------\n"
69892 : ">>> alg = gdal.Algorithm(\"raster\", \"polygonize\")\n"
69893 : ">>> arg = alg.GetArg(\"connect-diagonal-pixels\")\n"
69894 : ">>> arg.GetDescription()\n"
69895 : "'Consider diagonal pixels as connected'\n"
69896 : "\n"
69897 : "\n"
69898 : ""},
69899 : { "Algorithm_GetArgNonConst", _wrap_Algorithm_GetArgNonConst, METH_VARARGS, "\n"
69900 : "Algorithm_GetArgNonConst(Algorithm self, char const * argName) -> AlgorithmArg\n"
69901 : "\n"
69902 : "\n"
69903 : ":meta private:\n"
69904 : "\n"
69905 : "\n"
69906 : ""},
69907 : { "Algorithm_swigregister", Algorithm_swigregister, METH_O, NULL},
69908 : { "delete_AlgorithmRegistry", _wrap_delete_AlgorithmRegistry, METH_O, "delete_AlgorithmRegistry(AlgorithmRegistry self)"},
69909 : { "AlgorithmRegistry_GetAlgNames", _wrap_AlgorithmRegistry_GetAlgNames, METH_O, "\n"
69910 : "AlgorithmRegistry_GetAlgNames(AlgorithmRegistry self) -> char **\n"
69911 : "\n"
69912 : "\n"
69913 : "Return the names of available algorithms.\n"
69914 : "\n"
69915 : "Returns\n"
69916 : "-------\n"
69917 : "list\n"
69918 : "\n"
69919 : "Examples\n"
69920 : "--------\n"
69921 : ">>> gdal.GetGlobalAlgorithmRegistry().GetAlgNames()\n"
69922 : "['convert', 'dataset', 'info', 'mdim', 'pipeline', 'raster', 'vector', 'vsi']\n"
69923 : "\n"
69924 : "\n"
69925 : ""},
69926 : { "AlgorithmRegistry_InstantiateAlg", _wrap_AlgorithmRegistry_InstantiateAlg, METH_VARARGS, "\n"
69927 : "AlgorithmRegistry_InstantiateAlg(AlgorithmRegistry self, char const * algName) -> Algorithm\n"
69928 : "\n"
69929 : "\n"
69930 : "Instantiate an :py:class:`Algorithm`.\n"
69931 : "\n"
69932 : "Most useful algorithms are accessed as a sub-algorithm of another algorithm.\n"
69933 : "For example, ``polygonize`` is a sub-algorithm of ``raster`` and can be\n"
69934 : "instantiated by first instantiating the primary algorithm, then using\n"
69935 : ":py:meth:`Algorithm.InstantiateSubAlgorithm`.\n"
69936 : "\n"
69937 : "Returns\n"
69938 : "-------\n"
69939 : "Algorithm\n"
69940 : "\n"
69941 : "Examples\n"
69942 : "--------\n"
69943 : "\n"
69944 : ">>> alg = gdal.GetGlobalAlgorithmRegistry().InstantiateAlg('pipeline') # or alg= gdal.Algorithm(\"pipeline\")\n"
69945 : ">>> alg.GetName()\n"
69946 : "'pipeline'\n"
69947 : ">>> alg.GetArgNames()\n"
69948 : "['help', 'help-doc', 'json-usage', 'config', 'quiet', 'progress', 'input', 'output', 'output-format', 'pipeline', 'output-string', 'stdout']\n"
69949 : "\n"
69950 : ">>> subalg = gdal.GetGlobalAlgorithmRegistry().InstantiateAlg('raster').InstantiateSubAlgorithm('polygonize')\n"
69951 : ">>> subalg.GetArgNames()\n"
69952 : "['help', 'help-doc', 'json-usage', 'config', 'quiet', 'progress', 'input-format', 'open-option', 'input', 'output-format', 'output-open-option', 'output', 'creation-option', 'layer-creation-option', 'overwrite', 'update', 'overwrite-layer', 'append', 'output-layer', 'band', 'attribute-name', 'connect-diagonal-pixels', 'commit-interval']\n"
69953 : "\n"
69954 : "\n"
69955 : ""},
69956 : { "AlgorithmRegistry_swigregister", AlgorithmRegistry_swigregister, METH_O, NULL},
69957 : { "delete_ArgDatasetValue", _wrap_delete_ArgDatasetValue, METH_O, "delete_ArgDatasetValue(ArgDatasetValue self)"},
69958 : { "ArgDatasetValue_GetName", _wrap_ArgDatasetValue_GetName, METH_O, "ArgDatasetValue_GetName(ArgDatasetValue self) -> char const *"},
69959 : { "ArgDatasetValue_GetDataset", _wrap_ArgDatasetValue_GetDataset, METH_O, "ArgDatasetValue_GetDataset(ArgDatasetValue self) -> Dataset"},
69960 : { "ArgDatasetValue_SetName", _wrap_ArgDatasetValue_SetName, METH_VARARGS, "ArgDatasetValue_SetName(ArgDatasetValue self, char const * name)"},
69961 : { "ArgDatasetValue_SetDataset", _wrap_ArgDatasetValue_SetDataset, METH_VARARGS, "ArgDatasetValue_SetDataset(ArgDatasetValue self, Dataset ds)"},
69962 : { "ArgDatasetValue_swigregister", ArgDatasetValue_swigregister, METH_O, NULL},
69963 : { "ApplyGeoTransform", _wrap_ApplyGeoTransform, METH_VARARGS, "\n"
69964 : "ApplyGeoTransform(double [6] padfGeoTransform, double dfPixel, double dfLine)\n"
69965 : "\n"
69966 : "\n"
69967 : "Apply a geotransform to convert a (col, row) location\n"
69968 : "into a georeferenced (x, y) coordinate. To perform the\n"
69969 : "inverse transformation, see :py:func:`InvGeoTransform`.\n"
69970 : "\n"
69971 : "See :cpp:func:`GDALApplyGeoTransform`.\n"
69972 : "\n"
69973 : "Parameters\n"
69974 : "----------\n"
69975 : "gt : tuple\n"
69976 : " Geotransform array, as described in :ref:`geotransforms_tut`.\n"
69977 : "dfPixel : float\n"
69978 : " (Fractional) column in image coordinates (0.0 at the left edge of the image)\n"
69979 : "dfLine : float\n"
69980 : " (Fractional) row in image coordinates (0.0 at the top of the image)\n"
69981 : "\n"
69982 : "Returns\n"
69983 : "-------\n"
69984 : "List\n"
69985 : " x, y values corresponding to the input location\n"
69986 : "\n"
69987 : "Examples\n"
69988 : "--------\n"
69989 : ">>> ds = gdal.Open('byte.tif')\n"
69990 : ">>> gt = ds.GetGeoTransform()\n"
69991 : ">>> gdal.ApplyGeoTransform(gt, 5, 7)\n"
69992 : "[441020.0, 3750900.0]\n"
69993 : "\n"
69994 : "\n"
69995 : ""},
69996 : { "InvGeoTransform", _wrap_InvGeoTransform, METH_O, "\n"
69997 : "InvGeoTransform(double [6] gt_in) -> RETURN_NONE\n"
69998 : "\n"
69999 : "\n"
70000 : "Invert a geotransform array so that it represents a conversion\n"
70001 : "from georeferenced (x, y) coordinates to image (col, row) coordinates.\n"
70002 : "\n"
70003 : "Parameters\n"
70004 : "----------\n"
70005 : "gt : tuple\n"
70006 : " Geotransform array, as described in :ref:`geotransforms_tut`.\n"
70007 : "\n"
70008 : "Returns\n"
70009 : "-------\n"
70010 : "tuple\n"
70011 : " Geotransform array representing the inverse transformation\n"
70012 : "\n"
70013 : "Examples\n"
70014 : "--------\n"
70015 : ">>> ds = gdal.Open('byte.tif')\n"
70016 : ">>> inv_gt = gdal.InvGeoTransform(ds.GetGeoTransform())\n"
70017 : ">>> inv_gt\n"
70018 : "(-7345.333333333333, 0.016666666666666666, 0.0, 62522.0, 0.0, -0.016666666666666666)\n"
70019 : ">>> gdal.ApplyGeoTransform(inv_gt, 441020, 3750900)\n"
70020 : "[5.0, 7.0]\n"
70021 : "\n"
70022 : "\n"
70023 : ""},
70024 : { "ApplyHomography", _wrap_ApplyHomography, METH_VARARGS, "ApplyHomography(double [9] padfHomography, double dfPixel, double dfLine) -> int"},
70025 : { "InvHomography", _wrap_InvHomography, METH_O, "InvHomography(double [9] h_in) -> RETURN_NONE"},
70026 : { "VersionInfo", _wrap_VersionInfo, METH_VARARGS, "VersionInfo(char const * request=\"VERSION_NUM\") -> char const *"},
70027 : { "AllRegister", _wrap_AllRegister, METH_NOARGS, "\n"
70028 : "AllRegister()\n"
70029 : "\n"
70030 : "\n"
70031 : "Register all known configured GDAL drivers.\n"
70032 : "Automatically called when the :py:mod:`gdal` module is loaded.\n"
70033 : "Does not need to be called in user code unless a driver was\n"
70034 : "deregistered and needs to be re-registered.\n"
70035 : "See :cpp:func:`GDALAllRegister`.\n"
70036 : "\n"
70037 : "See Also\n"
70038 : "--------\n"
70039 : ":py:func:`Driver.Register`\n"
70040 : "\n"
70041 : ""},
70042 : { "GDALDestroyDriverManager", _wrap_GDALDestroyDriverManager, METH_NOARGS, "GDALDestroyDriverManager()"},
70043 : { "GetCacheMax", _wrap_GetCacheMax, METH_NOARGS, "\n"
70044 : "GetCacheMax() -> GIntBig\n"
70045 : "\n"
70046 : "\n"
70047 : "Get the maximum size of the block cache.\n"
70048 : "See :cpp:func:`GDALGetCacheMax`.\n"
70049 : "\n"
70050 : "Returns\n"
70051 : "-------\n"
70052 : "int\n"
70053 : " maximum cache size in bytes\n"
70054 : "\n"
70055 : ""},
70056 : { "GetCacheUsed", _wrap_GetCacheUsed, METH_NOARGS, "\n"
70057 : "GetCacheUsed() -> GIntBig\n"
70058 : "\n"
70059 : "\n"
70060 : "Get the number of bytes in used by the block cache.\n"
70061 : "See :cpp:func:`GDALGetCacheUsed`.\n"
70062 : "\n"
70063 : "Returns\n"
70064 : "-------\n"
70065 : "int\n"
70066 : " cache size in bytes\n"
70067 : "\n"
70068 : ""},
70069 : { "SetCacheMax", _wrap_SetCacheMax, METH_O, "\n"
70070 : "SetCacheMax(GIntBig nBytes)\n"
70071 : "\n"
70072 : "\n"
70073 : "Set the maximum size of the block cache.\n"
70074 : "See :cpp:func:`GDALSetCacheMax`.\n"
70075 : "\n"
70076 : "Parameters\n"
70077 : "----------\n"
70078 : "nBytes : int\n"
70079 : " Cache size in bytes\n"
70080 : "\n"
70081 : "See Also\n"
70082 : "--------\n"
70083 : ":config:`GDAL_CACHEMAX`\n"
70084 : "\n"
70085 : ""},
70086 : { "GetDataTypeSize", _wrap_GetDataTypeSize, METH_O, "GetDataTypeSize(GDALDataType eDataType) -> int"},
70087 : { "GetDataTypeSizeBits", _wrap_GetDataTypeSizeBits, METH_O, "GetDataTypeSizeBits(GDALDataType eDataType) -> int"},
70088 : { "GetDataTypeSizeBytes", _wrap_GetDataTypeSizeBytes, METH_O, "GetDataTypeSizeBytes(GDALDataType eDataType) -> int"},
70089 : { "DataTypeIsComplex", _wrap_DataTypeIsComplex, METH_O, "DataTypeIsComplex(GDALDataType eDataType) -> int"},
70090 : { "GetDataTypeName", _wrap_GetDataTypeName, METH_O, "\n"
70091 : "GetDataTypeName(GDALDataType eDataType) -> char const *\n"
70092 : "\n"
70093 : "\n"
70094 : "Return the name of the data type.\n"
70095 : "\n"
70096 : "Parameters\n"
70097 : "----------\n"
70098 : "eDataType : int\n"
70099 : " data type code\n"
70100 : "\n"
70101 : "Returns\n"
70102 : "-------\n"
70103 : "str\n"
70104 : "\n"
70105 : "Examples\n"
70106 : "--------\n"
70107 : ">>> gdal.GetDataTypeName(gdal.GDT_Int16)\n"
70108 : "'Int16'\n"
70109 : ">>> gdal.GetDataTypeName(gdal.GDT_Float64)\n"
70110 : "'Float64'\n"
70111 : "\n"
70112 : ""},
70113 : { "GetDataTypeByName", _wrap_GetDataTypeByName, METH_O, "\n"
70114 : "GetDataTypeByName(char const * pszDataTypeName) -> GDALDataType\n"
70115 : "\n"
70116 : "\n"
70117 : "Return the data type for a given name.\n"
70118 : "\n"
70119 : "Parameters\n"
70120 : "----------\n"
70121 : "pszDataTypeName : str\n"
70122 : " data type name\n"
70123 : "\n"
70124 : "Returns\n"
70125 : "-------\n"
70126 : "int\n"
70127 : " data type code\n"
70128 : "\n"
70129 : "Examples\n"
70130 : "--------\n"
70131 : ">>> gdal.GetDataTypeByName('Int16') == gdal.GDT_Int16\n"
70132 : "True\n"
70133 : "\n"
70134 : "\n"
70135 : ""},
70136 : { "DataTypeUnion", _wrap_DataTypeUnion, METH_VARARGS, "DataTypeUnion(GDALDataType a, GDALDataType b) -> GDALDataType"},
70137 : { "DataTypeUnionWithValue", _wrap_DataTypeUnionWithValue, METH_VARARGS, "DataTypeUnionWithValue(GDALDataType a, double val, bool isComplex) -> GDALDataType"},
70138 : { "GetColorInterpretationName", _wrap_GetColorInterpretationName, METH_O, "GetColorInterpretationName(GDALColorInterp eColorInterp) -> char const *"},
70139 : { "GetColorInterpretationByName", _wrap_GetColorInterpretationByName, METH_O, "GetColorInterpretationByName(char const * pszColorInterpName) -> GDALColorInterp"},
70140 : { "GetPaletteInterpretationName", _wrap_GetPaletteInterpretationName, METH_O, "GetPaletteInterpretationName(GDALPaletteInterp ePaletteInterp) -> char const *"},
70141 : { "DecToDMS", _wrap_DecToDMS, METH_VARARGS, "DecToDMS(double arg1, char const * arg2, int arg3=2) -> char const *"},
70142 : { "PackedDMSToDec", _wrap_PackedDMSToDec, METH_O, "PackedDMSToDec(double dfPacked) -> double"},
70143 : { "DecToPackedDMS", _wrap_DecToPackedDMS, METH_O, "DecToPackedDMS(double dfDec) -> double"},
70144 : { "ParseXMLString", _wrap_ParseXMLString, METH_O, "ParseXMLString(char * pszXMLString) -> CPLXMLNode *"},
70145 : { "SerializeXMLTree", _wrap_SerializeXMLTree, METH_O, "SerializeXMLTree(CPLXMLNode * xmlnode) -> retStringAndCPLFree *"},
70146 : { "GetJPEG2000Structure", _wrap_GetJPEG2000Structure, METH_VARARGS, "GetJPEG2000Structure(char const * pszFilename, char ** options=None) -> CPLXMLNode *"},
70147 : { "GetJPEG2000StructureAsString", _wrap_GetJPEG2000StructureAsString, METH_VARARGS, "GetJPEG2000StructureAsString(char const * pszFilename, char ** options=None) -> retStringAndCPLFree *"},
70148 : { "HasTriangulation", _wrap_HasTriangulation, METH_NOARGS, "HasTriangulation() -> int"},
70149 : { "GetDriverCount", _wrap_GetDriverCount, METH_NOARGS, "\n"
70150 : "GetDriverCount() -> int\n"
70151 : "\n"
70152 : "\n"
70153 : "Return the number of registered drivers.\n"
70154 : "See :cpp:func:`GDALGetDriverCount`.\n"
70155 : "\n"
70156 : "Examples\n"
70157 : "--------\n"
70158 : "\n"
70159 : ".. testsetup::\n"
70160 : " >>> pytest.skip()\n"
70161 : "\n"
70162 : ">>> gdal.GetDriverCount()\n"
70163 : ">>> 124\n"
70164 : ">>> gdal.GetDriverByName('MapInfo File').Deregister()\n"
70165 : ">>> gdal.GetDriverCount()\n"
70166 : ">>> 123\n"
70167 : "\n"
70168 : ""},
70169 : { "GetDriverByName", _wrap_GetDriverByName, METH_O, "GetDriverByName(char const * name) -> Driver"},
70170 : { "GetDriver", _wrap_GetDriver, METH_O, "GetDriver(int i) -> Driver"},
70171 : { "Open", _wrap_Open, METH_VARARGS, "\n"
70172 : "Open(char const * utf8_path, GDALAccess eAccess=GA_ReadOnly) -> Dataset\n"
70173 : "\n"
70174 : "\n"
70175 : "Opens a raster file as a :py:class:`Dataset` using default options.\n"
70176 : "See :cpp:func:`GDALOpen`.\n"
70177 : "For more control over how the file is opened, use :py:func:`OpenEx`.\n"
70178 : "\n"
70179 : "Parameters\n"
70180 : "----------\n"
70181 : "utf8_path : str\n"
70182 : " name of the file to open\n"
70183 : "eAccess : int, default = :py:const:`gdal.GA_ReadOnly`\n"
70184 : "\n"
70185 : "Returns\n"
70186 : "-------\n"
70187 : "Dataset or None\n"
70188 : " A dataset if successful, or ``None`` on failure.\n"
70189 : "\n"
70190 : "See Also\n"
70191 : "--------\n"
70192 : ":py:func:`OpenEx`\n"
70193 : ":py:func:`OpenShared`\n"
70194 : "\n"
70195 : "\n"
70196 : ""},
70197 : { "OpenEx", (PyCFunction)(void(*)(void))_wrap_OpenEx, METH_VARARGS|METH_KEYWORDS, "\n"
70198 : "OpenEx(char const * utf8_path, unsigned int nOpenFlags=0, char ** allowed_drivers=None, char ** open_options=None, char ** sibling_files=None) -> Dataset\n"
70199 : "\n"
70200 : "\n"
70201 : "Open a raster or vector file as a :py:class:`Dataset`.\n"
70202 : "See :cpp:func:`GDALOpenEx`.\n"
70203 : "\n"
70204 : "Parameters\n"
70205 : "----------\n"
70206 : "utf8_path : str\n"
70207 : " name of the file to open\n"
70208 : "flags : int\n"
70209 : " Flags controlling how the Dataset is opened. Multiple ``gdal.OF_XXX`` flags\n"
70210 : " may be combined using the ``|`` operator. See :cpp:func:`GDALOpenEx`.\n"
70211 : "allowed_drivers : list, optional\n"
70212 : " A list of the names of drivers that may attempt to open the dataset.\n"
70213 : "open_options : dict or list, optional\n"
70214 : " A dict or list of name=value driver-specific opening options.\n"
70215 : "sibling_files : list, optional\n"
70216 : " A list of filenames that are auxiliary to the main filename\n"
70217 : "\n"
70218 : "Returns\n"
70219 : "-------\n"
70220 : "Dataset or None\n"
70221 : " A dataset if successful, or ``None`` on failure.\n"
70222 : "\n"
70223 : "See Also\n"
70224 : "--------\n"
70225 : ":py:func:`Open`\n"
70226 : ":py:func:`OpenShared`\n"
70227 : "\n"
70228 : "\n"
70229 : ""},
70230 : { "OpenShared", _wrap_OpenShared, METH_VARARGS, "\n"
70231 : "OpenShared(char const * utf8_path, GDALAccess eAccess=GA_ReadOnly) -> Dataset\n"
70232 : "\n"
70233 : "\n"
70234 : "Open a raster file as a :py:class:`Dataset`. If the file has already been\n"
70235 : "opened in the current thread, return a reference to the already-opened\n"
70236 : ":py:class:`Dataset`. See :cpp:func:`GDALOpenShared`.\n"
70237 : "\n"
70238 : "Parameters\n"
70239 : "----------\n"
70240 : "utf8_path : str\n"
70241 : " name of the file to open\n"
70242 : "eAccess : int, default = :py:const:`gdal.GA_ReadOnly`\n"
70243 : "\n"
70244 : "Returns\n"
70245 : "-------\n"
70246 : "Dataset or None\n"
70247 : " A dataset if successful, or ``None`` on failure.\n"
70248 : "\n"
70249 : "See Also\n"
70250 : "--------\n"
70251 : ":py:func:`Open`\n"
70252 : ":py:func:`OpenEx`\n"
70253 : "\n"
70254 : "\n"
70255 : ""},
70256 : { "IdentifyDriver", _wrap_IdentifyDriver, METH_VARARGS, "IdentifyDriver(char const * utf8_path, char ** papszSiblings=None) -> Driver"},
70257 : { "IdentifyDriverEx", (PyCFunction)(void(*)(void))_wrap_IdentifyDriverEx, METH_VARARGS|METH_KEYWORDS, "IdentifyDriverEx(char const * utf8_path, unsigned int nIdentifyFlags=0, char ** allowed_drivers=None, char ** sibling_files=None) -> Driver"},
70258 : { "GeneralCmdLineProcessor", _wrap_GeneralCmdLineProcessor, METH_VARARGS, "GeneralCmdLineProcessor(char ** papszArgv, int nOptions=0) -> char **"},
70259 : { "new_GDALInfoOptions", _wrap_new_GDALInfoOptions, METH_O, "new_GDALInfoOptions(char ** options) -> GDALInfoOptions"},
70260 : { "delete_GDALInfoOptions", _wrap_delete_GDALInfoOptions, METH_O, "delete_GDALInfoOptions(GDALInfoOptions self)"},
70261 : { "GDALInfoOptions_swigregister", GDALInfoOptions_swigregister, METH_O, NULL},
70262 : { "GDALInfoOptions_swiginit", GDALInfoOptions_swiginit, METH_VARARGS, NULL},
70263 : { "InfoInternal", _wrap_InfoInternal, METH_VARARGS, "InfoInternal(Dataset hDataset, GDALInfoOptions infoOptions) -> retStringAndCPLFree *"},
70264 : { "new_GDALVectorInfoOptions", _wrap_new_GDALVectorInfoOptions, METH_O, "new_GDALVectorInfoOptions(char ** options) -> GDALVectorInfoOptions"},
70265 : { "delete_GDALVectorInfoOptions", _wrap_delete_GDALVectorInfoOptions, METH_O, "delete_GDALVectorInfoOptions(GDALVectorInfoOptions self)"},
70266 : { "GDALVectorInfoOptions_swigregister", GDALVectorInfoOptions_swigregister, METH_O, NULL},
70267 : { "GDALVectorInfoOptions_swiginit", GDALVectorInfoOptions_swiginit, METH_VARARGS, NULL},
70268 : { "VectorInfoInternal", _wrap_VectorInfoInternal, METH_VARARGS, "VectorInfoInternal(Dataset hDataset, GDALVectorInfoOptions infoOptions) -> retStringAndCPLFree *"},
70269 : { "new_GDALMultiDimInfoOptions", _wrap_new_GDALMultiDimInfoOptions, METH_O, "new_GDALMultiDimInfoOptions(char ** options) -> GDALMultiDimInfoOptions"},
70270 : { "delete_GDALMultiDimInfoOptions", _wrap_delete_GDALMultiDimInfoOptions, METH_O, "delete_GDALMultiDimInfoOptions(GDALMultiDimInfoOptions self)"},
70271 : { "GDALMultiDimInfoOptions_swigregister", GDALMultiDimInfoOptions_swigregister, METH_O, NULL},
70272 : { "GDALMultiDimInfoOptions_swiginit", GDALMultiDimInfoOptions_swiginit, METH_VARARGS, NULL},
70273 : { "MultiDimInfoInternal", _wrap_MultiDimInfoInternal, METH_VARARGS, "MultiDimInfoInternal(Dataset hDataset, GDALMultiDimInfoOptions infoOptions) -> retStringAndCPLFree *"},
70274 : { "new_GDALTranslateOptions", _wrap_new_GDALTranslateOptions, METH_O, "new_GDALTranslateOptions(char ** options) -> GDALTranslateOptions"},
70275 : { "delete_GDALTranslateOptions", _wrap_delete_GDALTranslateOptions, METH_O, "delete_GDALTranslateOptions(GDALTranslateOptions self)"},
70276 : { "GDALTranslateOptions_swigregister", GDALTranslateOptions_swigregister, METH_O, NULL},
70277 : { "GDALTranslateOptions_swiginit", GDALTranslateOptions_swiginit, METH_VARARGS, NULL},
70278 : { "TranslateInternal", _wrap_TranslateInternal, METH_VARARGS, "TranslateInternal(char const * dest, Dataset dataset, GDALTranslateOptions translateOptions, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"},
70279 : { "new_GDALWarpAppOptions", _wrap_new_GDALWarpAppOptions, METH_O, "new_GDALWarpAppOptions(char ** options) -> GDALWarpAppOptions"},
70280 : { "delete_GDALWarpAppOptions", _wrap_delete_GDALWarpAppOptions, METH_O, "delete_GDALWarpAppOptions(GDALWarpAppOptions self)"},
70281 : { "GDALWarpAppOptions_swigregister", GDALWarpAppOptions_swigregister, METH_O, NULL},
70282 : { "GDALWarpAppOptions_swiginit", GDALWarpAppOptions_swiginit, METH_VARARGS, NULL},
70283 : { "wrapper_GDALWarpDestDS", _wrap_wrapper_GDALWarpDestDS, METH_VARARGS, "wrapper_GDALWarpDestDS(Dataset dstDS, int object_list_count, GDALWarpAppOptions warpAppOptions, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
70284 : { "wrapper_GDALWarpDestName", _wrap_wrapper_GDALWarpDestName, METH_VARARGS, "wrapper_GDALWarpDestName(char const * dest, int object_list_count, GDALWarpAppOptions warpAppOptions, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"},
70285 : { "new_GDALVectorTranslateOptions", _wrap_new_GDALVectorTranslateOptions, METH_O, "new_GDALVectorTranslateOptions(char ** options) -> GDALVectorTranslateOptions"},
70286 : { "delete_GDALVectorTranslateOptions", _wrap_delete_GDALVectorTranslateOptions, METH_O, "delete_GDALVectorTranslateOptions(GDALVectorTranslateOptions self)"},
70287 : { "GDALVectorTranslateOptions_swigregister", GDALVectorTranslateOptions_swigregister, METH_O, NULL},
70288 : { "GDALVectorTranslateOptions_swiginit", GDALVectorTranslateOptions_swiginit, METH_VARARGS, NULL},
70289 : { "wrapper_GDALVectorTranslateDestDS", _wrap_wrapper_GDALVectorTranslateDestDS, METH_VARARGS, "wrapper_GDALVectorTranslateDestDS(Dataset dstDS, Dataset srcDS, GDALVectorTranslateOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
70290 : { "wrapper_GDALVectorTranslateDestName", _wrap_wrapper_GDALVectorTranslateDestName, METH_VARARGS, "wrapper_GDALVectorTranslateDestName(char const * dest, Dataset srcDS, GDALVectorTranslateOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"},
70291 : { "new_GDALDEMProcessingOptions", _wrap_new_GDALDEMProcessingOptions, METH_O, "new_GDALDEMProcessingOptions(char ** options) -> GDALDEMProcessingOptions"},
70292 : { "delete_GDALDEMProcessingOptions", _wrap_delete_GDALDEMProcessingOptions, METH_O, "delete_GDALDEMProcessingOptions(GDALDEMProcessingOptions self)"},
70293 : { "GDALDEMProcessingOptions_swigregister", GDALDEMProcessingOptions_swigregister, METH_O, NULL},
70294 : { "GDALDEMProcessingOptions_swiginit", GDALDEMProcessingOptions_swiginit, METH_VARARGS, NULL},
70295 : { "DEMProcessingInternal", _wrap_DEMProcessingInternal, METH_VARARGS, "DEMProcessingInternal(char const * dest, Dataset dataset, char const * pszProcessing, char const * pszColorFilename, GDALDEMProcessingOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"},
70296 : { "new_GDALNearblackOptions", _wrap_new_GDALNearblackOptions, METH_O, "new_GDALNearblackOptions(char ** options) -> GDALNearblackOptions"},
70297 : { "delete_GDALNearblackOptions", _wrap_delete_GDALNearblackOptions, METH_O, "delete_GDALNearblackOptions(GDALNearblackOptions self)"},
70298 : { "GDALNearblackOptions_swigregister", GDALNearblackOptions_swigregister, METH_O, NULL},
70299 : { "GDALNearblackOptions_swiginit", GDALNearblackOptions_swiginit, METH_VARARGS, NULL},
70300 : { "wrapper_GDALNearblackDestDS", _wrap_wrapper_GDALNearblackDestDS, METH_VARARGS, "wrapper_GDALNearblackDestDS(Dataset dstDS, Dataset srcDS, GDALNearblackOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
70301 : { "wrapper_GDALNearblackDestName", _wrap_wrapper_GDALNearblackDestName, METH_VARARGS, "wrapper_GDALNearblackDestName(char const * dest, Dataset srcDS, GDALNearblackOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"},
70302 : { "new_GDALGridOptions", _wrap_new_GDALGridOptions, METH_O, "new_GDALGridOptions(char ** options) -> GDALGridOptions"},
70303 : { "delete_GDALGridOptions", _wrap_delete_GDALGridOptions, METH_O, "delete_GDALGridOptions(GDALGridOptions self)"},
70304 : { "GDALGridOptions_swigregister", GDALGridOptions_swigregister, METH_O, NULL},
70305 : { "GDALGridOptions_swiginit", GDALGridOptions_swiginit, METH_VARARGS, NULL},
70306 : { "GridInternal", _wrap_GridInternal, METH_VARARGS, "GridInternal(char const * dest, Dataset dataset, GDALGridOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"},
70307 : { "new_GDALContourOptions", _wrap_new_GDALContourOptions, METH_O, "new_GDALContourOptions(char ** options) -> GDALContourOptions"},
70308 : { "delete_GDALContourOptions", _wrap_delete_GDALContourOptions, METH_O, "delete_GDALContourOptions(GDALContourOptions self)"},
70309 : { "GDALContourOptions_swigregister", GDALContourOptions_swigregister, METH_O, NULL},
70310 : { "GDALContourOptions_swiginit", GDALContourOptions_swiginit, METH_VARARGS, NULL},
70311 : { "wrapper_GDALContourDestDS", _wrap_wrapper_GDALContourDestDS, METH_VARARGS, "wrapper_GDALContourDestDS(Dataset dstDS, Dataset srcDS, GDALContourOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
70312 : { "wrapper_GDALContourDestName", _wrap_wrapper_GDALContourDestName, METH_VARARGS, "wrapper_GDALContourDestName(char const * dest, Dataset srcDS, GDALContourOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"},
70313 : { "new_GDALRasterizeOptions", _wrap_new_GDALRasterizeOptions, METH_O, "new_GDALRasterizeOptions(char ** options) -> GDALRasterizeOptions"},
70314 : { "delete_GDALRasterizeOptions", _wrap_delete_GDALRasterizeOptions, METH_O, "delete_GDALRasterizeOptions(GDALRasterizeOptions self)"},
70315 : { "GDALRasterizeOptions_swigregister", GDALRasterizeOptions_swigregister, METH_O, NULL},
70316 : { "GDALRasterizeOptions_swiginit", GDALRasterizeOptions_swiginit, METH_VARARGS, NULL},
70317 : { "wrapper_GDALRasterizeDestDS", _wrap_wrapper_GDALRasterizeDestDS, METH_VARARGS, "wrapper_GDALRasterizeDestDS(Dataset dstDS, Dataset srcDS, GDALRasterizeOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
70318 : { "wrapper_GDALRasterizeDestName", _wrap_wrapper_GDALRasterizeDestName, METH_VARARGS, "wrapper_GDALRasterizeDestName(char const * dest, Dataset srcDS, GDALRasterizeOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"},
70319 : { "new_GDALFootprintOptions", _wrap_new_GDALFootprintOptions, METH_O, "new_GDALFootprintOptions(char ** options) -> GDALFootprintOptions"},
70320 : { "delete_GDALFootprintOptions", _wrap_delete_GDALFootprintOptions, METH_O, "delete_GDALFootprintOptions(GDALFootprintOptions self)"},
70321 : { "GDALFootprintOptions_swigregister", GDALFootprintOptions_swigregister, METH_O, NULL},
70322 : { "GDALFootprintOptions_swiginit", GDALFootprintOptions_swiginit, METH_VARARGS, NULL},
70323 : { "wrapper_GDALFootprintDestDS", _wrap_wrapper_GDALFootprintDestDS, METH_VARARGS, "wrapper_GDALFootprintDestDS(Dataset dstDS, Dataset srcDS, GDALFootprintOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> int"},
70324 : { "wrapper_GDALFootprintDestName", _wrap_wrapper_GDALFootprintDestName, METH_VARARGS, "wrapper_GDALFootprintDestName(char const * dest, Dataset srcDS, GDALFootprintOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"},
70325 : { "new_GDALBuildVRTOptions", _wrap_new_GDALBuildVRTOptions, METH_O, "new_GDALBuildVRTOptions(char ** options) -> GDALBuildVRTOptions"},
70326 : { "delete_GDALBuildVRTOptions", _wrap_delete_GDALBuildVRTOptions, METH_O, "delete_GDALBuildVRTOptions(GDALBuildVRTOptions self)"},
70327 : { "GDALBuildVRTOptions_swigregister", GDALBuildVRTOptions_swigregister, METH_O, NULL},
70328 : { "GDALBuildVRTOptions_swiginit", GDALBuildVRTOptions_swiginit, METH_VARARGS, NULL},
70329 : { "BuildVRTInternalObjects", _wrap_BuildVRTInternalObjects, METH_VARARGS, "BuildVRTInternalObjects(char const * dest, int object_list_count, GDALBuildVRTOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"},
70330 : { "BuildVRTInternalNames", _wrap_BuildVRTInternalNames, METH_VARARGS, "BuildVRTInternalNames(char const * dest, char ** source_filenames, GDALBuildVRTOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"},
70331 : { "new_GDALTileIndexOptions", _wrap_new_GDALTileIndexOptions, METH_O, "new_GDALTileIndexOptions(char ** options) -> GDALTileIndexOptions"},
70332 : { "delete_GDALTileIndexOptions", _wrap_delete_GDALTileIndexOptions, METH_O, "delete_GDALTileIndexOptions(GDALTileIndexOptions self)"},
70333 : { "GDALTileIndexOptions_swigregister", GDALTileIndexOptions_swigregister, METH_O, NULL},
70334 : { "GDALTileIndexOptions_swiginit", GDALTileIndexOptions_swiginit, METH_VARARGS, NULL},
70335 : { "TileIndexInternalNames", _wrap_TileIndexInternalNames, METH_VARARGS, "TileIndexInternalNames(char const * dest, char ** source_filenames, GDALTileIndexOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"},
70336 : { "new_GDALMultiDimTranslateOptions", _wrap_new_GDALMultiDimTranslateOptions, METH_O, "new_GDALMultiDimTranslateOptions(char ** options) -> GDALMultiDimTranslateOptions"},
70337 : { "delete_GDALMultiDimTranslateOptions", _wrap_delete_GDALMultiDimTranslateOptions, METH_O, "delete_GDALMultiDimTranslateOptions(GDALMultiDimTranslateOptions self)"},
70338 : { "GDALMultiDimTranslateOptions_swigregister", GDALMultiDimTranslateOptions_swigregister, METH_O, NULL},
70339 : { "GDALMultiDimTranslateOptions_swiginit", GDALMultiDimTranslateOptions_swiginit, METH_VARARGS, NULL},
70340 : { "wrapper_GDALMultiDimTranslateDestName", _wrap_wrapper_GDALMultiDimTranslateDestName, METH_VARARGS, "wrapper_GDALMultiDimTranslateDestName(char const * dest, int object_list_count, GDALMultiDimTranslateOptions multiDimTranslateOptions, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"},
70341 : { NULL, NULL, 0, NULL }
70342 : };
70343 :
70344 : static PyMethodDef SwigMethods_proxydocs[] = {
70345 : { NULL, NULL, 0, NULL }
70346 : };
70347 :
70348 :
70349 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
70350 :
70351 0 : static void *_p_p_GDALComputedRasterBandShadowTo_p_p_GDALRasterBandShadow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
70352 0 : return (void *)((GDALRasterBandShadow **) ((GDALComputedRasterBandShadow **) x));
70353 : }
70354 193 : static void *_p_GDALComputedRasterBandShadowTo_p_GDALRasterBandShadow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
70355 193 : return (void *)((GDALRasterBandShadow *) ((GDALComputedRasterBandShadow *) x));
70356 : }
70357 54982 : static void *_p_GDALDriverShadowTo_p_GDALMajorObjectShadow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
70358 54982 : return (void *)((GDALMajorObjectShadow *) ((GDALDriverShadow *) x));
70359 : }
70360 982 : static void *_p_OGRLayerShadowTo_p_GDALMajorObjectShadow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
70361 982 : return (void *)((GDALMajorObjectShadow *) ((OGRLayerShadow *) x));
70362 : }
70363 6476 : static void *_p_GDALDatasetShadowTo_p_GDALMajorObjectShadow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
70364 6476 : return (void *)((GDALMajorObjectShadow *) ((GDALDatasetShadow *) x));
70365 : }
70366 6686 : static void *_p_GDALRasterBandShadowTo_p_GDALMajorObjectShadow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
70367 6686 : return (void *)((GDALMajorObjectShadow *) ((GDALRasterBandShadow *) x));
70368 : }
70369 0 : static void *_p_GDALComputedRasterBandShadowTo_p_GDALMajorObjectShadow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
70370 0 : return (void *)((GDALMajorObjectShadow *) (GDALRasterBandShadow *) ((GDALComputedRasterBandShadow *) x));
70371 : }
70372 : static swig_type_info _swigt__p_CPLErrorHandler = {"_p_CPLErrorHandler", "CPLErrorHandler *", 0, 0, (void*)0, 0};
70373 : static swig_type_info _swigt__p_CPLVirtualMemShadow = {"_p_CPLVirtualMemShadow", "CPLVirtualMemShadow *", 0, 0, (void*)0, 0};
70374 : static swig_type_info _swigt__p_CPLXMLNode = {"_p_CPLXMLNode", "CPLXMLNode *", 0, 0, (void*)0, 0};
70375 : static swig_type_info _swigt__p_DirEntry = {"_p_DirEntry", "DirEntry *", 0, 0, (void*)0, 0};
70376 : static swig_type_info _swigt__p_GByte = {"_p_GByte", "GByte *", 0, 0, (void*)0, 0};
70377 : static swig_type_info _swigt__p_GDALAlgorithmArgHS = {"_p_GDALAlgorithmArgHS", "GDALAlgorithmArgHS *", 0, 0, (void*)0, 0};
70378 : static swig_type_info _swigt__p_GDALAlgorithmHS = {"_p_GDALAlgorithmHS", "GDALAlgorithmHS *", 0, 0, (void*)0, 0};
70379 : static swig_type_info _swigt__p_GDALAlgorithmRegistryHS = {"_p_GDALAlgorithmRegistryHS", "GDALAlgorithmRegistryHS *", 0, 0, (void*)0, 0};
70380 : static swig_type_info _swigt__p_GDALArgDatasetValueHS = {"_p_GDALArgDatasetValueHS", "GDALArgDatasetValueHS *", 0, 0, (void*)0, 0};
70381 : static swig_type_info _swigt__p_GDALAsyncReaderShadow = {"_p_GDALAsyncReaderShadow", "GDALAsyncReaderShadow *", 0, 0, (void*)0, 0};
70382 : static swig_type_info _swigt__p_GDALAttributeHS = {"_p_GDALAttributeHS", "GDALAttributeHS *", 0, 0, (void*)0, 0};
70383 : static swig_type_info _swigt__p_GDALBuildVRTOptions = {"_p_GDALBuildVRTOptions", "GDALBuildVRTOptions *", 0, 0, (void*)0, 0};
70384 : static swig_type_info _swigt__p_GDALColorEntry = {"_p_GDALColorEntry", "GDALColorEntry *", 0, 0, (void*)0, 0};
70385 : static swig_type_info _swigt__p_GDALColorTableShadow = {"_p_GDALColorTableShadow", "GDALColorTableShadow *", 0, 0, (void*)0, 0};
70386 : static swig_type_info _swigt__p_GDALComputedRasterBandShadow = {"_p_GDALComputedRasterBandShadow", "GDALComputedRasterBandShadow *", 0, 0, (void*)0, 0};
70387 : static swig_type_info _swigt__p_GDALContourOptions = {"_p_GDALContourOptions", "GDALContourOptions *", 0, 0, (void*)0, 0};
70388 : static swig_type_info _swigt__p_GDALDEMProcessingOptions = {"_p_GDALDEMProcessingOptions", "GDALDEMProcessingOptions *", 0, 0, (void*)0, 0};
70389 : static swig_type_info _swigt__p_GDALDatasetShadow = {"_p_GDALDatasetShadow", "GDALDatasetShadow *", 0, 0, (void*)0, 0};
70390 : static swig_type_info _swigt__p_GDALDimensionHS = {"_p_GDALDimensionHS", "GDALDimensionHS *", 0, 0, (void*)0, 0};
70391 : static swig_type_info _swigt__p_GDALDriverShadow = {"_p_GDALDriverShadow", "GDALDriverShadow *", 0, 0, (void*)0, 0};
70392 : static swig_type_info _swigt__p_GDALEDTComponentHS = {"_p_GDALEDTComponentHS", "GDALEDTComponentHS *", 0, 0, (void*)0, 0};
70393 : static swig_type_info _swigt__p_GDALExtendedDataTypeClass = {"_p_GDALExtendedDataTypeClass", "enum GDALExtendedDataTypeClass *|GDALExtendedDataTypeClass *", 0, 0, (void*)0, 0};
70394 : static swig_type_info _swigt__p_GDALExtendedDataTypeHS = {"_p_GDALExtendedDataTypeHS", "GDALExtendedDataTypeHS *", 0, 0, (void*)0, 0};
70395 : static swig_type_info _swigt__p_GDALExtendedDataTypeSubType = {"_p_GDALExtendedDataTypeSubType", "enum GDALExtendedDataTypeSubType *|GDALExtendedDataTypeSubType *", 0, 0, (void*)0, 0};
70396 : static swig_type_info _swigt__p_GDALFootprintOptions = {"_p_GDALFootprintOptions", "GDALFootprintOptions *", 0, 0, (void*)0, 0};
70397 : static swig_type_info _swigt__p_GDALGridOptions = {"_p_GDALGridOptions", "GDALGridOptions *", 0, 0, (void*)0, 0};
70398 : static swig_type_info _swigt__p_GDALGroupHS = {"_p_GDALGroupHS", "GDALGroupHS *", 0, 0, (void*)0, 0};
70399 : static swig_type_info _swigt__p_GDALInfoOptions = {"_p_GDALInfoOptions", "GDALInfoOptions *", 0, 0, (void*)0, 0};
70400 : static swig_type_info _swigt__p_GDALMDArrayHS = {"_p_GDALMDArrayHS", "GDALMDArrayHS *", 0, 0, (void*)0, 0};
70401 : static swig_type_info _swigt__p_GDALMDArrayRawBlockInfo = {"_p_GDALMDArrayRawBlockInfo", "GDALMDArrayRawBlockInfo *", 0, 0, (void*)0, 0};
70402 : static swig_type_info _swigt__p_GDALMajorObjectShadow = {"_p_GDALMajorObjectShadow", "GDALMajorObjectShadow *", 0, 0, (void*)0, 0};
70403 : static swig_type_info _swigt__p_GDALMultiDimInfoOptions = {"_p_GDALMultiDimInfoOptions", "GDALMultiDimInfoOptions *", 0, 0, (void*)0, 0};
70404 : static swig_type_info _swigt__p_GDALMultiDimTranslateOptions = {"_p_GDALMultiDimTranslateOptions", "GDALMultiDimTranslateOptions *", 0, 0, (void*)0, 0};
70405 : static swig_type_info _swigt__p_GDALNearblackOptions = {"_p_GDALNearblackOptions", "GDALNearblackOptions *", 0, 0, (void*)0, 0};
70406 : static swig_type_info _swigt__p_GDALProgressFunc = {"_p_GDALProgressFunc", "GDALProgressFunc *", 0, 0, (void*)0, 0};
70407 : static swig_type_info _swigt__p_GDALRATDateTime = {"_p_GDALRATDateTime", "GDALRATDateTime *", 0, 0, (void*)0, 0};
70408 : static swig_type_info _swigt__p_GDALRasterAlgebraBinaryOperation = {"_p_GDALRasterAlgebraBinaryOperation", "enum GDALRasterAlgebraBinaryOperation *|GDALRasterAlgebraBinaryOperation *", 0, 0, (void*)0, 0};
70409 : static swig_type_info _swigt__p_GDALRasterAlgebraUnaryOperation = {"_p_GDALRasterAlgebraUnaryOperation", "enum GDALRasterAlgebraUnaryOperation *|GDALRasterAlgebraUnaryOperation *", 0, 0, (void*)0, 0};
70410 : static swig_type_info _swigt__p_GDALRasterAttributeTableShadow = {"_p_GDALRasterAttributeTableShadow", "GDALRasterAttributeTableShadow *", 0, 0, (void*)0, 0};
70411 : static swig_type_info _swigt__p_GDALRasterBandShadow = {"_p_GDALRasterBandShadow", "GDALRasterBandShadow *", 0, 0, (void*)0, 0};
70412 : static swig_type_info _swigt__p_GDALRasterizeOptions = {"_p_GDALRasterizeOptions", "GDALRasterizeOptions *", 0, 0, (void*)0, 0};
70413 : static swig_type_info _swigt__p_GDALRelationshipShadow = {"_p_GDALRelationshipShadow", "GDALRelationshipShadow *", 0, 0, (void*)0, 0};
70414 : static swig_type_info _swigt__p_GDALSubdatasetInfo = {"_p_GDALSubdatasetInfo", "GDALSubdatasetInfo *|GDALSubdatasetInfoShadow *", 0, 0, (void*)0, 0};
70415 : static swig_type_info _swigt__p_GDALTileIndexOptions = {"_p_GDALTileIndexOptions", "GDALTileIndexOptions *", 0, 0, (void*)0, 0};
70416 : static swig_type_info _swigt__p_GDALTransformerInfoShadow = {"_p_GDALTransformerInfoShadow", "GDALTransformerInfoShadow *", 0, 0, (void*)0, 0};
70417 : static swig_type_info _swigt__p_GDALTranslateOptions = {"_p_GDALTranslateOptions", "GDALTranslateOptions *", 0, 0, (void*)0, 0};
70418 : static swig_type_info _swigt__p_GDALVectorInfoOptions = {"_p_GDALVectorInfoOptions", "GDALVectorInfoOptions *", 0, 0, (void*)0, 0};
70419 : static swig_type_info _swigt__p_GDALVectorTranslateOptions = {"_p_GDALVectorTranslateOptions", "GDALVectorTranslateOptions *", 0, 0, (void*)0, 0};
70420 : static swig_type_info _swigt__p_GDALViewshedMode = {"_p_GDALViewshedMode", "enum GDALViewshedMode *|GDALViewshedMode *", 0, 0, (void*)0, 0};
70421 : static swig_type_info _swigt__p_GDALViewshedOutputType = {"_p_GDALViewshedOutputType", "enum GDALViewshedOutputType *|GDALViewshedOutputType *", 0, 0, (void*)0, 0};
70422 : static swig_type_info _swigt__p_GDALWarpAppOptions = {"_p_GDALWarpAppOptions", "GDALWarpAppOptions *", 0, 0, (void*)0, 0};
70423 : static swig_type_info _swigt__p_GDAL_GCP = {"_p_GDAL_GCP", "GDAL_GCP *", 0, 0, (void*)0, 0};
70424 : static swig_type_info _swigt__p_GIntBig = {"_p_GIntBig", "GIntBig *", 0, 0, (void*)0, 0};
70425 : static swig_type_info _swigt__p_GUIntBig = {"_p_GUIntBig", "GUIntBig *", 0, 0, (void*)0, 0};
70426 : static swig_type_info _swigt__p_OGRFeatureShadow = {"_p_OGRFeatureShadow", "OGRFeatureShadow *", 0, 0, (void*)0, 0};
70427 : static swig_type_info _swigt__p_OGRFieldDomainShadow = {"_p_OGRFieldDomainShadow", "OGRFieldDomainShadow *", 0, 0, (void*)0, 0};
70428 : static swig_type_info _swigt__p_OGRGeomFieldDefnShadow = {"_p_OGRGeomFieldDefnShadow", "OGRGeomFieldDefnShadow *", 0, 0, (void*)0, 0};
70429 : static swig_type_info _swigt__p_OGRGeometryShadow = {"_p_OGRGeometryShadow", "OGRGeometryShadow *", 0, 0, (void*)0, 0};
70430 : static swig_type_info _swigt__p_OGRLayerShadow = {"_p_OGRLayerShadow", "OGRLayerShadow *", 0, 0, (void*)0, 0};
70431 : static swig_type_info _swigt__p_OGRStyleTableShadow = {"_p_OGRStyleTableShadow", "OGRStyleTableShadow *", 0, 0, (void*)0, 0};
70432 : static swig_type_info _swigt__p_OSRSpatialReferenceShadow = {"_p_OSRSpatialReferenceShadow", "OSRSpatialReferenceShadow *", 0, 0, (void*)0, 0};
70433 : static swig_type_info _swigt__p_StatBuf = {"_p_StatBuf", "StatBuf *", 0, 0, (void*)0, 0};
70434 : static swig_type_info _swigt__p_Statistics = {"_p_Statistics", "Statistics *", 0, 0, (void*)0, 0};
70435 : static swig_type_info _swigt__p_SuggestedWarpOutputRes = {"_p_SuggestedWarpOutputRes", "SuggestedWarpOutputRes *", 0, 0, (void*)0, 0};
70436 : static swig_type_info _swigt__p_VSIDIR = {"_p_VSIDIR", "VSIDIR *", 0, 0, (void*)0, 0};
70437 : static swig_type_info _swigt__p_VSILFILE = {"_p_VSILFILE", "VSILFILE *", 0, 0, (void*)0, 0};
70438 : static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
70439 : static swig_type_info _swigt__p_char = {"_p_char", "char *|retStringAndCPLFree *", 0, 0, (void*)0, 0};
70440 : static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
70441 : 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};
70442 : static swig_type_info _swigt__p_int = {"_p_int", "OGRFieldSubType *|OGRFieldDomainType *|GDALRATFieldType *|OGRFieldType *|RETURN_NONE *|GDALRelationshipType *|int *|GDALAccess *|OSRAxisMappingStrategy *|OGRwkbByteOrder *|CPLErr *|GDALRWFlag *|OGRJustification *|GDALRATFieldUsage *|GDALTileOrganization *|OGRAxisOrientation *|GDALPaletteInterp *|GDALColorInterp *|GDALRIOResampleAlg *|GDALResampleAlg *|OGRErr *|OGRwkbGeometryType *|GDALDataType *|GDALAsyncStatusType *|GDALAlgorithmArgType *|GDALRATTableType *|GDALRelationshipCardinality *|OGRFieldDomainMergePolicy *|OGRFieldDomainSplitPolicy *", 0, 0, (void*)0, 0};
70443 : static swig_type_info _swigt__p_long_long = {"_p_long_long", "long long *", 0, 0, (void*)0, 0};
70444 : static swig_type_info _swigt__p_p_GByte = {"_p_p_GByte", "GByte **", 0, 0, (void*)0, 0};
70445 : static swig_type_info _swigt__p_p_GDALDatasetShadow = {"_p_p_GDALDatasetShadow", "GDALDatasetShadow **", 0, 0, (void*)0, 0};
70446 : static swig_type_info _swigt__p_p_GDALDimensionHS = {"_p_p_GDALDimensionHS", "GDALDimensionHS **", 0, 0, (void*)0, 0};
70447 : static swig_type_info _swigt__p_p_GDALEDTComponentHS = {"_p_p_GDALEDTComponentHS", "GDALEDTComponentHS **", 0, 0, (void*)0, 0};
70448 : static swig_type_info _swigt__p_p_GDALMDArrayHS = {"_p_p_GDALMDArrayHS", "GDALMDArrayHS **", 0, 0, (void*)0, 0};
70449 : static swig_type_info _swigt__p_p_GDALRasterBandShadow = {"_p_p_GDALRasterBandShadow", "GDALRasterBandShadow **", 0, 0, (void*)0, 0};
70450 : static swig_type_info _swigt__p_p_GDALComputedRasterBandShadow = {"_p_p_GDALComputedRasterBandShadow", 0, 0, 0, 0, 0};
70451 : static swig_type_info _swigt__p_p_GDAL_GCP = {"_p_p_GDAL_GCP", "GDAL_GCP **", 0, 0, (void*)0, 0};
70452 : static swig_type_info _swigt__p_p_GUIntBig = {"_p_p_GUIntBig", "GUIntBig **", 0, 0, (void*)0, 0};
70453 : static swig_type_info _swigt__p_p_OGRLayerShadow = {"_p_p_OGRLayerShadow", "OGRLayerShadow **", 0, 0, (void*)0, 0};
70454 : static swig_type_info _swigt__p_p_OSRSpatialReferenceShadow = {"_p_p_OSRSpatialReferenceShadow", "OSRSpatialReferenceShadow **", 0, 0, (void*)0, 0};
70455 : static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
70456 : static swig_type_info _swigt__p_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0};
70457 : static swig_type_info _swigt__p_p_int = {"_p_p_int", "int **", 0, 0, (void*)0, 0};
70458 : static swig_type_info _swigt__p_p_long_long = {"_p_p_long_long", "long long **", 0, 0, (void*)0, 0};
70459 : static swig_type_info _swigt__p_p_p_GDALAttributeHS = {"_p_p_p_GDALAttributeHS", "GDALAttributeHS ***", 0, 0, (void*)0, 0};
70460 : static swig_type_info _swigt__p_p_p_GDALDimensionHS = {"_p_p_p_GDALDimensionHS", "GDALDimensionHS ***", 0, 0, (void*)0, 0};
70461 : static swig_type_info _swigt__p_p_p_GDALEDTComponentHS = {"_p_p_p_GDALEDTComponentHS", "GDALEDTComponentHS ***", 0, 0, (void*)0, 0};
70462 : static swig_type_info _swigt__p_p_p_GDALMDArrayHS = {"_p_p_p_GDALMDArrayHS", "GDALMDArrayHS ***", 0, 0, (void*)0, 0};
70463 : static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
70464 : static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
70465 : static swig_type_info _swigt__p_vsi_l_offset = {"_p_vsi_l_offset", "vsi_l_offset *", 0, 0, (void*)0, 0};
70466 :
70467 : static swig_type_info *swig_type_initial[] = {
70468 : &_swigt__p_CPLErrorHandler,
70469 : &_swigt__p_CPLVirtualMemShadow,
70470 : &_swigt__p_CPLXMLNode,
70471 : &_swigt__p_DirEntry,
70472 : &_swigt__p_GByte,
70473 : &_swigt__p_GDALAlgorithmArgHS,
70474 : &_swigt__p_GDALAlgorithmHS,
70475 : &_swigt__p_GDALAlgorithmRegistryHS,
70476 : &_swigt__p_GDALArgDatasetValueHS,
70477 : &_swigt__p_GDALAsyncReaderShadow,
70478 : &_swigt__p_GDALAttributeHS,
70479 : &_swigt__p_GDALBuildVRTOptions,
70480 : &_swigt__p_GDALColorEntry,
70481 : &_swigt__p_GDALColorTableShadow,
70482 : &_swigt__p_GDALComputedRasterBandShadow,
70483 : &_swigt__p_GDALContourOptions,
70484 : &_swigt__p_GDALDEMProcessingOptions,
70485 : &_swigt__p_GDALDatasetShadow,
70486 : &_swigt__p_GDALDimensionHS,
70487 : &_swigt__p_GDALDriverShadow,
70488 : &_swigt__p_GDALEDTComponentHS,
70489 : &_swigt__p_GDALExtendedDataTypeClass,
70490 : &_swigt__p_GDALExtendedDataTypeHS,
70491 : &_swigt__p_GDALExtendedDataTypeSubType,
70492 : &_swigt__p_GDALFootprintOptions,
70493 : &_swigt__p_GDALGridOptions,
70494 : &_swigt__p_GDALGroupHS,
70495 : &_swigt__p_GDALInfoOptions,
70496 : &_swigt__p_GDALMDArrayHS,
70497 : &_swigt__p_GDALMDArrayRawBlockInfo,
70498 : &_swigt__p_GDALMajorObjectShadow,
70499 : &_swigt__p_GDALMultiDimInfoOptions,
70500 : &_swigt__p_GDALMultiDimTranslateOptions,
70501 : &_swigt__p_GDALNearblackOptions,
70502 : &_swigt__p_GDALProgressFunc,
70503 : &_swigt__p_GDALRATDateTime,
70504 : &_swigt__p_GDALRasterAlgebraBinaryOperation,
70505 : &_swigt__p_GDALRasterAlgebraUnaryOperation,
70506 : &_swigt__p_GDALRasterAttributeTableShadow,
70507 : &_swigt__p_GDALRasterBandShadow,
70508 : &_swigt__p_GDALRasterizeOptions,
70509 : &_swigt__p_GDALRelationshipShadow,
70510 : &_swigt__p_GDALSubdatasetInfo,
70511 : &_swigt__p_GDALTileIndexOptions,
70512 : &_swigt__p_GDALTransformerInfoShadow,
70513 : &_swigt__p_GDALTranslateOptions,
70514 : &_swigt__p_GDALVectorInfoOptions,
70515 : &_swigt__p_GDALVectorTranslateOptions,
70516 : &_swigt__p_GDALViewshedMode,
70517 : &_swigt__p_GDALViewshedOutputType,
70518 : &_swigt__p_GDALWarpAppOptions,
70519 : &_swigt__p_GDAL_GCP,
70520 : &_swigt__p_GIntBig,
70521 : &_swigt__p_GUIntBig,
70522 : &_swigt__p_OGRFeatureShadow,
70523 : &_swigt__p_OGRFieldDomainShadow,
70524 : &_swigt__p_OGRGeomFieldDefnShadow,
70525 : &_swigt__p_OGRGeometryShadow,
70526 : &_swigt__p_OGRLayerShadow,
70527 : &_swigt__p_OGRStyleTableShadow,
70528 : &_swigt__p_OSRSpatialReferenceShadow,
70529 : &_swigt__p_StatBuf,
70530 : &_swigt__p_Statistics,
70531 : &_swigt__p_SuggestedWarpOutputRes,
70532 : &_swigt__p_VSIDIR,
70533 : &_swigt__p_VSILFILE,
70534 : &_swigt__p_bool,
70535 : &_swigt__p_char,
70536 : &_swigt__p_double,
70537 : &_swigt__p_f_double_p_q_const__char_p_void__int,
70538 : &_swigt__p_int,
70539 : &_swigt__p_long_long,
70540 : &_swigt__p_p_GByte,
70541 : &_swigt__p_p_GDALComputedRasterBandShadow,
70542 : &_swigt__p_p_GDALDatasetShadow,
70543 : &_swigt__p_p_GDALDimensionHS,
70544 : &_swigt__p_p_GDALEDTComponentHS,
70545 : &_swigt__p_p_GDALMDArrayHS,
70546 : &_swigt__p_p_GDALRasterBandShadow,
70547 : &_swigt__p_p_GDAL_GCP,
70548 : &_swigt__p_p_GUIntBig,
70549 : &_swigt__p_p_OGRLayerShadow,
70550 : &_swigt__p_p_OSRSpatialReferenceShadow,
70551 : &_swigt__p_p_char,
70552 : &_swigt__p_p_double,
70553 : &_swigt__p_p_int,
70554 : &_swigt__p_p_long_long,
70555 : &_swigt__p_p_p_GDALAttributeHS,
70556 : &_swigt__p_p_p_GDALDimensionHS,
70557 : &_swigt__p_p_p_GDALEDTComponentHS,
70558 : &_swigt__p_p_p_GDALMDArrayHS,
70559 : &_swigt__p_p_void,
70560 : &_swigt__p_size_t,
70561 : &_swigt__p_vsi_l_offset,
70562 : };
70563 :
70564 : static swig_cast_info _swigc__p_CPLErrorHandler[] = { {&_swigt__p_CPLErrorHandler, 0, 0, 0},{0, 0, 0, 0}};
70565 : static swig_cast_info _swigc__p_CPLVirtualMemShadow[] = { {&_swigt__p_CPLVirtualMemShadow, 0, 0, 0},{0, 0, 0, 0}};
70566 : static swig_cast_info _swigc__p_CPLXMLNode[] = { {&_swigt__p_CPLXMLNode, 0, 0, 0},{0, 0, 0, 0}};
70567 : static swig_cast_info _swigc__p_DirEntry[] = { {&_swigt__p_DirEntry, 0, 0, 0},{0, 0, 0, 0}};
70568 : static swig_cast_info _swigc__p_GByte[] = { {&_swigt__p_GByte, 0, 0, 0},{0, 0, 0, 0}};
70569 : static swig_cast_info _swigc__p_GDALAlgorithmArgHS[] = { {&_swigt__p_GDALAlgorithmArgHS, 0, 0, 0},{0, 0, 0, 0}};
70570 : static swig_cast_info _swigc__p_GDALAlgorithmHS[] = { {&_swigt__p_GDALAlgorithmHS, 0, 0, 0},{0, 0, 0, 0}};
70571 : static swig_cast_info _swigc__p_GDALAlgorithmRegistryHS[] = { {&_swigt__p_GDALAlgorithmRegistryHS, 0, 0, 0},{0, 0, 0, 0}};
70572 : static swig_cast_info _swigc__p_GDALArgDatasetValueHS[] = { {&_swigt__p_GDALArgDatasetValueHS, 0, 0, 0},{0, 0, 0, 0}};
70573 : static swig_cast_info _swigc__p_GDALAsyncReaderShadow[] = { {&_swigt__p_GDALAsyncReaderShadow, 0, 0, 0},{0, 0, 0, 0}};
70574 : static swig_cast_info _swigc__p_GDALAttributeHS[] = { {&_swigt__p_GDALAttributeHS, 0, 0, 0},{0, 0, 0, 0}};
70575 : static swig_cast_info _swigc__p_GDALBuildVRTOptions[] = { {&_swigt__p_GDALBuildVRTOptions, 0, 0, 0},{0, 0, 0, 0}};
70576 : static swig_cast_info _swigc__p_GDALColorEntry[] = { {&_swigt__p_GDALColorEntry, 0, 0, 0},{0, 0, 0, 0}};
70577 : static swig_cast_info _swigc__p_GDALColorTableShadow[] = { {&_swigt__p_GDALColorTableShadow, 0, 0, 0},{0, 0, 0, 0}};
70578 : static swig_cast_info _swigc__p_GDALComputedRasterBandShadow[] = { {&_swigt__p_GDALComputedRasterBandShadow, 0, 0, 0},{0, 0, 0, 0}};
70579 : static swig_cast_info _swigc__p_GDALContourOptions[] = { {&_swigt__p_GDALContourOptions, 0, 0, 0},{0, 0, 0, 0}};
70580 : static swig_cast_info _swigc__p_GDALDEMProcessingOptions[] = { {&_swigt__p_GDALDEMProcessingOptions, 0, 0, 0},{0, 0, 0, 0}};
70581 : static swig_cast_info _swigc__p_GDALDatasetShadow[] = { {&_swigt__p_GDALDatasetShadow, 0, 0, 0},{0, 0, 0, 0}};
70582 : static swig_cast_info _swigc__p_GDALDimensionHS[] = { {&_swigt__p_GDALDimensionHS, 0, 0, 0},{0, 0, 0, 0}};
70583 : static swig_cast_info _swigc__p_GDALDriverShadow[] = { {&_swigt__p_GDALDriverShadow, 0, 0, 0},{0, 0, 0, 0}};
70584 : static swig_cast_info _swigc__p_GDALEDTComponentHS[] = { {&_swigt__p_GDALEDTComponentHS, 0, 0, 0},{0, 0, 0, 0}};
70585 : static swig_cast_info _swigc__p_GDALExtendedDataTypeClass[] = { {&_swigt__p_GDALExtendedDataTypeClass, 0, 0, 0},{0, 0, 0, 0}};
70586 : static swig_cast_info _swigc__p_GDALExtendedDataTypeHS[] = { {&_swigt__p_GDALExtendedDataTypeHS, 0, 0, 0},{0, 0, 0, 0}};
70587 : static swig_cast_info _swigc__p_GDALExtendedDataTypeSubType[] = { {&_swigt__p_GDALExtendedDataTypeSubType, 0, 0, 0},{0, 0, 0, 0}};
70588 : static swig_cast_info _swigc__p_GDALFootprintOptions[] = { {&_swigt__p_GDALFootprintOptions, 0, 0, 0},{0, 0, 0, 0}};
70589 : static swig_cast_info _swigc__p_GDALGridOptions[] = { {&_swigt__p_GDALGridOptions, 0, 0, 0},{0, 0, 0, 0}};
70590 : static swig_cast_info _swigc__p_GDALGroupHS[] = { {&_swigt__p_GDALGroupHS, 0, 0, 0},{0, 0, 0, 0}};
70591 : static swig_cast_info _swigc__p_GDALInfoOptions[] = { {&_swigt__p_GDALInfoOptions, 0, 0, 0},{0, 0, 0, 0}};
70592 : static swig_cast_info _swigc__p_GDALMDArrayHS[] = { {&_swigt__p_GDALMDArrayHS, 0, 0, 0},{0, 0, 0, 0}};
70593 : static swig_cast_info _swigc__p_GDALMDArrayRawBlockInfo[] = { {&_swigt__p_GDALMDArrayRawBlockInfo, 0, 0, 0},{0, 0, 0, 0}};
70594 : static swig_cast_info _swigc__p_GDALMajorObjectShadow[] = { {&_swigt__p_GDALMajorObjectShadow, 0, 0, 0}, {&_swigt__p_GDALDriverShadow, _p_GDALDriverShadowTo_p_GDALMajorObjectShadow, 0, 0}, {&_swigt__p_OGRLayerShadow, _p_OGRLayerShadowTo_p_GDALMajorObjectShadow, 0, 0}, {&_swigt__p_GDALDatasetShadow, _p_GDALDatasetShadowTo_p_GDALMajorObjectShadow, 0, 0}, {&_swigt__p_GDALRasterBandShadow, _p_GDALRasterBandShadowTo_p_GDALMajorObjectShadow, 0, 0}, {&_swigt__p_GDALComputedRasterBandShadow, _p_GDALComputedRasterBandShadowTo_p_GDALMajorObjectShadow, 0, 0},{0, 0, 0, 0}};
70595 : static swig_cast_info _swigc__p_GDALMultiDimInfoOptions[] = { {&_swigt__p_GDALMultiDimInfoOptions, 0, 0, 0},{0, 0, 0, 0}};
70596 : static swig_cast_info _swigc__p_GDALMultiDimTranslateOptions[] = { {&_swigt__p_GDALMultiDimTranslateOptions, 0, 0, 0},{0, 0, 0, 0}};
70597 : static swig_cast_info _swigc__p_GDALNearblackOptions[] = { {&_swigt__p_GDALNearblackOptions, 0, 0, 0},{0, 0, 0, 0}};
70598 : static swig_cast_info _swigc__p_GDALProgressFunc[] = { {&_swigt__p_GDALProgressFunc, 0, 0, 0},{0, 0, 0, 0}};
70599 : static swig_cast_info _swigc__p_GDALRATDateTime[] = { {&_swigt__p_GDALRATDateTime, 0, 0, 0},{0, 0, 0, 0}};
70600 : static swig_cast_info _swigc__p_GDALRasterAlgebraBinaryOperation[] = { {&_swigt__p_GDALRasterAlgebraBinaryOperation, 0, 0, 0},{0, 0, 0, 0}};
70601 : static swig_cast_info _swigc__p_GDALRasterAlgebraUnaryOperation[] = { {&_swigt__p_GDALRasterAlgebraUnaryOperation, 0, 0, 0},{0, 0, 0, 0}};
70602 : static swig_cast_info _swigc__p_GDALRasterAttributeTableShadow[] = { {&_swigt__p_GDALRasterAttributeTableShadow, 0, 0, 0},{0, 0, 0, 0}};
70603 : static swig_cast_info _swigc__p_GDALRasterBandShadow[] = { {&_swigt__p_GDALRasterBandShadow, 0, 0, 0}, {&_swigt__p_GDALComputedRasterBandShadow, _p_GDALComputedRasterBandShadowTo_p_GDALRasterBandShadow, 0, 0},{0, 0, 0, 0}};
70604 : static swig_cast_info _swigc__p_GDALRasterizeOptions[] = { {&_swigt__p_GDALRasterizeOptions, 0, 0, 0},{0, 0, 0, 0}};
70605 : static swig_cast_info _swigc__p_GDALRelationshipShadow[] = { {&_swigt__p_GDALRelationshipShadow, 0, 0, 0},{0, 0, 0, 0}};
70606 : static swig_cast_info _swigc__p_GDALSubdatasetInfo[] = { {&_swigt__p_GDALSubdatasetInfo, 0, 0, 0},{0, 0, 0, 0}};
70607 : static swig_cast_info _swigc__p_GDALTileIndexOptions[] = { {&_swigt__p_GDALTileIndexOptions, 0, 0, 0},{0, 0, 0, 0}};
70608 : static swig_cast_info _swigc__p_GDALTransformerInfoShadow[] = { {&_swigt__p_GDALTransformerInfoShadow, 0, 0, 0},{0, 0, 0, 0}};
70609 : static swig_cast_info _swigc__p_GDALTranslateOptions[] = { {&_swigt__p_GDALTranslateOptions, 0, 0, 0},{0, 0, 0, 0}};
70610 : static swig_cast_info _swigc__p_GDALVectorInfoOptions[] = { {&_swigt__p_GDALVectorInfoOptions, 0, 0, 0},{0, 0, 0, 0}};
70611 : static swig_cast_info _swigc__p_GDALVectorTranslateOptions[] = { {&_swigt__p_GDALVectorTranslateOptions, 0, 0, 0},{0, 0, 0, 0}};
70612 : static swig_cast_info _swigc__p_GDALViewshedMode[] = { {&_swigt__p_GDALViewshedMode, 0, 0, 0},{0, 0, 0, 0}};
70613 : static swig_cast_info _swigc__p_GDALViewshedOutputType[] = { {&_swigt__p_GDALViewshedOutputType, 0, 0, 0},{0, 0, 0, 0}};
70614 : static swig_cast_info _swigc__p_GDALWarpAppOptions[] = { {&_swigt__p_GDALWarpAppOptions, 0, 0, 0},{0, 0, 0, 0}};
70615 : static swig_cast_info _swigc__p_GDAL_GCP[] = { {&_swigt__p_GDAL_GCP, 0, 0, 0},{0, 0, 0, 0}};
70616 : static swig_cast_info _swigc__p_GIntBig[] = { {&_swigt__p_GIntBig, 0, 0, 0},{0, 0, 0, 0}};
70617 : static swig_cast_info _swigc__p_GUIntBig[] = { {&_swigt__p_GUIntBig, 0, 0, 0},{0, 0, 0, 0}};
70618 : static swig_cast_info _swigc__p_OGRFeatureShadow[] = { {&_swigt__p_OGRFeatureShadow, 0, 0, 0},{0, 0, 0, 0}};
70619 : static swig_cast_info _swigc__p_OGRFieldDomainShadow[] = { {&_swigt__p_OGRFieldDomainShadow, 0, 0, 0},{0, 0, 0, 0}};
70620 : static swig_cast_info _swigc__p_OGRGeomFieldDefnShadow[] = { {&_swigt__p_OGRGeomFieldDefnShadow, 0, 0, 0},{0, 0, 0, 0}};
70621 : static swig_cast_info _swigc__p_OGRGeometryShadow[] = { {&_swigt__p_OGRGeometryShadow, 0, 0, 0},{0, 0, 0, 0}};
70622 : static swig_cast_info _swigc__p_OGRLayerShadow[] = { {&_swigt__p_OGRLayerShadow, 0, 0, 0},{0, 0, 0, 0}};
70623 : static swig_cast_info _swigc__p_OGRStyleTableShadow[] = { {&_swigt__p_OGRStyleTableShadow, 0, 0, 0},{0, 0, 0, 0}};
70624 : static swig_cast_info _swigc__p_OSRSpatialReferenceShadow[] = { {&_swigt__p_OSRSpatialReferenceShadow, 0, 0, 0},{0, 0, 0, 0}};
70625 : static swig_cast_info _swigc__p_StatBuf[] = { {&_swigt__p_StatBuf, 0, 0, 0},{0, 0, 0, 0}};
70626 : static swig_cast_info _swigc__p_Statistics[] = { {&_swigt__p_Statistics, 0, 0, 0},{0, 0, 0, 0}};
70627 : static swig_cast_info _swigc__p_SuggestedWarpOutputRes[] = { {&_swigt__p_SuggestedWarpOutputRes, 0, 0, 0},{0, 0, 0, 0}};
70628 : static swig_cast_info _swigc__p_VSIDIR[] = { {&_swigt__p_VSIDIR, 0, 0, 0},{0, 0, 0, 0}};
70629 : static swig_cast_info _swigc__p_VSILFILE[] = { {&_swigt__p_VSILFILE, 0, 0, 0},{0, 0, 0, 0}};
70630 : static swig_cast_info _swigc__p_bool[] = { {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
70631 : static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
70632 : static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
70633 : 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}};
70634 : static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
70635 : static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
70636 : static swig_cast_info _swigc__p_p_GByte[] = { {&_swigt__p_p_GByte, 0, 0, 0},{0, 0, 0, 0}};
70637 : static swig_cast_info _swigc__p_p_GDALDatasetShadow[] = { {&_swigt__p_p_GDALDatasetShadow, 0, 0, 0},{0, 0, 0, 0}};
70638 : static swig_cast_info _swigc__p_p_GDALDimensionHS[] = { {&_swigt__p_p_GDALDimensionHS, 0, 0, 0},{0, 0, 0, 0}};
70639 : static swig_cast_info _swigc__p_p_GDALEDTComponentHS[] = { {&_swigt__p_p_GDALEDTComponentHS, 0, 0, 0},{0, 0, 0, 0}};
70640 : static swig_cast_info _swigc__p_p_GDALMDArrayHS[] = { {&_swigt__p_p_GDALMDArrayHS, 0, 0, 0},{0, 0, 0, 0}};
70641 : static swig_cast_info _swigc__p_p_GDALComputedRasterBandShadow[] = {{&_swigt__p_p_GDALComputedRasterBandShadow, 0, 0, 0},{0, 0, 0, 0}};
70642 : static swig_cast_info _swigc__p_p_GDALRasterBandShadow[] = { {&_swigt__p_p_GDALRasterBandShadow, 0, 0, 0}, {&_swigt__p_p_GDALComputedRasterBandShadow, _p_p_GDALComputedRasterBandShadowTo_p_p_GDALRasterBandShadow, 0, 0},{0, 0, 0, 0}};
70643 : static swig_cast_info _swigc__p_p_GDAL_GCP[] = { {&_swigt__p_p_GDAL_GCP, 0, 0, 0},{0, 0, 0, 0}};
70644 : static swig_cast_info _swigc__p_p_GUIntBig[] = { {&_swigt__p_p_GUIntBig, 0, 0, 0},{0, 0, 0, 0}};
70645 : static swig_cast_info _swigc__p_p_OGRLayerShadow[] = { {&_swigt__p_p_OGRLayerShadow, 0, 0, 0},{0, 0, 0, 0}};
70646 : static swig_cast_info _swigc__p_p_OSRSpatialReferenceShadow[] = { {&_swigt__p_p_OSRSpatialReferenceShadow, 0, 0, 0},{0, 0, 0, 0}};
70647 : static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
70648 : static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
70649 : static swig_cast_info _swigc__p_p_int[] = { {&_swigt__p_p_int, 0, 0, 0},{0, 0, 0, 0}};
70650 : static swig_cast_info _swigc__p_p_long_long[] = { {&_swigt__p_p_long_long, 0, 0, 0},{0, 0, 0, 0}};
70651 : static swig_cast_info _swigc__p_p_p_GDALAttributeHS[] = { {&_swigt__p_p_p_GDALAttributeHS, 0, 0, 0},{0, 0, 0, 0}};
70652 : static swig_cast_info _swigc__p_p_p_GDALDimensionHS[] = { {&_swigt__p_p_p_GDALDimensionHS, 0, 0, 0},{0, 0, 0, 0}};
70653 : static swig_cast_info _swigc__p_p_p_GDALEDTComponentHS[] = { {&_swigt__p_p_p_GDALEDTComponentHS, 0, 0, 0},{0, 0, 0, 0}};
70654 : static swig_cast_info _swigc__p_p_p_GDALMDArrayHS[] = { {&_swigt__p_p_p_GDALMDArrayHS, 0, 0, 0},{0, 0, 0, 0}};
70655 : static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
70656 : static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
70657 : static swig_cast_info _swigc__p_vsi_l_offset[] = { {&_swigt__p_vsi_l_offset, 0, 0, 0},{0, 0, 0, 0}};
70658 :
70659 : static swig_cast_info *swig_cast_initial[] = {
70660 : _swigc__p_CPLErrorHandler,
70661 : _swigc__p_CPLVirtualMemShadow,
70662 : _swigc__p_CPLXMLNode,
70663 : _swigc__p_DirEntry,
70664 : _swigc__p_GByte,
70665 : _swigc__p_GDALAlgorithmArgHS,
70666 : _swigc__p_GDALAlgorithmHS,
70667 : _swigc__p_GDALAlgorithmRegistryHS,
70668 : _swigc__p_GDALArgDatasetValueHS,
70669 : _swigc__p_GDALAsyncReaderShadow,
70670 : _swigc__p_GDALAttributeHS,
70671 : _swigc__p_GDALBuildVRTOptions,
70672 : _swigc__p_GDALColorEntry,
70673 : _swigc__p_GDALColorTableShadow,
70674 : _swigc__p_GDALComputedRasterBandShadow,
70675 : _swigc__p_GDALContourOptions,
70676 : _swigc__p_GDALDEMProcessingOptions,
70677 : _swigc__p_GDALDatasetShadow,
70678 : _swigc__p_GDALDimensionHS,
70679 : _swigc__p_GDALDriverShadow,
70680 : _swigc__p_GDALEDTComponentHS,
70681 : _swigc__p_GDALExtendedDataTypeClass,
70682 : _swigc__p_GDALExtendedDataTypeHS,
70683 : _swigc__p_GDALExtendedDataTypeSubType,
70684 : _swigc__p_GDALFootprintOptions,
70685 : _swigc__p_GDALGridOptions,
70686 : _swigc__p_GDALGroupHS,
70687 : _swigc__p_GDALInfoOptions,
70688 : _swigc__p_GDALMDArrayHS,
70689 : _swigc__p_GDALMDArrayRawBlockInfo,
70690 : _swigc__p_GDALMajorObjectShadow,
70691 : _swigc__p_GDALMultiDimInfoOptions,
70692 : _swigc__p_GDALMultiDimTranslateOptions,
70693 : _swigc__p_GDALNearblackOptions,
70694 : _swigc__p_GDALProgressFunc,
70695 : _swigc__p_GDALRATDateTime,
70696 : _swigc__p_GDALRasterAlgebraBinaryOperation,
70697 : _swigc__p_GDALRasterAlgebraUnaryOperation,
70698 : _swigc__p_GDALRasterAttributeTableShadow,
70699 : _swigc__p_GDALRasterBandShadow,
70700 : _swigc__p_GDALRasterizeOptions,
70701 : _swigc__p_GDALRelationshipShadow,
70702 : _swigc__p_GDALSubdatasetInfo,
70703 : _swigc__p_GDALTileIndexOptions,
70704 : _swigc__p_GDALTransformerInfoShadow,
70705 : _swigc__p_GDALTranslateOptions,
70706 : _swigc__p_GDALVectorInfoOptions,
70707 : _swigc__p_GDALVectorTranslateOptions,
70708 : _swigc__p_GDALViewshedMode,
70709 : _swigc__p_GDALViewshedOutputType,
70710 : _swigc__p_GDALWarpAppOptions,
70711 : _swigc__p_GDAL_GCP,
70712 : _swigc__p_GIntBig,
70713 : _swigc__p_GUIntBig,
70714 : _swigc__p_OGRFeatureShadow,
70715 : _swigc__p_OGRFieldDomainShadow,
70716 : _swigc__p_OGRGeomFieldDefnShadow,
70717 : _swigc__p_OGRGeometryShadow,
70718 : _swigc__p_OGRLayerShadow,
70719 : _swigc__p_OGRStyleTableShadow,
70720 : _swigc__p_OSRSpatialReferenceShadow,
70721 : _swigc__p_StatBuf,
70722 : _swigc__p_Statistics,
70723 : _swigc__p_SuggestedWarpOutputRes,
70724 : _swigc__p_VSIDIR,
70725 : _swigc__p_VSILFILE,
70726 : _swigc__p_bool,
70727 : _swigc__p_char,
70728 : _swigc__p_double,
70729 : _swigc__p_f_double_p_q_const__char_p_void__int,
70730 : _swigc__p_int,
70731 : _swigc__p_long_long,
70732 : _swigc__p_p_GByte,
70733 : _swigc__p_p_GDALComputedRasterBandShadow,
70734 : _swigc__p_p_GDALDatasetShadow,
70735 : _swigc__p_p_GDALDimensionHS,
70736 : _swigc__p_p_GDALEDTComponentHS,
70737 : _swigc__p_p_GDALMDArrayHS,
70738 : _swigc__p_p_GDALRasterBandShadow,
70739 : _swigc__p_p_GDAL_GCP,
70740 : _swigc__p_p_GUIntBig,
70741 : _swigc__p_p_OGRLayerShadow,
70742 : _swigc__p_p_OSRSpatialReferenceShadow,
70743 : _swigc__p_p_char,
70744 : _swigc__p_p_double,
70745 : _swigc__p_p_int,
70746 : _swigc__p_p_long_long,
70747 : _swigc__p_p_p_GDALAttributeHS,
70748 : _swigc__p_p_p_GDALDimensionHS,
70749 : _swigc__p_p_p_GDALEDTComponentHS,
70750 : _swigc__p_p_p_GDALMDArrayHS,
70751 : _swigc__p_p_void,
70752 : _swigc__p_size_t,
70753 : _swigc__p_vsi_l_offset,
70754 : };
70755 :
70756 :
70757 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
70758 :
70759 : static swig_const_info swig_const_table[] = {
70760 : { SWIG_PY_POINTER, "TermProgress", 0, 0, (void *)((int (*)(double,char const *,void *))(GDALTermProgress)), &SWIGTYPE_p_f_double_p_q_const__char_p_void__int },
70761 : {0, 0, 0, 0.0, 0, 0}};
70762 :
70763 : #ifdef __cplusplus
70764 : }
70765 : #endif
70766 : /* -----------------------------------------------------------------------------
70767 : * Type initialization:
70768 : * This problem is tough by the requirement that no dynamic
70769 : * memory is used. Also, since swig_type_info structures store pointers to
70770 : * swig_cast_info structures and swig_cast_info structures store pointers back
70771 : * to swig_type_info structures, we need some lookup code at initialization.
70772 : * The idea is that swig generates all the structures that are needed.
70773 : * The runtime then collects these partially filled structures.
70774 : * The SWIG_InitializeModule function takes these initial arrays out of
70775 : * swig_module, and does all the lookup, filling in the swig_module.types
70776 : * array with the correct data and linking the correct swig_cast_info
70777 : * structures together.
70778 : *
70779 : * The generated swig_type_info structures are assigned statically to an initial
70780 : * array. We just loop through that array, and handle each type individually.
70781 : * First we lookup if this type has been already loaded, and if so, use the
70782 : * loaded structure instead of the generated one. Then we have to fill in the
70783 : * cast linked list. The cast data is initially stored in something like a
70784 : * two-dimensional array. Each row corresponds to a type (there are the same
70785 : * number of rows as there are in the swig_type_initial array). Each entry in
70786 : * a column is one of the swig_cast_info structures for that type.
70787 : * The cast_initial array is actually an array of arrays, because each row has
70788 : * a variable number of columns. So to actually build the cast linked list,
70789 : * we find the array of casts associated with the type, and loop through it
70790 : * adding the casts to the list. The one last trick we need to do is making
70791 : * sure the type pointer in the swig_cast_info struct is correct.
70792 : *
70793 : * First off, we lookup the cast->type name to see if it is already loaded.
70794 : * There are three cases to handle:
70795 : * 1) If the cast->type has already been loaded AND the type we are adding
70796 : * casting info to has not been loaded (it is in this module), THEN we
70797 : * replace the cast->type pointer with the type pointer that has already
70798 : * been loaded.
70799 : * 2) If BOTH types (the one we are adding casting info to, and the
70800 : * cast->type) are loaded, THEN the cast info has already been loaded by
70801 : * the previous module so we just ignore it.
70802 : * 3) Finally, if cast->type has not already been loaded, then we add that
70803 : * swig_cast_info to the linked list (because the cast->type) pointer will
70804 : * be correct.
70805 : * ----------------------------------------------------------------------------- */
70806 :
70807 : #ifdef __cplusplus
70808 : extern "C" {
70809 : #if 0
70810 : } /* c-mode */
70811 : #endif
70812 : #endif
70813 :
70814 : #if 0
70815 : #define SWIGRUNTIME_DEBUG
70816 : #endif
70817 :
70818 :
70819 : SWIGRUNTIME void
70820 : SWIG_InitializeModule(void *clientdata) {
70821 : size_t i;
70822 : swig_module_info *module_head, *iter;
70823 : int init;
70824 :
70825 : /* check to see if the circular list has been setup, if not, set it up */
70826 : if (swig_module.next==0) {
70827 : /* Initialize the swig_module */
70828 : swig_module.type_initial = swig_type_initial;
70829 : swig_module.cast_initial = swig_cast_initial;
70830 : swig_module.next = &swig_module;
70831 : init = 1;
70832 : } else {
70833 : init = 0;
70834 : }
70835 :
70836 : /* Try and load any already created modules */
70837 : module_head = SWIG_GetModule(clientdata);
70838 : if (!module_head) {
70839 : /* This is the first module loaded for this interpreter */
70840 : /* so set the swig module into the interpreter */
70841 : SWIG_SetModule(clientdata, &swig_module);
70842 : } else {
70843 : /* the interpreter has loaded a SWIG module, but has it loaded this one? */
70844 : iter=module_head;
70845 : do {
70846 : if (iter==&swig_module) {
70847 : /* Our module is already in the list, so there's nothing more to do. */
70848 : return;
70849 : }
70850 : iter=iter->next;
70851 : } while (iter!= module_head);
70852 :
70853 : /* otherwise we must add our module into the list */
70854 : swig_module.next = module_head->next;
70855 : module_head->next = &swig_module;
70856 : }
70857 :
70858 : /* When multiple interpreters are used, a module could have already been initialized in
70859 : a different interpreter, but not yet have a pointer in this interpreter.
70860 : In this case, we do not want to continue adding types... everything should be
70861 : set up already */
70862 : if (init == 0) return;
70863 :
70864 : /* Now work on filling in swig_module.types */
70865 : #ifdef SWIGRUNTIME_DEBUG
70866 : printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
70867 : #endif
70868 : for (i = 0; i < swig_module.size; ++i) {
70869 : swig_type_info *type = 0;
70870 : swig_type_info *ret;
70871 : swig_cast_info *cast;
70872 :
70873 : #ifdef SWIGRUNTIME_DEBUG
70874 : printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
70875 : #endif
70876 :
70877 : /* if there is another module already loaded */
70878 : if (swig_module.next != &swig_module) {
70879 : type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
70880 : }
70881 : if (type) {
70882 : /* Overwrite clientdata field */
70883 : #ifdef SWIGRUNTIME_DEBUG
70884 : printf("SWIG_InitializeModule: found type %s\n", type->name);
70885 : #endif
70886 : if (swig_module.type_initial[i]->clientdata) {
70887 : type->clientdata = swig_module.type_initial[i]->clientdata;
70888 : #ifdef SWIGRUNTIME_DEBUG
70889 : printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
70890 : #endif
70891 : }
70892 : } else {
70893 : type = swig_module.type_initial[i];
70894 : }
70895 :
70896 : /* Insert casting types */
70897 : cast = swig_module.cast_initial[i];
70898 : while (cast->type) {
70899 : /* Don't need to add information already in the list */
70900 : ret = 0;
70901 : #ifdef SWIGRUNTIME_DEBUG
70902 : printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
70903 : #endif
70904 : if (swig_module.next != &swig_module) {
70905 : ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
70906 : #ifdef SWIGRUNTIME_DEBUG
70907 : if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
70908 : #endif
70909 : }
70910 : if (ret) {
70911 : if (type == swig_module.type_initial[i]) {
70912 : #ifdef SWIGRUNTIME_DEBUG
70913 : printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
70914 : #endif
70915 : cast->type = ret;
70916 : ret = 0;
70917 : } else {
70918 : /* Check for casting already in the list */
70919 : swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
70920 : #ifdef SWIGRUNTIME_DEBUG
70921 : if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
70922 : #endif
70923 : if (!ocast) ret = 0;
70924 : }
70925 : }
70926 :
70927 : if (!ret) {
70928 : #ifdef SWIGRUNTIME_DEBUG
70929 : printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
70930 : #endif
70931 : if (type->cast) {
70932 : type->cast->prev = cast;
70933 : cast->next = type->cast;
70934 : }
70935 : type->cast = cast;
70936 : }
70937 : cast++;
70938 : }
70939 : /* Set entry in modules->types array equal to the type */
70940 : swig_module.types[i] = type;
70941 : }
70942 : swig_module.types[i] = 0;
70943 :
70944 : #ifdef SWIGRUNTIME_DEBUG
70945 : printf("**** SWIG_InitializeModule: Cast List ******\n");
70946 : for (i = 0; i < swig_module.size; ++i) {
70947 : int j = 0;
70948 : swig_cast_info *cast = swig_module.cast_initial[i];
70949 : printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
70950 : while (cast->type) {
70951 : printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
70952 : cast++;
70953 : ++j;
70954 : }
70955 : printf("---- Total casts: %d\n",j);
70956 : }
70957 : printf("**** SWIG_InitializeModule: Cast List ******\n");
70958 : #endif
70959 : }
70960 :
70961 : /* This function will propagate the clientdata field of type to
70962 : * any new swig_type_info structures that have been added into the list
70963 : * of equivalent types. It is like calling
70964 : * SWIG_TypeClientData(type, clientdata) a second time.
70965 : */
70966 : SWIGRUNTIME void
70967 : SWIG_PropagateClientData(void) {
70968 : size_t i;
70969 : swig_cast_info *equiv;
70970 : static int init_run = 0;
70971 :
70972 : if (init_run) return;
70973 : init_run = 1;
70974 :
70975 : for (i = 0; i < swig_module.size; i++) {
70976 : if (swig_module.types[i]->clientdata) {
70977 : equiv = swig_module.types[i]->cast;
70978 : while (equiv) {
70979 : if (!equiv->converter) {
70980 : if (equiv->type && !equiv->type->clientdata)
70981 : SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
70982 : }
70983 : equiv = equiv->next;
70984 : }
70985 : }
70986 : }
70987 : }
70988 :
70989 : #ifdef __cplusplus
70990 : #if 0
70991 : {
70992 : /* c-mode */
70993 : #endif
70994 : }
70995 : #endif
70996 :
70997 :
70998 :
70999 : #ifdef __cplusplus
71000 : extern "C" {
71001 : #endif
71002 :
71003 : /* Python-specific SWIG API */
71004 : #define SWIG_newvarlink() SWIG_Python_newvarlink()
71005 : #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
71006 : #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
71007 :
71008 : /* -----------------------------------------------------------------------------
71009 : * global variable support code.
71010 : * ----------------------------------------------------------------------------- */
71011 :
71012 : typedef struct swig_globalvar {
71013 : char *name; /* Name of global variable */
71014 : PyObject *(*get_attr)(void); /* Return the current value */
71015 : int (*set_attr)(PyObject *); /* Set the value */
71016 : struct swig_globalvar *next;
71017 : } swig_globalvar;
71018 :
71019 : typedef struct swig_varlinkobject {
71020 : PyObject_HEAD
71021 : swig_globalvar *vars;
71022 : } swig_varlinkobject;
71023 :
71024 : SWIGINTERN PyObject *
71025 : swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
71026 : #if PY_VERSION_HEX >= 0x03000000
71027 : return PyUnicode_InternFromString("<Swig global variables>");
71028 : #else
71029 : return PyString_FromString("<Swig global variables>");
71030 : #endif
71031 : }
71032 :
71033 : SWIGINTERN PyObject *
71034 : swig_varlink_str(swig_varlinkobject *v) {
71035 : #if PY_VERSION_HEX >= 0x03000000
71036 : PyObject *str = PyUnicode_InternFromString("(");
71037 : PyObject *tail;
71038 : PyObject *joined;
71039 : swig_globalvar *var;
71040 : for (var = v->vars; var; var=var->next) {
71041 : tail = PyUnicode_FromString(var->name);
71042 : joined = PyUnicode_Concat(str, tail);
71043 : Py_DecRef(str);
71044 : Py_DecRef(tail);
71045 : str = joined;
71046 : if (var->next) {
71047 : tail = PyUnicode_InternFromString(", ");
71048 : joined = PyUnicode_Concat(str, tail);
71049 : Py_DecRef(str);
71050 : Py_DecRef(tail);
71051 : str = joined;
71052 : }
71053 : }
71054 : tail = PyUnicode_InternFromString(")");
71055 : joined = PyUnicode_Concat(str, tail);
71056 : Py_DecRef(str);
71057 : Py_DecRef(tail);
71058 : str = joined;
71059 : #else
71060 : PyObject *str = PyString_FromString("(");
71061 : swig_globalvar *var;
71062 : for (var = v->vars; var; var=var->next) {
71063 : PyString_ConcatAndDel(&str,PyString_FromString(var->name));
71064 : if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
71065 : }
71066 : PyString_ConcatAndDel(&str,PyString_FromString(")"));
71067 : #endif
71068 : return str;
71069 : }
71070 :
71071 : SWIGINTERN void
71072 : swig_varlink_dealloc(swig_varlinkobject *v) {
71073 : swig_globalvar *var = v->vars;
71074 : while (var) {
71075 : swig_globalvar *n = var->next;
71076 : free(var->name);
71077 : free(var);
71078 : var = n;
71079 : }
71080 : }
71081 :
71082 : SWIGINTERN PyObject *
71083 : swig_varlink_getattr(swig_varlinkobject *v, char *n) {
71084 : PyObject *res = NULL;
71085 : swig_globalvar *var = v->vars;
71086 : while (var) {
71087 : if (strcmp(var->name,n) == 0) {
71088 : res = (*var->get_attr)();
71089 : break;
71090 : }
71091 : var = var->next;
71092 : }
71093 : if (res == NULL && !PyErr_Occurred()) {
71094 : PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
71095 : }
71096 : return res;
71097 : }
71098 :
71099 : SWIGINTERN int
71100 : swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
71101 : int res = 1;
71102 : swig_globalvar *var = v->vars;
71103 : while (var) {
71104 : if (strcmp(var->name,n) == 0) {
71105 : res = (*var->set_attr)(p);
71106 : break;
71107 : }
71108 : var = var->next;
71109 : }
71110 : if (res == 1 && !PyErr_Occurred()) {
71111 : PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
71112 : }
71113 : return res;
71114 : }
71115 :
71116 : SWIGINTERN PyTypeObject*
71117 : swig_varlink_type(void) {
71118 : static char varlink__doc__[] = "Swig var link object";
71119 : static PyTypeObject varlink_type;
71120 : static int type_init = 0;
71121 : if (!type_init) {
71122 : const PyTypeObject tmp = {
71123 : #if PY_VERSION_HEX >= 0x03000000
71124 : PyVarObject_HEAD_INIT(NULL, 0)
71125 : #else
71126 : PyObject_HEAD_INIT(NULL)
71127 : 0, /* ob_size */
71128 : #endif
71129 : "swigvarlink", /* tp_name */
71130 : sizeof(swig_varlinkobject), /* tp_basicsize */
71131 : 0, /* tp_itemsize */
71132 : (destructor) swig_varlink_dealloc, /* tp_dealloc */
71133 : 0, /* tp_print */
71134 : (getattrfunc) swig_varlink_getattr, /* tp_getattr */
71135 : (setattrfunc) swig_varlink_setattr, /* tp_setattr */
71136 : 0, /* tp_compare */
71137 : (reprfunc) swig_varlink_repr, /* tp_repr */
71138 : 0, /* tp_as_number */
71139 : 0, /* tp_as_sequence */
71140 : 0, /* tp_as_mapping */
71141 : 0, /* tp_hash */
71142 : 0, /* tp_call */
71143 : (reprfunc) swig_varlink_str, /* tp_str */
71144 : 0, /* tp_getattro */
71145 : 0, /* tp_setattro */
71146 : 0, /* tp_as_buffer */
71147 : 0, /* tp_flags */
71148 : varlink__doc__, /* tp_doc */
71149 : 0, /* tp_traverse */
71150 : 0, /* tp_clear */
71151 : 0, /* tp_richcompare */
71152 : 0, /* tp_weaklistoffset */
71153 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
71154 : 0, /* tp_del */
71155 : 0, /* tp_version_tag */
71156 : #if PY_VERSION_HEX >= 0x03040000
71157 : 0, /* tp_finalize */
71158 : #endif
71159 : #ifdef COUNT_ALLOCS
71160 : 0, /* tp_allocs */
71161 : 0, /* tp_frees */
71162 : 0, /* tp_maxalloc */
71163 : 0, /* tp_prev */
71164 : 0 /* tp_next */
71165 : #endif
71166 : };
71167 : varlink_type = tmp;
71168 : type_init = 1;
71169 : if (PyType_Ready(&varlink_type) < 0)
71170 : return NULL;
71171 : }
71172 : return &varlink_type;
71173 : }
71174 :
71175 : /* Create a variable linking object for use later */
71176 : SWIGINTERN PyObject *
71177 : SWIG_Python_newvarlink(void) {
71178 : swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
71179 : if (result) {
71180 : result->vars = 0;
71181 : }
71182 : return ((PyObject*) result);
71183 : }
71184 :
71185 : SWIGINTERN void
71186 : SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
71187 : swig_varlinkobject *v = (swig_varlinkobject *) p;
71188 : swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
71189 : if (gv) {
71190 : size_t size = strlen(name)+1;
71191 : gv->name = (char *)malloc(size);
71192 : if (gv->name) {
71193 : memcpy(gv->name, name, size);
71194 : gv->get_attr = get_attr;
71195 : gv->set_attr = set_attr;
71196 : gv->next = v->vars;
71197 : }
71198 : }
71199 : v->vars = gv;
71200 : }
71201 :
71202 : SWIGINTERN PyObject *
71203 : SWIG_globals(void) {
71204 : static PyObject *globals = 0;
71205 : if (!globals) {
71206 : globals = SWIG_newvarlink();
71207 : }
71208 : return globals;
71209 : }
71210 :
71211 : /* -----------------------------------------------------------------------------
71212 : * constants/methods manipulation
71213 : * ----------------------------------------------------------------------------- */
71214 :
71215 : /* Install Constants */
71216 : SWIGINTERN void
71217 277 : SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
71218 277 : PyObject *obj = 0;
71219 277 : size_t i;
71220 554 : for (i = 0; constants[i].type; ++i) {
71221 277 : switch(constants[i].type) {
71222 277 : case SWIG_PY_POINTER:
71223 277 : obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
71224 277 : break;
71225 0 : case SWIG_PY_BINARY:
71226 0 : obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
71227 : break;
71228 : default:
71229 : obj = 0;
71230 : break;
71231 : }
71232 277 : if (obj) {
71233 277 : PyDict_SetItemString(d, constants[i].name, obj);
71234 277 : Py_DECREF(obj);
71235 : }
71236 : }
71237 277 : }
71238 :
71239 : /* -----------------------------------------------------------------------------*/
71240 : /* Fix SwigMethods to carry the callback ptrs when needed */
71241 : /* -----------------------------------------------------------------------------*/
71242 :
71243 : SWIGINTERN void
71244 277 : SWIG_Python_FixMethods(PyMethodDef *methods,
71245 : swig_const_info *const_table,
71246 : swig_type_info **types,
71247 : swig_type_info **types_initial) {
71248 277 : size_t i;
71249 239051 : for (i = 0; methods[i].ml_name; ++i) {
71250 238774 : const char *c = methods[i].ml_doc;
71251 238774 : if (!c) continue;
71252 219107 : c = strstr(c, "swig_ptr: ");
71253 219107 : if (c) {
71254 0 : int j;
71255 0 : swig_const_info *ci = 0;
71256 0 : const char *name = c + 10;
71257 0 : for (j = 0; const_table[j].type; ++j) {
71258 0 : if (strncmp(const_table[j].name, name,
71259 : strlen(const_table[j].name)) == 0) {
71260 : ci = &(const_table[j]);
71261 : break;
71262 : }
71263 : }
71264 0 : if (ci) {
71265 238774 : void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
71266 0 : if (ptr) {
71267 0 : size_t shift = (ci->ptype) - types;
71268 0 : swig_type_info *ty = types_initial[shift];
71269 0 : size_t ldoc = (c - methods[i].ml_doc);
71270 0 : size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
71271 0 : char *ndoc = (char*)malloc(ldoc + lptr + 10);
71272 0 : if (ndoc) {
71273 0 : char *buff = ndoc;
71274 0 : memcpy(buff, methods[i].ml_doc, ldoc);
71275 0 : buff += ldoc;
71276 0 : memcpy(buff, "swig_ptr: ", 10);
71277 0 : buff += 10;
71278 0 : SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
71279 0 : methods[i].ml_doc = ndoc;
71280 : }
71281 : }
71282 : }
71283 : }
71284 : }
71285 277 : }
71286 :
71287 : /* -----------------------------------------------------------------------------
71288 : * Method creation and docstring support functions
71289 : * ----------------------------------------------------------------------------- */
71290 :
71291 : /* -----------------------------------------------------------------------------
71292 : * Function to find the method definition with the correct docstring for the
71293 : * proxy module as opposed to the low-level API
71294 : * ----------------------------------------------------------------------------- */
71295 :
71296 0 : SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
71297 : /* Find the function in the modified method table */
71298 0 : size_t offset = 0;
71299 0 : int found = 0;
71300 0 : while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
71301 0 : if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
71302 : found = 1;
71303 : break;
71304 : }
71305 0 : offset++;
71306 : }
71307 : /* Use the copy with the modified docstring if available */
71308 0 : return found ? &SwigMethods_proxydocs[offset] : NULL;
71309 : }
71310 :
71311 : /* -----------------------------------------------------------------------------
71312 : * Wrapper of PyInstanceMethod_New() used in Python 3
71313 : * It is exported to the generated module, used for -fastproxy
71314 : * ----------------------------------------------------------------------------- */
71315 :
71316 0 : SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
71317 0 : if (PyCFunction_Check(func)) {
71318 0 : PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
71319 0 : PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
71320 0 : if (ml)
71321 0 : func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
71322 : }
71323 : #if PY_VERSION_HEX >= 0x03000000
71324 0 : return PyInstanceMethod_New(func);
71325 : #else
71326 : return PyMethod_New(func, NULL, NULL);
71327 : #endif
71328 : }
71329 :
71330 : /* -----------------------------------------------------------------------------
71331 : * Wrapper of PyStaticMethod_New()
71332 : * It is exported to the generated module, used for -fastproxy
71333 : * ----------------------------------------------------------------------------- */
71334 :
71335 : SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
71336 : if (PyCFunction_Check(func)) {
71337 : PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
71338 : PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
71339 : if (ml)
71340 : func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
71341 : }
71342 : return PyStaticMethod_New(func);
71343 : }
71344 :
71345 : #ifdef __cplusplus
71346 : }
71347 : #endif
71348 :
71349 : /* -----------------------------------------------------------------------------*
71350 : * Partial Init method
71351 : * -----------------------------------------------------------------------------*/
71352 :
71353 : #ifdef __cplusplus
71354 : extern "C"
71355 : #endif
71356 :
71357 : SWIGEXPORT
71358 : #if PY_VERSION_HEX >= 0x03000000
71359 : PyObject*
71360 : #else
71361 : void
71362 : #endif
71363 277 : SWIG_init(void) {
71364 277 : PyObject *m, *d, *md, *globals;
71365 :
71366 : #if PY_VERSION_HEX >= 0x03000000
71367 277 : static struct PyModuleDef SWIG_module = {
71368 : PyModuleDef_HEAD_INIT,
71369 : SWIG_name,
71370 : NULL,
71371 : -1,
71372 : SwigMethods,
71373 : NULL,
71374 : NULL,
71375 : NULL,
71376 : NULL
71377 : };
71378 : #endif
71379 :
71380 : #if defined(SWIGPYTHON_BUILTIN)
71381 : static SwigPyClientData SwigPyObject_clientdata = {
71382 : 0, 0, 0, 0, 0, 0, 0
71383 : };
71384 : static PyGetSetDef this_getset_def = {
71385 : (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
71386 : };
71387 : static SwigPyGetSet thisown_getset_closure = {
71388 : SwigPyObject_own,
71389 : SwigPyObject_own
71390 : };
71391 : static PyGetSetDef thisown_getset_def = {
71392 : (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
71393 : };
71394 : PyTypeObject *builtin_pytype;
71395 : int builtin_base_count;
71396 : swig_type_info *builtin_basetype;
71397 : PyObject *tuple;
71398 : PyGetSetDescrObject *static_getset;
71399 : PyTypeObject *metatype;
71400 : PyTypeObject *swigpyobject;
71401 : SwigPyClientData *cd;
71402 : PyObject *public_interface, *public_symbol;
71403 : PyObject *this_descr;
71404 : PyObject *thisown_descr;
71405 : PyObject *self = 0;
71406 : int i;
71407 :
71408 : (void)builtin_pytype;
71409 : (void)builtin_base_count;
71410 : (void)builtin_basetype;
71411 : (void)tuple;
71412 : (void)static_getset;
71413 : (void)self;
71414 :
71415 : /* Metaclass is used to implement static member variables */
71416 : metatype = SwigPyObjectType();
71417 : assert(metatype);
71418 : #endif
71419 :
71420 277 : (void)globals;
71421 :
71422 : /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
71423 277 : SWIG_This();
71424 277 : SWIG_Python_TypeCache();
71425 277 : SwigPyPacked_type();
71426 : #ifndef SWIGPYTHON_BUILTIN
71427 277 : SwigPyObject_type();
71428 : #endif
71429 :
71430 : /* Fix SwigMethods to carry the callback ptrs when needed */
71431 277 : SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
71432 :
71433 : #if PY_VERSION_HEX >= 0x03000000
71434 277 : m = PyModule_Create(&SWIG_module);
71435 : #else
71436 : m = Py_InitModule(SWIG_name, SwigMethods);
71437 : #endif
71438 :
71439 277 : md = d = PyModule_GetDict(m);
71440 277 : (void)md;
71441 :
71442 277 : SWIG_InitializeModule(0);
71443 :
71444 : #ifdef SWIGPYTHON_BUILTIN
71445 : swigpyobject = SwigPyObject_TypeOnce();
71446 :
71447 : SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
71448 : assert(SwigPyObject_stype);
71449 : cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
71450 : if (!cd) {
71451 : SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
71452 : SwigPyObject_clientdata.pytype = swigpyobject;
71453 : } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
71454 : PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
71455 : # if PY_VERSION_HEX >= 0x03000000
71456 : return NULL;
71457 : # else
71458 : return;
71459 : # endif
71460 : }
71461 :
71462 : /* All objects have a 'this' attribute */
71463 : this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
71464 : (void)this_descr;
71465 :
71466 : /* All objects have a 'thisown' attribute */
71467 : thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
71468 : (void)thisown_descr;
71469 :
71470 : public_interface = PyList_New(0);
71471 : public_symbol = 0;
71472 : (void)public_symbol;
71473 :
71474 : PyDict_SetItemString(md, "__all__", public_interface);
71475 : Py_DECREF(public_interface);
71476 : for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
71477 : SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
71478 : for (i = 0; swig_const_table[i].name != 0; ++i)
71479 : SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
71480 : #endif
71481 :
71482 277 : SWIG_InstallConstants(d,swig_const_table);
71483 :
71484 277 : SWIG_Python_SetConstant(d, "GRAUO_LOGICAL_NOT",SWIG_From_int(static_cast< int >(GRAUO_LOGICAL_NOT)));
71485 277 : SWIG_Python_SetConstant(d, "GRAUO_ABS",SWIG_From_int(static_cast< int >(GRAUO_ABS)));
71486 277 : SWIG_Python_SetConstant(d, "GRAUO_SQRT",SWIG_From_int(static_cast< int >(GRAUO_SQRT)));
71487 277 : SWIG_Python_SetConstant(d, "GRAUO_LOG",SWIG_From_int(static_cast< int >(GRAUO_LOG)));
71488 277 : SWIG_Python_SetConstant(d, "GRAUO_LOG10",SWIG_From_int(static_cast< int >(GRAUO_LOG10)));
71489 277 : SWIG_Python_SetConstant(d, "GRABO_ADD",SWIG_From_int(static_cast< int >(GRABO_ADD)));
71490 277 : SWIG_Python_SetConstant(d, "GRABO_SUB",SWIG_From_int(static_cast< int >(GRABO_SUB)));
71491 277 : SWIG_Python_SetConstant(d, "GRABO_MUL",SWIG_From_int(static_cast< int >(GRABO_MUL)));
71492 277 : SWIG_Python_SetConstant(d, "GRABO_DIV",SWIG_From_int(static_cast< int >(GRABO_DIV)));
71493 277 : SWIG_Python_SetConstant(d, "GRABO_POW",SWIG_From_int(static_cast< int >(GRABO_POW)));
71494 277 : SWIG_Python_SetConstant(d, "GRABO_GT",SWIG_From_int(static_cast< int >(GRABO_GT)));
71495 277 : SWIG_Python_SetConstant(d, "GRABO_GE",SWIG_From_int(static_cast< int >(GRABO_GE)));
71496 277 : SWIG_Python_SetConstant(d, "GRABO_LT",SWIG_From_int(static_cast< int >(GRABO_LT)));
71497 277 : SWIG_Python_SetConstant(d, "GRABO_LE",SWIG_From_int(static_cast< int >(GRABO_LE)));
71498 277 : SWIG_Python_SetConstant(d, "GRABO_EQ",SWIG_From_int(static_cast< int >(GRABO_EQ)));
71499 277 : SWIG_Python_SetConstant(d, "GRABO_NE",SWIG_From_int(static_cast< int >(GRABO_NE)));
71500 277 : SWIG_Python_SetConstant(d, "GRABO_LOGICAL_AND",SWIG_From_int(static_cast< int >(GRABO_LOGICAL_AND)));
71501 277 : SWIG_Python_SetConstant(d, "GRABO_LOGICAL_OR",SWIG_From_int(static_cast< int >(GRABO_LOGICAL_OR)));
71502 :
71503 : /* gdal_python.i %init code */
71504 277 : if ( GDALGetDriverCount() == 0 ) {
71505 277 : GDALAllRegister();
71506 : }
71507 : // Will be turned on for GDAL 4.0
71508 : // UseExceptions();
71509 :
71510 :
71511 277 : SWIG_Python_SetConstant(d, "VSI_STAT_EXISTS_FLAG",SWIG_From_int(static_cast< int >(0x1)));
71512 277 : SWIG_Python_SetConstant(d, "VSI_STAT_NATURE_FLAG",SWIG_From_int(static_cast< int >(0x2)));
71513 277 : SWIG_Python_SetConstant(d, "VSI_STAT_SIZE_FLAG",SWIG_From_int(static_cast< int >(0x4)));
71514 277 : SWIG_Python_SetConstant(d, "VSI_STAT_SET_ERROR_FLAG",SWIG_From_int(static_cast< int >(0x8)));
71515 277 : SWIG_Python_SetConstant(d, "VSI_STAT_CACHE_ONLY",SWIG_From_int(static_cast< int >(0x10)));
71516 277 : SWIG_Python_SetConstant(d, "VSI_RANGE_STATUS_UNKNOWN",SWIG_From_int(static_cast< int >(0)));
71517 277 : SWIG_Python_SetConstant(d, "VSI_RANGE_STATUS_DATA",SWIG_From_int(static_cast< int >(1)));
71518 277 : SWIG_Python_SetConstant(d, "VSI_RANGE_STATUS_HOLE",SWIG_From_int(static_cast< int >(2)));
71519 277 : SWIG_Python_SetConstant(d, "GEDTST_NONE",SWIG_From_int(static_cast< int >(GEDTST_NONE)));
71520 277 : SWIG_Python_SetConstant(d, "GEDTST_JSON",SWIG_From_int(static_cast< int >(GEDTST_JSON)));
71521 277 : SWIG_Python_SetConstant(d, "GEDTC_NUMERIC",SWIG_From_int(static_cast< int >(GEDTC_NUMERIC)));
71522 277 : SWIG_Python_SetConstant(d, "GEDTC_STRING",SWIG_From_int(static_cast< int >(GEDTC_STRING)));
71523 277 : SWIG_Python_SetConstant(d, "GEDTC_COMPOUND",SWIG_From_int(static_cast< int >(GEDTC_COMPOUND)));
71524 :
71525 277 : SWIG_Python_SetConstant(d, "GVM_Diagonal",SWIG_From_int(static_cast< int >(GVM_Diagonal)));
71526 277 : SWIG_Python_SetConstant(d, "GVM_Edge",SWIG_From_int(static_cast< int >(GVM_Edge)));
71527 277 : SWIG_Python_SetConstant(d, "GVM_Max",SWIG_From_int(static_cast< int >(GVM_Max)));
71528 277 : SWIG_Python_SetConstant(d, "GVM_Min",SWIG_From_int(static_cast< int >(GVM_Min)));
71529 277 : SWIG_Python_SetConstant(d, "GVOT_NORMAL",SWIG_From_int(static_cast< int >(GVOT_NORMAL)));
71530 277 : SWIG_Python_SetConstant(d, "GVOT_MIN_TARGET_HEIGHT_FROM_DEM",SWIG_From_int(static_cast< int >(GVOT_MIN_TARGET_HEIGHT_FROM_DEM)));
71531 277 : SWIG_Python_SetConstant(d, "GVOT_MIN_TARGET_HEIGHT_FROM_GROUND",SWIG_From_int(static_cast< int >(GVOT_MIN_TARGET_HEIGHT_FROM_GROUND)));
71532 :
71533 : /* Initialize threading */
71534 277 : SWIG_PYTHON_INITIALIZE_THREADS;
71535 : #if PY_VERSION_HEX >= 0x03000000
71536 277 : return m;
71537 : #else
71538 : return;
71539 : #endif
71540 : }
71541 :
|
